cmd/format/misc.c

/*
 * 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 (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * This file contains miscellaneous routines.
 */
#include "global.h"

#include <stdlib.h>
#include <signal.h>
#include <malloc.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/time.h>
#include <ctype.h>
#include <termio.h>
#include "misc.h"
#include "analyze.h"
#include "label.h"
#include "startup.h"

/* Function prototypes for ANSI C Compilers */
static void	cleanup(int sig);

struct	env *current_env = NULL;	/* ptr to current environment */
static int	stop_pending = 0;	/* ctrl-Z is pending */
struct	ttystate ttystate;		/* tty info */
static int	aborting = 0;		/* in process of aborting */

/*
 * For 4.x, limit the choices of valid disk names to this set.
 */
static char		*disk_4x_identifiers[] = { "sd", "id"};
#define	N_DISK_4X_IDS	(sizeof (disk_4x_identifiers)/sizeof (char *))


/*
 * This is the list of legal inputs for all yes/no questions.
 */
char	*confirm_list[] = {
	"yes",
	"no",
	NULL,
};

/*
 * This routine is a wrapper for malloc.  It allocates pre-zeroed space,
 * and checks the return value so the caller doesn't have to.
 */
void *
zalloc(int count)
{
	void	*ptr;

	if ((ptr = calloc(1, (unsigned)count)) == NULL) {
		err_print("Error: unable to calloc more space.\n");
		fullabort();
	}
	return (ptr);
}

/*
 * This routine is a wrapper for realloc.  It reallocates the given
 * space, and checks the return value so the caller doesn't have to.
 * Note that the any space added by this call is NOT necessarily
 * zeroed.
 */
void *
rezalloc(void *ptr, int count)
{
	void	*new_ptr;


	if ((new_ptr = realloc((char *)ptr, (unsigned)count)) == NULL) {
		err_print("Error: unable to realloc more space.\n");
		fullabort();
	}
	return (new_ptr);
}

/*
 * This routine is a wrapper for free.
 */
void
destroy_data(char *data)
{
	free(data);
}

#ifdef	not
/*
 * This routine takes the space number returned by an ioctl call and
 * returns a mnemonic name for that space.
 */
char *
space2str(uint_t space)
{
	char	*name;

	switch (space&SP_BUSMASK) {
	case SP_VIRTUAL:
		name = "virtual";
		break;
	case SP_OBMEM:
		name = "obmem";
		break;
	case SP_OBIO:
		name = "obio";
		break;
	case SP_MBMEM:
		name = "mbmem";
		break;
	case SP_MBIO:
		name = "mbio";
		break;
	default:
		err_print("Error: unknown address space type encountered.\n");
		fullabort();
	}
	return (name);
}
#endif	/* not */

/*
 * This routine asks the user the given yes/no question and returns
 * the response.
 */
int
check(char *question)
{
	int		answer;
	u_ioparam_t	ioparam;

	/*
	 * If we are running out of a command file, assume a yes answer.
	 */
	if (option_f)
		return (0);
	/*
	 * Ask the user.
	 */
	ioparam.io_charlist = confirm_list;
	answer = input(FIO_MSTR, question, '?', &ioparam, NULL, DATA_INPUT);
	return (answer);
}

/*
 * This routine aborts the current command.  It is called by a ctrl-C
 * interrupt and also under certain error conditions.
 */
void
cmdabort(int sig __unused)
{
	/*
	 * If there is no usable saved environment, gracefully exit.  This
	 * allows the user to interrupt the program even when input is from
	 * a file, or if there is no current menu, like at the "Select disk:"
	 * prompt.
	 */
	if (current_env == NULL || !(current_env->flags & ENV_USE))
		fullabort();

	/*
	 * If we are in a critical zone, note the attempt and return.
	 */
	if (current_env->flags & ENV_CRITICAL) {
		current_env->flags |= ENV_ABORT;
		return;
	}
	/*
	 * All interruptions when we are running out of a command file
	 * cause the program to gracefully exit.
	 */
	if (option_f)
		fullabort();
	fmt_print("\n");
	/*
	 * Clean up any state left by the interrupted command.
	 */
	cleanup(sig);
	/*
	 * Jump to the saved environment.
	 */
	longjmp(current_env->env, 0);
}

/*
 * This routine implements the ctrl-Z suspend mechanism.  It is called
 * when a suspend signal is received.
 */
void
onsusp(int sig __unused)
{
	int		fix_term;
#ifdef	NOT_DEF
	sigset_t	sigmask;
#endif	/* NOT_DEF */

	/*
	 * If we are in a critical zone, note the attempt and return.
	 */
	if (current_env != NULL && current_env->flags & ENV_CRITICAL) {
		stop_pending = 1;
		return;
	}
	/*
	 * If the terminal is mucked up, note that we will need to
	 * re-muck it when we start up again.
	 */
	fix_term = ttystate.ttyflags;
	fmt_print("\n");
	/*
	 * Clean up any state left by the interrupted command.
	 */
	cleanup(sig);
#ifdef	NOT_DEF
	/* Investigate whether all this is necessary */
	/*
	 * Stop intercepting the suspend signal, then send ourselves one
	 * to cause us to stop.
	 */
	sigmask.sigbits[0] = (ulong_t)0xffffffff;
	if (sigprocmask(SIG_SETMASK, &sigmask, NULL) == -1)
		err_print("sigprocmask failed %d\n", errno);
#endif	/* NOT_DEF */
	(void) signal(SIGTSTP, SIG_DFL);
	(void) kill(0, SIGTSTP);
	/*
	 * PC stops here
	 */
	/*
	 * We are started again.  Set us up to intercept the suspend
	 * signal once again.
	 */
	(void) signal(SIGTSTP, onsusp);
	/*
	 * Re-muck the terminal if necessary.
	 */
	if (fix_term & TTY_ECHO_OFF)
		echo_off();
	if (fix_term & TTY_CBREAK_ON)
		charmode_on();
}

/*
 * This routine implements the timing function used during long-term
 * disk operations (e.g. formatting).  It is called when an alarm signal
 * is received.
 */
void
onalarm(int sig __unused)
{
}


/*
 * This routine gracefully exits the program.
 */
void
fullabort(void)
{

	fmt_print("\n");
	/*
	 * Clean up any state left by an interrupted command.
	 * Avoid infinite loops caused by a clean-up
	 * routine failing again...
	 */
	if (!aborting) {
		aborting = 1;
		cleanup(SIGKILL);
	}
	exit(1);
	/*NOTREACHED*/
}

/*
 * This routine cleans up the state of the world.  It is a hodge-podge
 * of kludges to allow us to interrupt commands whenever possible.
 *
 * Some cleanup actions may depend on the type of signal.
 */
static void
cleanup(int sig)
{

	/*
	 * Lock out interrupts to avoid recursion.
	 */
	enter_critical();
	/*
	 * Fix up the tty if necessary.
	 */
	if (ttystate.ttyflags & TTY_CBREAK_ON) {
		charmode_off();
	}
	if (ttystate.ttyflags & TTY_ECHO_OFF) {
		echo_on();
	}

	/*
	 * If the defect list is dirty, write it out.
	 */
	if (cur_list.flags & LIST_DIRTY) {
		cur_list.flags = 0;
		if (!EMBEDDED_SCSI)
			write_deflist(&cur_list);
	}
	/*
	 * If the label is dirty, write it out.
	 */
	if (cur_flags & LABEL_DIRTY) {
		cur_flags &= ~LABEL_DIRTY;
		(void) write_label();
	}
	/*
	 * If we are logging and just interrupted a scan, print out
	 * some summary info to the log file.
	 */
	if (log_file && scan_cur_block >= 0) {
		pr_dblock(log_print, scan_cur_block);
		log_print("\n");
	}
	if (scan_blocks_fixed >= 0)
		fmt_print("Total of %lld defective blocks repaired.\n",
		    scan_blocks_fixed);
	if (sig != SIGSTOP) { /* Don't reset on suspend (converted to stop) */
		scan_cur_block = scan_blocks_fixed = -1;
	}
	exit_critical();
}

/*
 * This routine causes the program to enter a critical zone.  Within the
 * critical zone, no interrupts are allowed.  Note that calls to this
 * routine for the same environment do NOT nest, so there is not
 * necessarily pairing between calls to enter_critical() and exit_critical().
 */
void
enter_critical(void)
{

	/*
	 * If there is no saved environment, interrupts will be ignored.
	 */
	if (current_env == NULL)
		return;
	/*
	 * Mark the environment to be in a critical zone.
	 */
	current_env->flags |= ENV_CRITICAL;
}

/*
 * This routine causes the program to exit a critical zone.  Note that
 * calls to enter_critical() for the same environment do NOT nest, so
 * one call to exit_critical() will erase any number of such calls.
 */
void
exit_critical(void)
{

	/*
	 * If there is a saved environment, mark it to be non-critical.
	 */
	if (current_env != NULL)
		current_env->flags &= ~ENV_CRITICAL;
	/*
	 * If there is a stop pending, execute the stop.
	 */
	if (stop_pending) {
		stop_pending = 0;
		onsusp(SIGSTOP);
	}
	/*
	 * If there is an abort pending, execute the abort.
	 */
	if (current_env == NULL)
		return;
	if (current_env->flags & ENV_ABORT) {
		current_env->flags &= ~ENV_ABORT;
		cmdabort(SIGINT);
	}
}

/*
 * This routine turns off echoing on the controlling tty for the program.
 */
void
echo_off(void)
{
	/*
	 * Open the tty and store the file pointer for later.
	 */
	if (ttystate.ttyflags == 0) {
		if ((ttystate.ttyfile = open("/dev/tty",
		    O_RDWR | O_NDELAY)) < 0) {
			err_print("Unable to open /dev/tty.\n");
			fullabort();
		}
	}
	/*
	 * Get the parameters for the tty, turn off echoing and set them.
	 */
	if (tcgetattr(ttystate.ttyfile, &ttystate.ttystate) < 0) {
		err_print("Unable to get tty parameters.\n");
		fullabort();
	}
	ttystate.ttystate.c_lflag &= ~ECHO;
	if (tcsetattr(ttystate.ttyfile, TCSANOW, &ttystate.ttystate) < 0) {
		err_print("Unable to set tty to echo off state.\n");
		fullabort();
	}

	/*
	 * Remember that we've successfully turned
	 * ECHO mode off, so we know to fix it later.
	 */
	ttystate.ttyflags |= TTY_ECHO_OFF;
}

/*
 * This routine turns on echoing on the controlling tty for the program.
 */
void
echo_on(void)
{

	/*
	 * Using the saved parameters, turn echoing on and set them.
	 */
	ttystate.ttystate.c_lflag |= ECHO;
	if (tcsetattr(ttystate.ttyfile, TCSANOW, &ttystate.ttystate) < 0) {
		err_print("Unable to set tty to echo on state.\n");
		fullabort();
	}
	/*
	 * Close the tty and mark it ok again.
	 */
	ttystate.ttyflags &= ~TTY_ECHO_OFF;
	if (ttystate.ttyflags == 0) {
		(void) close(ttystate.ttyfile);
	}
}

/*
 * This routine turns off single character entry mode for tty.
 */
void
charmode_on(void)
{

	/*
	 * If tty unopened, open the tty and store the file pointer for later.
	 */
	if (ttystate.ttyflags == 0) {
		if ((ttystate.ttyfile = open("/dev/tty",
		    O_RDWR | O_NDELAY)) < 0) {
			err_print("Unable to open /dev/tty.\n");
			fullabort();
		}
	}
	/*
	 * Get the parameters for the tty, turn on char mode.
	 */
	if (tcgetattr(ttystate.ttyfile, &ttystate.ttystate) < 0) {
		err_print("Unable to get tty parameters.\n");
		fullabort();
	}
	ttystate.vmin = ttystate.ttystate.c_cc[VMIN];
	ttystate.vtime = ttystate.ttystate.c_cc[VTIME];

	ttystate.ttystate.c_lflag &= ~ICANON;
	ttystate.ttystate.c_cc[VMIN] = 1;
	ttystate.ttystate.c_cc[VTIME] = 0;

	if (tcsetattr(ttystate.ttyfile, TCSANOW, &ttystate.ttystate) < 0) {
		err_print("Unable to set tty to cbreak on state.\n");
		fullabort();
	}

	/*
	 * Remember that we've successfully turned
	 * CBREAK mode on, so we know to fix it later.
	 */
	ttystate.ttyflags |= TTY_CBREAK_ON;
}

/*
 * This routine turns on single character entry mode for tty.
 * Note, this routine must be called before echo_on.
 */
void
charmode_off(void)
{

	/*
	 * Using the saved parameters, turn char mode on.
	 */
	ttystate.ttystate.c_lflag |= ICANON;
	ttystate.ttystate.c_cc[VMIN] = ttystate.vmin;
	ttystate.ttystate.c_cc[VTIME] = ttystate.vtime;
	if (tcsetattr(ttystate.ttyfile, TCSANOW, &ttystate.ttystate) < 0) {
		err_print("Unable to set tty to cbreak off state.\n");
		fullabort();
	}
	/*
	 * Close the tty and mark it ok again.
	 */
	ttystate.ttyflags &= ~TTY_CBREAK_ON;
	if (ttystate.ttyflags == 0) {
		(void) close(ttystate.ttyfile);
	}
}


/*
 * Allocate space for and return a pointer to a string
 * on the stack.  If the string is null, create
 * an empty string.
 * Use destroy_data() to free when no longer used.
 */
char *
alloc_string(char *s)
{
	char	*ns;

	if (s == NULL) {
		ns = zalloc(1);
	} else {
		ns = zalloc(strlen(s) + 1);
		(void) strcpy(ns, s);
	}
	return (ns);
}


/*
 * This function can be used to build up an array of strings
 * dynamically, with a trailing NULL to terminate the list.
 *
 * Parameters:
 *	argvlist:  a pointer to the base of the current list.
 *		   does not have to be initialized.
 *	size:	   pointer to an integer, indicating the number
 *		   of string installed in the list.  Must be
 *		   initialized to zero.
 *	alloc:	   pointer to an integer, indicating the amount
 *		   of space allocated.  Must be initialized to
 *		   zero.  For efficiency, we allocate the list
 *		   in chunks and use it piece-by-piece.
 *	str:	   the string to be inserted in the list.
 *		   A copy of the string is malloc'ed, and
 *		   appended at the end of the list.
 * Returns:
 *	a pointer to the possibly-moved argvlist.
 *
 * No attempt to made to free unused memory when the list is
 * completed, although this would not be hard to do.  For
 * reasonably small lists, this should suffice.
 */
#define	INITIAL_LISTSIZE	32
#define	INCR_LISTSIZE		32

char **
build_argvlist(char **argvlist, int *size, int *alloc, char *str)
{
	if (*size + 2 > *alloc) {
		if (*alloc == 0) {
			*alloc = INITIAL_LISTSIZE;
			argvlist = zalloc(sizeof (char *) * (*alloc));
		} else {
			*alloc += INCR_LISTSIZE;
			argvlist = rezalloc((void *) argvlist,
			    sizeof (char *) * (*alloc));
		}
	}

	argvlist[*size] = alloc_string(str);
	*size += 1;
	argvlist[*size] = NULL;

	return (argvlist);
}


/*
 * Useful parsing macros
 */
#define	must_be(s, c)		if (*s++ != c) return (0)
#define	skip_digits(s)		while (isdigit(*s)) s++
/* Parsing macro below is created to handle fabric devices which contains */
/* upper hex digits like c2t210000203708B8CEd0s0.			  */
/* To get the target id(tid) the digit and hex upper digit need to	  */
/* be processed.							  */
#define	skip_digit_or_hexupper(s)	while (isdigit(*s) || \
					(isxdigit(*s) && isupper(*s))) s++

/*
 * Return true if a device name matches the conventions
 * for the particular system.
 */
int
conventional_name(char *name)
{
	must_be(name, 'c');
	skip_digits(name);
	if (*name == 't') {
		name++;
		skip_digit_or_hexupper(name);
	}
	must_be(name, 'd');
	skip_digits(name);
	must_be(name, 's');
	skip_digits(name);
	return (*name == 0);
}

#ifdef i386
/*
 * Return true if a device name match the emc powerpath name scheme:
 * emcpowerN[a-p,p0,p1,p2,p3,p4]
 */
int
emcpower_name(char *name)
{
	char	*emcp = "emcpower";
	char	*devp = "/dev/dsk";
	char	*rdevp = "/dev/rdsk";

	if (strncmp(devp, name, strlen(devp)) == 0) {
		name += strlen(devp) + 1;
	} else if (strncmp(rdevp, name, strlen(rdevp)) == 0) {
		name += strlen(rdevp) + 1;
	}
	if (strncmp(emcp, name, strlen(emcp)) == 0) {
		name += strlen(emcp);
		if (isdigit(*name)) {
			skip_digits(name);
			if ((*name >= 'a') && (*name <= 'p')) {
				name ++;
				if ((*name >= '0') && (*name <= '4')) {
					name++;
				}
			}
			return (*name == '\0');
		}
	}
	return (0);
}
#endif

/*
 * Return true if a device name matches the intel physical name conventions
 * for the particular system.
 */
int
fdisk_physical_name(char *name)
{
	must_be(name, 'c');
	skip_digits(name);
	if (*name == 't') {
		name++;
		skip_digit_or_hexupper(name);
	}
	must_be(name, 'd');
	skip_digits(name);
	must_be(name, 'p');
	skip_digits(name);
	return (*name == 0);
}

/*
 * Return true if a device name matches the conventions
 * for a "whole disk" name for the particular system.
 * The name in this case must match exactly that which
 * would appear in the device directory itself.
 */
int
whole_disk_name(char *name)
{
	must_be(name, 'c');
	skip_digits(name);
	if (*name == 't') {
		name++;
		skip_digit_or_hexupper(name);
	}
	must_be(name, 'd');
	skip_digits(name);
	must_be(name, 's');
	must_be(name, '2');
	return (*name == 0);
}


/*
 * Return true if a name is in the internal canonical form
 */
int
canonical_name(char *name)
{
	must_be(name, 'c');
	skip_digits(name);
	if (*name == 't') {
		name++;
		skip_digit_or_hexupper(name);
	}
	must_be(name, 'd');
	skip_digits(name);
	return (*name == 0);
}


/*
 * Return true if a name is in the internal canonical form for 4.x
 * Used to support 4.x naming conventions under 5.0.
 */
int
canonical4x_name(char *name)
{
	char    **p;
	int	i;

	p = disk_4x_identifiers;
	for (i = N_DISK_4X_IDS; i > 0; i--, p++) {
		if (match_substr(name, *p)) {
			name += strlen(*p);
			break;
		}
	}
	if (i == 0)
		return (0);
	skip_digits(name);
	return (*name == 0);
}


/*
 * Map a conventional name into the internal canonical form:
 *
 *	/dev/rdsk/c0t0d0s0 -> c0t0d0
 */
void
canonicalize_name(char *dst, char *src)
{
	char	*s;

	/*
	 * Copy from the 'c' to the end to the destination string...
	 */
	s = strchr(src, 'c');
	if (s != NULL) {
		(void) strcpy(dst, s);
		/*
		 * Remove the trailing slice (partition) reference
		 */
		s = dst + strlen(dst) - 2;
		if (*s == 's') {
			*s = 0;
		}
	} else {
		*dst = 0;	/* be tolerant of garbage input */
	}
}


/*
 * Return true if we find an occurance of s2 at the
 * beginning of s1.  We don't have to match all of
 * s1, but we do have to match all of s2
 */
int
match_substr(char *s1, char *s2)
{
	while (*s2 != 0) {
		if (*s1++ != *s2++)
		return (0);
	}

	return (1);
}


/*
 * Dump a structure in hexadecimal, for diagnostic purposes
 */
#define	BYTES_PER_LINE		16

void
dump(char *hdr, caddr_t src, int nbytes, int format)
{
	int	i;
	int	n;
	char	*p;
	char	s[256];

	assert(format == HEX_ONLY || format == HEX_ASCII);

	(void) strcpy(s, hdr);
	for (p = s; *p; p++) {
		*p = ' ';
	}

	p = hdr;
	while (nbytes > 0) {
		err_print("%s", p);
		p = s;
		n = min(nbytes, BYTES_PER_LINE);
		for (i = 0; i < n; i++) {
			err_print("%02x ", src[i] & 0xff);
		}
		if (format == HEX_ASCII) {
			for (i = BYTES_PER_LINE-n; i > 0; i--) {
				err_print("   ");
			}
			err_print("    ");
			for (i = 0; i < n; i++) {
				err_print("%c", isprint(src[i]) ? src[i] : '.');
			}
		}
		err_print("\n");
		nbytes -= n;
		src += n;
	}
}


float
bn2mb(uint64_t nblks)
{
	float	n;

	n = (float)nblks / 1024.0;
	return ((n / 1024.0) * cur_blksz);
}


diskaddr_t
mb2bn(float mb)
{
	diskaddr_t	n;

	n = (diskaddr_t)(mb * 1024.0 * (1024.0 / cur_blksz));
	return (n);
}

float
bn2gb(uint64_t nblks)
{
	float	n;

	n = (float)nblks / (1024.0 * 1024.0);
	return ((n/1024.0) * cur_blksz);

}

float
bn2tb(uint64_t nblks)
{
	float	n;

	n = (float)nblks / (1024.0 * 1024.0 * 1024.0);
	return ((n/1024.0) * cur_blksz);
}

diskaddr_t
gb2bn(float gb)
{
	diskaddr_t	n;

	n = (diskaddr_t)(gb * 1024.0 * 1024.0 * (1024.0 / cur_blksz));
	return (n);
}

/*
 * This routine finds out the number of lines (rows) in a terminal
 * window. The default value of TTY_LINES is returned on error.
 */
int
get_tty_lines(void)
{
	int	tty_lines = TTY_LINES;
	struct	winsize	winsize;

	if ((option_f == NULL) && isatty(0) == 1 && isatty(1) == 1) {
		/*
		 * We have a real terminal for std input and output
		 */
		winsize.ws_row = 0;
		if (ioctl(1, TIOCGWINSZ, &winsize) == 0) {
			if (winsize.ws_row > 2) {
				/*
				 * Should be atleast 2 lines, for division
				 * by (tty_lines - 1, tty_lines - 2) to work.
				 */
				tty_lines = winsize.ws_row;
			}
		}
	}
	return (tty_lines);
}