/*

 * 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

 */

/*

 */

/*

 * Functions to convert between a list of vdevs and an nvlist representing the

 * configuration.  Each entry in the list can be one of:

 *

 * 	Device vdevs

 * 		disk=(path=..., devid=...)

 * 		file=(path=...)

 *

 * 	Group vdevs

 * 		raidz[1|2]=(...)

 * 		mirror=(...)

 *

 * 	Hot spares

 *

 * While the underlying implementation supports it, group vdevs cannot contain

 * other group vdevs.  All userland verification of devices is contained within

 * this file.  If successful, the nvlist returned can be passed directly to the

 * kernel; we've done as much verification as possible in userland.

 *

 * Hot spares are a special case, and passed down as an array of disk vdevs, at

 * the same level as the root of the vdev tree.

 *

 * The only function exported by this file is 'make_root_vdev'.  The

 * function performs several passes:

 *

 * 	1. Construct the vdev specification.  Performs syntax validation and

 *         makes sure each device is valid.

 * 	2. Check for devices in use.  Using libdiskmgt, makes sure that no

 *         devices are also in use.  Some can be overridden using the 'force'

 *         flag, others cannot.

 * 	3. Check for replication errors if the 'force' flag is not specified.

 *         validates that the replication level is consistent across the

 *         entire pool.

 * 	4. Call libzfs to label any whole disks with an EFI label.

 */

#include <assert.h>

#include <devid.h>

#include <errno.h>

#include <fcntl.h>

#include <libdiskmgt.h>

#include <libintl.h>

#include <libnvpair.h>

#include <limits.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <sys/efi_partition.h>

#include <sys/stat.h>

#include <sys/vtoc.h>

#include <sys/mntent.h>

#include "zpool_util.h"

#define	DISK_ROOT	"/dev/dsk"

#define	RDISK_ROOT	"/dev/rdsk"

#define	BACKUP_SLICE	"s2"

/*

 * For any given vdev specification, we can have multiple errors.  The

 * vdev_error() function keeps track of whether we have seen an error yet, and

 * prints out a header if its the first error we've seen.

 */

boolean_t error_seen;

boolean_t is_force;

/*PRINTFLIKE1*/

static void

vdev_error(const char *fmt, ...)

{

	va_list ap;

	if (!error_seen) {

		(void) fprintf(stderr, gettext("invalid vdev specification\n"));

		if (!is_force)

			(void) fprintf(stderr, gettext("use '-f' to override "

			    "the following errors:\n"));

		else

			(void) fprintf(stderr, gettext("the following errors "

			    "must be manually repaired:\n"));

		error_seen = B_TRUE;

	}

	va_start(ap, fmt);

	(void) vfprintf(stderr, fmt, ap);

	va_end(ap);

}

static void

libdiskmgt_error(int error)

{

	/*

	 * ENXIO/ENODEV is a valid error message if the device doesn't live in

	 * /dev/dsk.  Don't bother printing an error message in this case.

	 */

	if (error == ENXIO || error == ENODEV)

		return;

	(void) fprintf(stderr, gettext("warning: device in use checking "

	    "failed: %s\n"), strerror(error));

}

/*

 * Validate a device, passing the bulk of the work off to libdiskmgt.

 */

static int

check_slice(const char *path, int force, boolean_t wholedisk, boolean_t isspare)

{

	char *msg;

	int error = 0;

	dm_who_type_t who;

	if (force)

		who = DM_WHO_ZPOOL_FORCE;

	else if (isspare)

		who = DM_WHO_ZPOOL_SPARE;

	else

		who = DM_WHO_ZPOOL;

	if (dm_inuse((char *)path, &msg, who, &error) || error) {

		if (error != 0) {

			libdiskmgt_error(error);

			return (0);

		} else {

			vdev_error("%s", msg);

			free(msg);

			return (-1);

		}

	}

	/*

	 * If we're given a whole disk, ignore overlapping slices since we're

	 * about to label it anyway.

	 */

	error = 0;

	if (!wholedisk && !force &&

	    (dm_isoverlapping((char *)path, &msg, &error) || error)) {

		if (error == 0) {

			/* dm_isoverlapping returned -1 */

			vdev_error(gettext("%s overlaps with %s\n"), path, msg);

			free(msg);

			return (-1);

		} else if (error != ENODEV) {

			/* libdiskmgt's devcache only handles physical drives */

			libdiskmgt_error(error);

			return (0);

		}

	}

	return (0);

}

/*

 * Validate a whole disk.  Iterate over all slices on the disk and make sure

 * that none is in use by calling check_slice().

 */

static int

check_disk(const char *name, dm_descriptor_t disk, int force, int isspare)

{

	dm_descriptor_t *drive, *media, *slice;

	int err = 0;

	int i;

	int ret;

	/*

	 * Get the drive associated with this disk.  This should never fail,

	 * because we already have an alias handle open for the device.

	 */

	if ((drive = dm_get_associated_descriptors(disk, DM_DRIVE,

	    &err)) == NULL || *drive == NULL) {

		if (err)

			libdiskmgt_error(err);

		return (0);

	}

	if ((media = dm_get_associated_descriptors(*drive, DM_MEDIA,

	    &err)) == NULL) {

		dm_free_descriptors(drive);

		if (err)

			libdiskmgt_error(err);

		return (0);

	}

	dm_free_descriptors(drive);

	/*

	 * It is possible that the user has specified a removable media drive,

	 * and the media is not present.

	 */

	if (*media == NULL) {

		dm_free_descriptors(media);

		vdev_error(gettext("'%s' has no media in drive\n"), name);

		return (-1);

	}

	if ((slice = dm_get_associated_descriptors(*media, DM_SLICE,

	    &err)) == NULL) {

		dm_free_descriptors(media);

		if (err)

			libdiskmgt_error(err);

		return (0);

	}

	dm_free_descriptors(media);

	ret = 0;

	/*

	 * Iterate over all slices and report any errors.  We don't care about

	 * overlapping slices because we are using the whole disk.

	 */

	for (i = 0; slice[i] != NULL; i++) {

		char *name = dm_get_name(slice[i], &err);

		if (check_slice(name, force, B_TRUE, isspare) != 0)

			ret = -1;

		dm_free_name(name);

	}

	dm_free_descriptors(slice);

	return (ret);

}

/*

 * Validate a device.

 */

static int

check_device(const char *path, boolean_t force, boolean_t isspare)

{

	dm_descriptor_t desc;

	int err;

	char *dev;

	/*

	 * For whole disks, libdiskmgt does not include the leading dev path.

	 */

	dev = strrchr(path, '/');

	assert(dev != NULL);

	dev++;

	if ((desc = dm_get_descriptor_by_name(DM_ALIAS, dev, &err)) != NULL) {

		err = check_disk(path, desc, force, isspare);

		dm_free_descriptor(desc);

		return (err);

	}

	return (check_slice(path, force, B_FALSE, isspare));

}

/*

 * Check that a file is valid.  All we can do in this case is check that it's

 * not in use by another pool, and not in use by swap.

 */

static int

check_file(const char *file, boolean_t force, boolean_t isspare)

{

	char  *name;

	int fd;

	int ret = 0;

	int err;

	pool_state_t state;

	boolean_t inuse;

	if (dm_inuse_swap(file, &err)) {

		if (err)

			libdiskmgt_error(err);

		else

			vdev_error(gettext("%s is currently used by swap. "

			    "Please see swap(1M).\n"), file);

		return (-1);

	}

	if ((fd = open(file, O_RDONLY)) < 0)

		return (0);

	if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) == 0 && inuse) {

		const char *desc;

		switch (state) {

		case POOL_STATE_ACTIVE:

			desc = gettext("active");

			break;

		case POOL_STATE_EXPORTED:

			desc = gettext("exported");

			break;

		case POOL_STATE_POTENTIALLY_ACTIVE:

			desc = gettext("potentially active");

			break;

		default:

			desc = gettext("unknown");

			break;

		}

		/*

		 * Allow hot spares to be shared between pools.

		 */

		if (state == POOL_STATE_SPARE && isspare)

			return (0);

		if (state == POOL_STATE_ACTIVE ||

		    state == POOL_STATE_SPARE || !force) {

			switch (state) {

			case POOL_STATE_SPARE:

				vdev_error(gettext("%s is reserved as a hot "

				    "spare for pool %s\n"), file, name);

				break;

			default:

				vdev_error(gettext("%s is part of %s pool "

				    "'%s'\n"), file, desc, name);

				break;

			}

			ret = -1;

		}

		free(name);

	}

	(void) close(fd);

	return (ret);

}

/*

 * By "whole disk" we mean an entire physical disk (something we can

 * label, toggle the write cache on, etc.) as opposed to the full

 * capacity of a pseudo-device such as lofi or did.  We act as if we

 * are labeling the disk, which should be a pretty good test of whether

 * it's a viable device or not.  Returns B_TRUE if it is and B_FALSE if

 * it isn't.

 */

static boolean_t

is_whole_disk(const char *arg)

{

	struct dk_gpt *label;

	int	fd;

	char	path[MAXPATHLEN];

	(void) snprintf(path, sizeof (path), "%s%s%s",

	    RDISK_ROOT, strrchr(arg, '/'), BACKUP_SLICE);

	if ((fd = open(path, O_RDWR | O_NDELAY)) < 0)

		return (B_FALSE);

	if (efi_alloc_and_init(fd, EFI_NUMPAR, &label) != 0) {

		(void) close(fd);

		return (B_FALSE);

	}

	efi_free(label);

	(void) close(fd);

	return (B_TRUE);

}

/*

 * Create a leaf vdev.  Determine if this is a file or a device.  If it's a

 * device, fill in the device id to make a complete nvlist.  Valid forms for a

 * leaf vdev are:

 *

 * 	/dev/dsk/xxx	Complete disk path

 * 	/xxx		Full path to file

 * 	xxx		Shorthand for /dev/dsk/xxx

 */

static nvlist_t *

make_leaf_vdev(const char *arg, uint64_t is_log)

{

	char path[MAXPATHLEN];

	struct stat64 statbuf;

	nvlist_t *vdev = NULL;

	char *type = NULL;

	boolean_t wholedisk = B_FALSE;

	/*

	 * Determine what type of vdev this is, and put the full path into

	 * 'path'.  We detect whether this is a device of file afterwards by

	 * checking the st_mode of the file.

	 */

	if (arg[0] == '/') {

		/*

		 * Complete device or file path.  Exact type is determined by

		 * examining the file descriptor afterwards.

		 */

		wholedisk = is_whole_disk(arg);

		if (!wholedisk && (stat64(arg, &statbuf) != 0)) {

			(void) fprintf(stderr,

			    gettext("cannot open '%s': %s\n"),

			    arg, strerror(errno));

			return (NULL);

		}

		(void) strlcpy(path, arg, sizeof (path));

	} else {

		/*

		 * This may be a short path for a device, or it could be total

		 * gibberish.  Check to see if it's a known device in

		 * /dev/dsk/.  As part of this check, see if we've been given a

		 * an entire disk (minus the slice number).

		 */

		(void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT,

		    arg);

		wholedisk = is_whole_disk(path);

		if (!wholedisk && (stat64(path, &statbuf) != 0)) {

			/*

			 * If we got ENOENT, then the user gave us

			 * gibberish, so try to direct them with a

			 * reasonable error message.  Otherwise,

			 * regurgitate strerror() since it's the best we

			 * can do.

			 */

			if (errno == ENOENT) {

				(void) fprintf(stderr,

				    gettext("cannot open '%s': no such "

				    "device in %s\n"), arg, DISK_ROOT);

				(void) fprintf(stderr,

				    gettext("must be a full path or "

				    "shorthand device name\n"));

				return (NULL);

			} else {

				(void) fprintf(stderr,

				    gettext("cannot open '%s': %s\n"),

				    path, strerror(errno));

				return (NULL);

			}

		}

	}

	/*

	 * Determine whether this is a device or a file.

	 */

	if (wholedisk || S_ISBLK(statbuf.st_mode)) {

		type = VDEV_TYPE_DISK;

	} else if (S_ISREG(statbuf.st_mode)) {

		type = VDEV_TYPE_FILE;

	} else {

		(void) fprintf(stderr, gettext("cannot use '%s': must be a "

		    "block device or regular file\n"), path);

		return (NULL);

	}

	/*

	 * Finally, we have the complete device or file, and we know that it is

	 * acceptable to use.  Construct the nvlist to describe this vdev.  All

	 * vdevs have a 'path' element, and devices also have a 'devid' element.

	 */

	verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0);

	verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0);

	verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0);

	verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_LOG, is_log) == 0);

	if (strcmp(type, VDEV_TYPE_DISK) == 0)

		verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK,

		    (uint64_t)wholedisk) == 0);

	/*

	 * For a whole disk, defer getting its devid until after labeling it.

	 */

	if (S_ISBLK(statbuf.st_mode) && !wholedisk) {

		/*

		 * Get the devid for the device.

		 */

		int fd;

		ddi_devid_t devid;

		char *minor = NULL, *devid_str = NULL;

		if ((fd = open(path, O_RDONLY)) < 0) {

			(void) fprintf(stderr, gettext("cannot open '%s': "

			    "%s\n"), path, strerror(errno));

			nvlist_free(vdev);

			return (NULL);

		}

		if (devid_get(fd, &devid) == 0) {

			if (devid_get_minor_name(fd, &minor) == 0 &&

			    (devid_str = devid_str_encode(devid, minor)) !=

			    NULL) {

				verify(nvlist_add_string(vdev,

				    ZPOOL_CONFIG_DEVID, devid_str) == 0);

			}

			if (devid_str != NULL)

				devid_str_free(devid_str);

			if (minor != NULL)

				devid_str_free(minor);

			devid_free(devid);

		}