path: root/usr/src/lib/lvm/libmeta/common/meta_print.c

/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * Just in case we're not in a build environment, make sure that
 * TEXT_DOMAIN gets set to something.
 */
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif

/*
 * report metadevice status
 */

#include <meta.h>

/*
 * print named metadevice
 */
int
meta_print_name(
	mdsetname_t	*sp,
	mdname_t	*namep,
	mdnamelist_t   **nlpp,
	char		*fname,
	FILE		*fp,
	mdprtopts_t	options,
	mdnamelist_t	**lognlpp,
	md_error_t	*ep
)
{
	char		*miscname;

	/* must have set */
	assert(sp != NULL);

	/* get type */
	if ((miscname = metagetmiscname(namep, ep)) == NULL)
		return (-1);

	/* dispatch */
	if (strcmp(miscname, MD_TRANS) == 0) {
		return (meta_trans_print(sp, namep, nlpp, fname, fp,
		    options, NULL, lognlpp, ep));
	}
	if (strcmp(miscname, MD_MIRROR) == 0) {
		return (meta_mirror_print(sp, namep, nlpp, fname, fp,
		    options, ep));
	}
	if (strcmp(miscname, MD_RAID) == 0) {
		return (meta_raid_print(sp, namep, nlpp, fname, fp,
		    options, ep));
	}
	if (strcmp(miscname, MD_STRIPE) == 0) {
		return (meta_stripe_print(sp, namep, nlpp, fname, fp,
		    options, ep));
	}
	if (strcmp(miscname, MD_SP) == 0) {
		return (meta_sp_print(sp, namep, nlpp, fname, fp,
		    options, ep));
	}

	/* unknown type */
	return (mdmderror(ep, MDE_UNKNOWN_TYPE, meta_getminor(namep->dev),
	    namep->cname));
}

/*
 * print all metadevices
 */
int
meta_print_all(
	mdsetname_t	*sp,
	char		*fname,
	mdnamelist_t	**nlpp,
	FILE		*fp,
	mdprtopts_t	options,
	int		*meta_print_trans_msgp,
	md_error_t	*ep
)
{
	md_error_t	status = mdnullerror;
	int		rval = 0;
	mdnamelist_t	*lognlp = NULL;


	/* print various types (save first error) */
	if (meta_trans_print(sp, NULL, nlpp, fname, fp, options,
	    meta_print_trans_msgp, &lognlp, ep) != 0) {
		rval = -1;
		ep = &status;
	}
	if (meta_logs_print(sp, lognlp, nlpp, fname, fp, options, ep) != 0) {
		rval = -1;
		ep = &status;
	}
	metafreenamelist(lognlp);
	if (meta_mirror_print(sp, NULL, nlpp, fname, fp, options, ep) != 0) {
		rval = -1;
		ep = &status;
	}
	if (meta_raid_print(sp, NULL, nlpp, fname, fp, options, ep) != 0) {
		rval = -1;
		ep = &status;
	}
	if (meta_stripe_print(sp, NULL, nlpp, fname, fp, options, ep) != 0) {
		rval = -1;
		ep = &status;
	}
	if (meta_sp_print(sp, NULL, nlpp, fname, fp, options, ep) != 0) {
		rval = -1;
		ep = &status;
	}
	if (meta_hsp_print(sp, NULL, nlpp, fname, fp, options, ep) != 0) {
		rval = -1;
		ep = &status;
	}

	/* discard further errors */
	mdclrerror(&status);

	/* return success */
	return (rval);
}

/*
 * format timestamp
 */
char *
meta_print_time(
	md_timeval32_t	*tvp
)
{
	static char	buf[128];
	struct tm	*tmp;
	char		*dcmsg;

	if (tvp == NULL)
		return ("");

	/*
	 * TRANSLATION_NOTE_LC_TIME
	 * This message is the format of file
	 * timestamps written with the -C and
	 * -c options.
	 * %a -- locale's abbreviated weekday name
	 * %b -- locale's abbreviated month name
	 * %e -- day of month [1,31]
	 * %T -- Time as %H:%M:%S
	 * %Y -- Year, including the century
	 */
	dcmsg = dcgettext(TEXT_DOMAIN, "%a %b %e %T %Y", LC_TIME);

	if (((tvp->tv_sec == 0) && (tvp->tv_usec == 0)) ||
	    ((tmp = localtime((const time_t *)&tvp->tv_sec)) == NULL) ||
	    (strftime(buf, sizeof (buf), dcmsg, tmp) == 0)) {
		return (dgettext(TEXT_DOMAIN, "(invalid time)"));
	}
	return (buf);
}

/*
 * format high resolution time into a tuple of seconds:milliseconds:microseconds
 */
char *
meta_print_hrtime(
	hrtime_t	secs
)
{
	long long	sec, msec, usec;
	static char	buf[128];

	usec = secs / 1000;
	msec = usec / 1000;
	sec  = msec / 1000;
	msec %= 1000;
	usec %= 1000;

	(void) snprintf(buf, sizeof (buf), "%4lld:%03lld:%03lld", sec, msec,
	    usec);
	return (buf);
}

/*
 * Routine to print 32 bit bitmasks
 *
 * Takes:
 *	fp	- a file descriptor
 *	fmt	- optional text
 *	ul	- unsigned long bit vector
 *	bitfmt	- special string to map bits to words.
 *		bitfmt is layed out as follows:
 *			byte 0 is the output base.
 *			byte 1 a bit position less than 32
 *			byte 2-n text for position in byte 1
 *			byte n+1 another bit position
 *			byte n+2-m text for position in byte n+1
 *				.
 *				.
 *				.
 *
 *		Eg. - "\020\001DOG\002CAT\003PIG"
 *		Print the bitmask in hex.
 *		If bit 1 (0x0001) is set print "<DOG>"
 *		If bit 2 (0x0002) is set print "<CAT>"
 *		If bit 3 (0x0004) is set print "<PIG>"
 *		If bit 4 (0x0008) is set nothing is printed.
 *		If bit 1 and bit 2 (0x0003) are set print <DOG,CAT>
 *
 *	Returns 0 on OK
 *		EOF on error
 *
 *	Outputs on fp
 *
 */

int
meta_prbits(FILE *fp, const char *fmt, ...)
{
	va_list		ap;
	unsigned long	ul;
	int		set;
	int		n;
	char		*p;

	va_start(ap, fmt);

	if (fmt && *fmt)
		if (fprintf(fp, fmt) == EOF)
			return (EOF);

	ul = va_arg(ap, int);
	p = va_arg(ap, char *);

	switch (*p++) {
	    case 8:
		if (fprintf(fp, "0%lo", ul) == EOF)
			return (EOF);
		break;

	    case 16:
		if (fprintf(fp, "0x%lx", ul) == EOF)
			return (EOF);
		break;

	    default:
	    case 10:
		if (fprintf(fp, "%ld", ul) == EOF)
			return (EOF);
		break;
	}

	if (! ul)
		return (0);

	for (set = 0; (n = *p++) != '\0'; /* void */) {
		if (ul & (1 << (n - 1))) {
			if (fputc(set ? ',' : '<', fp) == EOF)
				return (EOF);
			for (/* void */; (n = *p) > ' '; ++p)
				if (fputc(n, fp) == EOF)
					return (EOF);
			set = 1;
		} else
			for (/* void */; *p > ' '; ++p);
	}
	if (set)
		if (fputc('>', fp) == EOF)
			return (EOF);

	return (0);
}


/*
 * Convert a number of blocks to a string representation
 * Input:  64 bit wide number of blocks
 * Outout: string like "199MB" or "27TB" or "3.5GB"
 * Returns a pointer to the buffer.
 */
char *
meta_number_to_string(diskaddr_t number, u_longlong_t blk_sz)
{
	diskaddr_t save = 0;
	char *M = " KMGTPE"; /* kilo, mega, giga, tera, peta, exa */
	char *uom = M;    /* unit of measurement, initially ' ' (=M[0]) */
	static char buf[64];
	u_longlong_t	total_bytes;

	/* convert from blocks to bytes */
	total_bytes = number * blk_sz;

	/*
	 * Stop scaling when we reached exa bytes, then something is
	 * probably wrong with our number.
	 */
	while ((total_bytes >= 1024) && (*uom != 'E')) {
		uom++; /* next unit of measurement */
		save = total_bytes;
		total_bytes = total_bytes / 1024;
	}

	/* check if we should output a decimal place after the point */
	if (save && ((save / 1024) < 10)) {
		/* sprintf() will round for us */
		float fnum = (float)save / 1024;
		(void) sprintf(buf, "%1.1f %cB", fnum, *uom);
	} else {
		(void) sprintf(buf, "%llu %cB", total_bytes, *uom);
	}
	return (buf);
}

/*
 * meta_get_tstate: get the transient state bits from the kernel.
 * this is for use with printing out the state field in metastat.
 * INPUT: dev64 -- devt of the metadevice
 *	  tstatep -- return for tstate
 *	  ep	-- error
 * RETURN: -1 for error
 *	    0 for success
 */
int
meta_get_tstate(md_dev64_t dev64, uint_t *tstatep, md_error_t *ep)
{
	md_i_get_tstate_t	params;
	minor_t			mnum = meta_getminor(dev64);

	(void) memset(&params, 0, sizeof (params));
	params.id = mnum;
	if (metaioctl(MD_IOCGET_TSTATE, &params, &params.mde, NULL) != 0) {
		return (mdstealerror(ep, &params.mde));
	}
	*tstatep = params.tstate;
	return (0);
}

/*
 * meta_print_devid: print out the devid information, given a mddevid_t list.
 * INPUT: mdsetname_t	set we're looking at
 *	  FILE	where to print to
 *        mddevid_t list to print from.
 *	  md_error_t	error
 * RETURN: -1 for error
 *          0 for success
 */
int
meta_print_devid(
	mdsetname_t	*sp,
	FILE		*fp,
	mddevid_t	*mddevidp,
	md_error_t	*ep
)
{
	int		len = 0;
	mddevid_t	*tmp_mddevidp = NULL;
	ddi_devid_t	did = NULL;
	char		*devid = "";
	int		freedevid = 0;
	char		*reloc = "";


	/* print header */
	if (fprintf(fp, gettext("Device Relocation Information:\n")) < 0)
		return (-1);

	/*
	 * Building a format string on the fly that will
	 * be used in (f)printf. This allows the length
	 * of the ctd to vary from small to large without
	 * looking horrible.
	 */

	tmp_mddevidp = mddevidp;
	while (tmp_mddevidp != NULL) {
		len = max(len, strlen(tmp_mddevidp->ctdname));
		tmp_mddevidp = tmp_mddevidp->next;
	}

	if (fprintf(fp, "%-*s %-5s\t%s\n", len + 2,
	    gettext("Device  "),
	    gettext("Reloc"),
	    gettext("Device ID")) < 0)
		return (-1);

	/* print ctd's and devids */
	while (mddevidp != NULL) {
		did = (ddi_devid_t)
		    meta_getdidbykey(sp->setno, getmyside(sp, ep),
		    mddevidp->key, ep);

		if (did == (ddi_devid_t)NULL) {
			devid = "-";
			reloc = gettext("No ");
			freedevid = 0;
		} else {
			devid = devid_str_encode(did, NULL);
			reloc = gettext("Yes");
			freedevid = 1;
			Free(did);
		}

		if (fprintf(fp, "%-*s %-5s\t%s\n", len + 2, mddevidp->ctdname,
		    reloc, devid) < 0)
			return (-1);

		mddevidp = mddevidp->next;

		if (freedevid == 1)
			devid_str_free(devid);
	}
	return (0);
}