xref: /titanic_41/usr/src/lib/lvm/libmeta/common/meta_statconcise.c (revision 257873cfc1dd3337766407f80397db60a56f2f5a)

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

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

#include <meta.h>
#include <assert.h>
#include <ctype.h>
#include <mdiox.h>
#include <meta.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/lvm/md_mddb.h>
#include <sys/lvm/md_names.h>
#include <sys/lvm/md_crc.h>
#include <sys/lvm/md_convert.h>


/*
 * Design Notes:
 *
 * All of the code in this file supports the addition of metastat -c output
 * for the verbose option of metaimport.  Some of this code is also used by
 * the command metastat for concise output(cmd/lvm/util/metastat.c).
 * The code is designed to produce the same output as metastat -c does for a
 * given diskset--with a couple exceptions.
 * The primary differences between the output for the metastat -c command and
 * metastat output for metaimport -v are:
 *  - the set name is not printed next to each metadevice
 *  - top-level state information is not printed for some metadevices
 *  - the percent that a disk has completed resyncing is not listed
 * in metaimport -v.
 *
 *
 * The general layout of this file is as follows:
 *
 *  - report_metastat_info()
 *	This is the primary entry point for the functions in this file, with
 *	the exception of several functions that are also called from
 *	cmd/io/lvm/util/metastat.c
 *	report_metastat_info() calls functions to read in all the the
 *	Directory blocks and Record blocks and then process the information
 *	needed to print out the metadevice records in the same format as
 *	metastat -c.
 *
 *  - read_all_mdrecords()
 *	Reads in all the Directory blocks in the diskset and verifies their
 *	validity.  For each Directly block, it loops through all Directory
 *	Entries and for each one that contains a metadevice record calls
 *	read_md_record().  Because the output is designed to imitate the
 *	output of metastat -c, we ignore metadevice records for
 *	optimized resync, changelog, and translog.
 *
 *  - read_md_record()
 *	Reads in a Directory Entry and its associated Record block.  The
 *	revision information for the Record block is checked and it is
 *	determined whether or not it is a 64bit Record block or a 32bit record
 *	block.  For each valid Record block, it allocates an md_im_rec_t
 *	structure and calls extract_mduser_data().
 *
 *  - extract_mduser_data()
 *	Populates the md_im_rec_t data structure with information about the
 *	record's associated metadevice.  Also, the name of the metadevice is
 *	either copied from the NM namespace(if it exists there) or is generated
 *	from the record's un_self_id.
 *
 *  - process_toplevel_devices()
 *	For a given metadevice type, searchs through the md_im_rec_t **mdimpp,
 *	list of all metadevices in the set, to find all records of the
 *	specified type that do not have a parent and puts them on a temp list.
 *	The temp list is then iterated through and the associated processing
 *	function is called.
 *
 *  - process_(trans, hotspare, hotspare_pool, soft_part, mirror, stripe, raid)
 *	These functions are called by using the dfunc field in the mdimpp list.
 *	Each process function only understands its own type of metadevice. Once
 *	it processes the metadevice it was called for, it then loops through
 *	all of the underlying metadevices.  After printing the name of the
 *	underlying metadevice, it puts in on a list to be processed.  If the
 *	underlying device is a physical device, then print_physical_device is
 *	called.
 *	Once all information about the original metadevice is processed, it
 *	loops through the list of underlying metadevices and calls the
 *	appropriate function to process them.
 *
 *  - process_toplevel_softparts()
 *	To match the output for metastat -c, all top-level softpartions
 *	are printed out in groups based on their underlying metadevice--so that
 *	the underlying metadevice only needs to be processed once.
 *
 *  - meta_get_(sm_state, raid_col_state, stripe_state, hs_state)
 *	These functions are used to retrieve the metadevice state information.
 *	They are also used by the metastat concise routines in
 *	cmd/lvm/util/metastat.c.
 *
 */


/*
 * md_im_rec is a doubly linked list used to store the rb_data for each
 * directory entry that corresponds to a metadevice.
 * n_key: is set, if there is an associated entry in the NM namespace.
 * dfunc: is set to point to the function that processes the particular
 * metadevice associated with the record.
 * hs_record_id: is only set, if the metadevice is a hotspare.
 * un_self_id: is set for all other records. This is also used to generate
 * the name of the metadevice if there is no entry for the metadevice in
 * the NM namespace--n_key is not set.
 */
typedef struct md_im_rec {
	mdkey_t			n_key; /* NM namespace key */
	struct md_im_rec 	*next;
	struct md_im_rec 	*prev;
	uint_t			md_type;
	uint_t			has_parent; /* either 0(no parent) or 1 */
	minor_t			un_self_id;
	mddb_recid_t		hs_record_id; /* hotspare recid */
	char 			*n_name;  /* name of metadevice */
	void 			(*dfunc) ();
	ushort_t		record_len;
	/* pointer to the unit structure for the metadevice, e.g. rb_data[0] */
	void			*record;
} md_im_rec_t;

/*
 * md_im_list is used to group toplevel metadevices by type and to group
 * the underlying devices for a particular metadevice.
 */
typedef struct md_im_list {
	struct md_im_list	*next;
	struct md_im_rec 	*mdrec;
} md_im_list_t;


/*
 * MAXSIZEMDRECNAME is the value that has historically been used to allocate
 * space for the metadevice name
 */
#define	MAXSIZEMDRECNAME	20
#define	NAMEWIDTH		16
#define	offsetof(s, m)	((size_t)(&(((s *)0)->m)))
#define	NOT_PHYSICAL_DEV	0
#define	PHYSICAL_DEV		1


/*
 * strip_blacks()
 *
 * Strip blanks from string.  Used for size field in concise output.
 */
static char *
strip_blanks(char *s)
{
	char *p;

	for (p = s; *p; ) {
		if (*p == ' ') {
			char *t;
			for (t = p; *t; t++) {
				*t = *(t + 1);
			}
		} else {
			p++;
		}
	}

	return (s);
}


/*
 * print_concise_entry()
 *
 * Print properly indented metadevice name, type and size for concise output.
 * This function is also called from: cmd/lvm/util/metastat.c.
 */
void
print_concise_entry(int indent, char *name, diskaddr_t size, char mtype)
{
	int	i;
	int	width = NAMEWIDTH;	/* minumum field width for name */
	char	in[MAXPATHLEN];
	char	*sz;

	in[0] = 0;
	for (i = 0; i < indent; i++)
		(void) strlcat(in, " ", sizeof (in));

	/* set up minimum field width. negative for left justified */
	width -= indent;
	if (width < 0)
		width = 0;	/* overflowed; no minimum field needed */
	else
		width = 0 - width; /* negative for left justification */

	if (size == 0) {
		sz = "-";
	} else {
		sz = strip_blanks(meta_number_to_string(size, DEV_BSIZE));
	}

	(void) printf("%s%*s %c %6s", in, width, name, mtype, sz);
}


/*
 * free_mdrec_list_entry()
 *
 * Removing entry from the list of metadevices in the diskset(mdimpp).
 * This function will not remove the dummy entry at the head of the
 * list, so we don't have to set mdrec equal to NULL.
 */
static void
free_mdrec_list_entry(md_im_rec_t  **mdrec)
{
	(*mdrec)->prev->next = (*mdrec)->next;
	if ((*mdrec)->next != NULL) {
		(*mdrec)->next->prev = (*mdrec)->prev;
	}
	Free((*mdrec)->record);
	Free((*mdrec)->n_name);
	Free(*mdrec);
}


/*
 * ucomponent_append()
 *
 * Appending entry to the underlying component list.  The list
 * is used to group all of the underlying devices before
 * processing them.
 */
static void
ucomponent_append(
	md_im_list_t	**ucomp_head,
	md_im_list_t	**ucomp_tail,
	md_im_list_t	*ucomp
)
{
	ucomp->next = NULL;
	if (*ucomp_head == NULL) {
		*ucomp_head = ucomp;
		*ucomp_tail = ucomp;
	} else {
		(*ucomp_tail)->next = ucomp;
		*ucomp_tail = (*ucomp_tail)->next;
	}
}


/*
 * free_md_im_list_entries()
 *
 * Freeing entries on an md_im_list_t.  This list is used to group
 * underlying components for processing and to group top-level metadevices
 * by type.
 */
static void
free_md_im_list_entries(md_im_list_t **list_head)
{
	md_im_list_t	*tmp_list_entry = *list_head;
	md_im_list_t	*rm_list_entry;

	while (tmp_list_entry != NULL) {
		rm_list_entry = tmp_list_entry;
		tmp_list_entry = tmp_list_entry->next;
		Free(rm_list_entry);
	}
}


/*
 * print_physical_device()
 *
 * If a metadevice has an underlying component that is a physical
 * device, then this searches the pnm_rec_t list to match an entry's
 * n_key to the key for the underlying component.  The ctd name of the
 * physical device is printed on the same line as the metadevice.
 */
static void
print_physical_device(
	pnm_rec_t	*phys_nm,
	mdkey_t		key
)
{
	pnm_rec_t	*tmpphys_nm;

	for (tmpphys_nm = phys_nm; tmpphys_nm != NULL;
	    tmpphys_nm = tmpphys_nm->next) {
		if (tmpphys_nm->n_key == key) {
			(void) printf(" %s", tmpphys_nm->n_name);
			break;
		}
	}
}


/*
 * get_stripe_req_size()
 *
 * Given a 64bit stripe unit, compute the size of the stripe unit.
 * This function is a derivation of:
 *	common/lvm/md_convert.c:get_big_stripe_req_size()
 * and any changes made to either this function or get_big_stripe_req_size()
 * should be reviewed to make sure the functionality in both places is correct.
 *
 * Returns:
 *	total size of the 64bit stripe
 */
size_t
get_stripe_req_size(ms_unit_t *un)
{
	struct ms_row *mdr;
	uint_t row;
	uint_t ncomps = 0;
	size_t mdsize = 0;
	size_t first_comp = 0;


	/* Compute the offset of the first component */
	first_comp = sizeof (ms_unit_t) +
	    sizeof (struct ms_row) * (un->un_nrows - 1);
	first_comp = roundup(first_comp, sizeof (long long));

	/*
	 * Requestor wants to have the total size, add the sizes of
	 * all components
	 */
	mdr = &un->un_row[0];
	for (row = 0; (row < un->un_nrows); row++)
	    ncomps += mdr[row].un_ncomp;
	mdsize = first_comp + sizeof (ms_comp_t) * ncomps;
	return (mdsize);
}


/*
 * meta_get_sm_state()
 *
 * Gets the state for the underlying components(submirrors) of a mirror.
 * This function is also called from: cmd/lvm/util/metastat.c.
 *
 * Returns:
 *	string for state of the sub-mirror
 */
static char *
meta_get_sm_state(
	sm_state_t	state
)
{
	/* all is well */
	if (state & SMS_RUNNING) {
		return (NULL);
	}

	/* resyncing, needs repair */
	if ((state & (SMS_COMP_RESYNC | SMS_ATTACHED_RESYNC |
	    SMS_OFFLINE_RESYNC))) {
		return (gettext("resyncing"));
	}

	/* needs repair */
	if (state & (SMS_COMP_ERRED | SMS_ATTACHED | SMS_OFFLINE))
		return (gettext("maint"));

	/* unknown */
	return (gettext("unknown"));
}


/*
 * meta_get_raid_col_state()
 *
 * Gets the state for the underlying components(columns) of a raid.
 * This function is also called from: cmd/lvm/util/metastat.c.
 *
 * Returns:
 *	string for state of the raid column
 *
 */
char *
meta_get_raid_col_state(
	rcs_state_t	state
)
{
	switch (state) {
		case RCS_INIT:
			return (gettext("initializing"));
		case RCS_OKAY:
			return (NULL);
		case RCS_INIT_ERRED:
			/*FALLTHROUGH*/
		case RCS_ERRED:
			return (gettext("maint"));
		case RCS_LAST_ERRED:
			return (gettext("last-erred"));
		case RCS_RESYNC:
			return (gettext("resyncing"));
		default:
			return (gettext("unknown"));
	}
}


/*
 * meta_get_stripe_state()
 *
 * Gets the state for the underlying components of a stripe.
 * This function is also called from: cmd/lvm/util/metastat.c.
 *
 * Returns:
 *	string for state of the stripe
 *
 */
char *
meta_get_stripe_state(
	comp_state_t	state
)
{
	switch (state) {
		case CS_OKAY:
			return (NULL);
		case CS_ERRED:
			return (gettext("maint"));
		case CS_LAST_ERRED:
			return (gettext("last-erred"));
		case CS_RESYNC:
			return (gettext("resyncing"));
		default:
			return (gettext("invalid"));
	}
}


/*
 * meta_get_hs_state()
 *
 * Gets the state for the underlying components(hotspares) of a hotspare pool.
 * This function is also called from: cmd/lvm/util/metastat.c.
 *
 * Returns:
 *	string for state of the hotspare
 *
 */
char *
meta_get_hs_state(
	hotspare_states_t	state
)
{
	switch (state) {
		case HSS_AVAILABLE:
			return (NULL);
		case HSS_RESERVED:
			return (gettext("in-use"));
		case HSS_BROKEN:
			return (gettext("broken"));
		case HSS_UNUSED:
			/* FALLTHROUGH */
		default:
			return (gettext("invalid"));
	}
}


/*
 * process_trans()
 *
 * Prints unit information for a trans metadevice and calls the respective
 * functions to process the underlying metadevices.
 *
 */
static void
process_trans(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	mt_unit_t	*mt;
	mdc_unit_t	uc;
	md_im_rec_t	*tmpmdrec;
	int		underlying_device = PHYSICAL_DEV;

	mt = (mt_unit_t *)mdrec->record;
	uc = mt->c;

	/* Printing name, size, and type of metadevice */
	print_concise_entry(indent, mdrec->n_name,
	    uc.un_total_blocks, 't');

	/*
	 * Loops through md_im_rec_t **mdimpp list of all metadevices to find
	 * record that matches the underlying device.
	 * Trans devices can only have one underlying device, so once a
	 * match is found, we are done.
	 */
	for (tmpmdrec = *mdimpp; tmpmdrec != NULL;
	    tmpmdrec = tmpmdrec->next) {
		if (tmpmdrec->n_key == mt->un_m_key) {
			/* Printing name of the underlying metadevice */
			(void) printf(" %s", tmpmdrec->n_name);
			underlying_device = NOT_PHYSICAL_DEV;
			break;
		}
	}

	/*
	 * If a metadevice was not found, then the underlying device must be a
	 * physical device.  Otherwise, call the functions to process the
	 * underlying devices.
	 */
	if (underlying_device == PHYSICAL_DEV) {
		print_physical_device(phys_nm, mt->un_m_key);
		(void) printf("\n");
	} else {
		/* process underlying component */
		(void) printf("\n");
		indent += META_INDENT;
		tmpmdrec->dfunc(mdimpp, indent, phys_nm, tmpmdrec);
	}

	/*
	 * Removing the md_entry from the list
	 * of all metadevices
	 */
	free_mdrec_list_entry(&mdrec);
}


/*
 * process_hotspare()
 *
 * Searches though list of physical devices to match hotspare record.
 * Prints physical device name and state of a hotspare unit.
 *
 */
/*ARGSUSED*/
static void
process_hotspare(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	hot_spare_t	*hs;
	pnm_rec_t	*tmpphys_nm;
	char 		*state = NULL;

	hs =  (hot_spare_t *)mdrec->record;

	/*
	 * Loops through physical namespace to find the device that matches
	 * the hotspare entry.
	 */
	for (tmpphys_nm = phys_nm; tmpphys_nm != NULL;
	    tmpphys_nm = tmpphys_nm->next) {
		if (tmpphys_nm->n_key ==
		    ((hot_spare_t *)hs)->hs_key) {
			/* Printing name of hotspare device */
			(void) printf(" %s", tmpphys_nm->n_name);
			break;
		}
	}

	state = meta_get_hs_state(hs->hs_state);
	if (state != NULL)
		(void) printf(" (%s)", state);

	/* Not removing entry, because it can be processed more than once. */
}


/*
 * process_hotspare_pool()
 *
 * Prints concise unit information for a hotspare pool metadevice and calls a
 * function to process each attached hotspare device.
 *
 */
static void
process_hotspare_pool(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	hot_spare_pool_ond_t	*hsp;
	int			i;
	md_im_rec_t		*tmpmdrec;

	hsp =  (hot_spare_pool_ond_t *)mdrec->record;

	/*
	 * Printing name, size, and type of metadevice. Setting size field to
	 * 0, so that output is the as metastat -c.
	 */
	print_concise_entry(indent, mdrec->n_name,
	    0, 'h');

	/* Looping through list of attached hotspare devices. */
	for (i = 0; i < hsp->hsp_nhotspares; i++) {
		/* Looking for the matching record for the hotspare device. */
		for (tmpmdrec = *mdimpp; tmpmdrec != NULL;
		    tmpmdrec = tmpmdrec->next) {
			if (tmpmdrec->hs_record_id == hsp->hsp_hotspares[i]) {
				/* Calling function to print name of hotspare */
				tmpmdrec->dfunc(mdimpp, indent, phys_nm,
				    tmpmdrec);
			}
		}
	}
	(void) printf("\n");

	/*
	 * Removing the md_entry from the list
	 * of all metadevices
	 */
	free_mdrec_list_entry(&mdrec);
}


/*
 * process_raid()
 *
 * Prints concise unit information for a raid metadevice and calls the
 * respective functions to process the underlying metadevices.
 *
 */
static void
process_raid(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	mr_unit_t	*mr;
	mr_column_t	*mc;
	mdc_unit_t	uc;
	int		i;
	md_im_rec_t	*tmpmdrec;
	md_im_rec_t	*hstmpmdrec;
	md_im_list_t	*ucomp_head = NULL;
	md_im_list_t	*ucomp_tail = NULL;
	md_im_list_t	*ucomp = NULL;
	pnm_rec_t	*tmpphys_nm;
	int		underlying_device;

	mr =  (mr_unit_t *)mdrec->record;
	uc = mr->c;

	/* Printing name, size, and type of metadevice */
	print_concise_entry(indent, mdrec->n_name,
	    uc.un_total_blocks, 'r');

	/* Loops through raid columns to find underlying metadevices */
	for (i = 0, mc = &mr->un_column[0];  i < mr->un_totalcolumncnt;
	    i++, mc++) {
		char	*state = NULL;
		char	*hsname = NULL;

		/*
		 * Need to assume that underlying device is a physical device,
		 * unless we find a matching metadevice record.
		 */
		underlying_device = PHYSICAL_DEV;

		/*
		 * Loops through list of metadevices to find record that matches
		 * the underlying device.
		 */
		for (tmpmdrec = *mdimpp; tmpmdrec != NULL;
		    tmpmdrec = tmpmdrec->next) {
			if (tmpmdrec->n_key == mc->un_orig_key) {
				/* check if hotspare device enabled */
				if (mc->un_hs_id !=  NULL) {
					/*
					 * Find matching metadevice record
					 * for the hotspare device.
					 */
					for (hstmpmdrec = *mdimpp;
					    hstmpmdrec != NULL;
					    hstmpmdrec = hstmpmdrec->next) {
						if (hstmpmdrec->hs_record_id ==
						    mc->un_hs_id) {
							/* print name of hs */
							hstmpmdrec->dfunc(
							    mdimpp, indent,
							    phys_nm,
							    hstmpmdrec);
							break;
						}
					}
				}
				/* print name of underlying metadevice */
				(void) printf(" %s", tmpmdrec->n_name);
				underlying_device = NOT_PHYSICAL_DEV;
				ucomp = Zalloc(sizeof (md_im_list_t));
				ucomp->mdrec = tmpmdrec;
				ucomponent_append(&ucomp_head, &ucomp_tail,
				    ucomp);
			}
		}

		if (underlying_device == PHYSICAL_DEV) {
			print_physical_device(phys_nm, mc->un_orig_key);
		}
		state = meta_get_raid_col_state(mc->un_devstate);

		/*
		 * An underlying hotspare must be a physical device.
		 * If support is ever added for soft-partitions under
		 * hotspare pools, then this code should be updated to
		 * include a search for underlying metadevices.
		 */
		if (mc->un_hs_id != 0) {
			for (tmpphys_nm = phys_nm; tmpphys_nm != NULL;
			    tmpphys_nm = tmpphys_nm->next) {
				if (tmpphys_nm->n_key == mc->un_hs_key) {
					hsname = tmpphys_nm->n_name;
					break;
				}
			}
		}

		if (state != NULL) {
			if (hsname != NULL)
				(void) printf(" (%s-%s)", state,
				    hsname);
			else
				(void) printf(" (%s)", state);
		} else if (hsname != NULL) {
			(void) printf(gettext(" (spared-%s)"), hsname);
		}
	}
	(void) printf("\n");

	/* process underlying components */
	indent += META_INDENT;
	for (ucomp = ucomp_head; ucomp != NULL;
	    ucomp = ucomp->next) {
		ucomp->mdrec->dfunc(mdimpp, indent, phys_nm,
		    ucomp->mdrec);
	}
	free_md_im_list_entries(&ucomp_head);

	/*
	 * Removing the md_entry from the list
	 * of all metadevices
	 */
	free_mdrec_list_entry(&mdrec);
}


/*
 * process_mirror()
 *
 * Prints concise unit information for a mirror metadevice and calls the
 * respective functions to process the underlying metadevices.
 *
 */
static void
process_mirror(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	mm_unit_t	*mm;
	mm_submirror_t 	*sm;
	mdc_unit_t	uc;
	int		i;
	md_im_rec_t	*tmpmdrec;
	md_im_list_t	*ucomp_head = NULL;
	md_im_list_t	*ucomp_tail = NULL;
	md_im_list_t	*ucomp = NULL;

	mm =  (mm_unit_t *)mdrec->record;
	uc = mm->c;

	/* Printing name, size, and type of metadevice */
	print_concise_entry(indent, mdrec->n_name,
	    uc.un_total_blocks, 'm');

	/* Looping through sub-mirrors to find underlying devices */
	for (i = 0, sm = &mm->un_sm[0]; i < mm->un_nsm; i++, sm++) {
		char 	*state = NULL;

		for (tmpmdrec = *mdimpp; tmpmdrec != NULL;
		    tmpmdrec = tmpmdrec->next) {
			if (tmpmdrec->n_key == sm->sm_key) {
				(void) printf(" %s", tmpmdrec->n_name);
				ucomp = Zalloc(sizeof (md_im_list_t));
				ucomp->mdrec = tmpmdrec;
				ucomponent_append(&ucomp_head, &ucomp_tail,
				    ucomp);
			}
		}

		/*
		 * It is not possible to have an underlying physical device
		 * for a submirror, so there is no need to search the phys_nm
		 * list.
		 */

		/* Printing the state for the submirror */
		state = meta_get_sm_state(sm->sm_state);
		if (state != NULL) {
			(void) printf(" (%s)", state);
		}
	}
	(void) printf("\n");

	/* process underlying components */
	indent += META_INDENT;
	for (ucomp = ucomp_head; ucomp != NULL;
	    ucomp = ucomp->next) {
		ucomp->mdrec->dfunc(mdimpp, indent, phys_nm,
		    ucomp->mdrec);
	}
	free_md_im_list_entries(&ucomp_head);

	/*
	 * Removing the md_entry from the list
	 * of all metadevices
	 */
	free_mdrec_list_entry(&mdrec);
}


/*
 * process_stripe()
 *
 * Prints concise unit information for a stripe metadevice and calls the
 * respective functions to process the underlying metadevices.
 *
 */
static void
process_stripe(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	ms_unit_t	*ms;
	mdc_unit_t	uc;
	md_im_rec_t	*tmpmdrec;
	md_im_list_t	*ucomp_head = NULL;
	md_im_list_t	*ucomp_tail = NULL;
	md_im_list_t	*ucomp = NULL;
	pnm_rec_t	*tmpphys_nm;
	int		underlying_device;
	uint_t		row;

	ms =  (ms_unit_t *)mdrec->record;
	uc = ms->c;

	/* Printing name, size, and type of metadevice */
	print_concise_entry(indent, mdrec->n_name,
	    uc.un_total_blocks, 's');

	/* Looping through stripe rows */
	for (row = 0; (row < ms->un_nrows); ++row) {
		struct ms_row	*mdr = &ms->un_row[row];
		ms_comp_t	*mdcomp = (void *)&((char *)ms)
		    [ms->un_ocomp];
		uint_t		comp, c;

		/*
		 * Looping through the components in each row to find the
		 * underlying devices.
		 */
		for (comp = 0, c = mdr->un_icomp; (comp < mdr->un_ncomp);
		    ++comp, ++c) {
			char		*state = NULL;
			char		*hsname = NULL;
			ms_comp_t	*mdc = &mdcomp[c];
			md_m_shared_t 	*mdm = &mdc->un_mirror;

			/*
			 * Need to assume that underlying device is a
			 * physical device, unless we find a matching
			 * metadevice record.
			 */
			underlying_device = PHYSICAL_DEV;

			for (tmpmdrec = *mdimpp; tmpmdrec != NULL;
			    tmpmdrec = tmpmdrec->next) {
				if (tmpmdrec->n_key == mdc->un_key) {
					(void) printf(" %s", tmpmdrec->n_name);
					underlying_device = NOT_PHYSICAL_DEV;
					ucomp = Zalloc(sizeof (md_im_list_t));
					ucomp->mdrec = tmpmdrec;
					ucomponent_append(&ucomp_head,
					    &ucomp_tail, ucomp);
				}
			}
			/* if an underlying metadevice was not found */
			if (underlying_device == PHYSICAL_DEV) {
				print_physical_device(phys_nm, mdc->un_key);
			}
			state = meta_get_stripe_state(mdm->ms_state);

			/*
			 * An underlying hotspare must be a physical device.
			 * If support is ever added for soft-partitions under
			 * hotspare pools, then this code should be updated to
			 * include a search for underlying metadevices.
			 */
			if (mdm->ms_hs_key != 0) {
				for (tmpphys_nm = phys_nm; tmpphys_nm != NULL;
				    tmpphys_nm = tmpphys_nm->next) {
					if (tmpphys_nm->n_key ==
					    mdm->ms_hs_key) {
						hsname = tmpphys_nm->n_name;
						break;
					}
				}
			}
			if (state != NULL) {
				if (hsname != NULL) {
					(void) printf(" (%s-%s)", state,
					    hsname);
				} else {
					(void) printf(" (%s)", state);
				}
			} else if (hsname != NULL) {
				(void) printf(gettext(" (spared-%s)"), hsname);
			}
		}
	}
	(void) printf("\n");

	/* Process underlying metadevices */
	indent += META_INDENT;
	for (ucomp = ucomp_head; ucomp != NULL;
	    ucomp = ucomp->next) {
		ucomp->mdrec->dfunc(mdimpp, indent, phys_nm,
		    ucomp->mdrec);
	}
	free_md_im_list_entries(&ucomp_head);

	/*
	 * Removing the md_entry from the list
	 * of all metadevices
	 */
	free_mdrec_list_entry(&mdrec);
}


/*
 * process_softpart()
 *
 * Prints concise unit information for a softpart metadevice and calls the
 * respective functions to process the underlying metadevices.
 *
 */
static void
process_softpart(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm,
	md_im_rec_t	*mdrec
)
{
	mp_unit_t	*mp;
	mdc_unit_t	uc;
	md_im_rec_t	*tmpmdrec;
	int		underlying_device = PHYSICAL_DEV;

	mp =  (mp_unit_t *)mdrec->record;
	uc = mp->c;

	/* Printing name, size, and type of metadevice */
	print_concise_entry(indent, mdrec->n_name,
	    uc.un_total_blocks, 'p');

	/*
	 * Loops through md_im_rec_t **mdimpp list of all metadevices to find
	 * record that matches the underlying device.
	 * Softpartitions can only have one underlying device, so once a
	 * match is found, we are done.
	 */
	for (tmpmdrec = *mdimpp; tmpmdrec != NULL;
	    tmpmdrec = tmpmdrec->next) {
		if (tmpmdrec->n_key == mp->un_key) {
			/* Printing name of the underlying metadevice */
			(void) printf(" %s", tmpmdrec->n_name);
			underlying_device = NOT_PHYSICAL_DEV;
			break;
		}
	}

	/* This is only executed if an underlying metadevice was not found */
	if (underlying_device == PHYSICAL_DEV) {
		print_physical_device(phys_nm, mp->un_key);
		(void) printf("\n");
	} else {
		/* Process underlying metadevice */
		(void) printf("\n");
		indent += META_INDENT;
		tmpmdrec->dfunc(mdimpp, indent, phys_nm,
		    tmpmdrec);
	}

	/*
	 * Removing the md_entry from the list
	 * of all metadevices
	 */
	free_mdrec_list_entry(&mdrec);
}


/*
 * process_toplevel_softparts()
 *
 * Toplevel softpartions need to be grouped so that their underlying devices
 * can be printed just once.
 */
static void
process_toplevel_softparts(
	md_im_rec_t	**mdimpp,
	int		indent,
	pnm_rec_t	*phys_nm
)
{
	mp_unit_t	*mp;
	mdc_unit_t	uc;
	md_im_rec_t	*mdrec;
	md_im_rec_t	*comp_mdrec; /* pntr to underlying component's record */
	md_im_rec_t	*tmp_mdrec, *rm_mdrec;
	mp_unit_t	*tmp_mp;
	int		underlying_device;

	/*
	 * Loops through md_im_rec_t **mdimpp list of all metadevices to find
	 * all softpartions that are toplevel softpartitions(softparts w/out
	 * a parent). Groups output for these entries so that the function to
	 * process the underlying metadevice is only called once.
	 */
	for (mdrec = *mdimpp; mdrec != NULL; mdrec = mdrec->next) {

		underlying_device = PHYSICAL_DEV;
		if ((mdrec->md_type == MDDB_F_SOFTPART) &&
		    (mdrec->has_parent == 0)) {
			mp =  (mp_unit_t *)mdrec->record;
			uc = mp->c;
			/* Printing name, size, and type of metadevice */
			print_concise_entry(indent, mdrec->n_name,
			    uc.un_total_blocks, 'p');
			/*
			 * Looking for record that matches underlying
			 * component.
			 */
			for (comp_mdrec = *mdimpp; comp_mdrec != NULL;
			    comp_mdrec = comp_mdrec->next) {
				if (comp_mdrec->n_key == mp->un_key) {
					/* Print name of underlying device */
					(void) printf(" %s",
					    comp_mdrec->n_name);
					underlying_device = NOT_PHYSICAL_DEV;
					break;
				}
			}
			if (underlying_device == PHYSICAL_DEV) {
				print_physical_device(phys_nm, mp->un_key);
			}
			(void) printf("\n");

			/*
			 * Looking for any other toplevel softpartitions with
			 * same underlying device. We know that all other
			 * matching metadevices, that share the same underlying
			 * metadevice, are also soft-partitions.
			 */
			for (tmp_mdrec = mdrec->next; tmp_mdrec != NULL; ) {
				tmp_mp = (mp_unit_t *)tmp_mdrec->record;
				if ((tmp_mdrec->has_parent == 0) &&
				    (tmp_mp->un_key == mp->un_key)) {
					uc = tmp_mp->c;
					print_concise_entry(indent,
					    tmp_mdrec->n_name,
					    uc.un_total_blocks, 'p');
					if (underlying_device ==
					    NOT_PHYSICAL_DEV) {
						(void) printf(" %s",
						    comp_mdrec->n_name);
					} else {
						print_physical_device(
						    phys_nm, tmp_mp->un_key);
					}
					(void) printf("\n");
					/*
					 * Need to advance so that will not lose
					 * position after removing processed
					 * record.
					 */
					rm_mdrec = tmp_mdrec;
					tmp_mdrec = tmp_mdrec->next;
					/*
					 * Removing the md_entry from the list
					 * of all metadevices.
					 */
					free_mdrec_list_entry(&rm_mdrec);
				} else {
					tmp_mdrec = tmp_mdrec->next;
				}
			}
			/* Process the underlying device */
			if (underlying_device == NOT_PHYSICAL_DEV) {
				indent += META_INDENT;
				comp_mdrec->dfunc(mdimpp, indent, phys_nm,
				    comp_mdrec);
			}
		}
	}
}


/*
 * process_toplevel_devices()
 *
 * Search through list of metadevices for metadevices of md_type that do not
 * have a parent.
 *
 */
static void
process_toplevel_devices(
	md_im_rec_t	**mdimpp,
	pnm_rec_t	*pnm,
	uint_t		md_type
)
{
	md_im_rec_t	*mdrec;
	md_im_list_t	*mdrec_tl_tail = NULL;
	md_im_list_t	*mdrec_tl_head = NULL;
	md_im_list_t	*tmp_tl_list = NULL;
	int		indent = 0;

	indent += META_INDENT;

	/*
	 * Need to group soft partitions so that common underlying device
	 * are only processed once.
	 */
	if (md_type == MDDB_F_SOFTPART) {
		process_toplevel_softparts(mdimpp, indent, pnm);
		return;
	}

	/*
	 * Search the list of metadevices to find all metadevices that match
	 * the type and don't have a parent.  Put them on a separate list
	 * that will be processed.
	 */
	for (mdrec = *mdimpp; mdrec != NULL; mdrec = mdrec->next) {
		if ((mdrec->md_type == md_type)&&(mdrec->has_parent == 0)) {
			tmp_tl_list = Zalloc(sizeof (md_im_list_t));
			tmp_tl_list->mdrec = mdrec;
			tmp_tl_list->next = NULL;
			if (mdrec_tl_tail == NULL) {
				mdrec_tl_tail = tmp_tl_list;
				mdrec_tl_head = mdrec_tl_tail;
			} else {
				mdrec_tl_tail->next = tmp_tl_list;
				mdrec_tl_tail = mdrec_tl_tail->next;
			}
		}

	}

	/*
	 * Loop through list and process all top-level metadevices of a
	 * given type.
	 */
	for (tmp_tl_list = mdrec_tl_head; tmp_tl_list != NULL;
	    tmp_tl_list = tmp_tl_list->next) {
		tmp_tl_list->mdrec->dfunc(mdimpp, indent, pnm,
		    tmp_tl_list->mdrec);
	}

	free_md_im_list_entries(&mdrec_tl_head);
}


/*
 * extract_mduser_data()
 *
 * Converts or copies the (mddb_rb_t->rb_data) metadevice record to a 64bit
 * record.
 * Sets the dfunc field to point to the appropriate function to process the
 * metadevice.
 * Sets the parent field for the metadevice.
 * Extracts the name from the NM namespace if it is available, otherwise
 * generates it from the metadevice's minor number.
 *
 * Returns:
 *	< 0 for failure
 *	  0 for success
 *
 */
static int
extract_mduser_data(
	mddb_rb_t		*nm,
	md_im_rec_t		*mdrec,
	void			*rbp,
	int 			is_32bit_record,
	md_error_t		*ep
)
{
	mdc_unit_t		uc;
	hot_spare_t 		*hs;
	hot_spare_pool_ond_t 	*hsp;
	size_t			newreqsize;
	mddb_rb_t		*rbp_nm = nm;
	struct nm_rec		*nm_record;
	struct nm_name		*nmname;
	char 			*uname = NULL;


	/*LINTED*/
	nm_record = (struct nm_rec *)((caddr_t)(&rbp_nm->rb_data));

	/*
	 * Setting the un_self_id or the hs_self_id, in the case of hotspare
	 * records, for each metadevice entry. Also setting has_parent and
	 * setting dfunc so that it points to the correct function to process
	 * the record type.
	 * If the record was stored ondisk in 32bit format, then it is
	 * converted to the 64bits equivalent 64bit format and the memory
	 * for the 32bit pointer is freed.
	 */
	switch (mdrec->md_type) {
		case MDDB_F_SOFTPART:
			if (is_32bit_record) {
				mp_unit32_od_t	*small_un;
				mp_unit_t	*big_un;

				small_un = (mp_unit32_od_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (mp_unit_t) +
				    ((small_un->un_numexts - 1) *
				    sizeof (struct mp_ext));
				big_un = (void *)Zalloc(newreqsize);
				softpart_convert((caddr_t)small_un,
				    (caddr_t)big_un, SMALL_2_BIG);
				mdrec->record = (void *)big_un;
			} else {
				mp_unit_t	*big_un;

				big_un = (mp_unit_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (mp_unit_t) +
				    ((big_un->un_numexts - 1) *
				    sizeof (struct mp_ext));
				mdrec->record = (void *)Zalloc(newreqsize);
				bcopy(big_un, mdrec->record, newreqsize);
			}
			uc = ((mp_unit_t *)mdrec->record)->c;
			mdrec->dfunc = &process_softpart;
			mdrec->un_self_id = uc.un_self_id;
			mdrec->has_parent = MD_HAS_PARENT(
			    uc.un_parent);
			break;
		case MDDB_F_STRIPE:
			if (is_32bit_record) {
				ms_unit32_od_t	*small_un;
				ms_unit_t	*big_un;

				small_un = (ms_unit32_od_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = get_big_stripe_req_size(
				    small_un, COMPLETE_STRUCTURE);
				    big_un = (void *)Zalloc(newreqsize);
				stripe_convert((caddr_t)small_un,
				    (caddr_t)big_un, SMALL_2_BIG);
				mdrec->record = (void *)big_un;
			} else {
				ms_unit_t	*big_un;

				big_un = (ms_unit_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = get_stripe_req_size(big_un);
				mdrec->record = (void *)Zalloc(newreqsize);
				bcopy(big_un, mdrec->record, newreqsize);
			}
			uc = ((ms_unit_t *)mdrec->record)->c;
			mdrec->dfunc = &process_stripe;
			mdrec->un_self_id = uc.un_self_id;
			mdrec->has_parent = MD_HAS_PARENT(
			    uc.un_parent);
			break;
		case MDDB_F_MIRROR:
			if (is_32bit_record) {
				mm_unit32_od_t	*small_un;
				mm_unit_t	*big_un;

				small_un = (mm_unit32_od_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (mm_unit_t);
				big_un = (void *)Zalloc(newreqsize);
				mirror_convert((caddr_t)small_un,
				    (caddr_t)big_un, SMALL_2_BIG);
				mdrec->record = (void *)big_un;
			} else {
				mm_unit_t	*big_un;

				big_un = (mm_unit_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (mm_unit_t);
				mdrec->record = (void *)Zalloc(newreqsize);
				bcopy(big_un, mdrec->record, newreqsize);
			}
			uc = ((mm_unit_t *)mdrec->record)->c;
			mdrec->dfunc = &process_mirror;
			mdrec->un_self_id = uc.un_self_id;
			mdrec->has_parent = MD_HAS_PARENT(
			    uc.un_parent);
			break;
		case MDDB_F_RAID:
			if (is_32bit_record) {
				mr_unit32_od_t	*small_un;
				mr_unit_t	*big_un;
				uint_t		ncol;

				small_un = (mr_unit32_od_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				ncol = small_un->un_totalcolumncnt;
				newreqsize = sizeof (mr_unit_t) +
				    ((ncol - 1) * sizeof (mr_column_t));
				big_un = (void *)Zalloc(newreqsize);
				raid_convert((caddr_t)small_un,
				    (caddr_t)big_un, SMALL_2_BIG);
				mdrec->record = (void *)big_un;
			} else {
				mr_unit_t	*big_un;
				uint_t		ncol;

				big_un = (mr_unit_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				ncol = big_un->un_totalcolumncnt;
				newreqsize = sizeof (mr_unit_t) +
				    ((ncol - 1) * sizeof (mr_column_t));
				mdrec->record = (void *)Zalloc(newreqsize);
				bcopy(big_un, mdrec->record, newreqsize);
			}
			uc = ((mr_unit_t *)mdrec->record)->c;
			mdrec->dfunc = &process_raid;
			mdrec->un_self_id = uc.un_self_id;
			mdrec->has_parent = MD_HAS_PARENT(
			    uc.un_parent);
			break;
		case MDDB_F_TRANS_MASTER:
			if (is_32bit_record) {
				mt_unit32_od_t	*small_un;
				mt_unit_t	*big_un;

				small_un = (mt_unit32_od_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (mt_unit_t);
				big_un = (void *)Zalloc(newreqsize);
				trans_master_convert((caddr_t)small_un,
				    (caddr_t)big_un, SMALL_2_BIG);
				mdrec->record = (void *)big_un;
			} else {
				mt_unit_t	*big_un;

				big_un = (mt_unit_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (mt_unit_t);
				mdrec->record = (void *)Zalloc(newreqsize);
				bcopy(big_un, mdrec->record, newreqsize);
			}
			uc = ((mt_unit_t *)mdrec->record)->c;
			mdrec->dfunc = &process_trans;
			mdrec->un_self_id = uc.un_self_id;
			mdrec->has_parent = MD_HAS_PARENT(
			    uc.un_parent);
			break;
		case MDDB_F_HOTSPARE:
			if (is_32bit_record) {
				hot_spare32_od_t	*small_un;
				hot_spare_t		*big_un;

				small_un = (hot_spare32_od_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (hot_spare_t);
				big_un = (void *)Zalloc(newreqsize);
				hs_convert((caddr_t)small_un,
				    (caddr_t)big_un, SMALL_2_BIG);
				mdrec->record = (void *)big_un;
			} else {
				hot_spare_t		*big_un;

				big_un = (hot_spare_t *)((uintptr_t)rbp +
				    (sizeof (mddb_rb_t) - sizeof (int)));
				newreqsize = sizeof (hot_spare_t);
				mdrec->record = (void *)Zalloc(newreqsize);
				bcopy(big_un, mdrec->record, newreqsize);
			}
			hs = (hot_spare_t *)mdrec->record;
			mdrec->dfunc = &process_hotspare;
			mdrec->un_self_id = NULL;
			mdrec->hs_record_id = hs->hs_record_id;
			mdrec->has_parent = 1;
			break;
		case MDDB_F_HOTSPARE_POOL:
			/*
			 * Ondisk and incore records are always same size.
			 */
			hsp = (hot_spare_pool_ond_t *)((uintptr_t)rbp +
			    (sizeof (mddb_rb_t) - sizeof (int)));
			newreqsize = sizeof (hot_spare_pool_ond_t) +
			    (sizeof (mddb_recid_t) * hsp->hsp_nhotspares);
			mdrec->record = (void *)Zalloc(newreqsize);
			bcopy(hsp, mdrec->record, newreqsize);
			hsp = (hot_spare_pool_ond_t *)mdrec->record;
			mdrec->dfunc = &process_hotspare_pool;
			/*
			 * If the hsp has descriptive name we'll get
			 * the un_self_id
			 */
			if (HSP_ID_IS_FN(hsp->hsp_self_id))
				mdrec->un_self_id = hsp->hsp_self_id;
			else
				mdrec->un_self_id = NULL;
			mdrec->has_parent = 0;
			break;
		/* All valid cases have been dealt with */
		default:
			(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
			return (-1);
	}

	/*
	 * If metadevice record has an entry in the NM namespace
	 * then it is copied into the mdrec->n_name field.
	 */
	if (mdrec->un_self_id != NULL) {
		for (nmname = &nm_record->r_name[0]; nmname->n_key != 0;
		/*LINTED*/
		    nmname = (struct nm_name *)((char *)nmname +
		    NAMSIZ(nmname))) {
			/*
			 * Extract the metadevice/hsp name if it is
			 * in the namespace.
			 *
			 * If it is a hot spare pool we will find our
			 * match by comparing the NM record's n_key
			 * with the extracted key from the hsp_self_id
			 * Else, match the un_self_id for the record
			 * to the n_minor name in the NM record.
			 */
			    if (mdrec->md_type == MDDB_F_HOTSPARE_POOL) {
				if (nmname->n_key ==
				    HSP_ID_TO_KEY(hsp->hsp_self_id)) {
					mdrec->n_key = nmname->n_key;
					uname = Strdup(nmname->n_name);
					mdrec->n_name = uname;
					break;
				}
			    } else {
				if ((nmname->n_minor) == (uc.un_self_id)) {
					(*mdrec).n_key = nmname->n_key;
					uname = Strdup(nmname->n_name);
					mdrec->n_name = uname;
					break;
				}
			    }
		}
	}

	/*
	 * If the metadevice name is not in the namespace, then
	 * then we will generate the name from the minor number
	 * for the metadevice.  In the case of records for a hotspare
	 * pool we use hsp_self_id, otherwise we use un_self_id.
	 */
	if (uname == NULL) {
		if (mdrec->md_type == MDDB_F_HOTSPARE_POOL) {
			uname = Malloc(MAXSIZEMDRECNAME);
			(void) sprintf(uname, "hsp%03u",
			    HSP_ID(hsp->hsp_self_id));
			mdrec->n_name = uname;
		} else if (mdrec->md_type != MDDB_F_HOTSPARE) {
			/*
			 * Generate the metadevice name for all other records
			 * (except for hotspares, because hotspares can only
			 * be physical devices.)
			 */
			uname = Malloc(MAXSIZEMDRECNAME);
			(void) sprintf(uname, "d%lu",
			    MD_MIN2UNIT(mdrec->un_self_id));
			mdrec->n_name = uname;
		}
	}

	return (0);
}


/*
 * read_mdrecord()
 *
 * Reads the mddb_rb32_od_t or mddb_rb_t and the associated metadevice record
 * from the disk.  Runs magic, checksum, and revision checks on the record
 * block.
 *
 * Returns:
 *	< 0 for failure
 *	  0 for success
 *
 */
static int
read_mdrecord(
	md_im_rec_t	**mdimpp,
	mddb_mb_t	*mbp,
	mddb_rb_t	*nm,
	mddb_de_t	*dep,
	char		*diskname,
	int 		fd,
	md_timeval32_t	*lastaccess,
	md_error_t 	*ep
)
{
	int		cnt, rval = 0;
	daddr_t		pblk;
	md_im_rec_t	*tmp_mdrec;
	void 		*rbp = NULL;
	char 		*rbp_tmp = NULL;
	mddb_rb32_t	*rbp_32;
	mddb_rb_t	*rbp_64;
	crc_skip_t	*skip = NULL;
	int		is_32bit_record;

	tmp_mdrec = Zalloc(sizeof (md_im_rec_t));
	rbp = (void *)Zalloc(dbtob(dep->de_blkcount));
	rbp_tmp = (char *)rbp;

	/* Read in the appropriate record and return configurations */
	for (cnt = 0; cnt < dep->de_blkcount; cnt++) {
		if ((pblk = getphysblk(dep->de_blks[cnt], mbp)) < 0) {
			rval = mdmddberror(ep, MDE_DB_BLKRANGE,
			    NODEV32, MD_LOCAL_SET,
			    dep->de_blks[cnt], diskname);
			return (rval);
		}

		if (lseek(fd, (off_t)dbtob(pblk), SEEK_SET) < 0) {
			rval = mdsyserror(ep, errno, diskname);
			return (rval);
		}

		if (read(fd, rbp_tmp, DEV_BSIZE) != DEV_BSIZE) {
			rval = mdsyserror(ep, errno, diskname);
			return (rval);
		}

		rbp_tmp += DEV_BSIZE;
	}
	tmp_mdrec->md_type = dep->de_flags;

	/*
	 * The only place to discover whether or not the record is a
	 * 32bit or 64bit record is from the record's rb_revision field.
	 * The mddb_rb_t and mddb_rb32_t structures are identical for the
	 * following fields:
	 *	rb_magic, rb_revision, rb_checksum, and rb_checksum_fiddle.
	 * So we can assume that the record is a 32bit structure when we
	 * check the record's magic number and revision and when we calculate
	 * the records checksum.
	 */
	rbp_32 = (mddb_rb32_t *)rbp;

	/*
	 * Checking the magic number for the record block.
	 */
	if (rbp_32->rb_magic != MDDB_MAGIC_RB) {
		rval = -1;
		(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
		goto out;
	}

	/*
	 * Checking the revision for the record block. Must match either
	 * revision for the current 64bit or 32bit record block.  Also,
	 * setting the flag for whether or not it is a 32bit record.
	 */
	is_32bit_record = 0;
	switch (rbp_32->rb_revision) {
	case MDDB_REV_RB:
	case MDDB_REV_RBFN:
		is_32bit_record = 1;
		break;
	case MDDB_REV_RB64:
	case MDDB_REV_RB64FN:
		break;
	default:
		rval = -1;
		(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
		goto out;
	}

	/*
	 * Calculating the checksum for this record block. Need
	 * to skip the rb's checksum fiddle.
	 */
	skip = (crc_skip_t *)Malloc(sizeof (crc_skip_t));
	skip->skip_next = NULL;
	skip->skip_offset = offsetof(mddb_rb_t, rb_checksum_fiddle);
	skip->skip_size = 3 * sizeof (uint_t);
	if (crcchk(rbp_32, &rbp_32->rb_checksum, dep->de_recsize, skip)) {
		rval = -1;
		(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
		goto out;
	}

	/* mddb_rb_t and mddb_rb32_t differ before the rb_timestamp field */
	if (!is_32bit_record) {
		if ((*lastaccess).tv_sec < rbp_32->rb_timestamp.tv_sec) {
		    *lastaccess = rbp_32->rb_timestamp;
		} else if ((*lastaccess).tv_sec ==
		    rbp_32->rb_timestamp.tv_sec) {
			if ((*lastaccess).tv_usec <
			    rbp_32->rb_timestamp.tv_usec)
				*lastaccess = rbp_32->rb_timestamp;
		}
	} else {
		rbp_64 = (mddb_rb_t *)rbp;
		if ((*lastaccess).tv_sec < rbp_64->rb_timestamp.tv_sec) {
		    *lastaccess = rbp_64->rb_timestamp;
		} else if ((*lastaccess).tv_sec ==
		    rbp_64->rb_timestamp.tv_sec) {
			if ((*lastaccess).tv_usec <
			    rbp_64->rb_timestamp.tv_usec)
				*lastaccess = rbp_64->rb_timestamp;
		}
	}

	/* Populates the fields in md_im_rec_t *tmp_mdrec. */
	rval = extract_mduser_data(nm, tmp_mdrec, rbp, is_32bit_record, ep);
	if (rval < 0)
		goto out;

	/* Adding record to the head of the list of all metadevices. */
	tmp_mdrec->prev = NULL;
	if (*mdimpp == NULL) {
		tmp_mdrec->next = NULL;
		*mdimpp = tmp_mdrec;
	} else {
		(*mdimpp)->prev = tmp_mdrec;
		tmp_mdrec->next = *mdimpp;
		*mdimpp = tmp_mdrec;
	}

out:
	/* Free the skip list */
	while (skip) {
		crc_skip_t	*skip_rm = skip;

		skip = skip->skip_next;
		Free(skip_rm);
	}

	if (rbp)
		Free(rbp);

	return (rval);
}


/*
 * read_all_mdrecords()
 *
 * Reads the directory block and directory entries.
 * Runs magic, checksum, and revision checks on the directory block.
 *
 * Returns:
 *	< 0 for failure
 *	  0 for success
 */
static int
read_all_mdrecords(
	md_im_rec_t	**mdimpp,
	mddb_mb_t	*mbp,
	mddb_lb_t	*lbp,
	mddb_rb_t	*nm,
	mdname_t	*rsp,
	int 		fd,
	md_timeval32_t	*lastaccess,
	md_error_t 	*ep
)
{
	int		dbblk, rval = 0;
	char		db[DEV_BSIZE];
	mddb_de_t	*dep;
	int		desize;
	/*LINTED*/
	mddb_db_t	*dbp = (mddb_db_t *)&db;

	/* Read in all directory blocks */
	for (dbblk = lbp->lb_dbfirstblk;
	    dbblk != 0;
	    dbblk = dbp->db_nextblk) {

		if ((rval = read_database_block(ep, fd, mbp, dbblk,
		    dbp, sizeof (db))) <= 0)
			goto out;

		/*
		 * Set ep with error code for MDE_DB_NODB.  This is the
		 * error code used in the kernel when there is a problem
		 * with reading records in.  Checks the magic number, the
		 * revision, and the checksum for each directory block.
		 */
		if (dbp->db_magic != MDDB_MAGIC_DB) {
			rval = -1;
			(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
			goto out;
		}

		if (revchk(MDDB_REV_DB, dbp->db_revision)) {
			rval = -1;
			(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
			goto out;
		}

		if (crcchk(dbp, &dbp->db_checksum, MDDB_BSIZE, NULL)) {
			rval = -1;
			(void) mdmddberror(ep, MDE_DB_NODB, 0, 0, 0, NULL);
			goto out;
		}

		/*
		 * If db timestamp is more recent than the previously recorded
		 * last modified timestamp, then update last modified.
		 */
		if ((*lastaccess).tv_sec < dbp->db_timestamp.tv_sec) {
			*lastaccess = dbp->db_timestamp;
		} else if ((*lastaccess).tv_sec == dbp->db_timestamp.tv_sec) {
			if ((*lastaccess).tv_usec < dbp->db_timestamp.tv_usec)
				*lastaccess = dbp->db_timestamp;
		}

		/* Creates dep list of all directory entries in the db */
		if (dbp->db_firstentry != NULL) {
			/* LINTED */
			dep = (mddb_de_t *)((caddr_t)(&dbp->db_firstentry)
			    + sizeof (dbp->db_firstentry));
			dbp->db_firstentry = dep;
			while (dep && dep->de_next) {
				desize = sizeof (*dep) -
				    sizeof (dep->de_blks) +
				    sizeof (daddr_t) * dep->de_blkcount;
				/* LINTED */
				dep->de_next = (mddb_de_t *)
				    ((caddr_t)dep + desize);
				dep = dep->de_next;
			}
		}

		/*
		 * Process all directory entries in the directory block.
		 * For each directory entry, read_mdrec is called to read
		 * in the record data.
		 */
		for (dep = dbp->db_firstentry; dep != NULL;
		    dep = dep->de_next) {

			/*
			 * de_flags is set to the type of metadevice.
			 * If directory entry does not correspond to a
			 * specific metadevice then it is set to zero.
			 * All namespace records(NM, SHR_NM, DID_SHR_NM) have a
			 * value of zero in their de_flags field.
			 */
			if ((dep->de_flags != 0)&&
			    (dep->de_flags != MDDB_F_OPT) &&
			    (dep->de_flags != MDDB_F_TRANS_LOG) &&
			    (dep->de_flags != MDDB_F_CHANGELOG)) {
				rval = read_mdrecord(mdimpp, mbp, nm, dep,
				    rsp->cname, fd, lastaccess, ep);
				if (rval < 0)
					goto out;
			}
		}
	}

out:
	return (rval);
}


/*
 * report_metastat_info()
 *
 * Generates the metastat -c output.  Also, updates the global variable
 * for a last accessed timestamp.
 *
 * Returns:
 *	< 0 for failure
 *	  0 for success
 *
 */
int
report_metastat_info(
	mddb_mb_t		*mb,
	mddb_lb_t		*lbp,
	mddb_rb_t		*nm,
	pnm_rec_t		**pnm,
	mdname_t		*rsp,
	int			fd,
	md_timeval32_t		*lastaccess,
	md_error_t		*ep
)
{
	int rval = 0;
	/* list of all metadevices in diskset */
	md_im_rec_t	*mdimp = NULL;
	md_im_rec_t	*tmp_mdrec, *rm_mdrec;

	/* Read in metadevice records and add entries to mdimp list. */
	rval = read_all_mdrecords(&mdimp, mb, lbp, nm, rsp, fd, lastaccess,
	    ep);
	if (rval < 0)
		goto out;

	/* Adding a fake record to the head of the list of all metadevices. */
	if (mdimp != NULL) {
		tmp_mdrec = Zalloc(sizeof (md_im_rec_t));
		tmp_mdrec->prev = NULL;
		mdimp->prev = tmp_mdrec;
		tmp_mdrec->next = mdimp;
		mdimp = tmp_mdrec;
	}

	/* Calling functions to process all metadevices on mdimp list */
	process_toplevel_devices(&mdimp, *pnm, MDDB_F_SOFTPART);
	process_toplevel_devices(&mdimp, *pnm, MDDB_F_TRANS_MASTER);
	process_toplevel_devices(&mdimp, *pnm, MDDB_F_MIRROR);
	process_toplevel_devices(&mdimp, *pnm, MDDB_F_RAID);
	process_toplevel_devices(&mdimp, *pnm, MDDB_F_STRIPE);
	process_toplevel_devices(&mdimp, *pnm, MDDB_F_HOTSPARE_POOL);
	(void) printf("\n");

out:
	/*
	 * If mdreclist is not null, then this will walk through all
	 * elements and free them.
	 */
	tmp_mdrec = mdimp;
	while (tmp_mdrec != NULL) {
		rm_mdrec = tmp_mdrec;
		tmp_mdrec = tmp_mdrec->next;
		if (rm_mdrec->record != NULL)
			Free(rm_mdrec->record);
		if (rm_mdrec->n_name != NULL)
			Free(rm_mdrec->n_name);
		Free(rm_mdrec);
	}

	free_pnm_rec_list(pnm);
	return (rval);
}