illumos/onarm: usr/src/cmd/format/io.c comparison

comparison usr/src/cmd/format/io.c @ 0:c9caec207d52 b86

Initial porting based on b86

author	Koji Uno <koji.uno@sun.com>
date	Tue, 02 Jun 2009 18:56:50 +0900
parents
children	1a15d5aaf794

comparison

equal deleted inserted replaced

--1:000000000000
+:c9caec207d52
+/*
+* CDDL HEADER START
+*
+* The contents of this file are subject to the terms of the
+* Common Development and Distribution License (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 2007 Sun Microsystems, Inc.  All rights reserved.
+* Use is subject to license terms.
+*/
+#pragma ident	"@(#)io.c	1.32	07/06/01 SMI"
+/*
+* This file contains I/O related functions.
+*/
+#include "global.h"
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <sys/tty.h>
+#include <sys/termio.h>
+#include <sys/termios.h>
+#include "startup.h"
+#include "misc.h"
+#include "menu_partition.h"
+#include "param.h"
+#include "menu.h"
+extern int	data_lineno;
+extern char	*space2str();
+extern long	strtol();
+/*
+* This variable is used to determine whether a token is present in the pipe
+* already.
+*/
+static	char	token_present = 0;
+/*
+* This variable always gives us access to the most recent token type
+*/
+int	last_token_type = 0;
+#ifdef	__STDC__
+/*
+* Prototypes for ANSI C compilers
+*/
+static int	sup_get_token(char *);
+static void	pushchar(int c);
+static int	checkeof(void);
+static void	flushline(void);
+static int	strcnt(char *s1, char *s2);
+static int	getbn(char *str, daddr_t *iptr);
+static void	print_input_choices(int type, u_ioparam_t *param);
+static int	slist_widest_str(slist_t *slist);
+static void	ljust_print(char *str, int width);
+static int	sup_inputchar(void);
+static void	sup_pushchar(int c);
+static int	geti64(char *str, uint64_t *iptr, uint64_t *wild);
+#else	/* __STDC__ */
+/*
+* Prototypes for non-ANSI C compilers
+*/
+static int	sup_get_token();
+static void	pushchar(int c);
+static int	checkeof(void);
+static void	flushline(void);
+static int	strcnt(char *s1, char *s2);
+static int	getbn(char *str, daddr_t *iptr);
+static void	print_input_choices(int type, u_ioparam_t *param);
+static int	slist_widest_str(slist_t *slist);
+static void	ljust_print(char *str, int width);
+static int	sup_inputchar(void);
+static void	sup_pushchar(int c);
+static int	geti64(char *str, uint64_t *iptr, uint64_t *wild);
+#endif	/* __STDC__ */
+/*
+* This routine pushes the given character back onto the input stream.
+*/
+static void
+pushchar(c)
+	int	c;
+{
+	(void) ungetc(c, stdin);
+}
+/*
+* This routine checks the input stream for an eof condition.
+*/
+static int
+checkeof()
+{
+	return (feof(stdin));
+}
+/*
+* This routine gets the next token off the input stream.  A token is
+* basically any consecutive non-white characters.
+*/
+char *
+gettoken(inbuf)
+	char	*inbuf;
+{
+	char	*ptr = inbuf;
+	int	c, quoted = 0;
+retoke:
+	/*
+	 * Remove any leading white-space.
+	 */
+	while ((isspace(c = getchar())) && (c != '\n'))
+		;
+	/*
+	 * If we are at the beginning of a line and hit the comment character,
+	 * flush the line and start again.
+	 */
+	if (!token_present && c == COMMENT_CHAR) {
+		token_present = 1;
+		flushline();
+		goto retoke;
+	}
+	/*
+	 * Loop on each character until we hit unquoted white-space.
+	 */
+	while (!isspace(c) || quoted && (c != '\n')) {
+		/*
+		 * If we hit eof, get out.
+		 */
+		if (checkeof())
+			return (NULL);
+		/*
+		 * If we hit a double quote, change the state of quotedness.
+		 */
+		if (c == '"')
+			quoted = !quoted;
+		/*
+		 * If there's room in the buffer, add the character to the end.
+		 */
+		else if (ptr - inbuf < TOKEN_SIZE)
+			*ptr++ = (char)c;
+		/*
+		 * Get the next character.
+		 */
+		c = getchar();
+	}
+	/*
+	 * Null terminate the token.
+	 */
+	*ptr = '\0';
+	/*
+	 * Peel off white-space still in the pipe.
+	 */
+	while (isspace(c) && (c != '\n'))
+		c = getchar();
+	/*
+	 * If we hit another token, push it back and set state.
+	 */
+	if (c != '\n') {
+		pushchar(c);
+		token_present = 1;
+	} else
+		token_present = 0;
+	/*
+	 * Return the token.
+	 */
+	return (inbuf);
+}
+/*
+* This routine removes the leading and trailing spaces from a token.
+*/
+void
+clean_token(cleantoken, token)
+	char	*cleantoken, *token;
+{
+	char	*ptr;
+	/*
+	 * Strip off leading white-space.
+	 */
+	for (ptr = token; isspace(*ptr); ptr++)
+		;
+	/*
+	 * Copy it into the clean buffer.
+	 */
+	(void) strcpy(cleantoken, ptr);
+	/*
+	 * Strip off trailing white-space.
+	 */
+	for (ptr = cleantoken + strlen(cleantoken) - 1;
+		isspace(*ptr) && (ptr >= cleantoken); ptr--) {
+		*ptr = '\0';
+	}
+}
+/*
+* This routine checks if a token is already present on the input line
+*/
+int
+istokenpresent()
+{
+	return (token_present);
+}
+/*
+* This routine flushes the rest of an input line if there is known
+* to be data in it.  The flush has to be qualified because the newline
+* may have already been swallowed by the last gettoken.
+*/
+static void
+flushline()
+{
+	if (token_present) {
+		/*
+		 * Flush the pipe to eol or eof.
+		 */
+		while ((getchar() != '\n') && !checkeof())
+			;
+		/*
+		 * Mark the pipe empty.
+		 */
+		token_present = 0;
+	}
+}
+/*
+* This routine returns the number of characters that are identical
+* between s1 and s2, stopping as soon as a mismatch is found.
+*/
+static int
+strcnt(s1, s2)
+	char	*s1, *s2;
+{
+	int	i = 0;
+	while ((*s1 != '\0') && (*s1++ == *s2++))
+		i++;
+	return (i);
+}
+/*
+* This routine converts the given token into an integer.  The token
+* must convert cleanly into an integer with no unknown characters.
+* If the token is the wildcard string, and the wildcard parameter
+* is present, the wildcard value will be returned.
+*/
+int
+geti(str, iptr, wild)
+	char	*str;
+	int	*iptr, *wild;
+{
+	char	*str2;
+	/*
+	 * If there's a wildcard value and the string is wild, return the
+	 * wildcard value.
+	 */
+	if (wild != NULL && strcmp(str, WILD_STRING) == 0)
+		*iptr = *wild;
+	else {
+		/*
+		 * Conver the string to an integer.
+		 */
+		*iptr = (int)strtol(str, &str2, 0);
+		/*
+		 * If any characters didn't convert, it's an error.
+		 */
+		if (*str2 != '\0') {
+			err_print("`%s' is not an integer.\n", str);
+			return (-1);
+		}
+	}
+	return (0);
+}
+/*
+* This routine converts the given token into a long long.  The token
+* must convert cleanly into a 64-bit integer with no unknown characters.
+* If the token is the wildcard string, and the wildcard parameter
+* is present, the wildcard value will be returned.
+*/
+static int
+geti64(str, iptr, wild)
+	char		*str;
+	uint64_t	*iptr, *wild;
+{
+	char	*str2;
+	/*
+	 * If there's a wildcard value and the string is wild, return the
+	 * wildcard value.
+	 */
+	if ((wild != NULL) && (strcmp(str, WILD_STRING)) == 0) {
+		*iptr = *wild;
+	} else {
+		/*
+		 * Conver the string to an integer.
+		 */
+		*iptr = (uint64_t)strtoll(str, &str2, 0);
+		/*
+		 * If any characters didn't convert, it's an error.
+		 */
+		if (*str2 != '\0') {
+			err_print("`%s' is not an integer.\n", str);
+			return (-1);
+		}
+	}
+	return (0);
+}
+/*
+* This routine converts the given string into a block number on the
+* current disk.  The format of a block number is either a self-based
+* number, or a series of self-based numbers separated by slashes.
+* Any number preceeding the first slash is considered a cylinder value.
+* Any number succeeding the first slash but preceeding the second is
+* considered a head value.  Any number succeeding the second slash is
+* considered a sector value.  Any of these numbers can be wildcarded
+* to the highest possible legal value.
+*/
+static int
+getbn(str, iptr)
+	char	*str;
+	daddr_t	*iptr;
+{
+	char	*cptr, *hptr, *sptr;
+	int	cyl, head, sect, wild;
+	TOKEN	buf;
+	/*
+	 * Set cylinder pointer to beginning of string.
+	 */
+	cptr = str;
+	/*
+	 * Look for the first slash.
+	 */
+	while ((*str != '\0') && (*str != '/'))
+		str++;
+	/*
+	 * If there wasn't one, convert string to an integer and return it.
+	 */
+	if (*str == '\0') {
+		wild = physsects() - 1;
+		if (geti(cptr, (int *)iptr, &wild))
+			return (-1);
+		return (0);
+	}
+	/*
+	 * Null out the slash and set head pointer just beyond it.
+	 */
+	*str++ = '\0';
+	hptr = str;
+	/*
+	 * Look for the second slash.
+	 */
+	while ((*str != '\0') && (*str != '/'))
+		str++;
+	/*
+	 * If there wasn't one, sector pointer points to a .
+	 */
+	if (*str == '\0')
+		sptr = str;
+	/*
+	 * If there was, null it out and set sector point just beyond it.
+	 */
+	else {
+		*str++ = '\0';
+		sptr = str;
+	}
+	/*
+	 * Convert the cylinder part to an integer and store it.
+	 */
+	clean_token(buf, cptr);
+	wild = ncyl + acyl - 1;
+	if (geti(buf, &cyl, &wild))
+		return (-1);
+	if ((cyl < 0) || (cyl >= (ncyl + acyl))) {
+		err_print("`%d' is out of range.\n", cyl);
+		return (-1);
+	}
+	/*
+	 * Convert the head part to an integer and store it.
+	 */
+	clean_token(buf, hptr);
+	wild = nhead - 1;
+	if (geti(buf, &head, &wild))
+		return (-1);
+	if ((head < 0) || (head >= nhead)) {
+		err_print("`%d' is out of range.\n", head);
+		return (-1);
+	}
+	/*
+	 * Convert the sector part to an integer and store it.
+	 */
+	clean_token(buf, sptr);
+	wild = sectors(head) - 1;
+	if (geti(buf, &sect, &wild))
+		return (-1);
+	if ((sect < 0) || (sect >= sectors(head))) {
+		err_print("`%d' is out of range.\n", sect);
+		return (-1);
+	}
+	/*
+	 * Combine the pieces into a block number and return it.
+	 */
+	*iptr = chs2bn(cyl, head, sect);
+	return (0);
+}
+/*
+* This routine is the basis for all input into the program.  It
+* understands the semantics of a set of input types, and provides
+* consistent error messages for all input.  It allows for default
+* values and prompt strings.
+*/
+uint64_t
+input(type, promptstr, delim, param, deflt, cmdflag)
+	int		type;
+	char		*promptstr;
+	int		delim;
+	u_ioparam_t	*param;
+	int		*deflt;
+	int		cmdflag;
+{
+	int		interactive, help, i, length, index, tied;
+	daddr_t		bn;
+	diskaddr_t	bn64;
+	char		**str, **strings;
+	TOKEN		token, cleantoken;
+	TOKEN		token2, cleantoken2;
+	char		*arg;
+	struct		bounds *bounds;
+	char		*s;
+	int		value;
+	int		cyls, cylno;
+	uint64_t	blokno;
+	float		nmegs;
+	float		ngigs;
+	char		shell_argv[MAXPATHLEN];
+	part_deflt_t	*part_deflt;
+	efi_deflt_t	*efi_deflt;
+	/*
+	 * Optional integer input has been added as a hack.
+	 * Function result is 1 if user typed anything.
+	 * Whatever they typed is returned in *deflt.
+	 * This permits us to distinguish between "no value",
+	 * and actually entering in some value, for instance.
+	 */
+	if (type == FIO_OPINT) {
+		assert(deflt != NULL);
+	}
+reprompt:
+	help = interactive = 0;
+	/*
+	 * If we are inputting a command, flush any current input in the pipe.
+	 */
+	if (cmdflag == CMD_INPUT)
+		flushline();
+	/*
+	 * Note whether the token is already present.
+	 */
+	if (!token_present)
+		interactive = 1;
+	/*
+	 * Print the prompt.
+	 */
+	fmt_print(promptstr);
+	/*
+	 * If there is a default value, print it in a format appropriate
+	 * for the input type.
+	 */
+	if (deflt != NULL) {
+		switch (type) {
+		case FIO_BN:
+			fmt_print("[%d, ", *deflt);
+			pr_dblock(fmt_print, (daddr_t)*deflt);
+			fmt_print("]");
+			break;
+		case FIO_INT:
+			fmt_print("[%d]", *deflt);
+			break;
+		case FIO_INT64:
+#if defined(lint)
+			/* caller is longlong aligned specifying FIO_INT64 */
+			efi_deflt = NULL;
+#else
+			efi_deflt = (efi_deflt_t *)deflt;
+#endif
+			fmt_print("[%llu]", efi_deflt->start_sector);
+			break;
+		case FIO_CSTR:
+		case FIO_MSTR:
+			strings = (char **)param->io_charlist;
+			for (i = 0, str = strings; i < *deflt; i++, str++)
+				;
+			fmt_print("[%s]", *str);
+			break;
+		case FIO_OSTR:
+			fmt_print("[\"%s\"]", (char *)deflt);
+			break;
+		case FIO_SLIST:
+			/*
+			 * Search for a string matching the default
+			 * value.  If found, use it.  Otherwise
+			 * assume the default value is actually
+			 * an illegal choice, and default to
+			 * the first item in the list.
+			 */
+			s = find_string(param->io_slist, *deflt);
+			if (s == (char *)NULL) {
+				s = (param->io_slist)->str;
+			}
+			fmt_print("[%s]", s);
+			break;
+		case FIO_CYL:
+			/*
+			 * Old-style partition size input, used to
+			 * modify complete partition tables
+			 */
+			fmt_print("[%db, %dc, %1.2fmb, %1.2fgb]", *deflt,
+			    bn2c(*deflt), bn2mb(*deflt), bn2gb(*deflt));
+			break;
+		case FIO_ECYL:
+			/*
+			 * set up pointer to partition defaults
+			 * structure
+			 */
+			part_deflt = (part_deflt_t *)deflt;
+			/*
+			 * Build print format specifier.  We use the
+			 * starting cylinder number which was entered
+			 * before this call to input(), in case the
+			 * user has changed it from the value in the
+			 * cur_parts->pinfo_map[].dkl_cylno
+			 * field for the current parition
+			 */
+			/*
+			 * Determine the proper default end cylinder:
+			 * Start Cyl	Default Size	End Cylinder
+			 *	0		0	0
+			 *	>0		0	Start Cyl
+			 *	0		>0	Default Size
+			 *				(Cyls) - 1
+			 *	>0		>0	(Start +
+			 *				Default Size
+			 *				(Cyls)) -1
+			 */
+			if (part_deflt->deflt_size == 0) {
+				cylno = part_deflt->start_cyl;
+			} else if (part_deflt->start_cyl == 0) {
+				cylno = bn2c(part_deflt->deflt_size)
+				    - 1;
+			} else {
+				cylno = (bn2c(part_deflt->deflt_size) +
+					    part_deflt->start_cyl) - 1;
+			}
+			fmt_print("[%db, %dc, %de, %1.2fmb, %1.2fgb]",
+			    part_deflt->deflt_size,
+			    bn2c(part_deflt->deflt_size),
+			    cylno,
+			    bn2mb(part_deflt->deflt_size),
+			    bn2gb(part_deflt->deflt_size));
+			break;
+		case FIO_EFI:
+#if defined(lint)
+			/* caller is longlong aligned when specifying FIO_EFI */
+			efi_deflt = NULL;
+#else
+			efi_deflt = (efi_deflt_t *)deflt;
+#endif
+			fmt_print("[%llub, %llue, %llumb, %llugb, %llutb]",
+			    efi_deflt->end_sector,
+			    efi_deflt->start_sector + efi_deflt->end_sector - 1,
+			    (efi_deflt->end_sector * DEV_BSIZE) /
+				(1024 * 1024),
+			    (efi_deflt->end_sector * DEV_BSIZE) /
+				(1024 * 1024 * 1024),
+			    (efi_deflt->end_sector * DEV_BSIZE) /
+				((uint64_t)1024 * 1024 * 1024 * 1024));
+			break;
+		case FIO_OPINT:
+			/* no default value for optional input type */
+			fmt_print("[default]");
+			break;
+		default:
+			err_print("Error: unknown input type.\n");
+			fullabort();
+		}
+	}
+	/*
+	 * Print the delimiter character.
+	 */
+	fmt_print("%c ", delim);
+	/*
+	 * Get the token.  If we hit eof, exit the program gracefully.
+	 */
+	if (gettoken(token) == NULL)
+		fullabort();
+	/*
+	 * check if the user has issued (!) , escape to shell
+	 */
+	if ((cmdflag == CMD_INPUT) && (token[0] == '!')) {
+	    /* get the list of arguments to shell command */
+		(void) memset(shell_argv, 0, sizeof (shell_argv));
+		/* initialize to the first token... */
+		arg = &token[1];
+		/*
+		 * ... and then collect all tokens until the end of
+		 * the line as arguments
+		 */
+		do {
+			/* skip empty tokens. */
+			if (*arg == '\0')
+				continue;
+			/*
+			 * If either of the following two strlcat()
+			 * operations overflows, report an error and
+			 * exit gracefully.
+			 */
+			if ((strlcat(shell_argv, arg, sizeof (shell_argv)) >=
+				sizeof (shell_argv)) ||
+			    (strlcat(shell_argv, " ", sizeof (shell_argv)) >=
+				sizeof (shell_argv))) {
+				err_print("Error: Command line too long.\n");
+				fullabort();
+			}
+		} while (token_present && (arg = gettoken(token)) != NULL);
+		/* execute the shell command */
+		(void) execute_shell(shell_argv, sizeof (shell_argv));
+		redisplay_menu_list((char **)param->io_charlist);
+		if (interactive) {
+			goto reprompt;
+		}
+	}
+	/*
+	 * Certain commands accept up to two tokens
+	 * Unfortunately, this is kind of a hack.
+	 */
+	token2[0] = 0;
+	cleantoken2[0] = 0;
+	if (type == FIO_CYL || type == FIO_ECYL) {
+		if (token_present) {
+			if (gettoken(token2) == NULL)
+				fullabort();
+			clean_token(cleantoken2, token2);
+		}
+	}
+	/*
+	 * Echo the token back to the user if it was in the pipe or we
+	 * are running out of a command file.
+	 */
+	if (!interactive || option_f) {
+		if (token2[0] == 0) {
+			fmt_print("%s\n", token);
+		} else {
+			fmt_print("%s %s\n", token, token2);
+		}
+	}
+	/*
+	 * If we are logging, echo the token to the log file.  The else
+	 * is necessary here because the above printf will also put the
+	 * token in the log file.
+	 */
+	else if (log_file) {
+		log_print("%s %s\n", token, token2);
+	}
+	/*
+	 * If the token was not in the pipe and it wasn't a command, flush
+	 * the rest of the line to keep things in sync.
+	 */
+	if (interactive && cmdflag != CMD_INPUT)
+		flushline();
+	/*
+	 * Scrub off the white-space.
+	 */
+	clean_token(cleantoken, token);
+	/*
+	 * If the input was a blank line and we weren't prompting
+	 * specifically for a blank line...
+	 */
+	if ((strcmp(cleantoken, "") == 0) && (type != FIO_BLNK)) {
+		/*
+		 * If there's a default, return it.
+		 */
+		if (deflt != NULL) {
+			if (type == FIO_OSTR) {
+				/*
+				 * Duplicate and return the default string
+				 */
+				return ((int)alloc_string((char *)deflt));
+			} else if (type == FIO_SLIST) {
+				/*
+				 * If we can find a match for the default
+				 * value in the list, return the default
+				 * value.  If there's no match for the
+				 * default value, it's an illegal
+				 * choice.  Return the first value in
+				 * the list.
+				 */
+				s = find_string(param->io_slist, *deflt);
+				if ((cur_label == L_TYPE_EFI) &&
+				    (s == (char *)NULL)) {
+					return (*deflt);
+				}
+				if (s == (char *)NULL) {
+					return ((param->io_slist)->value);
+				} else {
+					return (*deflt);
+				}
+			} else if (type == FIO_OPINT) {
+				/*
+				 * The user didn't enter anything
+				 */
+				return (0);
+			} else if (type == FIO_ECYL) {
+				return (part_deflt->deflt_size);
+			} else if (type == FIO_INT64) {
+				return (efi_deflt->start_sector);
+			} else if (type == FIO_EFI) {
+				return (efi_deflt->end_sector);
+			} else {
+				return (*deflt);
+			}
+		}
+		/*
+		 * If the blank was not in the pipe, just reprompt.
+		 */
+		if (interactive) {
+			goto reprompt;
+		}
+		/*
+		 * If the blank was in the pipe, it's an error.
+		 */
+		err_print("No default for this entry.\n");
+		cmdabort(SIGINT);
+	}
+	/*
+	 * If token is a '?' or a 'h', it is a request for help.
+	 */
+	if ((strcmp(cleantoken, "?") == 0) ||
+		(strcmp(cleantoken, "h") == 0) ||
+			(strcmp(cleantoken, "help") == 0)) {
+		help = 1;
+	}
+	/*
+	 * Switch on the type of input expected.
+	 */
+	switch (type) {
+	/*
+	 * Expecting a disk block number.
+	 */
+	case FIO_BN:
+		/*
+		 * Parameter is the bounds of legal block numbers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting a block number from %llu (",
+			    bounds->lower);
+			pr_dblock(fmt_print, bounds->lower);
+			fmt_print(") to %llu (", bounds->upper);
+			pr_dblock(fmt_print, bounds->upper);
+			fmt_print(")\n");
+			break;
+		}
+		/*
+		 * Convert token to a disk block number.
+		 */
+		if (cur_label == L_TYPE_EFI) {
+		    if (geti64(cleantoken, (uint64_t *)&bn64,
+			(uint64_t *)NULL))
+			    break;
+		} else {
+		    if (getbn(cleantoken, &bn))
+			break;
+		}
+		if (cur_label == L_TYPE_EFI) {
+		    if ((bn64 < bounds->lower) || (bn64 > bounds->upper)) {
+			err_print("`");
+			pr_dblock(err_print, bn64);
+			err_print("' is out of range.\n");
+			break;
+		    }
+		    return (bn64);
+		}
+		/*
+		 * Check to be sure it is within the legal bounds.
+		 */
+		if ((bn < bounds->lower) || (bn > bounds->upper)) {
+			err_print("`");
+			pr_dblock(err_print, bn);
+			err_print("' is out of range.\n");
+			break;
+		}
+		/*
+		 * If it's ok, return it.
+		 */
+		return (bn);
+	/*
+	 * Expecting an integer.
+	 */
+	case FIO_INT:
+		/*
+		 * Parameter is the bounds of legal integers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting an integer from %llu",
+			    bounds->lower);
+			fmt_print(" to %llu\n", bounds->upper);
+			break;
+		}
+		/*
+		 * Convert the token into an integer.
+		 */
+		if (geti(cleantoken, (int *)&bn, (int *)NULL))
+			break;
+		/*
+		 * Check to be sure it is within the legal bounds.
+		 */
+		if ((bn < bounds->lower) || (bn > bounds->upper)) {
+			err_print("`%ld' is out of range.\n", bn);
+			break;
+		}
+		/*
+		 * If it's ok, return it.
+		 */
+		return (bn);
+	case FIO_INT64:
+		/*
+		 * Parameter is the bounds of legal integers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting an integer from %llu",
+			    bounds->lower);
+			fmt_print(" to %llu\n", bounds->upper);
+			break;
+		}
+		/*
+		 * Convert the token into an integer.
+		 */
+		if (geti64(cleantoken, (uint64_t *)&bn64, (uint64_t *)NULL)) {
+			break;
+		}
+		/*
+		 * Check to be sure it is within the legal bounds.
+		 */
+		if ((bn64 < bounds->lower) || (bn64 > bounds->upper)) {
+			err_print("`%llu' is out of range.\n", bn64);
+			break;
+		}
+		/*
+		 * If it's ok, return it.
+		 */
+		return (bn64);
+	/*
+	 * Expecting an integer, or no input.
+	 */
+	case FIO_OPINT:
+		/*
+		 * Parameter is the bounds of legal integers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting an integer from %llu",
+			    bounds->lower);
+			fmt_print(" to %llu, or no input\n", bounds->upper);
+			break;
+		}
+		/*
+		 * Convert the token into an integer.
+		 */
+		if (geti(cleantoken, (int *)&bn, (int *)NULL))
+			break;
+		/*
+		 * Check to be sure it is within the legal bounds.
+		 */
+		if ((bn < bounds->lower) || (bn > bounds->upper)) {
+			err_print("`%ld' is out of range.\n", bn);
+			break;
+		}
+		/*
+		 * For optional case, return 1 indicating that
+		 * the user actually did enter something.
+		 */
+		*deflt = bn;
+		return (1);
+	/*
+	 * Expecting a closed string.  This means that the input
+	 * string must exactly match one of the strings passed in
+	 * as the parameter.
+	 */
+	case FIO_CSTR:
+		/*
+		 * The parameter is a null terminated array of character
+		 * pointers, each one pointing to a legal input string.
+		 */
+		strings = (char **)param->io_charlist;
+		/*
+		 * Walk through the legal strings, seeing if any of them
+		 * match the token.  If a match is made, return the index
+		 * of the string that was matched.
+		 */
+		for (str = strings; *str != NULL; str++)
+			if (strcmp(cleantoken, *str) == 0)
+				return (str - strings);
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			print_input_choices(type, param);
+		} else {
+			err_print("`%s' is not expected.\n", cleantoken);
+		}
+		break;
+	/*
+	 * Expecting a matched string.  This means that the input
+	 * string must either match one of the strings passed in,
+	 * or be a unique abbreviation of one of them.
+	 */
+	case FIO_MSTR:
+		/*
+		 * The parameter is a null terminated array of character
+		 * pointers, each one pointing to a legal input string.
+		 */
+		strings = (char **)param->io_charlist;
+		length = index = tied = 0;
+		/*
+		 * Loop through the legal input strings.
+		 */
+		for (str = strings; *str != NULL; str++) {
+			/*
+			 * See how many characters of the token match
+			 * this legal string.
+			 */
+			i = strcnt(cleantoken, *str);
+			/*
+			 * If it's not the whole token, then it's not a match.
+			 */
+			if ((uint_t)i < strlen(cleantoken))
+				continue;
+			/*
+			 * If it ties with another input, remember that.
+			 */
+			if (i == length)
+				tied = 1;
+			/*
+			 * If it matches the most so far, record that.
+			 */
+			if (i > length) {
+				index = str - strings;
+				tied = 0;
+				length = i;
+			}
+		}
+		/*
+		 * Print help message if required.
+		 */
+		if (length == 0) {
+			if (help) {
+				print_input_choices(type, param);
+			} else {
+				err_print("`%s' is not expected.\n",
+				    cleantoken);
+			}
+			break;
+		}
+		/*
+		 * If the abbreviation was non-unique, it's an error.
+		 */
+		if (tied) {
+			err_print("`%s' is ambiguous.\n", cleantoken);
+			break;
+		}
+		/*
+		 * We matched one.  Return the index of the string we matched.
+		 */
+		return (index);
+	/*
+	 * Expecting an open string.  This means that any string is legal.
+	 */
+	case FIO_OSTR:
+		/*
+		 * Print a help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting a string\n");
+			break;
+		}
+		/*
+		 * alloc a copy of the string and return it
+		 */
+		return ((int)alloc_string(token));
+	/*
+	 * Expecting a blank line.
+	 */
+	case FIO_BLNK:
+		/*
+		 * We are always in non-echo mode when we are inputting
+		 * this type.  We echo the newline as a carriage return
+		 * only so the prompt string will be covered over.
+		 */
+		nolog_print("\015");
+		/*
+		 * If we are logging, send a newline to the log file.
+		 */
+		if (log_file)
+			log_print("\n");
+		/*
+		 * There is no value returned for this type.
+		 */
+		return (0);
+	/*
+	 * Expecting one of the entries in a string list.
+	 * Accept unique abbreviations.
+	 * Return the value associated with the matched string.
+	 */
+	case FIO_SLIST:
+		i = find_value((slist_t *)param->io_slist,
+			cleantoken, &value);
+		if (i == 1) {
+			return (value);
+		} else {
+			/*
+			 * Print help message if required.
+			 */
+			if (help) {
+				print_input_choices(type, param);
+			} else {
+				if (i == 0)
+					err_print("`%s' not expected.\n",
+					    cleantoken);
+				else
+					err_print("`%s' is ambiguous.\n",
+					    cleantoken);
+			}
+		}
+		break;
+	/*
+	 * Cylinder size input when modifying a complete partition map
+	 */
+	case FIO_CYL:
+		/*
+		 * Parameter is the bounds of legal block numbers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		assert(bounds->lower == 0);
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting up to %llu blocks,",
+			    bounds->upper);
+			fmt_print(" %llu cylinders, ", bn2c(bounds->upper));
+			fmt_print(" %1.2f megabytes, ", bn2mb(bounds->upper));
+			fmt_print("or %1.2f gigabytes\n", bn2gb(bounds->upper));
+			break;
+		}
+		/*
+		 * Parse the first token: try to find 'b', 'c' or 'm'
+		 */
+		s = cleantoken;
+		while (*s && (isdigit(*s) || (*s == '.') || (*s == '$'))) {
+			s++;
+		}
+		/*
+		 * If we found a conversion specifier, second token is unused
+		 * Otherwise, the second token should supply it.
+		 */
+		if (*s != 0) {
+			value = *s;
+			*s = 0;
+		} else {
+			value = cleantoken2[0];
+		}
+		/*
+		 * If the token is the wild card, simply supply the max
+		 * This order allows the user to specify the maximum in
+		 * either blocks/cyls/megabytes - a convenient fiction.
+		 */
+		if (strcmp(cleantoken, WILD_STRING) == 0) {
+			return (bounds->upper);
+		}
+		/*
+		 * Allow the user to specify zero with no units,
+		 * by just defaulting to cylinders.
+		 */
+		if (strcmp(cleantoken, "0") == 0) {
+			value = 'c';
+		}
+		/*
+		 * If there's a decimal point, but no unit specification,
+		 * let's assume megabytes.
+		 */
+		if ((value == 0) && (strchr(cleantoken, '.') != NULL)) {
+			value = 'm';
+		}
+		/*
+		 * Handle each unit type we support
+		 */
+		switch (value) {
+		case 'b':
+			/*
+			 * Convert token to a disk block number.
+			 */
+			i = bounds->upper;
+			if (geti(cleantoken, &value, &i))
+				break;
+			bn = value;
+			/*
+			 * Check to be sure it is within the legal bounds.
+			 */
+			if ((bn < bounds->lower) || (bn > bounds->upper)) {
+				err_print(
+"`%ldb' is out of the range %llu to %llu\n",
+				    bn, bounds->lower, bounds->upper);
+				break;
+			}
+			/*
+			 * Verify the block lies on a cylinder boundary
+			 */
+			if ((bn % spc()) != 0) {
+				err_print(
+"partition size must be a multiple of %d blocks to lie on a cylinder \
+boundary\n",
+				    spc());
+				err_print(
+"%ld blocks is approximately %ld cylinders, %1.2f megabytes or %1.2f\
+gigabytes\n",
+				    bn, bn2c(bn), bn2mb(bn), bn2gb(bn));
+				break;
+			}
+			return (bn);
+		case 'c':
+			/*
+			 * Convert token from a number of cylinders to
+			 * a number of blocks.
+			 */
+			i = bn2c(bounds->upper);
+			if (geti(cleantoken, &cyls, &i))
+				break;
+			/*
+			 * Check the bounds - cyls is number of cylinders
+			 */
+			if (cyls > (bounds->upper/spc())) {
+				err_print("`%dc' is out of range\n", cyls);
+				break;
+			}
+			/*
+			 * Convert cylinders to blocks and return
+			 */
+			return (cyls * spc());
+		case 'm':
+			/*
+			 * Convert token from megabytes to a block number.
+			 */
+			if (sscanf(cleantoken, "%f2", &nmegs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			/*
+			 * Check the bounds
+			 */
+			if (nmegs > bn2mb(bounds->upper)) {
+				err_print("`%1.2fmb' is out of range\n", nmegs);
+				break;
+			}
+			/*
+			 * Convert to blocks
+			 */
+			bn = mb2bn(nmegs);
+			/*
+			 * Round value up to nearest cylinder
+			 */
+			i = spc();
+			bn = ((bn + (i-1)) / i) * i;
+			return (bn);
+		case 'g':
+			/*
+			 * Convert token from gigabytes to a block number.
+			 */
+			if (sscanf(cleantoken, "%f2", &ngigs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			/*
+			 * Check the bounds
+			 */
+			if (ngigs > bn2gb(bounds->upper)) {
+				err_print("`%1.2fgb' is out of range\n", ngigs);
+				break;
+			}
+			/*
+			 * Convert to blocks
+			 */
+			bn = gb2bn(ngigs);
+			/*
+			 * Round value up to nearest cylinder
+			 */
+			i = spc();
+			bn = ((bn + (i-1)) / i) * i;
+			return (bn);
+		default:
+			err_print(
+"Please specify units in either b(blocks), c(cylinders), m(megabytes) \
+or g(gigabytes)\n");
+			break;
+		}
+		break;
+	case FIO_ECYL:
+		/*
+		 * Parameter is the bounds of legal block numbers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		assert(bounds->lower == 0);
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting up to %llu blocks,",
+			    bounds->upper);
+			fmt_print(" %llu cylinders, ",
+			    bn2c(bounds->upper));
+			fmt_print(" %llu end cylinder, ",
+			    (bounds->upper / spc()));
+			fmt_print(" %1.2f megabytes, ",
+			    bn2mb(bounds->upper));
+			fmt_print("or %1.2f gigabytes\n",
+			    bn2gb(bounds->upper));
+			break;
+		}
+		/*
+		 * Parse the first token: try to find 'b', 'c', 'e'
+		 * or 'm'
+		 */
+		s = cleantoken;
+		while (*s && (isdigit(*s) || (*s == '.') || (*s == '$'))) {
+			s++;
+		}
+		/*
+		 * If we found a conversion specifier, second token is
+		 * unused Otherwise, the second token should supply it.
+		 */
+		if (*s != 0) {
+			value = *s;
+			*s = 0;
+		} else {
+			value = cleantoken2[0];
+		}
+		/*
+		 * If the token is the wild card, simply supply the max
+		 * This order allows the user to specify the maximum in
+		 * either blocks/cyls/megabytes - a convenient fiction.
+		 */
+		if (strcmp(cleantoken, WILD_STRING) == 0) {
+			return (bounds->upper);
+		}
+		/*
+		 * Allow the user to specify zero with no units,
+		 * by just defaulting to cylinders.
+		 */
+		if (value != 'e' && strcmp(cleantoken, "0") == 0) {
+			value = 'c';
+		}
+		/*
+		 * If there's a decimal point, but no unit
+		 * specification, let's assume megabytes.
+		 */
+		if ((value == 0) && (strchr(cleantoken, '.') != NULL)) {
+			value = 'm';
+		}
+		/*
+		 * Handle each unit type we support
+		 */
+		switch (value) {
+		case 'b':
+			/*
+			 * Convert token to a disk block number.
+			 */
+			i = bounds->upper;
+			if (geti(cleantoken, &value, &i))
+				break;
+			bn = value;
+			/*
+			 * Check to be sure it is within the
+			 * legal bounds.
+			 */
+			if ((bn < bounds->lower) || (bn > bounds->upper)) {
+				err_print(
+"`%ldb' is out of the range %llu to %llu\n",
+				    bn, bounds->lower, bounds->upper);
+				break;
+			}
+			/*
+			 * Verify the block lies on a cylinder
+			 * boundary
+			 */
+			if ((bn % spc()) != 0) {
+				err_print(
+"partition size must be a multiple of %d blocks to lie on a cylinder \
+boundary\n",
+				    spc());
+				err_print(
+"%ld blocks is approximately %ld cylinders, %1.2f \
+megabytes or %1.2f gigabytes\n",
+				    bn, bn2c(bn), bn2mb(bn), bn2gb(bn));
+				break;
+			}
+			return (bn);
+		case 'e':
+			/*
+			 * Token is ending cylinder
+			 */
+			/* convert token to integer */
+			if (geti(cleantoken, &cylno, (int *)NULL)) {
+				break;
+			}
+			/*
+			 * check that input cylno isn't before the current
+			 * starting cylinder number.  Note that we are NOT
+			 * using the starting cylinder from
+			 * cur_parts->pinfo_map[].dkl_cylno!
+			 */
+			if (cylno < part_deflt->start_cyl) {
+				err_print(
+"End cylinder must fall on or after start cylinder %d\n",
+				    part_deflt->start_cyl);
+				break;
+			}
+			/*
+			 * calculate cylinder number of upper boundary, and
+			 * verify that our input is within range
+			 */
+			i = (bn2c(bounds->upper) + part_deflt->start_cyl - 1);
+			if (cylno > i) {
+				err_print(
+"End cylinder %d is beyond max cylinder %d\n",
+				    cylno, i);
+				break;
+			}
+			/*
+			 * calculate number of cylinders based on input
+			 */
+			cyls = ((cylno - part_deflt->start_cyl) + 1);
+			return (cyls * spc());
+		case 'c':
+			/*
+			 * Convert token from a number of
+			 * cylinders to a number of blocks.
+			 */
+			i = bn2c(bounds->upper);
+			if (geti(cleantoken, &cyls, &i))
+				break;
+			/*
+			 * Check the bounds - cyls is number of
+			 * cylinders
+			 */
+			if (cyls > (bounds->upper/spc())) {
+				err_print("`%dc' is out of range\n", cyls);
+				break;
+			}
+			/*
+			 * Convert cylinders to blocks and
+			 * return
+			 */
+			return (cyls * spc());
+		case 'm':
+			/*
+			 * Convert token from megabytes to a
+			 * block number.
+			 */
+			if (sscanf(cleantoken, "%f2", &nmegs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			/*
+			 * Check the bounds
+			 */
+			if (nmegs > bn2mb(bounds->upper)) {
+				err_print("`%1.2fmb' is out of range\n", nmegs);
+				break;
+			}
+			/*
+			 * Convert to blocks
+			 */
+			bn = mb2bn(nmegs);
+			/*
+			 * Round value up to nearest cylinder
+			 */
+			i = spc();
+			bn = ((bn + (i-1)) / i) * i;
+			return (bn);
+		case 'g':
+			/*
+			 * Convert token from gigabytes to a
+			 * block number.
+			 */
+			if (sscanf(cleantoken, "%f2", &ngigs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			/*
+			 * Check the bounds
+			 */
+			if (ngigs > bn2gb(bounds->upper)) {
+				err_print("`%1.2fgb' is out of range\n", ngigs);
+				break;
+			}
+			/*
+			 * Convert to blocks
+			 */
+			bn = gb2bn(ngigs);
+			/*
+			 * Round value up to nearest cylinder
+			 */
+			i = spc();
+			bn = ((bn + (i-1)) / i) * i;
+			return (bn);
+		default:
+			err_print(
+"Please specify units in either b(blocks), c(cylinders), e(end cylinder),\n");
+			err_print("m(megabytes) or g(gigabytes)\n");
+			break;
+		}
+		break;
+	case FIO_EFI:
+		/*
+		 * Parameter is the bounds of legal block numbers.
+		 */
+		bounds = (struct bounds *)&param->io_bounds;
+		/*
+		 * Print help message if required.
+		 */
+		if (help) {
+			fmt_print("Expecting up to %llu sectors,",
+			    cur_parts->etoc->efi_last_u_lba);
+			fmt_print("or %llu megabytes,",
+			    (cur_parts->etoc->efi_last_u_lba * DEV_BSIZE)/
+				(1024 * 1024));
+			fmt_print("or %llu gigabytes\n",
+			    (cur_parts->etoc->efi_last_u_lba * DEV_BSIZE)/
+				(1024 * 1024 * 1024));
+			fmt_print("or %llu terabytes\n",
+			    (cur_parts->etoc->efi_last_u_lba * DEV_BSIZE)/
+				((uint64_t)1024 * 1024 * 1024 * 1024));
+			break;
+		}
+		/*
+		 * Parse the first token: try to find 'b', 'c', 'e'
+		 * or 'm'
+		 */
+		s = cleantoken;
+		while (*s && (isdigit(*s) || (*s == '.') || (*s == '$'))) {
+			s++;
+		}
+		/*
+		 * If we found a conversion specifier, second token is
+		 * unused Otherwise, the second token should supply it.
+		 */
+		if (*s != 0) {
+			value = *s;
+			*s = 0;
+		} else {
+			value = cleantoken2[0];
+		}
+		/*
+		 * If the token is the wild card, simply supply the max
+		 * This order allows the user to specify the maximum in
+		 * either blocks/cyls/megabytes - a convenient fiction.
+		 */
+		if (strcmp(cleantoken, WILD_STRING) == 0) {
+			return (bounds->upper - EFI_MIN_RESV_SIZE -
+			    efi_deflt->start_sector);
+		}
+		/*
+		 * Allow the user to specify zero with no units,
+		 * by just defaulting to sectors.
+		 */
+		if (value != 'e' && strcmp(cleantoken, "0") == 0) {
+			value = 'm';
+		}
+		/*
+		 * If there's a decimal point, but no unit
+		 * specification, let's assume megabytes.
+		 */
+		if ((value == 0) && (strchr(cleantoken, '.') != NULL)) {
+			value = 'm';
+		}
+		/*
+		 * Handle each unit type we support
+		 */
+		switch (value) {
+		case 'b':
+			/*
+			 * Token is number of blocks
+			 */
+			if (geti64(cleantoken, &blokno, (uint64_t *)NULL)) {
+			    break;
+			}
+			if (blokno > bounds->upper) {
+			    err_print(
+"Number of blocks must be less that the total available blocks.\n");
+			    break;
+			}
+			return (blokno);
+		case 'e':
+			/*
+			 * Token is ending block number
+			 */
+			/* convert token to integer */
+			if (geti64(cleantoken, &blokno, (uint64_t *)NULL)) {
+				break;
+			}
+			/*
+			 * Some sanity check
+			 */
+			if (blokno < efi_deflt->start_sector) {
+				err_print(
+"End Sector must fall on or after start sector %llu\n",
+				    efi_deflt->start_sector);
+				break;
+			}
+			/*
+			 * verify that our input is within range
+			 */
+			if (blokno > cur_parts->etoc->efi_last_u_lba) {
+				err_print(
+"End Sector %llu is beyond max Sector %llu\n",
+				    blokno, cur_parts->etoc->efi_last_u_lba);
+				break;
+			}
+			/*
+			 * calculate number of blocks based on input
+			 */
+			return (blokno - efi_deflt->start_sector + 1);
+		case 'm':
+			/*
+			 * Convert token from megabytes to a
+			 * block number.
+			 */
+			if (sscanf(cleantoken, "%f2", &nmegs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			/*
+			 * Check the bounds
+			 */
+			if (nmegs > bn2mb(bounds->upper - bounds->lower)) {
+				err_print("`%1.2fmb' is out of range\n", nmegs);
+				break;
+			}
+			return (mb2bn(nmegs));
+		case 'g':
+			if (sscanf(cleantoken, "%f2", &nmegs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			if (nmegs > bn2gb(bounds->upper - bounds->lower)) {
+				err_print("`%1.2fgb' is out of range\n", nmegs);
+				break;
+			}
+			return (gb2bn(nmegs));
+		case 't':
+			if (sscanf(cleantoken, "%f2", &nmegs) != 1) {
+				err_print("`%s' is not recognized\n",
+				    cleantoken);
+				break;
+			}
+			if (nmegs > bn2tb(bounds->upper - bounds->lower)) {
+				err_print("`%1.2ftb' is out of range\n", nmegs);
+				break;
+			}
+			return (uint64_t)((float)nmegs * 1024.0 *
+				1024.0 * 1024.0 * 1024.0 / DEV_BSIZE);
+		default:
+			err_print(
+"Please specify units in either b(number of blocks), e(end sector),\n");
+			err_print(" g(gigabytes), m(megabytes)");
+			err_print(" or t(terabytes)\n");
+			break;
+		}
+		break;
+	/*
+	 * If we don't recognize the input type, it's bad news.
+	 */
+	default:
+		err_print("Error: unknown input type.\n");
+		fullabort();
+	}
+	/*
+	 * If we get here, it's because some error kept us from accepting
+	 * the token.  If we are running out of a command file, gracefully
+	 * leave the program.  If we are interacting with the user, simply
+	 * reprompt.  If the token was in the pipe, abort the current command.
+	 */
+	if (option_f)
+		fullabort();
+	else if (interactive)
+		goto reprompt;
+	else
+		cmdabort(SIGINT);
+	/*
+	 * Never actually reached.
+	 */
+	return (-1);
+}
+/*
+* Print input choices
+*/
+static void
+print_input_choices(type, param)
+	int		type;
+	u_ioparam_t	*param;
+{
+	char		**sp;
+	slist_t		*lp;
+	int		width;
+	int		col;
+	int		ncols;
+	switch (type) {
+	case FIO_CSTR:
+		fmt_print("Expecting one of the following:\n");
+		goto common;
+	case FIO_MSTR:
+		fmt_print("Expecting one of the following: ");
+		fmt_print("(abbreviations ok):\n");
+common:
+		for (sp = (char **)param->io_charlist; *sp != NULL; sp++) {
+			fmt_print("\t%s\n", *sp);
+		}
+		break;
+	case FIO_SLIST:
+		fmt_print("Expecting one of the following: ");
+		fmt_print("(abbreviations ok):\n");
+		/*
+		 * Figure out the width of the widest string
+		 */
+		width = slist_widest_str((slist_t *)param->io_slist);
+		width += 4;
+		/*
+		 * If the help messages are empty, print the
+		 * possible choices in left-justified columns
+		 */
+		lp = (slist_t *)param->io_slist;
+		if (*lp->help == 0) {
+			col = 0;
+			ncols = 60 / width;
+			for (; lp->str != NULL; lp++) {
+				if (col == 0)
+					fmt_print("\t");
+				ljust_print(lp->str,
+				    (++col == ncols) ? 0 : width);
+				if (col == ncols) {
+					col = 0;
+					fmt_print("\n");
+				}
+			}
+			if (col != 0)
+				fmt_print("\n");
+		} else {
+			/*
+			 * With help messages, print each choice,
+			 * and help message, on its own line.
+			 */
+			for (; lp->str != NULL; lp++) {
+				fmt_print("\t");
+				ljust_print(lp->str, width);
+				fmt_print("- %s\n", lp->help);
+			}
+		}
+		break;
+	default:
+		err_print("Error: unknown input type.\n");
+		fullabort();
+	}
+	fmt_print("\n");
+}
+/*
+* Search a string list for a particular string.
+* Use minimum recognition, to accept unique abbreviations
+* Return the number of possible matches found.
+* If only one match was found, return the arbitrary value
+* associated with the matched string in match_value.
+*/
+int
+find_value(slist, match_str, match_value)
+	slist_t		*slist;
+	char		*match_str;
+	int		*match_value;
+{
+	int		i;
+	int		nmatches;
+	int		length;
+	int		match_length;
+	nmatches = 0;
+	length = 0;
+	match_length = strlen(match_str);
+	for (; slist->str != NULL; slist++) {
+		/*
+		 * See how many characters of the token match
+		 */
+		i = strcnt(match_str, slist->str);
+		/*
+		 * If it's not the whole token, then it's not a match.
+		 */
+		if (i  < match_length)
+			continue;
+		/*
+		 * If it ties with another input, remember that.
+		 */
+		if (i == length)
+			nmatches++;
+		/*
+		 * If it matches the most so far, record that.
+		 */
+		if (i > length) {
+			*match_value = slist->value;
+			nmatches = 1;
+			length = i;
+		}
+	}
+	return (nmatches);
+}
+/*
+* Search a string list for a particular value.
+* Return the string associated with that value.
+*/
+char *
+find_string(slist, match_value)
+	slist_t		*slist;
+	int		match_value;
+{
+	for (; slist->str != NULL; slist++) {
+		if (slist->value == match_value) {
+			return (slist->str);
+		}
+	}
+	return ((char *)NULL);
+}
+/*
+* Return the width of the widest string in an slist
+*/
+static int
+slist_widest_str(slist)
+	slist_t	*slist;
+{
+	int	i;
+	int	width;
+	width = 0;
+	for (; slist->str != NULL; slist++) {
+		if ((i = strlen(slist->str)) > width)
+			width = i;
+	}
+	return (width);
+}
+/*
+* Print a string left-justified to a fixed width.
+*/
+static void
+ljust_print(str, width)
+	char	*str;
+	int	width;
+{
+	int	i;
+	fmt_print("%s", str);
+	for (i = width - strlen(str); i > 0; i--) {
+		fmt_print(" ");
+	}
+}
+/*
+* This routine is a modified version of printf.  It handles the cases
+* of silent mode and logging; other than that it is identical to the
+* library version.
+*/
+/*PRINTFLIKE1*/
+void
+fmt_print(char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	/*
+	 * If we are running silent, skip it.
+	 */
+	if (option_s == 0) {
+		/*
+		 * Do the print to standard out.
+		 */
+		if (need_newline) {
+			(void) printf("\n");
+		}
+		(void) vprintf(format, ap);
+		/*
+		 * If we are logging, also print to the log file.
+		 */
+		if (log_file) {
+			if (need_newline) {
+				(void) fprintf(log_file, "\n");
+			}
+			(void) vfprintf(log_file, format, ap);
+			(void) fflush(log_file);
+		}
+	}
+	need_newline = 0;
+	va_end(ap);
+}
+/*
+* This routine is a modified version of printf.  It handles the cases
+* of silent mode; other than that it is identical to the
+* library version.  It differs from the above printf in that it does
+* not print the message to a log file.
+*/
+/*PRINTFLIKE1*/
+void
+nolog_print(char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	/*
+	 * If we are running silent, skip it.
+	 */
+	if (option_s == 0) {
+		/*
+		 * Do the print to standard out.
+		 */
+		if (need_newline) {
+			(void) printf("\n");
+		}
+		(void) vprintf(format, ap);
+	}
+	va_end(ap);
+	need_newline = 0;
+}
+/*
+* This routine is a modified version of printf.  It handles the cases
+* of silent mode, and only prints the message to the log file, not
+* stdout.  Other than that is identical to the library version.
+*/
+/*PRINTFLIKE1*/
+void
+log_print(char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	/*
+	 * If we are running silent, skip it.
+	 */
+	if (option_s == 0) {
+		/*
+		 * Do the print to the log file.
+		 */
+		if (need_newline) {
+			(void) fprintf(log_file, "\n");
+		}
+		(void) vfprintf(log_file, format, ap);
+		(void) fflush(log_file);
+	}
+	va_end(ap);
+	need_newline = 0;
+}
+/*
+* This routine is a modified version of printf.  It prints the message
+* to stderr, and to the log file is appropriate.
+* Other than that is identical to the library version.
+*/
+/*PRINTFLIKE1*/
+void
+err_print(char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	/*
+	 * Flush anything pending to stdout
+	 */
+	if (need_newline) {
+		(void) printf("\n");
+	}
+	(void) fflush(stdout);
+	/*
+	 * Do the print to stderr.
+	 */
+	(void) vfprintf(stderr, format, ap);
+	/*
+	 * If we are logging, also print to the log file.
+	 */
+	if (log_file) {
+		if (need_newline) {
+			(void) fprintf(log_file, "\n");
+		}
+		(void) vfprintf(log_file, format, ap);
+		(void) fflush(log_file);
+	}
+	va_end(ap);
+	need_newline = 0;
+}
+/*
+* Print a number of characters from a buffer.  The buffer
+* does not need to be null-terminated.  Since the data
+* may be coming from a device, we cannot be sure the
+* data is not crud, so be rather defensive.
+*/
+void
+print_buf(buf, nbytes)
+	char	*buf;
+	int	nbytes;
+{
+	int	c;
+	while (nbytes-- > 0) {
+		c = *buf++;
+		if (isascii(c) && isprint(c)) {
+			fmt_print("%c", c);
+		} else
+			break;
+	}
+}
+#ifdef	not
+/*
+* This routine prints out a message describing the given ctlr.
+* The message is identical to the one printed by the kernel during
+* booting.
+*/
+void
+pr_ctlrline(ctlr)
+	register struct ctlr_info *ctlr;
+{
+	fmt_print("           %s%d at %s 0x%x ",
+		ctlr->ctlr_cname, ctlr->ctlr_num,
+		space2str(ctlr->ctlr_space), ctlr->ctlr_addr);
+	if (ctlr->ctlr_vec != 0)
+		fmt_print("vec 0x%x ", ctlr->ctlr_vec);
+	else
+		fmt_print("pri %d ", ctlr->ctlr_prio);
+	fmt_print("\n");
+}
+#endif /* not */
+/*
+* This routine prints out a message describing the given disk.
+* The message is identical to the one printed by the kernel during
+* booting.
+*/
+void
+pr_diskline(disk, num)
+	register struct disk_info *disk;
+	int	num;
+{
+	struct	ctlr_info *ctlr = disk->disk_ctlr;
+	struct	disk_type *type = disk->disk_type;
+	fmt_print("    %4d. %s ", num, disk->disk_name);
+	if ((type != NULL) && (disk->label_type == L_TYPE_SOLARIS)) {
+		fmt_print("<%s cyl %d alt %d hd %d sec %d>",
+			type->dtype_asciilabel, type->dtype_ncyl,
+			type->dtype_acyl, type->dtype_nhead,
+			type->dtype_nsect);
+	} else if ((type != NULL) && (disk->label_type == L_TYPE_EFI)) {
+		print_efi_string(type->vendor, type->product,
+			type->revision, type->capacity);
+	} else if (disk->disk_flags & DSK_RESERVED) {
+		fmt_print("<drive not available: reserved>");
+	} else if (disk->disk_flags & DSK_UNAVAILABLE) {
+		fmt_print("<drive not available>");
+	} else {
+		fmt_print("<drive type unknown>");
+	}
+	if (chk_volname(disk)) {
+		fmt_print("  ");
+		print_volname(disk);
+	}
+	fmt_print("\n");
+	if (disk->devfs_name != NULL) {
+		fmt_print("          %s\n", disk->devfs_name);
+	} else {
+		fmt_print("          %s%d at %s%d slave %d\n",
+			ctlr->ctlr_dname, disk->disk_dkinfo.dki_unit,
+			ctlr->ctlr_cname, ctlr->ctlr_num,
+			disk->disk_dkinfo.dki_slave);
+	}
+#ifdef	OLD
+	fmt_print("    %4d. %s at %s%d slave %d", num, disk->disk_name,
+	    ctlr->ctlr_cname, ctlr->ctlr_num, disk->disk_dkinfo.dki_slave);
+	if (chk_volname(disk)) {
+		fmt_print(": ");
+		print_volname(disk);
+	}
+	fmt_print("\n");
+	if (type != NULL) {
+		fmt_print(
+"           %s%d: <%s cyl %d alt %d hd %d sec %d>\n",
+		    ctlr->ctlr_dname, disk->disk_dkinfo.dki_unit,
+		    type->dtype_asciilabel, type->dtype_ncyl,
+		    type->dtype_acyl, type->dtype_nhead,
+		    type->dtype_nsect);
+	} else {
+		fmt_print("           %s%d: <drive type unknown>\n",
+		    ctlr->ctlr_dname, disk->disk_dkinfo.dki_unit);
+	}
+#endif /* OLD */
+}
+/*
+* This routine prints out a given disk block number in cylinder/head/sector
+* format.  It uses the printing routine passed in to do the actual output.
+* Downcasting bn is okay for L_TYPE_SOLARIS because the number of blocks
+* on a Solaris (VTOC) label will never exceed 4 bytes (daddr_t).
+*/
+void
+pr_dblock(void (*func)(char *, ...), diskaddr_t bn)
+{
+	if (cur_label == L_TYPE_SOLARIS) {
+		(*func)("%d/%d/%d", bn2c((daddr_t)bn),
+		    bn2h((daddr_t)bn), bn2s((daddr_t)bn));
+	} else {
+		(*func)("%llu", bn);
+	}
+}
+/*
+* This routine inputs a character from the data file.  It understands
+* the use of '\' to prevent interpretation of a newline.  It also keeps
+* track of the current line in the data file via a global variable.
+*/
+static int
+sup_inputchar()
+{
+	int	c;
+	/*
+	 * Input the character.
+	 */
+	c = getc(data_file);
+	/*
+	 * If it's not a backslash, return it.
+	 */
+	if (c != '\\')
+		return (c);
+	/*
+	 * It was a backslash.  Get the next character.
+	 */
+	c = getc(data_file);
+	/*
+	 * If it was a newline, update the line counter and get the next
+	 * character.
+	 */
+	if (c == '\n') {
+		data_lineno++;
+		c = getc(data_file);
+	}
+	/*
+	 * Return the character.
+	 */
+	return (c);
+}
+/*
+* This routine pushes a character back onto the input pipe for the data file.
+*/
+static void
+sup_pushchar(c)
+	int	c;
+{
+	(void) ungetc(c, data_file);
+}
+/*
+* Variables to support pushing back tokens
+*/
+static  int	have_pushed_token = 0;
+static  TOKEN	pushed_buf;
+static  int	pushed_token;
+/*
+* This routine inputs a token from the data file.  A token is a series
+* of contiguous non-white characters or a recognized special delimiter
+* character.  Use of the wrapper lets us always have the value of the
+* last token around, which is useful for error recovery.
+*/
+int
+sup_gettoken(buf)
+	char	*buf;
+{
+	last_token_type = sup_get_token(buf);
+	return (last_token_type);
+}
+static int
+sup_get_token(buf)
+	char	*buf;
+{
+	char	*ptr = buf;
+	int	c, quoted = 0;
+	/*
+	 * First check for presence of push-backed token.
+	 * If so, return it.
+	 */
+	if (have_pushed_token) {
+		have_pushed_token = 0;
+		bcopy(pushed_buf, buf, TOKEN_SIZE+1);
+		return (pushed_token);
+	}
+	/*
+	 * Zero out the returned token buffer
+	 */
+	bzero(buf, TOKEN_SIZE + 1);
+	/*
+	 * Strip off leading white-space.
+	 */
+	while ((isspace(c = sup_inputchar())) && (c != '\n'))
+		;
+	/*
+	 * Read in characters until we hit unquoted white-space.
+	 */
+	for (; !isspace(c) || quoted; c = sup_inputchar()) {
+		/*
+		 * If we hit eof, that's a token.
+		 */
+		if (feof(data_file))
+			return (SUP_EOF);
+		/*
+		 * If we hit a double quote, change the state of quoting.
+		 */
+		if (c == '"') {
+			quoted = !quoted;
+			continue;
+		}
+		/*
+		 * If we hit a newline, that delimits a token.
+		 */
+		if (c == '\n')
+			break;
+		/*
+		 * If we hit any nonquoted special delimiters, that delimits
+		 * a token.
+		 */
+		if (!quoted && (c == '=' || c == ',' || c == ':' ||
+			c == '#' || c == '|' || c == '&' || c == '~'))
+			break;
+		/*
+		 * Store the character if there's room left.
+		 */
+		if (ptr - buf < TOKEN_SIZE)
+			*ptr++ = (char)c;
+	}
+	/*
+	 * If we stored characters in the buffer, then we inputted a string.
+	 * Push the delimiter back into the pipe and return the string.
+	 */
+	if (ptr - buf > 0) {
+		sup_pushchar(c);
+		return (SUP_STRING);
+	}
+	/*
+	 * We didn't input a string, so we must have inputted a known delimiter.
+	 * store the delimiter in the buffer, so it will get returned.
+	 */
+	buf[0] = c;
+	/*
+	 * Switch on the delimiter.  Return the appropriate value for each one.
+	 */
+	switch (c) {
+	case '=':
+		return (SUP_EQL);
+	case ':':
+		return (SUP_COLON);
+	case ',':
+		return (SUP_COMMA);
+	case '\n':
+		return (SUP_EOL);
+	case '|':
+		return (SUP_OR);
+	case '&':
+		return (SUP_AND);
+	case '~':
+		return (SUP_TILDE);
+	case '#':
+		/*
+		 * For comments, we flush out the rest of the line and return
+		 * an EOL.
+		 */
+		while ((c = sup_inputchar()) != '\n' && !feof(data_file))
+			;
+		if (feof(data_file))
+			return (SUP_EOF);
+		else
+			return (SUP_EOL);
+	/*
+	 * Shouldn't ever get here.
+	 */
+	default:
+		return (SUP_STRING);
+	}
+}
+/*
+* Push back a token
+*/
+void
+sup_pushtoken(token_buf, token_type)
+	char	*token_buf;
+	int	token_type;
+{
+	/*
+	 * We can only push one token back at a time
+	 */
+	assert(have_pushed_token == 0);
+	have_pushed_token = 1;
+	bcopy(token_buf, pushed_buf, TOKEN_SIZE+1);
+	pushed_token = token_type;
+}
+/*
+* Get an entire line of input.  Handles logging, comments,
+* and EOF.
+*/
+void
+get_inputline(line, nbytes)
+	char	*line;
+	int	nbytes;
+{
+	char	*p = line;
+	int	c;
+	/*
+	 * Remove any leading white-space and comments
+	 */
+	do {
+		while ((isspace(c = getchar())) && (c != '\n'))
+			;
+	} while (c == COMMENT_CHAR);
+	/*
+	 * Loop on each character until end of line
+	 */
+	while (c != '\n') {
+		/*
+		 * If we hit eof, get out.
+		 */
+		if (checkeof()) {
+			fullabort();
+		}
+		/*
+		 * Add the character to the buffer.
+		 */
+		if (nbytes > 1) {
+			*p++ = (char)c;
+			nbytes --;
+		}
+		/*
+		 * Get the next character.
+		 */
+		c = getchar();
+	}
+	/*
+	 * Null terminate the token.
+	 */
+	*p = 0;
+	/*
+	 * Indicate that we've emptied the pipe
+	 */
+	token_present = 0;
+	/*
+	 * If we're running out of a file, echo the line to
+	 * the user, otherwise if we're logging, copy the
+	 * input to the log file.
+	 */
+	if (option_f) {
+		fmt_print("%s\n", line);
+	} else if (log_file) {
+		log_print("%s\n", line);
+	}
+}
+/*
+* execute the shell escape command
+*/
+int
+execute_shell(s, buff_size)
+	char	*s;
+	size_t	buff_size;
+{
+	struct	termio	termio;
+	struct	termios	tty;
+	int	tty_flag, i, j;
+	char	*shell_name;
+	static char	*default_shell = "/bin/sh";
+	tty_flag = -1;
+	if (*s == NULL) {
+		shell_name = getenv("SHELL");
+		if (shell_name == NULL) {
+			shell_name = default_shell;
+		}
+		if (strlcpy(s, shell_name, buff_size) >=
+		    buff_size) {
+			err_print("Error: Shell command ($SHELL) too long.\n");
+			fullabort();
+		}
+	}
+	/* save tty information */
+	if (isatty(0)) {
+		if (ioctl(0, TCGETS, &tty) == 0)
+			tty_flag = 1;
+		else {
+			if (ioctl(0, TCGETA, &termio) == 0) {
+				tty_flag = 0;
+				tty.c_iflag = termio.c_iflag;
+				tty.c_oflag = termio.c_oflag;
+				tty.c_cflag = termio.c_cflag;
+				tty.c_lflag = termio.c_lflag;
+				for (i = 0; i < NCC; i++)
+					tty.c_cc[i] = termio.c_cc[i];
+			}
+		}
+	}
+	/* close the current file descriptor */
+	if (cur_disk != NULL) {
+		(void) close(cur_file);
+	}
+	/* execute the shell escape */
+	(void) system(s);
+	/* reopen file descriptor if one was open before */
+	if (cur_disk != NULL) {
+		if ((cur_file = open_disk(cur_disk->disk_path,
+			O_RDWR | O_NDELAY)) < 0) {
+			err_print("Error: can't reopen selected disk '%s'. \n",
+				cur_disk->disk_name);
+			fullabort();
+		}
+	}
+	/* Restore tty information */
+	if (isatty(0)) {
+		if (tty_flag > 0)
+			(void) ioctl(0, TCSETSW, &tty);
+		else if (tty_flag == 0) {
+			termio.c_iflag = tty.c_iflag;
+			termio.c_oflag = tty.c_oflag;
+			termio.c_cflag = tty.c_cflag;
+			termio.c_lflag = tty.c_lflag;
+			for (j = 0; j < NCC; j++)
+				termio.c_cc[j] = tty.c_cc[j];
+			(void) ioctl(0, TCSETAW, &termio);
+		}
+		if (isatty(1)) {
+			fmt_print("\n[Hit Return to continue] \n");
+			(void) fflush(stdin);
+			if (getchar() == EOF)
+				fullabort();
+		}
+	}
+	return (0);
+}
+void
+print_efi_string(char *vendor, char *product, char *revision,
+uint64_t capacity)
+{
+	char new_vendor[9];
+	char new_product[17];
+	char new_revision[5];
+	char capacity_string[10];
+	float scaled;
+	int i;
+	/* Strip whitespace from the end of inquiry strings */
+	(void) strlcpy(new_vendor, vendor, sizeof (new_vendor));
+	for (i = (strlen(new_vendor) - 1); i >= 0; i--) {
+		if (new_vendor[i] != 0x20) {
+			new_vendor[i+1] = '\0';
+			break;
+		}
+	}
+	(void) strlcpy(new_product, product, sizeof (new_product));
+	for (i = (strlen(new_product) - 1); i >= 0; i--) {
+		if (new_product[i] != 0x20) {
+			new_product[i+1] = '\0';
+			break;
+		}
+	}
+	(void) strlcpy(new_revision, revision, sizeof (new_revision));
+	for (i = (strlen(new_revision) - 1); i >= 0; i--) {
+		if (new_revision[i] != 0x20) {
+			new_revision[i+1] = '\0';
+			break;
+		}
+	}
+	/* Now build size string */
+	scaled = bn2mb(capacity);
+	if (scaled >= (float)1024.0 * 1024) {
+		(void) snprintf(capacity_string, sizeof (capacity_string),
+		    "%.2fTB", scaled/((float)1024.0 * 1024));
+	} else if (scaled >= (float)1024.0) {
+		(void) snprintf(capacity_string, sizeof (capacity_string),
+		    "%.2fGB", scaled/(float)1024.0);
+	} else {
+		(void) snprintf(capacity_string, sizeof (capacity_string),
+		    "%.2fMB", scaled);
+	}
+	fmt_print("<%s-%s-%s-%s>",
+	    new_vendor, new_product, new_revision, capacity_string);
+}

Mercurial > illumos > onarm

comparison usr/src/cmd/format/io.c @ 0:c9caec207d52 b86