xref: /titanic_52/usr/src/cmd/format/startup.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * This file contains the code to perform program startup.  This
 * includes reading the data file and the search for disks.
 */
#include "global.h"

#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <errno.h>
#include <memory.h>
#include <dirent.h>
#include <sys/fcntl.h>
#include <sys/param.h>
#include <sys/stat.h>

#include "startup.h"
#include "param.h"
#include "label.h"
#include "misc.h"
#include "menu_command.h"
#include "partition.h"
#include "ctlr_scsi.h"

#include "auto_sense.h"

extern	struct	ctlr_type ctlr_types[];
extern	int	nctypes;
extern	struct	ctlr_ops	genericops;
extern	long	strtol();

extern	int	errno;

#ifdef __STDC__

/* Function prototypes for ANSI C Compilers */
static void	usage(void);
static int	sup_prxfile(void);
static void	sup_setpath(void);
static void	sup_setdtype(void);
static int	sup_change_spec(struct disk_type *, char *);
static void	sup_setpart(void);
static void	search_for_logical_dev(char *devname);
static void	add_device_to_disklist(char *devname, char *devpath);
static int	disk_is_known(struct dk_cinfo *dkinfo);
static void	datafile_error(char *errmsg, char *token);
static void	search_duplicate_dtypes(void);
static void	search_duplicate_pinfo(void);
static void	check_dtypes_for_inconsistency(struct disk_type *dp1,
		struct disk_type *dp2);
static void	check_pinfo_for_inconsistency(struct partition_info *pp1,
		struct partition_info *pp2);
static int	str2blks(char *str);
static int	str2cyls(char *str);
static struct	chg_list *new_chg_list(struct disk_type *);
static char	*get_physical_name(char *);
static void	sort_disk_list(void);
static int	disk_name_compare(const void *, const void *);
static void	make_controller_list(void);
static void	check_for_duplicate_disknames(char *arglist[]);

#else	/* __STDC__ */

/* Function prototypes for non-ANSI C Compilers */
static void	usage();
static int	sup_prxfile();
static void	sup_setpath();
static void	sup_setdtype();
static int	sup_change_spec();
static void	sup_setpart();
static void	search_for_logical_dev();
static void	add_device_to_disklist();
static int	disk_is_known();
static void	datafile_error();
static void	search_duplicate_dtypes();
static void	search_duplicate_pinfo();
static void	check_dtypes_for_inconsistency();
static void	check_pinfo_for_inconsistency();
static int	str2blks();
static int	str2cyls();
static struct	chg_list *new_chg_list();
static char	*get_physical_name();
static void	sort_disk_list();
static int	disk_name_compare();
static void	make_controller_list();
static void	check_for_duplicate_disknames();

#endif	/* __STDC__ */

#if defined(sparc)
static char *other_ctlrs[] = {
	"ata"
	};
#define	OTHER_CTLRS 1

#elif defined(i386)
static char *other_ctlrs[] = {
	"ISP-80"
	};
#define	OTHER_CTLRS 2

#else
#error No Platform defined.
#endif


/*
 * This global is used to store the current line # in the data file.
 * It must be global because the I/O routines are allowed to side
 * effect it to keep track of backslashed newlines.
 */
int	data_lineno;			/* current line # in data file */

/*
 * Search path as defined in the format.dat files
 */
static char	**search_path = NULL;


static int name_represents_wholedisk(char *name);



/*
 * This routine digests the options on the command line.  It returns
 * the index into argv of the first string that is not an option.  If
 * there are none, it returns -1.
 */
int
do_options(int argc, char *argv[])
{
	char	*ptr;
	int	i;
	int	next;

	/*
	 * Default is no extended messages.  Can be enabled manually.
	 */
	option_msg = 0;
	diag_msg = 0;
	expert_mode = 0;
	need_newline = 0;
	dev_expert = 0;

	/*
	 * Loop through the argument list, incrementing each time by
	 * an amount determined by the options found.
	 */
	for (i = 1; i < argc; i = next) {
		/*
		 * Start out assuming an increment of 1.
		 */
		next = i + 1;
		/*
		 * As soon as we hit a non-option, we're done.
		 */
		if (*argv[i] != '-')
			return (i);
		/*
		 * Loop through all the characters in this option string.
		 */
		for (ptr = argv[i] + 1; *ptr != '\0'; ptr++) {
			/*
			 * Determine each option represented.  For options
			 * that use a second string, increase the increment
			 * of the main loop so they aren't re-interpreted.
			 */
			switch (*ptr) {
			    case 's':
			    case 'S':
				option_s = 1;
				break;
			    case 'f':
			    case 'F':
				option_f = argv[next++];
				if (next > argc)
					goto badopt;
				break;
			    case 'l':
			    case 'L':
				option_l = argv[next++];
				if (next > argc)
					goto badopt;
				break;
			    case 'x':
			    case 'X':
				option_x = argv[next++];
				if (next > argc)
					goto badopt;
				break;
			    case 'd':
			    case 'D':
				option_d = argv[next++];
				if (next > argc)
					goto badopt;
				break;
			    case 't':
			    case 'T':
				option_t = argv[next++];
				if (next > argc)
					goto badopt;
				break;
			    case 'p':
			    case 'P':
				option_p = argv[next++];
				if (next > argc)
					goto badopt;
				break;
			    case 'm':
				option_msg = 1;
				break;
			    case 'M':
				option_msg = 1;
				diag_msg = 1;
				break;
			    case 'e':
				expert_mode = 1;
				break;
#ifdef DEBUG
			    case 'z':
				dev_expert = 1;
				break;
#endif
			    default:
badopt:
				usage();
				break;
			}
		}
	}
	/*
	 * All the command line strings were options.  Return that fact.
	 */
	return (-1);
}


static void
usage()
{
	err_print("Usage:  format [-s][-d disk_name]");
	err_print("[-t disk_type][-p partition_name]\n");
	err_print("\t[-f cmd_file][-l log_file]");
	err_print("[-x data_file] [-m] [-M] [-e] disk_list\n");
	fullabort();
}


/*
 * This routine reads in and digests the data file.  The data file contains
 * definitions for the search path, known disk types, and known partition
 * maps.
 *
 * Note: for each file being processed, file_name is a pointer to that
 * file's name.  We are careful to make sure that file_name points to
 * globally-accessible data, not data on the stack, because each
 * disk/partition/controller definition now keeps a pointer to the
 * filename in which it was defined.  In the case of duplicate,
 * conflicting definitions, we can thus tell the user exactly where
 * the problem is occurring.
 */
void
sup_init()
{
	int		nopened_files = 0;

#if defined(sparc)
	char		fname[MAXPATHLEN];
	char		*path;
	char		*p;
	struct stat	stbuf;
#endif /* defined(sparc) */


	/*
	 * Create a singly-linked list of controller types so that we may
	 * dynamically add unknown controllers to this for 3'rd
	 * party disk support.
	 */

	make_controller_list();

	/*
	 * If a data file was specified on the command line, use it first
	 * If the file cannot be opened, fail.  We want to guarantee
	 * that, if the user explicitly names a file, they can
	 * access it.
	 *
	 * option_x is already global, no need to dup it on the heap.
	 */
	if (option_x) {
		file_name = option_x;
		if (sup_prxfile()) {
			nopened_files++;
		} else {
			err_print("Unable to open data file '%s' - %s.\n",
				file_name, strerror(errno));
			fullabort();
		}
	}

#if defined(sparc)
	/*
	 * Now look for an environment variable FORMAT_PATH.
	 * If found, we use it as a colon-separated list
	 * of directories.  If no such environment variable
	 * is defined, use a default path of "/etc".
	 */
	path = getenv("FORMAT_PATH");
	if (path == NULL) {
		path = "/etc";
	}
	/*
	 * Traverse the path one file at a time.  Pick off
	 * the file name, and append the name "format.dat"
	 * at the end of the pathname.
	 * Whatever string we construct, duplicate it on the
	 * heap, so that file_name is globally accessible.
	 */
	while (*path != 0) {
		p = fname;
		while (*path != 0 && *path != ':')
			*p++ = *path++;
		if (p == fname)
			continue;
		*p = 0;
		if (*path == ':')
			path++;
		/*
		 * If the path we have so far is a directory,
		 * look for a format.dat file in that directory,
		 * otherwise try using the path name specified.
		 * This permits arbitrary file names in the
		 * path specification, if this proves useful.
		 */
		if (stat(fname, &stbuf) == -1) {
			err_print("Unable to access '%s' - %s.\n",
				fname, strerror(errno));
		} else {
			if (S_ISDIR(stbuf.st_mode)) {
				if (*(p-1) != '/')
					*p++ = '/';
				(void) strcpy(p, "format.dat");
			}
			file_name = alloc_string(fname);
			if (sup_prxfile()) {
				nopened_files++;
			}
		}
	}
#endif	/* defined(sparc) */

	/*
	 * Check for duplicate disk or partitions definitions
	 * that are inconsistent - this would be very confusing.
	 */
	search_duplicate_dtypes();
	search_duplicate_pinfo();
}


/*
 * Open and process a format data file.  Unfortunately, we use
 * globals: file_name for the file name, and data_file
 * for the descriptor.  Return true if able to open the file.
 */
static int
sup_prxfile()
{
	int	status;
	TOKEN	token;
	TOKEN	cleaned;

	/*
	 * Open the data file.  Return 0 if unable to do so.
	 */
	data_file = fopen(file_name, "r");
	if (data_file == NULL) {
		return (0);
	}
	/*
	 * Step through the data file a meta-line at a time.  There are
	 * typically several backslashed newlines in each meta-line,
	 * so data_lineno will be getting side effected along the way.
	 */
	data_lineno = 0;
	for (;;) {
		data_lineno++;
		/*
		 * Get the keyword.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit the end of the data file, we're done.
		 */
		if (status == SUP_EOF)
			break;
		/*
		 * If the line is blank, skip it.
		 */
		if (status == SUP_EOL)
			continue;
		/*
		 * If the line starts with some key character, it's an error.
		 */
		if (status != SUP_STRING) {
			datafile_error("Expecting keyword, found '%s'", token);
			continue;
		}
		/*
		 * Clean up the token and see which keyword it is.  Call
		 * the appropriate routine to process the rest of the line.
		 */
		clean_token(cleaned, token);
		if (strcmp(cleaned, "search_path") == 0)
			sup_setpath();
		else if (strcmp(cleaned, "disk_type") == 0)
			sup_setdtype();
		else if (strcmp(cleaned, "partition") == 0)
			sup_setpart();
		else {
			datafile_error("Unknown keyword '%s'", cleaned);
		}
	}
	/*
	 * Close the data file.
	 */
	(void) fclose(data_file);

	return (1);
}

/*
 * This routine processes a 'search_path' line in the data file.  The
 * search path is a list of disk names that will be searched for by the
 * program.
 *
 * The static path_size and path_alloc are used to build up the
 * list of files comprising the search path.  The static definitions
 * enable supporting multiple search path definitions.
 */
static void
sup_setpath()
{
	TOKEN		token;
	TOKEN		cleaned;
	int		status;
	static int	path_size;
	static int	path_alloc;

	/*
	 * Pull in some grammar.
	 */
	status = sup_gettoken(token);
	if (status != SUP_EQL) {
		datafile_error("Expecting '=', found '%s'", token);
		return;
	}
	/*
	 * Loop through the entries.
	 */
	for (;;) {
		/*
		 * Pull in the disk name.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit end of line, we're done.
		 */
		if (status == SUP_EOL)
			break;
		/*
		 * If we hit some key character, it's an error.
		 */
		if (status != SUP_STRING) {
			datafile_error("Expecting value, found '%s'", token);
			break;
		}
		clean_token(cleaned, token);
		/*
		 * Build the string into an argvlist.  This array
		 * is dynamically sized, as necessary, and terminated
		 * with a null.  Each name is alloc'ed on the heap,
		 * so no dangling references.
		 */
		search_path = build_argvlist(search_path, &path_size,
			&path_alloc, cleaned);
		/*
		 * Pull in some grammar.
		 */
		status = sup_gettoken(token);
		if (status == SUP_EOL)
			break;
		if (status != SUP_COMMA) {
			datafile_error("Expecting ', ', found '%s'", token);
			break;
		}
	}
}

/*
 * This routine processes a 'disk_type' line in the data file.  It defines
 * the physical attributes of a brand of disk when connected to a specific
 * controller type.
 */
static void
sup_setdtype()
{
	TOKEN	token, cleaned, ident;
	int	val, status, i;
	ulong_t	flags = 0;
	struct	disk_type *dtype, *type;
	struct	ctlr_type *ctype;
	char	*dtype_name, *ptr;
	struct	mctlr_list	*mlp;

	/*
	 * Pull in some grammar.
	 */
	status = sup_gettoken(token);
	if (status != SUP_EQL) {
		datafile_error("Expecting '=', found '%s'", token);
		return;
	}
	/*
	 * Pull in the name of the disk type.
	 */
	status = sup_gettoken(token);
	if (status != SUP_STRING) {
		datafile_error("Expecting value, found '%s'", token);
		return;
	}
	clean_token(cleaned, token);
	/*
	 * Allocate space for the disk type and copy in the name.
	 */
	dtype_name = (char *)zalloc(strlen(cleaned) + 1);
	(void) strcpy(dtype_name, cleaned);
	dtype = (struct disk_type *)zalloc(sizeof (struct disk_type));
	dtype->dtype_asciilabel = dtype_name;
	/*
	 * Save the filename/linenumber where this disk was defined
	 */
	dtype->dtype_filename = file_name;
	dtype->dtype_lineno = data_lineno;
	/*
	 * Loop for each attribute.
	 */
	for (;;) {
		/*
		 * Pull in some grammar.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit end of line, we're done.
		 */
		if (status == SUP_EOL)
			break;
		if (status != SUP_COLON) {
			datafile_error("Expecting ':', found '%s'", token);
			return;
		}
		/*
		 * Pull in the attribute.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit end of line, we're done.
		 */
		if (status == SUP_EOL)
			break;
		/*
		 * If we hit a key character, it's an error.
		 */
		if (status != SUP_STRING) {
			datafile_error("Expecting keyword, found '%s'", token);
			return;
		}
		clean_token(ident, token);
		/*
		 * Check to see if we've got a change specification
		 * If so, this routine will parse the entire
		 * specification, so just restart at top of loop
		 */
		if (sup_change_spec(dtype, ident)) {
			continue;
		}
		/*
		 * Pull in more grammar.
		 */
		status = sup_gettoken(token);
		if (status != SUP_EQL) {
			datafile_error("Expecting '=', found '%s'", token);
			return;
		}
		/*
		 * Pull in the value of the attribute.
		 */
		status = sup_gettoken(token);
		if (status != SUP_STRING) {
			datafile_error("Expecting value, found '%s'", token);
			return;
		}
		clean_token(cleaned, token);
		/*
		 * If the attribute defined the ctlr...
		 */
		if (strcmp(ident, "ctlr") == 0) {
			/*
			 * Match the value with a ctlr type.
			 */
			mlp = controlp;

			while (mlp != NULL) {
				if (strcmp(mlp->ctlr_type->ctype_name,
				    cleaned) == 0)
					break;
				mlp = mlp->next;
			}
			/*
			 * If we couldn't match it, it's an error.
			 */
			if (mlp == NULL) {
				for (i = 0; i < OTHER_CTLRS; i++) {
					if (strcmp(other_ctlrs[i], cleaned)
					    == 0) {
						datafile_error(NULL, NULL);
						return;
					}
				}
				if (i == OTHER_CTLRS) {
				    datafile_error("Unknown controller '%s'",
					cleaned);
				    return;
				}
			}
			/*
			 * Found a match.  Add this disk type to the list
			 * for the ctlr type if we can complete the
			 * disk specification correctly.
			 */
			ctype = mlp->ctlr_type;
			flags |= SUP_CTLR;
			continue;
		}
		/*
		 * All other attributes require a numeric value.  Convert
		 * the value to a number.
		 */
		val = (int)strtol(cleaned, &ptr, 0);
		if (*ptr != '\0') {
			datafile_error("Expecting an integer, found '%s'",
				cleaned);
			return;
		}
		/*
		 * Figure out which attribute it was and fill in the
		 * appropriate value.  Also note that the attribute
		 * has been defined.
		 */
		if (strcmp(ident, "ncyl") == 0) {
			dtype->dtype_ncyl = val;
			flags |= SUP_NCYL;
		} else if (strcmp(ident, "acyl") == 0) {
			dtype->dtype_acyl = val;
			flags |= SUP_ACYL;
		} else if (strcmp(ident, "pcyl") == 0) {
			dtype->dtype_pcyl = val;
			flags |= SUP_PCYL;
		} else if (strcmp(ident, "nhead") == 0) {
			dtype->dtype_nhead = val;
			flags |= SUP_NHEAD;
		} else if (strcmp(ident, "nsect") == 0) {
			dtype->dtype_nsect = val;
			flags |= SUP_NSECT;
		} else if (strcmp(ident, "rpm") == 0) {
			dtype->dtype_rpm = val;
			flags |= SUP_RPM;
		} else if (strcmp(ident, "bpt") == 0) {
			dtype->dtype_bpt = val;
			flags |= SUP_BPT;
		} else if (strcmp(ident, "bps") == 0) {
			dtype->dtype_bps = val;
			flags |= SUP_BPS;
		} else if (strcmp(ident, "drive_type") == 0) {
			dtype->dtype_dr_type = val;
			flags |= SUP_DRTYPE;
		} else if (strcmp(ident, "cache") == 0) {
			dtype->dtype_cache = val;
			flags |= SUP_CACHE;
		} else if (strcmp(ident, "prefetch") == 0) {
			dtype->dtype_threshold = val;
			flags |= SUP_PREFETCH;
		} else if (strcmp(ident, "read_retries") == 0) {
			dtype->dtype_read_retries = val;
			flags |= SUP_READ_RETRIES;
		} else if (strcmp(ident, "write_retries") == 0) {
			dtype->dtype_write_retries = val;
			flags |= SUP_WRITE_RETRIES;
		} else if (strcmp(ident, "min_prefetch") == 0) {
			dtype->dtype_prefetch_min = val;
			flags |= SUP_CACHE_MIN;
		} else if (strcmp(ident, "max_prefetch") == 0) {
			dtype->dtype_prefetch_max = val;
			flags |= SUP_CACHE_MAX;
		} else if (strcmp(ident, "trks_zone") == 0) {
			dtype->dtype_trks_zone = val;
			flags |= SUP_TRKS_ZONE;
		} else if (strcmp(ident, "atrks") == 0) {
			dtype->dtype_atrks = val;
			flags |= SUP_ATRKS;
		} else if (strcmp(ident, "asect") == 0) {
			dtype->dtype_asect = val;
			flags |= SUP_ASECT;
		} else if (strcmp(ident, "psect") == 0) {
			dtype->dtype_psect = val;
			flags |= SUP_PSECT;
		} else if (strcmp(ident, "phead") == 0) {
			dtype->dtype_phead = val;
			flags |= SUP_PHEAD;
		} else if (strcmp(ident, "fmt_time") == 0) {
			dtype->dtype_fmt_time = val;
			flags |= SUP_FMTTIME;
		} else if (strcmp(ident, "cyl_skew") == 0) {
			dtype->dtype_cyl_skew = val;
			flags |= SUP_CYLSKEW;
		} else if (strcmp(ident, "trk_skew") == 0) {
			dtype->dtype_trk_skew = val;
			flags |= SUP_TRKSKEW;
		} else {
			datafile_error("Unknown keyword '%s'", ident);
		}
	}
	/*
	 * Check to be sure all the necessary attributes have been defined.
	 * If any are missing, it's an error.  Also, log options for later
	 * use by specific driver.
	 */
	dtype->dtype_options = flags;
	if ((flags & SUP_MIN_DRIVE) != SUP_MIN_DRIVE) {
		datafile_error("Incomplete specification", "");
		return;
	}
	if ((!(ctype->ctype_flags & CF_SCSI)) && (!(flags & SUP_BPT)) &&
	    (!(ctype->ctype_flags & CF_NOFORMAT))) {
		datafile_error("Incomplete specification", "");
		return;
	}
	if ((ctype->ctype_flags & CF_SMD_DEFS) && (!(flags & SUP_BPS))) {
		datafile_error("Incomplete specification", "");
		return;
	}
	/*
	 * Add this disk type to the list for the ctlr type
	 */
	assert(flags & SUP_CTLR);
	type = ctype->ctype_dlist;
	if (type == NULL) {
		ctype->ctype_dlist = dtype;
	} else {
		while (type->dtype_next != NULL)
			type = type->dtype_next;
		type->dtype_next = dtype;
	}
}


/*
 * Parse a SCSI mode page change specification.
 *
 * Return:
 *		0:  not change specification, continue parsing
 *		1:  was change specification, it was ok,
 *		    or we already handled the error.
 */
static int
sup_change_spec(struct disk_type *disk, char *id)
{
	char		*p;
	char		*p2;
	int		pageno;
	int		byteno;
	int		mode;
	int		value;
	TOKEN		token;
	TOKEN		ident;
	struct chg_list	*cp;
	int		tilde;
	int		i;

	/*
	 * Syntax: p[<nn>|0x<xx>]
	 */
	if (*id != 'p') {
		return (0);
	}
	pageno = (int)strtol(id+1, &p2, 0);
	if (*p2 != 0) {
		return (0);
	}
	/*
	 * Once we get this far, we know we have the
	 * beginnings of a change specification.
	 * If there's a problem now, report the problem,
	 * and return 1, so that the caller can restart
	 * parsing at the next expression.
	 */
	if (!scsi_supported_page(pageno)) {
		datafile_error("Unsupported mode page '%s'", id);
		return (1);
	}
	/*
	 * Next token should be the byte offset
	 */
	if (sup_gettoken(token) != SUP_STRING) {
		datafile_error("Unexpected value '%s'", token);
		return (1);
	}
	clean_token(ident, token);

	/*
	 * Syntax: b[<nn>|0x<xx>]
	 */
	p = ident;
	if (*p++ != 'b') {
		datafile_error("Unknown keyword '%s'", ident);
		return (1);
	}
	byteno = (int)strtol(p, &p2, 10);
	if (*p2 != 0) {
		datafile_error("Unknown keyword '%s'", ident);
		return (1);
	}
	if (byteno == 0 || byteno == 1) {
		datafile_error("Unsupported byte offset '%s'", ident);
		return (1);
	}

	/*
	 * Get the operator for this expression
	 */
	mode = CHG_MODE_UNDEFINED;
	switch (sup_gettoken(token)) {
	case SUP_EQL:
		mode = CHG_MODE_ABS;
		break;
	case SUP_OR:
		if (sup_gettoken(token) == SUP_EQL)
			mode = CHG_MODE_SET;
		break;
	case SUP_AND:
		if (sup_gettoken(token) == SUP_EQL)
			mode = CHG_MODE_CLR;
		break;
	}
	if (mode == CHG_MODE_UNDEFINED) {
		datafile_error("Unexpected operator: '%s'", token);
		return (1);
	}

	/*
	 * Get right-hand of expression - accept optional tilde
	 */
	tilde = 0;
	if ((i = sup_gettoken(token)) == SUP_TILDE) {
		tilde = 1;
		i = sup_gettoken(token);
	}
	if (i != SUP_STRING) {
		datafile_error("Expecting value, found '%s'", token);
		return (1);
	}
	clean_token(ident, token);
	value = (int)strtol(ident, &p, 0);
	if (*p != 0) {
		datafile_error("Expecting value, found '%s'", token);
		return (1);
	}

	/*
	 * Apply the tilde operator, if found.
	 * Constrain to a byte value.
	 */
	if (tilde) {
		value = ~value;
	}
	value &= 0xff;

	/*
	 * We parsed a successful change specification expression.
	 * Add it to the list for this disk type.
	 */
	cp = new_chg_list(disk);
	cp->pageno = pageno;
	cp->byteno = byteno;
	cp->mode = mode;
	cp->value = value;
	return (1);
}


/*
 * This routine processes a 'partition' line in the data file.  It defines
 * a known partition map for a particular disk type on a particular
 * controller type.
 */
static void
sup_setpart()
{
	TOKEN	token, cleaned, disk, ctlr, ident;
	struct	disk_type *dtype = NULL;
	struct	ctlr_type *ctype = NULL;
	struct	partition_info *pinfo, *parts;
	char	*pinfo_name;
	int	i, index, status, val1, val2, flags = 0;
	ushort_t	vtoc_tag;
	ushort_t	vtoc_flag;
	struct	mctlr_list	*mlp;

	/*
	 * Pull in some grammar.
	 */
	status = sup_gettoken(token);
	if (status != SUP_EQL) {
		datafile_error("Expecting '=', found '%s'", token);
		return;
	}
	/*
	 * Pull in the name of the map.
	 */
	status = sup_gettoken(token);
	if (status != SUP_STRING) {
		datafile_error("Expecting value, found '%s'", token);
		return;
	}
	clean_token(cleaned, token);
	/*
	 * Allocate space for the partition map and fill in the name.
	 */
	pinfo_name = (char *)zalloc(strlen(cleaned) + 1);
	(void) strcpy(pinfo_name, cleaned);
	pinfo = (struct partition_info *)zalloc(sizeof (struct partition_info));
	pinfo->pinfo_name = pinfo_name;
	/*
	 * Save the filename/linenumber where this partition was defined
	 */
	pinfo->pinfo_filename = file_name;
	pinfo->pinfo_lineno = data_lineno;

	/*
	 * Install default vtoc information into the new partition table
	 */
	set_vtoc_defaults(pinfo);

	/*
	 * Loop for each attribute in the line.
	 */
	for (;;) {
		/*
		 * Pull in some grammar.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit end of line, we're done.
		 */
		if (status == SUP_EOL)
			break;
		if (status != SUP_COLON) {
			datafile_error("Expecting ':', found '%s'", token);
			return;
		}
		/*
		 * Pull in the attribute.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit end of line, we're done.
		 */
		if (status == SUP_EOL)
			break;
		if (status != SUP_STRING) {
			datafile_error("Expecting keyword, found '%s'", token);
			return;
		}
		clean_token(ident, token);
		/*
		 * Pull in more grammar.
		 */
		status = sup_gettoken(token);
		if (status != SUP_EQL) {
			datafile_error("Expecting '=', found '%s'", token);
			return;
		}
		/*
		 * Pull in the value of the attribute.
		 */
		status = sup_gettoken(token);
		/*
		 * If we hit a key character, it's an error.
		 */
		if (status != SUP_STRING) {
			datafile_error("Expecting value, found '%s'", token);
			return;
		}
		clean_token(cleaned, token);
		/*
		 * If the attribute is the ctlr, save the ctlr name and
		 * mark it defined.
		 */
		if (strcmp(ident, "ctlr") == 0) {
			(void) strcpy(ctlr, cleaned);
			flags |= SUP_CTLR;
			continue;
		/*
		 * If the attribute is the disk, save the disk name and
		 * mark it defined.
		 */
		} else if (strcmp(ident, "disk") == 0) {
			(void) strcpy(disk, cleaned);
			flags |= SUP_DISK;
			continue;
		}
		/*
		 * If we now know both the controller name and the
		 * disk name, let's see if we can find the controller
		 * and disk type.  This will give us the geometry,
		 * which can permit us to accept partitions specs
		 * in cylinders or blocks.
		 */
		if (((flags & (SUP_DISK|SUP_CTLR)) == (SUP_DISK|SUP_CTLR)) &&
				dtype == NULL && ctype == NULL) {
			/*
			 * Attempt to match the specified ctlr to a known type.
			 */
			mlp = controlp;

			while (mlp != NULL) {
				if (strcmp(mlp->ctlr_type->ctype_name,
				    ctlr) == 0)
					break;
				mlp = mlp->next;
			}
			/*
			 * If no match is found, it's an error.
			 */
			if (mlp == NULL) {
				for (i = 0; i < OTHER_CTLRS; i++) {
					if (strcmp(other_ctlrs[i], ctlr) == 0) {
						datafile_error(NULL, NULL);
						return;
					}
				}
				if (i == OTHER_CTLRS) {
					datafile_error(
					    "Unknown controller '%s'", ctlr);
					return;
				}
			}
			ctype = mlp->ctlr_type;
			/*
			 * Attempt to match the specified disk to a known type.
			 */
			for (dtype = ctype->ctype_dlist; dtype != NULL;
						dtype = dtype->dtype_next) {
				if (strcmp(dtype->dtype_asciilabel, disk) == 0)
					break;
			}
			/*
			 * If no match is found, it's an error.
			 */
			if (dtype == NULL) {
				datafile_error("Unknown disk '%s'", disk);
				return;
			}
			/*
			 * Now that we know the disk type, set up the
			 * globals that let that magic macro "spc()"
			 * do it's thing.  Sorry that this is glued
			 * together so poorly...
			 */
			nhead = dtype->dtype_nhead;
			nsect = dtype->dtype_nsect;
			acyl = dtype->dtype_acyl;
			ncyl = dtype->dtype_ncyl;
		}
		/*
		 * By now, the disk and controller type must be defined
		 */
		if (dtype == NULL || ctype == NULL) {
			datafile_error("Incomplete specification", "");
			return;
		}
		/*
		 * The rest of the attributes are all single letters.
		 * Make sure the specified attribute is a single letter.
		 */
		if (strlen(ident) != 1) {
			datafile_error("Unknown keyword '%s'", ident);
			return;
		}
		/*
		 * Also make sure it is within the legal range of letters.
		 */
		if (ident[0] < PARTITION_BASE || ident[0] > PARTITION_BASE+9) {
			datafile_error("Unknown keyword '%s'", ident);
			return;
		}
		/*
		 * Here's the index of the partition we're dealing with
		 */
		index = ident[0] - PARTITION_BASE;
		/*
		 * For SunOS 5.0, we support the additional syntax:
		 *	[<tag>, ] [<flag>, ] <start>, <end>
		 * instead of:
		 *	<start>, <end>
		 *
		 * <tag> may be one of: boot, root, swap, etc.
		 * <flag> consists of two characters:
		 *	W (writable) or R (read-only)
		 *	M (mountable) or U (unmountable)
		 *
		 * Start with the defaults assigned above:
		 */
		vtoc_tag = pinfo->vtoc.v_part[index].p_tag;
		vtoc_flag = pinfo->vtoc.v_part[index].p_flag;

		/*
		 * First try to match token against possible tag values
		 */
		if (find_value(ptag_choices, cleaned, &i) == 1) {
			/*
			 * Found valid tag. Use it and advance parser
			 */
			vtoc_tag = (ushort_t)i;
			status = sup_gettoken(token);
			if (status != SUP_COMMA) {
				datafile_error(
					"Expecting ', ', found '%s'",
					token);
				return;
			}
			status = sup_gettoken(token);
			if (status != SUP_STRING) {
				datafile_error("Expecting value, found '%s'",
					token);
				return;
			}
			clean_token(cleaned, token);
		}

		/*
		 * Try to match token against possible flag values
		 */
		if (find_value(pflag_choices, cleaned, &i) == 1) {
			/*
			 * Found valid flag. Use it and advance parser
			 */
			vtoc_flag = (ushort_t)i;
			status = sup_gettoken(token);
			if (status != SUP_COMMA) {
				datafile_error("Expecting ', ', found '%s'",
					token);
				return;
			}
			status = sup_gettoken(token);
			if (status != SUP_STRING) {
				datafile_error("Expecting value, found '%s'",
					token);
				return;
			}
			clean_token(cleaned, token);
		}
		/*
		 * All other attributes have a pair of numeric values.
		 * Convert the first value to a number.  This value
		 * is the starting cylinder number of the partition.
		 */
		val1 = str2cyls(cleaned);
		if (val1 == -1) {
			datafile_error("Expecting an integer, found '%s'",
				cleaned);
			return;
		}
		/*
		 * Pull in some grammar.
		 */
		status = sup_gettoken(token);
		if (status != SUP_COMMA) {
			datafile_error("Expecting ', ', found '%s'", token);
			return;
		}
		/*
		 * Pull in the second value.
		 */
		status = sup_gettoken(token);
		if (status != SUP_STRING) {
			datafile_error("Expecting value, found '%s'", token);
			return;
		}
		clean_token(cleaned, token);
		/*
		 * Convert the second value to a number.  This value
		 * is the number of blocks composing the partition.
		 * If the token is terminated with a 'c', the units
		 * are cylinders, not blocks.  Also accept a 'b', if
		 * they choose to be so specific.
		 */
		val2 = str2blks(cleaned);
		if (val2 == -1) {
			datafile_error("Expecting an integer, found '%s'",
				cleaned);
			return;
		}
		/*
		 * Fill in the appropriate map entry with the values.
		 */
		pinfo->pinfo_map[index].dkl_cylno = val1;
		pinfo->pinfo_map[index].dkl_nblk = val2;
		pinfo->vtoc.v_part[index].p_tag = vtoc_tag;
		pinfo->vtoc.v_part[index].p_flag = vtoc_flag;

#if defined(_SUNOS_VTOC_16)
		pinfo->vtoc.v_part[index].p_start = val1 * (nhead * nsect);
		pinfo->vtoc.v_part[index].p_size = val2;

		if (val2 == 0) {
			pinfo->vtoc.v_part[index].p_tag = 0;
			pinfo->vtoc.v_part[index].p_flag = 0;
			pinfo->vtoc.v_part[index].p_start = 0;
			pinfo->pinfo_map[index].dkl_cylno = 0;
		}
#endif /* defined(_SUNOS_VTOC_16) */

	}
	/*
	 * Check to be sure that all necessary attributes were defined.
	 */
	if ((flags & SUP_MIN_PART) != SUP_MIN_PART) {
		datafile_error("Incomplete specification", "");
		return;
	}
	/*
	 * Add this partition map to the list of known maps for the
	 * specified disk/ctlr.
	 */
	parts = dtype->dtype_plist;
	if (parts == NULL)
		dtype->dtype_plist = pinfo;
	else {
		while (parts->pinfo_next != NULL)
			parts = parts->pinfo_next;
		parts->pinfo_next = pinfo;
	}
}

/*
 * Open the disk device - just a wrapper for open.
 */
int
open_disk(char *diskname, int flags)
{
	return (open(diskname, flags));
}

/*
 * This routine performs the disk search during startup.  It looks for
 * all the disks in the search path, and creates a list of those that
 * are found.
 */
void
do_search(char *arglist[])
{
	char			**sp;
	DIR			*dir;
	struct dirent		*dp;
	char			s[MAXPATHLEN];
	char			path[MAXPATHLEN];
	char			curdir[MAXPATHLEN];
	char			*directory = "/dev/rdsk";
	struct disk_info	*disk;
	int			i;

	/*
	 * Change directory to the device directory.  This
	 * gives us the most efficient access to that directory.
	 * Remember where we were, and return there when finished.
	 */
	if (getcwd(curdir, sizeof (curdir)) == NULL) {
		err_print("Cannot get current directory - %s\n",
			strerror(errno));
		fullabort();
	}
	if (chdir(directory) == -1) {
		err_print("Cannot set directory to %s - %s\n",
			directory, strerror(errno));
		fullabort();
	}

	/*
	 * If there were disks specified on the command line,
	 * use those disks, and nothing but those disks.
	 */
	if (arglist != NULL) {
		check_for_duplicate_disknames(arglist);
		for (; *arglist != NULL; arglist++) {
			search_for_logical_dev(*arglist);
		}
	} else {
		/*
		 * If there were no disks specified on the command line,
		 * search for all disks attached to the system.
		 */
		fmt_print("Searching for disks...");
		(void) fflush(stdout);
		need_newline = 1;

		/*
		 * Find all disks specified in search_path definitions
		 * in whatever format.dat files were processed.
		 */
		sp = search_path;
		if (sp != NULL) {
			while (*sp != NULL) {
				search_for_logical_dev(*sp++);
			}
		}

		/*
		 * Open the device directory
		 */
		if ((dir = opendir(".")) == NULL) {
			err_print("Cannot open %s - %s\n",
				directory, strerror(errno));
			fullabort();
		}

		/*
		 * Now find all usable nodes in /dev/rdsk (or /dev, if 4.x)
		 * First find all nodes which do not conform to
		 * standard disk naming conventions.  This permits
		 * all user-defined names to override the default names.
		 */
		while ((dp = readdir(dir)) != NULL) {
			if (strcmp(dp->d_name, ".") == 0 ||
						strcmp(dp->d_name, "..") == 0)
				continue;
			if (!conventional_name(dp->d_name)) {
			    if (!fdisk_physical_name(dp->d_name)) {
				/*
				 * If non-conventional name represents
				 * a link to non-s2 slice , ignore it.
				 */
				    if (!name_represents_wholedisk
						(dp->d_name)) {
					(void) strcpy(path, directory);
					(void) strcat(path, "/");
					(void) strcat(path, dp->d_name);
					add_device_to_disklist(dp->d_name,
							path);
				    }
			    }
			}

		}
		rewinddir(dir);


		/*
		 * Now find all nodes corresponding to the standard
		 * device naming conventions.
		 */
		while ((dp = readdir(dir)) != NULL) {
			if (strcmp(dp->d_name, ".") == 0 ||
						strcmp(dp->d_name, "..") == 0)
				continue;
			if (whole_disk_name(dp->d_name)) {
				(void) strcpy(path, directory);
				(void) strcat(path, "/");
				(void) strcat(path, dp->d_name);
				canonicalize_name(s, dp->d_name);
				add_device_to_disklist(s, path);
			}
		}
		/*
		 * Close the directory
		 */
		if (closedir(dir) == -1) {
			err_print("Cannot close directory %s - %s\n",
				directory, strerror(errno));
			fullabort();
		}

		need_newline = 0;
		fmt_print("done\n");
	}

	/*
	 * Return to whence we came
	 */
	if (chdir(curdir) == -1) {
		err_print("Cannot set directory to %s - %s\n",
			curdir, strerror(errno));
		fullabort();
	}

	/*
	 * If we didn't find any disks, give up.
	 */
	if (disk_list == NULL) {
		if (geteuid() == 0) {
			err_print("No disks found!\n");
		} else {
			err_print("No permission (or no disks found)!\n");
		}
		(void) fflush(stdout);
		fullabort();
	}

	sort_disk_list();

	/*
	 * Tell user the results of the auto-configure process
	 */
	i = 0;
	for (disk = disk_list; disk != NULL; disk = disk->disk_next) {
		float			scaled;
		long			nblks;
		struct disk_type	*type;
		if (disk->disk_flags & DSK_AUTO_CONFIG) {
			if (i++ == 0) {
				fmt_print("\n");
			}
			fmt_print("%s: ", disk->disk_name);
			if (disk->disk_flags & DSK_LABEL_DIRTY) {
				fmt_print("configured ");
			} else {
				fmt_print("configured and labeled ");
			}
			type = disk->disk_type;
			nblks = type->dtype_ncyl * type->dtype_nhead *
				type->dtype_nsect;
			if (disk->label_type == L_TYPE_SOLARIS)
			    scaled = bn2mb(nblks);
			else
			    scaled = bn2mb(type->capacity);
			fmt_print("with capacity of ");
			if (scaled > 1024.0) {
				fmt_print("%1.2fGB\n", scaled/1024.0);
			} else {
				fmt_print("%1.2fMB\n", scaled);
			}
		}
	}
}


/*
 * For a given "logical" disk name as specified in a format.dat
 * search path, try to find the device it actually refers to.
 * Since we are trying to maintain 4.x naming convention
 * compatibility in 5.0, this involves a little bit of work.
 * We also want to be able to function under 4.x, if needed.
 *
 * canonical:	standard name reference.  append a partition
 *	reference, and open that file in the device directory.
 *	examples:	SVR4:	c0t0d0
 *			4.x:	sd0
 *
 * absolute:	begins with a '/', and is assumed to be an
 *	absolute pathname to some node.
 *
 * relative:	non-canonical, doesn't begin with a '/'.
 *	assumed to be the name of a file in the appropriate
 *	device directory.
 */
static void
search_for_logical_dev(char *devname)
{
	char		path[MAXPATHLEN];
	char		*directory = "/dev/rdsk/";
	char		*partition = "s2";

	/*
	 * If the name is an absolute path name, accept it as is
	 */
	if (*devname == '/') {
		(void) strcpy(path, devname);
	} else if (canonical_name(devname)) {
		/*
		 * If canonical name, construct a standard path name.
		 */
		(void) strcpy(path, directory);
		(void) strcat(path, devname);
		(void) strcat(path, partition);
	} else if (canonical4x_name(devname)) {
		/*
		 * Check to see if it's a 4.x file name in the /dev
		 * directory on 5.0.  Here, we only accept the
		 * canonicalized form: sd0.
		 */
		(void) strcpy(path, "/dev/r");
		(void) strcat(path, devname);
		(void) strcat(path, "c");
	} else {
		/*
		 * If it's not a canonical name, then it may be a
		 * reference to an actual file name in the device
		 * directory itself.
		 */
		(void) strcpy(path, directory);
		(void) strcat(path, devname);
	}

	/* now add the device */
	add_device_to_disklist(devname, path);
}


/*
 * Add a device to the disk list, if it appears to be a disk,
 * and we haven't already found it under some other name.
 */
static void
add_device_to_disklist(char *devname, char *devpath)
{
	struct disk_info	*search_disk;
	struct ctlr_info	*search_ctlr;
	struct disk_type	*search_dtype, *efi_disk;
	struct partition_info	*search_parts;
	struct disk_info	*dptr;
	struct ctlr_info	*cptr;
	struct disk_type	*type;
	struct partition_info	*parts;
	struct dk_label		search_label;
	struct dk_cinfo		dkinfo;
	struct stat		stbuf;
	struct ctlr_type	*ctlr, *tctlr;
	struct	mctlr_list	*mlp;
	struct	efi_info	efi_info;
	int			search_file;
	int			status;
	int			i;
	int			access_flags = 0;

	/*
	 * Attempt to open the disk.  If it fails, skip it.
	 */
	if ((search_file = open_disk(devpath, O_RDWR | O_NDELAY)) < 0) {
		return;
	}
	/*
	 * Must be a character device
	 */
	if (fstat(search_file, &stbuf) == -1 || !S_ISCHR(stbuf.st_mode)) {
		(void) close(search_file);
		return;
	}
	/*
	 * Attempt to read the configuration info on the disk.
	 * Again, if it fails, we assume the disk's not there.
	 * Note we must close the file for the disk before we
	 * continue.
	 */
	if (ioctl(search_file, DKIOCINFO, &dkinfo) < 0) {
		(void) close(search_file);
		return;
	}

	/* If it is a removable media, skip it. */

	if (!expert_mode) {
		int isremovable, ret;
		ret = ioctl(search_file, DKIOCREMOVABLE, &isremovable);
		if ((ret >= 0) && (isremovable != 0)) {
			(void) close(search_file);
			return;
		}
	}

	/*
	 * If the type of disk is one we don't know about,
	 * add it to the list.
	 */
	mlp = controlp;

	while (mlp != NULL) {
		if (mlp->ctlr_type->ctype_ctype == dkinfo.dki_ctype &&
		    strcmp(mlp->ctlr_type->ctype_name, dkinfo.dki_cname) == 0) {
			break;
		}
		mlp = mlp->next;
	}

	if (mlp == NULL) {
		/*
		 * Skip CDROM devices, they are read only.
		 *	Also skip PCMCIA memory card device since
		 *	it is used as a pseudo floppy disk drive
		 *	at the present time (BugID 1201473)
		 */
		if ((dkinfo.dki_ctype == DKC_CDROM) ||
		    (dkinfo.dki_ctype == DKC_PCMCIA_MEM)) {
			(void) close(search_file);
			return;
		}
		/*
		 * create the new ctlr_type structure and fill it in.
		 */
		tctlr = zalloc(sizeof (struct ctlr_type));
		tctlr->ctype_ctype = dkinfo.dki_ctype;
		tctlr->ctype_name = zalloc(DK_DEVLEN);
		if (strlcpy(tctlr->ctype_name, dkinfo.dki_cname,
			DK_DEVLEN) > DK_DEVLEN) {
			/*
			 * DKIOCINFO returned a controller name longer
			 * than DK_DEVLEN bytes, which means more of the
			 * dk_cinfo structure may be corrupt.  We don't
			 * allow the user to perform any operations on
			 * the device in this case
			 */
			err_print("\nError: Device %s: controller "
			    "name (%s)\nis invalid.  Device will not "
			    "be displayed.\n", devname, dkinfo.dki_cname);
			(void) close(search_file);
			destroy_data(tctlr->ctype_name);
			destroy_data((char *)tctlr);
			return;
		} else {
			tctlr->ctype_ops = zalloc(sizeof (struct ctlr_ops));

			/*
			 * copy the generic disk ops structure into local copy.
			 */
			*(tctlr->ctype_ops) = genericops;

			tctlr->ctype_flags = CF_WLIST;

			mlp = controlp;

			while (mlp->next != NULL) {
				mlp = mlp->next;
			}

			mlp->next = zalloc(sizeof (struct mctlr_list));
			mlp->next->ctlr_type = tctlr;
		}
	}

	/*
	 * Search through all disks known at this time, to
	 * determine if we're already identified this disk.
	 * If so, then there's no need to include it a
	 * second time.  This permits the user-defined names
	 * to supercede the standard conventional names.
	 */
	if (disk_is_known(&dkinfo)) {
		(void) close(search_file);
		return;
	}
#if defined(sparc)
	/*
	 * Because opening id with FNDELAY always succeeds,
	 * read the label early on to see whether the device
	 * really exists.  A result of DSK_RESERVED
	 * means the disk may be reserved.
	 * In the future, it will be good
	 * to move these into controller specific files and have a common
	 * generic check for reserved disks here, including intel disks.
	 */
	if (dkinfo.dki_ctype == DKC_SCSI_CCS) {
		i = scsi_rdwr(DIR_READ, search_file, (daddr_t)0,
			1, (char *)&search_label, F_SILENT, NULL);
		switch (i) {
		case DSK_RESERVED:
			access_flags |= DSK_RESERVED;
			break;
		case DSK_UNAVAILABLE:
			access_flags |= DSK_UNAVAILABLE;
			break;
		default:
			break;
		}
	}
#endif /* defined(sparc) */

	/*
	 * The disk appears to be present.  Allocate space for the
	 * disk structure and add it to the list of found disks.
	 */
	search_disk = (struct disk_info *)zalloc(sizeof (struct disk_info));
	if (disk_list == NULL)
		disk_list = search_disk;
	else {
		for (dptr = disk_list; dptr->disk_next != NULL;
		    dptr = dptr->disk_next)
			;
		dptr->disk_next = search_disk;
	}
	/*
	 * Fill in some info from the ioctls.
	 */
	search_disk->disk_dkinfo = dkinfo;
	if (is_efi_type(search_file)) {
		search_disk->label_type = L_TYPE_EFI;
	} else {
		search_disk->label_type = L_TYPE_SOLARIS;
	}
	/*
	 * Remember the names of the disk
	 */
	search_disk->disk_name = alloc_string(devname);
	search_disk->disk_path = alloc_string(devpath);

	(void) strcpy(x86_devname, devname);

	/*
	 * Determine if this device is linked to a physical name.
	 */
	search_disk->devfs_name = get_physical_name(devpath);

	/*
	 * Try to match the ctlr for this disk with a ctlr we
	 * have already found.  A match is assumed if the ctlrs
	 * are at the same address && ctypes agree
	 */
	for (search_ctlr = ctlr_list; search_ctlr != NULL;
	    search_ctlr = search_ctlr->ctlr_next)
		if (search_ctlr->ctlr_addr == dkinfo.dki_addr &&
		    search_ctlr->ctlr_space == dkinfo.dki_space &&
			search_ctlr->ctlr_ctype->ctype_ctype ==
				dkinfo.dki_ctype)
			break;
	/*
	 * If no match was found, we need to identify this ctlr.
	 */
	if (search_ctlr == NULL) {
		/*
		 * Match the type of the ctlr to a known type.
		 */
		mlp = controlp;

		while (mlp != NULL) {
			if (mlp->ctlr_type->ctype_ctype == dkinfo.dki_ctype)
				break;
			mlp = mlp->next;
		}
		/*
		 * If no match was found, it's an error.
		 * Close the disk and report the error.
		 */
		if (mlp == NULL) {
			err_print("\nError: found disk attached to ");
			err_print("unsupported controller type '%d'.\n",
			    dkinfo.dki_ctype);
			(void) close(search_file);
			return;
		}
		/*
		 * Allocate space for the ctlr structure and add it
		 * to the list of found ctlrs.
		 */
		search_ctlr = (struct ctlr_info *)
			zalloc(sizeof (struct ctlr_info));
		search_ctlr->ctlr_ctype = mlp->ctlr_type;
		if (ctlr_list == NULL)
			ctlr_list = search_ctlr;
		else {
			for (cptr = ctlr_list; cptr->ctlr_next != NULL;
			    cptr = cptr->ctlr_next)
				;
			cptr->ctlr_next = search_ctlr;
		}
		/*
		 * Fill in info from the ioctl.
		 */
		for (i = 0; i < DK_DEVLEN; i++) {
			search_ctlr->ctlr_cname[i] = dkinfo.dki_cname[i];
			search_ctlr->ctlr_dname[i] = dkinfo.dki_dname[i];
		}
		/*
		 * Make sure these can be used as simple strings
		 */
		search_ctlr->ctlr_cname[i] = 0;
		search_ctlr->ctlr_dname[i] = 0;

		search_ctlr->ctlr_flags = dkinfo.dki_flags;
		search_ctlr->ctlr_num = dkinfo.dki_cnum;
		search_ctlr->ctlr_addr = dkinfo.dki_addr;
		search_ctlr->ctlr_space = dkinfo.dki_space;
		search_ctlr->ctlr_prio = dkinfo.dki_prio;
		search_ctlr->ctlr_vec = dkinfo.dki_vec;
	}
	/*
	 * By this point, we have a known ctlr.  Link the disk
	 * to the ctlr.
	 */
	search_disk->disk_ctlr = search_ctlr;
	if (access_flags & (DSK_RESERVED | DSK_UNAVAILABLE)) {
		if (access_flags & DSK_RESERVED)
			search_disk->disk_flags |= DSK_RESERVED;
		else
			search_disk->disk_flags |= DSK_UNAVAILABLE;
		(void) close(search_file);
		return;
	} else {
		search_disk->disk_flags &= ~(DSK_RESERVED | DSK_UNAVAILABLE);
	}

	/*
	 * Attempt to read the primary label.
	 * (Note that this is really through the DKIOCGVTOC
	 * ioctl, then converted from vtoc to label.)
	 */
	if (search_disk->label_type == L_TYPE_SOLARIS) {
		status = read_label(search_file, &search_label);
	} else {
		status = read_efi_label(search_file, &efi_info);
	}
	/*
	 * If reading the label failed, and this is a SCSI
	 * disk, we can attempt to auto-sense the disk
	 * configuration.
	 */
	ctlr = search_ctlr->ctlr_ctype;
	if ((status == -1) && (ctlr->ctype_ctype == DKC_SCSI_CCS)) {
	    if (option_msg && diag_msg) {
		err_print("%s: attempting auto configuration\n",
		    search_disk->disk_name);
	    }
	    switch (search_disk->label_type) {
	    case (L_TYPE_SOLARIS):
		if (auto_sense(search_file, 0, &search_label) != NULL) {
		/*
		 * Auto config worked, so we now have
		 * a valid label for the disk.  Mark
		 * the disk as needing the label flushed.
		 */
			status = 0;
			search_disk->disk_flags |=
			    (DSK_LABEL_DIRTY | DSK_AUTO_CONFIG);
		}
		break;
	    case (L_TYPE_EFI):
		efi_disk = auto_efi_sense(search_file, &efi_info);
		if (efi_disk != NULL) {
		/*
		 * Auto config worked, so we now have
		 * a valid label for the disk.
		 */
			status = 0;
			search_disk->disk_flags |=
			    (DSK_LABEL_DIRTY | DSK_AUTO_CONFIG);
		}
		break;
	    default:
		    /* Should never happen */
		break;
	    }
	}
	/*
	 * Close the file for this disk.
	 */
	(void) close(search_file);
	/*
	 * If we didn't successfully read the label, or the label
	 * appears corrupt, just leave the disk as an unknown type.
	 */
	if (status == -1) {
		return;
	}

	if (search_disk->label_type == L_TYPE_SOLARIS) {
		if (!checklabel(&search_label)) {
			return;
		}
		if (trim_id(search_label.dkl_asciilabel)) {
			return;
		}
	}
	/*
	 * The label looks ok.  Mark the disk as labeled.
	 */
	search_disk->disk_flags |= DSK_LABEL;

	if (search_disk->label_type == L_TYPE_EFI) {
		search_dtype = (struct disk_type *)
		    zalloc(sizeof (struct disk_type));
		type = search_ctlr->ctlr_ctype->ctype_dlist;
		if (type == NULL) {
			search_ctlr->ctlr_ctype->ctype_dlist =
			    search_dtype;
		} else {
			while (type->dtype_next != NULL) {
				type = type->dtype_next;
			}
			type->dtype_next = search_dtype;
		}

		(void) strlcpy(search_dtype->vendor, efi_info.vendor, 9);
		(void) strlcpy(search_dtype->product, efi_info.product, 17);
		(void) strlcpy(search_dtype->revision, efi_info.revision, 5);
		search_dtype->capacity = efi_info.capacity;
		search_disk->disk_type = search_dtype;

		search_parts = (struct partition_info *)
		    zalloc(sizeof (struct partition_info));
		search_dtype->dtype_plist = search_parts;

		search_parts->pinfo_name = alloc_string("original");
		search_parts->pinfo_next = NULL;
		search_parts->etoc = efi_info.e_parts;
		search_disk->disk_parts = search_parts;

		/*
		 * Copy the volume name, if present
		 */
		for (i = 0; i < search_parts->etoc->efi_nparts; i++) {
		    if (search_parts->etoc->efi_parts[i].p_tag ==
			V_RESERVED) {
			    if (search_parts->etoc->efi_parts[i].p_name) {
				bcopy(search_parts->etoc->efi_parts[i].p_name,
				    search_disk->v_volume, LEN_DKL_VVOL);
			    } else {
				bzero(search_disk->v_volume, LEN_DKL_VVOL);
			    }
			    break;
		    }
		}
		return;
	}

	/*
	 * Attempt to match the disk type in the label with a
	 * known disk type.
	 */
	for (search_dtype = search_ctlr->ctlr_ctype->ctype_dlist;
	    search_dtype != NULL;
	    search_dtype = search_dtype->dtype_next)
		if (dtype_match(&search_label, search_dtype))
			break;
	/*
	 * If no match was found, we need to create a disk type
	 * for this disk.
	 */
	if (search_dtype == NULL) {
		/*
		 * Allocate space for the disk type and add it
		 * to the list of disk types for this ctlr type.
		 */
		search_dtype = (struct disk_type *)
		    zalloc(sizeof (struct disk_type));
		type = search_ctlr->ctlr_ctype->ctype_dlist;
		if (type == NULL)
			search_ctlr->ctlr_ctype->ctype_dlist =
			    search_dtype;
		else {
			while (type->dtype_next != NULL)
				type = type->dtype_next;
			type->dtype_next = search_dtype;
		}
		/*
		 * Fill in the drive info from the disk label.
		 */
		search_dtype->dtype_next = NULL;
		search_dtype->dtype_asciilabel = (char *)
		    zalloc(strlen(search_label.dkl_asciilabel) + 1);
		(void) strcpy(search_dtype->dtype_asciilabel,
		    search_label.dkl_asciilabel);
		search_dtype->dtype_pcyl = search_label.dkl_pcyl;
		search_dtype->dtype_ncyl = search_label.dkl_ncyl;
		search_dtype->dtype_acyl = search_label.dkl_acyl;
		search_dtype->dtype_nhead = search_label.dkl_nhead;
		search_dtype->dtype_nsect = search_label.dkl_nsect;
		search_dtype->dtype_rpm = search_label.dkl_rpm;
		/*
		 * Mark the disk as needing specification of
		 * ctlr specific attributes.  This is necessary
		 * because the label doesn't contain these attributes,
		 * and they aren't known at this point.  They will
		 * be asked for if this disk is ever selected by
		 * the user.
		 * Note: for SCSI, we believe the label.
		 */
		if ((search_ctlr->ctlr_ctype->ctype_ctype != DKC_SCSI_CCS) &&
		    (search_ctlr->ctlr_ctype->ctype_ctype != DKC_DIRECT) &&
		    (search_ctlr->ctlr_ctype->ctype_ctype != DKC_PCMCIA_ATA)) {
			search_dtype->dtype_flags |= DT_NEED_SPEFS;
		}
	}
	/*
	 * By this time we have a known disk type.  Link the disk
	 * to the disk type.
	 */
	search_disk->disk_type = search_dtype;
	/*
	 * Attempt to match the partition map in the label with
	 * a known partition map for this disk type.
	 */
	for (search_parts = search_dtype->dtype_plist;
	    search_parts != NULL;
	    search_parts = search_parts->pinfo_next)
		if (parts_match(&search_label, search_parts)) {
			break;
		}
	/*
	 * If no match was made, we need to create a partition
	 * map for this disk.
	 */
	if (search_parts == NULL) {
		/*
		 * Allocate space for the partition map and add
		 * it to the list of maps for this disk type.
		 */
		search_parts = (struct partition_info *)
		    zalloc(sizeof (struct partition_info));
		parts = search_dtype->dtype_plist;
		if (parts == NULL)
			search_dtype->dtype_plist = search_parts;
		else {
			while (parts->pinfo_next != NULL)
				parts = parts->pinfo_next;
			parts->pinfo_next = search_parts;
		}
		search_parts->pinfo_next = NULL;
		/*
		 * Fill in the name of the map with a name derived
		 * from the name of this disk.  This is necessary
		 * because the label contains no name for the
		 * partition map.
		 */
		search_parts->pinfo_name = alloc_string("original");
		/*
		 * Fill in the partition info from the disk label.
		 */
		for (i = 0; i < NDKMAP; i++) {

#if defined(_SUNOS_VTOC_8)
			search_parts->pinfo_map[i] =
			    search_label.dkl_map[i];

#elif defined(_SUNOS_VTOC_16)
			search_parts->pinfo_map[i].dkl_cylno =
			    search_label.dkl_vtoc.v_part[i].p_start /
			    ((int)(search_label.dkl_nhead *
			    search_label.dkl_nsect));
			search_parts->pinfo_map[i].dkl_nblk =
			    search_label.dkl_vtoc.v_part[i].p_size;

#else
#error No VTOC format defined.
#endif
		}
	}
	/*
	 * If the vtoc looks valid, copy the volume name and vtoc
	 * info from the label.  Otherwise, install a default vtoc.
	 * This permits vtoc info to automatically appear in the sun
	 * label, without requiring an upgrade procedure.
	 */
	if (search_label.dkl_vtoc.v_version == V_VERSION) {
		bcopy(search_label.dkl_vtoc.v_volume,
			search_disk->v_volume, LEN_DKL_VVOL);
		search_parts->vtoc = search_label.dkl_vtoc;
	} else {
		bzero(search_disk->v_volume, LEN_DKL_VVOL);
		set_vtoc_defaults(search_parts);
	}
	/*
	 * By this time we have a known partitition map.  Link the
	 * disk to the partition map.
	 */
	search_disk->disk_parts = search_parts;
}


/*
 * Search the disk list for a disk with the identical configuration.
 * Return true if one is found.
 */
static int
disk_is_known(struct dk_cinfo *dkinfo)
{
	struct disk_info	*dp;

	dp = disk_list;
	while (dp != NULL) {
		if (dp->disk_dkinfo.dki_ctype == dkinfo->dki_ctype &&
			dp->disk_dkinfo.dki_cnum == dkinfo->dki_cnum &&
			dp->disk_dkinfo.dki_unit == dkinfo->dki_unit &&
				strcmp(dp->disk_dkinfo.dki_dname,
					dkinfo->dki_dname) == 0) {
			return (1);
		}
		dp = dp->disk_next;
	}
	return (0);
}


/*
 * This routine checks to see if a given disk type matches the type
 * in the disk label.
 */
int
dtype_match(label, dtype)
	register struct dk_label *label;
	register struct disk_type *dtype;
{

	if (dtype->dtype_asciilabel == NULL) {
	    return (0);
	}

	/*
	 * If the any of the physical characteristics are different, or
	 * the name is different, it doesn't match.
	 */
	if ((strcmp(label->dkl_asciilabel, dtype->dtype_asciilabel) != 0) ||
	    (label->dkl_ncyl != dtype->dtype_ncyl) ||
	    (label->dkl_acyl != dtype->dtype_acyl) ||
	    (label->dkl_nhead != dtype->dtype_nhead) ||
	    (label->dkl_nsect != dtype->dtype_nsect)) {
		return (0);
	}
	/*
	 * If those are all identical, assume it's a match.
	 */
	return (1);
}

/*
 * This routine checks to see if a given partition map matches the map
 * in the disk label.
 */
int
parts_match(label, pinfo)
	register struct dk_label *label;
	register struct partition_info *pinfo;
{
	int i;

	/*
	 * If any of the partition entries is different, it doesn't match.
	 */
	for (i = 0; i < NDKMAP; i++)

#if defined(_SUNOS_VTOC_8)
		if ((label->dkl_map[i].dkl_cylno !=
		    pinfo->pinfo_map[i].dkl_cylno) ||
		    (label->dkl_map[i].dkl_nblk !=
		    pinfo->pinfo_map[i].dkl_nblk))

#elif defined(_SUNOS_VTOC_16)
		if ((pinfo->pinfo_map[i].dkl_cylno !=
		    label->dkl_vtoc.v_part[i].p_start /
		    (label->dkl_nhead * label->dkl_nsect)) ||
		    (pinfo->pinfo_map[i].dkl_nblk !=
		    label->dkl_vtoc.v_part[i].p_size))
#else
#error No VTOC format defined.
#endif
			return (0);
	/*
	 * Compare the vtoc information for a match
	 * Do not require the volume name to be equal, for a match!
	 */
	if (label->dkl_vtoc.v_version != pinfo->vtoc.v_version)
		return (0);
	if (label->dkl_vtoc.v_nparts != pinfo->vtoc.v_nparts)
		return (0);
	for (i = 0; i < NDKMAP; i++) {
		if (label->dkl_vtoc.v_part[i].p_tag !=
				pinfo->vtoc.v_part[i].p_tag)
			return (0);
		if (label->dkl_vtoc.v_part[i].p_flag !=
				pinfo->vtoc.v_part[i].p_flag)
			return (0);
	}
	/*
	 * If they are all identical, it's a match.
	 */
	return (1);
}

/*
 * This routine checks to see if the given disk name refers to the disk
 * in the given disk structure.
 */
int
diskname_match(char *name, struct disk_info *disk)
{
	struct dk_cinfo		dkinfo;
	char			s[MAXPATHLEN];
	int			fd;

	/*
	 * Match the name of the disk in the disk_info structure
	 */
	if (strcmp(name, disk->disk_name) == 0) {
		return (1);
	}

	/*
	 * Check to see if it's a 4.x file name in the /dev
	 * directory on 5.0.  Here, we only accept the
	 * canonicalized form: sd0.
	 */
	if (canonical4x_name(name) == 0) {
		return (0);
	}

	(void) strcpy(s, "/dev/r");
	(void) strcat(s, name);
	(void) strcat(s, "c");

	if ((fd = open_disk(s, O_RDWR | O_NDELAY)) < 0) {
		return (0);
	}

	if (ioctl(fd, DKIOCINFO, &dkinfo) < 0) {
		(void) close(fd);
		return (0);
	}
	(void) close(fd);

	if (disk->disk_dkinfo.dki_ctype == dkinfo.dki_ctype &&
		disk->disk_dkinfo.dki_cnum == dkinfo.dki_cnum &&
			disk->disk_dkinfo.dki_unit == dkinfo.dki_unit &&
				strcmp(disk->disk_dkinfo.dki_dname,
					dkinfo.dki_dname) == 0) {
		return (1);
	}
	return (0);
}


static void
datafile_error(char *errmsg, char *token)
{
	int	token_type;
	TOKEN	token_buf;

	/*
	 * Allow us to get by controllers that the other platforms don't
	 * know about.
	 */
	if (errmsg != NULL) {
		err_print(errmsg, token);
		err_print(" - %s (%d)\n", file_name, data_lineno);
	}

	/*
	 * Re-sync the parsing at the beginning of the next line
	 * unless of course we're already there.
	 */
	if (last_token_type != SUP_EOF && last_token_type != SUP_EOL) {
		do {
			token_type = sup_gettoken(token_buf);
		} while (token_type != SUP_EOF && token_type != SUP_EOL);

		if (token_type == SUP_EOF) {
			sup_pushtoken(token_buf, token_type);
		}
	}
}


/*
 * Search through all defined disk types for duplicate entries
 * that are inconsistent with each other.  Disks with different
 * characteristics should be named differently.
 * Note that this function only checks for duplicate disks
 * for the same controller.  It's possible to have two disks with
 * the same name, but defined for different controllers.
 * That may or may not be a problem...
 */
static void
search_duplicate_dtypes()
{
	struct disk_type	*dp1;
	struct disk_type	*dp2;
	struct mctlr_list	*mlp;

	mlp = controlp;

	while (mlp != NULL) {
		dp1 = mlp->ctlr_type->ctype_dlist;
		while (dp1 != NULL) {
			dp2 = dp1->dtype_next;
			while (dp2 != NULL) {
				check_dtypes_for_inconsistency(dp1, dp2);
				dp2 = dp2->dtype_next;
			}
			dp1 = dp1->dtype_next;
		}
	mlp = mlp->next;
	}
}


/*
 * Search through all defined partition types for duplicate entries
 * that are inconsistent with each other.  Partitions with different
 * characteristics should be named differently.
 * Note that this function only checks for duplicate partitions
 * for the same disk.  It's possible to have two partitions with
 * the same name, but defined for different disks.
 * That may or may not be a problem...
 */
static void
search_duplicate_pinfo()
{
	struct disk_type	*dp;
	struct partition_info	*pp1;
	struct partition_info	*pp2;
	struct mctlr_list	*mlp;

	mlp = controlp;

	while (mlp != NULL) {
		dp = mlp->ctlr_type->ctype_dlist;
		while (dp != NULL) {
			pp1 = dp->dtype_plist;
			while (pp1 != NULL) {
				pp2 = pp1->pinfo_next;
				while (pp2 != NULL) {
					check_pinfo_for_inconsistency(pp1, pp2);
					pp2 = pp2->pinfo_next;
				}
				pp1 = pp1->pinfo_next;
			}
			dp = dp->dtype_next;
		}
	mlp = mlp->next;
	}
}


/*
 * Determine if two particular disk definitions are inconsistent.
 * Ie:  same name, but different characteristics.
 * If so, print an error message and abort.
 */
static void
check_dtypes_for_inconsistency(dp1, dp2)
	struct disk_type	*dp1;
	struct disk_type	*dp2;
{
	int		i;
	int		result;
	struct chg_list	*cp1;
	struct chg_list	*cp2;


	/*
	 * If the name's different, we're ok
	 */
	if (strcmp(dp1->dtype_asciilabel, dp2->dtype_asciilabel) != 0) {
		return;
	}

	/*
	 * Compare all the disks' characteristics
	 */
	result = 0;
	result |= (dp1->dtype_flags != dp2->dtype_flags);
	result |= (dp1->dtype_options != dp2->dtype_options);
	result |= (dp1->dtype_fmt_time != dp2->dtype_fmt_time);
	result |= (dp1->dtype_bpt != dp2->dtype_bpt);
	result |= (dp1->dtype_ncyl != dp2->dtype_ncyl);
	result |= (dp1->dtype_acyl != dp2->dtype_acyl);
	result |= (dp1->dtype_pcyl != dp2->dtype_pcyl);
	result |= (dp1->dtype_nhead != dp2->dtype_nhead);
	result |= (dp1->dtype_nsect != dp2->dtype_nsect);
	result |= (dp1->dtype_rpm != dp2->dtype_rpm);
	result |= (dp1->dtype_cyl_skew != dp2->dtype_cyl_skew);
	result |= (dp1->dtype_trk_skew != dp2->dtype_trk_skew);
	result |= (dp1->dtype_trks_zone != dp2->dtype_trks_zone);
	result |= (dp1->dtype_atrks != dp2->dtype_atrks);
	result |= (dp1->dtype_asect != dp2->dtype_asect);
	result |= (dp1->dtype_cache != dp2->dtype_cache);
	result |= (dp1->dtype_threshold != dp2->dtype_threshold);
	result |= (dp1->dtype_read_retries != dp2->dtype_read_retries);
	result |= (dp1->dtype_write_retries != dp2->dtype_write_retries);
	result |= (dp1->dtype_prefetch_min != dp2->dtype_prefetch_min);
	result |= (dp1->dtype_prefetch_max != dp2->dtype_prefetch_max);
	for (i = 0; i < NSPECIFICS; i++) {
		result |= (dp1->dtype_specifics[i] != dp2->dtype_specifics[i]);
	}

	cp1 = dp1->dtype_chglist;
	cp2 = dp2->dtype_chglist;
	while (cp1 != NULL && cp2 != NULL) {
		if (cp1 == NULL || cp2 == NULL) {
			result = 1;
			break;
		}
		result |= (cp1->pageno != cp2->pageno);
		result |= (cp1->byteno != cp2->byteno);
		result |= (cp1->mode != cp2->mode);
		result |= (cp1->value != cp2->value);
		cp1 = cp1->next;
		cp2 = cp2->next;
	}

	if (result) {
		err_print("Inconsistent definitions for disk type '%s'\n",
			dp1->dtype_asciilabel);
		if (dp1->dtype_filename != NULL &&
					dp2->dtype_filename != NULL) {
			err_print("%s (%d) - %s (%d)\n",
				dp1->dtype_filename, dp1->dtype_lineno,
				dp2->dtype_filename, dp2->dtype_lineno);
			}
		fullabort();
	}
}


/*
 * Determine if two particular partition definitions are inconsistent.
 * Ie:  same name, but different characteristics.
 * If so, print an error message and abort.
 */
static void
check_pinfo_for_inconsistency(pp1, pp2)
	struct partition_info	*pp1;
	struct partition_info	*pp2;
{
	int		i;
	int		result;
	struct dk_map32	*map1;
	struct dk_map32	*map2;

#if defined(_SUNOS_VTOC_8)
	struct dk_map2	*vp1;
	struct dk_map2	*vp2;

#elif defined(_SUNOS_VTOC_16)
	struct dkl_partition    *vp1;
	struct dkl_partition    *vp2;
#else
#error No VTOC layout defined.
#endif /* defined(_SUNOS_VTOC_8) */

	/*
	 * If the name's different, we're ok
	 */
	if (strcmp(pp1->pinfo_name, pp2->pinfo_name) != 0) {
		return;
	}

	/*
	 * Compare all the partitions' characteristics
	 */
	result = 0;
	map1 = pp1->pinfo_map;
	map2 = pp2->pinfo_map;
	for (i = 0; i < NDKMAP; i++, map1++, map2++) {
		result |= (map1->dkl_cylno != map2->dkl_cylno);
		result |= (map1->dkl_nblk != map2->dkl_nblk);
	}

	/*
	 * Compare the significant portions of the vtoc information
	 */
	vp1 = pp1->vtoc.v_part;
	vp2 = pp2->vtoc.v_part;
	for (i = 0; i < NDKMAP; i++, vp1++, vp2++) {
		result |= (vp1->p_tag != vp2->p_tag);
		result |= (vp1->p_flag != vp2->p_flag);
	}

	if (result) {
		err_print("Inconsistent definitions for partition type '%s'\n",
			pp1->pinfo_name);
		if (pp1->pinfo_filename != NULL &&
					pp2->pinfo_filename != NULL) {
			err_print("%s (%d) - %s (%d)\n",
				pp1->pinfo_filename, pp1->pinfo_lineno,
				pp2->pinfo_filename, pp2->pinfo_lineno);
			}
		fullabort();
	}
}

/*
 * Convert a string of digits into a block number.
 * The digits are assumed to be a block number unless the
 * the string is terminated by 'c', in which case it is
 * assumed to be in units of cylinders.  Accept a 'b'
 * to explictly specify blocks, for consistency.
 *
 * NB: uses the macro spc(), which requires that the
 * globals nhead/nsect/acyl be set up correctly.
 *
 * Returns -1 in the case of an error.
 */
static int
str2blks(char *str)
{
	int	blks;
	char	*p;

	blks = (int)strtol(str, &p, 0);
	/*
	 * Check what terminated the conversion.
	 */
	if (*p != 0) {
		/*
		 * Units specifier of 'c': convert cylinders to blocks
		 */
		if (*p == 'c') {
			p++;
			blks = blks * spc();
		/*
		 * Ignore a 'b' specifier.
		 */
		} else if (*p == 'b') {
			p++;
		}
		/*
		 * Anthing left over is an error
		 */
		if (*p != 0) {
			blks = -1;
		}
	}

	return (blks);
}
/*
 * Convert a string of digits into a cylinder number.
 * Accept a an optional 'c' specifier, for consistency.
 *
 * Returns -1 in the case of an error.
 */
int
str2cyls(char *str)
{
	int	cyls;
	char	*p;

	cyls = (int)strtol(str, &p, 0);
	/*
	 * Check what terminated the conversion.
	 */
	if (*p != 0) {
		/*
		 * Units specifier of 'c': convert cylinders to blocks
		 */
		if (*p == 'c') {
			p++;
		}
		/*
		 * Anthing left over is an error
		 */
		if (*p != 0) {
			cyls = -1;
		}
	}

	return (cyls);
}


/*
 * Create a new chg_list structure, and append it onto the
 * end of the current chg_list under construction.  By
 * applying changes in the order in which listed in the
 * data file, the changes we make are deterministic.
 * Return a pointer to the new structure, so that the
 * caller can fill in the appropriate information.
 */
static struct chg_list *
new_chg_list(struct disk_type *disk)
{
	struct chg_list		*cp;
	struct chg_list		*nc;

	nc = zalloc(sizeof (struct chg_list));

	if (disk->dtype_chglist == NULL) {
		disk->dtype_chglist = nc;
	} else {
		for (cp = disk->dtype_chglist; cp->next; cp = cp->next)
			;
		cp->next = nc;
	}
	nc->next = NULL;
	return (nc);
}


/*
 * Follow symbolic links from the logical device name to
 * the /devfs physical device name.  To be complete, we
 * handle the case of multiple links.  This function
 * either returns NULL (no links, or some other error),
 * or the physical device name, alloc'ed on the heap.
 *
 * Note that the standard /devices prefix is stripped from
 * the final pathname, if present.  The trailing options
 * are also removed (":c, raw").
 */
static char *
get_physical_name(char *path)
{
	struct stat	stbuf;
	int		i;
	int		level;
	char		*p;
	char		s[MAXPATHLEN];
	char		buf[MAXPATHLEN];
	char		dir[MAXPATHLEN];
	char		savedir[MAXPATHLEN];
	char		*result = NULL;

	if (getcwd(savedir, sizeof (savedir)) == NULL) {
		err_print("getcwd() failed - %s\n", strerror(errno));
		return (NULL);
	}

	(void) strcpy(s, path);
	if ((p = strrchr(s, '/')) != NULL) {
		*p = 0;
	}
	if (s[0] == 0) {
		(void) strcpy(s, "/");
	}
	if (chdir(s) == -1) {
		err_print("cannot chdir() to %s - %s\n",
			s, strerror(errno));
		goto exit;
	}

	level = 0;
	(void) strcpy(s, path);
	for (;;) {
		/*
		 * See if there's a real file out there.  If not,
		 * we have a dangling link and we ignore it.
		 */
		if (stat(s, &stbuf) == -1) {
			goto exit;
		}
		if (lstat(s, &stbuf) == -1) {
			err_print("%s: lstat() failed - %s\n",
				s, strerror(errno));
			goto exit;
		}
		/*
		 * If the file is not a link, we're done one
		 * way or the other.  If there were links,
		 * return the full pathname of the resulting
		 * file.
		 */
		if (!S_ISLNK(stbuf.st_mode)) {
			if (level > 0) {
				/*
				 * Strip trailing options from the
				 * physical device name
				 */
				if ((p = strrchr(s, ':')) != NULL) {
					*p = 0;
				}
				/*
				 * Get the current directory, and
				 * glue the pieces together.
				 */
				if (getcwd(dir, sizeof (dir)) == NULL) {
					err_print("getcwd() failed - %s\n",
						strerror(errno));
					goto exit;
				}
				(void) strcat(dir, "/");
				(void) strcat(dir, s);
				/*
				 * If we have the standard fixed
				 * /devices prefix, remove it.
				 */
				p = (strstr(dir, DEVFS_PREFIX) == dir) ?
					dir+strlen(DEVFS_PREFIX) : dir;
				result = alloc_string(p);
			}
			goto exit;
		}
		i = readlink(s, buf, sizeof (buf));
		if (i == -1) {
			err_print("%s: readlink() failed - %s\n",
				s, strerror(errno));
			goto exit;
		}
		level++;
		buf[i] = 0;

		/*
		 * Break up the pathname into the directory
		 * reference, if applicable and simple filename.
		 * chdir()'ing to the directory allows us to
		 * handle links with relative pathnames correctly.
		 */
		(void) strcpy(dir, buf);
		if ((p = strrchr(dir, '/')) != NULL) {
			*p = 0;
			if (chdir(dir) == -1) {
				err_print("cannot chdir() to %s - %s\n",
					dir, strerror(errno));
				goto exit;
			}
			(void) strcpy(s, p+1);
		} else {
			(void) strcpy(s, buf);
		}
	}

exit:
	if (chdir(savedir) == -1) {
		err_print("cannot chdir() to %s - %s\n",
			savedir, strerror(errno));
	}

	return (result);
}


static void
sort_disk_list()
{
	int			n;
	struct disk_info	**disks;
	struct disk_info	*d;
	struct disk_info	**dp;
	struct disk_info	**dp2;

	/*
	 * Count the number of disks in the list
	 */
	n = 0;
	for (d = disk_list; d != NULL; d = d->disk_next) {
		n++;
	}
	if (n == 0) {
		return;
	}

	/*
	 * Allocate a simple disk list array and fill it in
	 */
	disks = (struct disk_info **)
		zalloc((n+1) * sizeof (struct disk_info *));

	dp = disks;
	for (d = disk_list; d != NULL; d = d->disk_next) {
		*dp++ = d;
	}
	*dp = NULL;

	/*
	 * Sort the disk list array
	 */
	qsort((void *) disks, n, sizeof (struct disk_info *),
		disk_name_compare);

	/*
	 * Rebuild the linked list disk list structure
	 */
	dp = disks;
	disk_list = *dp;
	dp2 = dp + 1;
	do {
		(*dp++)->disk_next = *dp2++;
	} while (*dp != NULL);

	/*
	 * Clean up
	 */
	(void) destroy_data((void *)disks);
}


/*
 * Compare two disk names
 */
static int
disk_name_compare(
	const void	*arg1,
	const void	*arg2)
{
	char		*s1;
	char		*s2;
	int		n1;
	int		n2;
	char		*p1;
	char		*p2;

	s1 = (*((struct disk_info **)arg1))->disk_name;
	s2 = (*((struct disk_info **)arg2))->disk_name;

	for (;;) {
		if (*s1 == 0 || *s2 == 0)
			break;
		if (isdigit(*s1) && isdigit(*s2)) {
			n1 = strtol(s1, &p1, 10);
			n2 = strtol(s2, &p2, 10);
			if (n1 != n2) {
				return (n1 - n2);
			}
			s1 = p1;
			s2 = p2;
		} else if (*s1 != *s2) {
			break;
		} else {
			s1++;
			s2++;
		}
	}

	return (*s1 - *s2);
}

static void
make_controller_list()
{
	int	x;
	struct	mctlr_list	*ctlrp;

	ctlrp = controlp;

	for (x = nctypes; x != 0; x--) {
		ctlrp = zalloc(sizeof (struct mctlr_list));
		ctlrp->next = controlp;
		ctlrp->ctlr_type = &ctlr_types[x - 1];
		controlp = ctlrp;

	}
}

static void
check_for_duplicate_disknames(arglist)
char *arglist[];
{
	char			*directory = "/dev/rdsk/";
	char			**disklist;
	int			len;
	char			s[MAXPATHLEN], t[MAXPATHLEN];
	int			diskno = 0;
	int			i;


	len = strlen(directory);
	disklist = arglist;
	for (; *disklist != NULL; disklist++) {
		if (strncmp(directory, *disklist, len) == 0) {
			/* Disk is in conventional format */
			canonicalize_name(s, *disklist);
			/*
			 *  check if the disk is already present in
			 *  disk list.
			 */
			for (i = 0; i < diskno; i++) {
			    canonicalize_name(t, arglist[i]);
			    if (strncmp(s, t, strlen(t)) == 0)
				break;
			}
			if (i != diskno)
				continue;
		}
		(void) strcpy(arglist[diskno], *disklist);
		diskno++;
	}
	arglist[diskno] = NULL;
}

#define	DISK_PREFIX	"/dev/rdsk/"

/*
 * This Function checks if the non-conventional name is a a link to
 * one of the conventional whole disk name.
 */
static int
name_represents_wholedisk(name)
char	*name;
{
	char	symname[MAXPATHLEN];
	char	localname[MAXPATHLEN];
	char	*nameptr;


	(void) memset(symname, 0, MAXPATHLEN);
	(void) memset(localname, 0, MAXPATHLEN);
	(void) strcpy(localname, name);

	while (readlink(localname, symname, MAXPATHLEN) != -1) {
		nameptr = symname;
		if (strncmp(symname, DISK_PREFIX, strlen(DISK_PREFIX)) == 0)
			nameptr += strlen(DISK_PREFIX);
		if (conventional_name(nameptr)) {
			if (whole_disk_name(nameptr))
				return (0);
			else
				return (1);
		}
		(void) strcpy(localname, symname);
		(void) memset(symname, 0, MAXPATHLEN);
	}
	return (0);
}