/*

 * 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

 */

/*

 * Use is subject to license terms.

 */

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

/*

 * ZFS syseventd module.

 *

 * The purpose of this module is to identify when devices are added to the

 * system, and appropriately online or replace the affected vdevs.

 *

 * When a device is added to the system:

 *

 * 	1. Search for any vdevs whose devid matches that of the newly added

 *	   device.

 *

 * 	2. If no vdevs are found, then search for any vdevs whose devfs path

 *	   matches that of the new device.

 *

 *	3. If no vdevs match by either method, then ignore the event.

 *

 * 	4. Attempt to online the device with a flag to indicate that it should

 *	   be unspared when resilvering completes.  If this succeeds, then the

 *	   same device was inserted and we should continue normally.

 *

 *	5. If the pool does not have the 'autoreplace' property set, attempt to

 *	   online the device again without the unspare flag, which will

 *	   generate a FMA fault.

 *

 *	6. If the pool has the 'autoreplace' property set, and the matching vdev

 *	   is a whole disk, then label the new disk and attempt a 'zpool

 *	   replace'.

 *

 * The module responds to EC_DEV_ADD events for both disks and lofi devices,

 * with the latter used for testing.  The special ESC_ZFS_VDEV_CHECK event

 * indicates that a device failed to open during pool load, but the autoreplace

 * property was set.  In this case, we deferred the associated FMA fault until

 * our module had a chance to process the autoreplace logic.  If the device

 * could not be replaced, then the second online attempt will trigger the FMA

 * fault that we skipped earlier.

 */

#include <alloca.h>

#include <devid.h>

#include <fcntl.h>

#include <libnvpair.h>

#include <libsysevent.h>

#include <libzfs.h>

#include <limits.h>

#include <stdlib.h>

#include <string.h>

#include <syslog.h>

#include <sys/sunddi.h>

#include <sys/sysevent/eventdefs.h>

#include <sys/sysevent/dev.h>

#include <unistd.h>

#if defined(__i386) || defined(__amd64)

#define	PHYS_PATH	":q"

#define	RAW_SLICE	"p0"

#elif defined(__sparc)

#define	PHYS_PATH	":c"

#define	RAW_SLICE	"s2"

#else

#error Unknown architecture

#endif

typedef void (*zfs_process_func_t)(zpool_handle_t *, nvlist_t *, boolean_t);

libzfs_handle_t *g_zfshdl;

/*

 * The device associated with the given vdev (either by devid or physical path)

 * has been added to the system.  If 'isdisk' is set, then we only attempt a

 * replacement if it's a whole disk.  This also implies that we should label the

 * disk first.

 *

 * First, we attempt to online the device (making sure to undo any spare

 * operation when finished).  If this succeeds, then we're done.  If it fails,

 * and the new state is VDEV_CANT_OPEN, it indicates that the device was opened,

 * but that the label was not what we expected.  If the 'autoreplace' property

 * is not set, then we relabel the disk (if specified), and attempt a 'zpool

 * replace'.  If the online is successful, but the new state is something else

 * (REMOVED or FAULTED), it indicates that we're out of sync or in some sort of

 * race, and we should avoid attempting to relabel the disk.

 */

static void

zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t isdisk)

{

	char *path;

	vdev_state_t newstate;

	nvlist_t *nvroot, *newvd;

	uint64_t wholedisk = 0ULL;

	char *devid = NULL;

	char rawpath[PATH_MAX], fullpath[PATH_MAX];

	size_t len;

	if (nvlist_lookup_string(vdev, ZPOOL_CONFIG_PATH, &path) != 0)

		return;

	(void) nvlist_lookup_string(vdev, ZPOOL_CONFIG_DEVID, &devid);

	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, &wholedisk);

	/*

	 * We should have a way to online a device by guid.  With the current

	 * interface, we are forced to chop off the 's0' for whole disks.

	 */

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

	if (wholedisk)

		fullpath[strlen(fullpath) - 2] = '\0';

	/*

	 * Attempt to online the device.  It would be nice to online this by

	 * GUID, but the current interface only supports lookup by path.

	 */

	if (zpool_vdev_online(zhp, fullpath,

	    ZFS_ONLINE_CHECKREMOVE | ZFS_ONLINE_UNSPARE, &newstate) == 0 &&

	    newstate != VDEV_STATE_CANT_OPEN)

		return;

	/*

	 * If the pool doesn't have the autoreplace property set, then attempt a

	 * true online (without the unspare flag), which will trigger a FMA

	 * fault.

	 */

	if (!zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOREPLACE, NULL) ||

	    (isdisk && !wholedisk)) {

		(void) zpool_vdev_online(zhp, fullpath, ZFS_ONLINE_FORCEFAULT,

		    &newstate);

		return;

	}

	if (isdisk) {

		/*

		 * If this is a request to label a whole disk, then attempt to

		 * write out the label.  Before we can label the disk, we need

		 * access to a raw node.  Ideally, we'd like to walk the devinfo

		 * tree and find a raw node from the corresponding parent node.

		 * This is overly complicated, and since we know how we labeled

		 * this device in the first place, we know it's save to switch

		 * from /dev/dsk to /dev/rdsk and append the backup slice.

		 */

		if (strncmp(path, "/dev/dsk/", 9) != 0)

			return;

		(void) strlcpy(rawpath, path + 9, sizeof (rawpath));

		len = strlen(rawpath);

		rawpath[len - 2] = '\0';

		if (zpool_label_disk(g_zfshdl, zhp, rawpath) != 0)

			return;

	}

	/*

	 * Cosntruct the root vdev to pass to zpool_vdev_attach().  While adding

	 * the entire vdev structure is harmless, we construct a reduced set of

	 * path/devid/wholedisk to keep it simple.

	 */

	if (nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) != 0)

		return;

	if (nvlist_alloc(&newvd, NV_UNIQUE_NAME, 0) != 0) {

		nvlist_free(nvroot);

		return;

	}

	if (nvlist_add_string(newvd, ZPOOL_CONFIG_TYPE, VDEV_TYPE_DISK) != 0 ||

	    nvlist_add_string(newvd, ZPOOL_CONFIG_PATH, path) != 0 ||

	    (devid && nvlist_add_string(newvd, ZPOOL_CONFIG_DEVID,

	    devid) != 0) ||

	    nvlist_add_uint64(newvd, ZPOOL_CONFIG_WHOLE_DISK, wholedisk) != 0 ||

	    nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) != 0 ||

	    nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, &newvd,

	    1) != 0) {

		nvlist_free(newvd);

		nvlist_free(nvroot);

		return;

	}

	nvlist_free(newvd);

	(void) zpool_vdev_attach(zhp, fullpath, path, nvroot, B_TRUE);

	nvlist_free(nvroot);

}

/*

 * Utility functions to find a vdev matching given criteria.

 */

typedef struct dev_data {

	const char		*dd_compare;

	const char		*dd_prop;

	zfs_process_func_t	dd_func;

	boolean_t		dd_found;

	boolean_t		dd_isdisk;

	uint64_t		dd_pool_guid;

	uint64_t		dd_vdev_guid;

} dev_data_t;

static void

zfs_iter_vdev(zpool_handle_t *zhp, nvlist_t *nvl, void *data)

{

	dev_data_t *dp = data;

	char *path;

	uint_t c, children;

	nvlist_t **child;

	uint64_t guid;

	/*

	 * First iterate over any children.

	 */

	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN,

	    &child, &children) == 0) {

		for (c = 0; c < children; c++)

			zfs_iter_vdev(zhp, child[c], data);

		return;

	}

	if (dp->dd_vdev_guid != 0) {

		if (nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_GUID,

		    &guid) != 0 || guid != dp->dd_vdev_guid)

			return;

	} else {

		if (nvlist_lookup_string(nvl, dp->dd_prop, &path) != 0 ||

		    strncmp(dp->dd_compare, path, len) != 0)

			return;

		/*

		 * Normally, we want to have an exact match for the comparison

		 * string.  However, we allow substring matches in the following

		 * cases:

		 *

		 * 	<path>:		This is a devpath, and the target is one

		 * 			of its children.

		 *

		 * 	<path/>		This is a devid for a whole disk, and

		 * 			the target is one of its children.

		 */

		if (path[len] != '\0' && path[len] != ':' &&

		    path[len - 1] != '/')

			return;

	}

	(dp->dd_func)(zhp, nvl, dp->dd_isdisk);

}

static int

zfs_iter_pool(zpool_handle_t *zhp, void *data)

{

	nvlist_t *config, *nvl;

	dev_data_t *dp = data;

	uint64_t pool_guid;

	if ((config = zpool_get_config(zhp, NULL)) != NULL) {

		if (dp->dd_pool_guid == 0 ||

		    (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,

		    &pool_guid) == 0 && pool_guid == dp->dd_pool_guid)) {

			(void) nvlist_lookup_nvlist(config,

			    ZPOOL_CONFIG_VDEV_TREE, &nvl);

			zfs_iter_vdev(zhp, nvl, data);

		}

	}

	zpool_close(zhp);

	return (0);

}

/*

 * Given a physical device path, iterate over all (pool, vdev) pairs which

 * correspond to the given path.

 */

static boolean_t

devpath_iter(const char *devpath, zfs_process_func_t func, boolean_t wholedisk)

{

	dev_data_t data = { 0 };

	data.dd_compare = devpath;

	data.dd_func = func;

	data.dd_prop = ZPOOL_CONFIG_PHYS_PATH;

	data.dd_found = B_FALSE;

	data.dd_isdisk = wholedisk;

	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);

	return (data.dd_found);

}

/*

 * Given a /devices path, lookup the corresponding devid for each minor node,

 * and find any vdevs with matching devids.  Doing this straight up would be

 * rather inefficient, O(minor nodes * vdevs in system), so we take advantage of

 * the fact that each devid ends with "/<minornode>".  Once we find any valid

 * minor node, we chop off the portion after the last slash, and then search for

 * matching vdevs, which is O(vdevs in system).

 */

static boolean_t

devid_iter(const char *devpath, zfs_process_func_t func, boolean_t wholedisk)

{

	size_t len = strlen(devpath) + sizeof ("/devices") +

	    sizeof (PHYS_PATH) - 1;

	char *fullpath;

	int fd;

	ddi_devid_t devid;

	char *devidstr, *fulldevid;

	dev_data_t data = { 0 };

	/*

	 * Try to open a known minor node.

	 */

	fullpath = alloca(len);

	(void) snprintf(fullpath, len, "/devices%s%s", devpath, PHYS_PATH);

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

		return (B_FALSE);

	/*

	 * Determine the devid as a string, with no trailing slash for the minor

	 * node.

	 */

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

		(void) close(fd);

		return (B_FALSE);

	}

	(void) close(fd);

	if ((devidstr = devid_str_encode(devid, NULL)) == NULL) {

		devid_free(devid);

		return (B_FALSE);

	}

	len = strlen(devidstr) + 2;

	fulldevid = alloca(len);

	(void) snprintf(fulldevid, len, "%s/", devidstr);

	data.dd_compare = fulldevid;

	data.dd_func = func;

	data.dd_prop = ZPOOL_CONFIG_DEVID;

	data.dd_found = B_FALSE;

	data.dd_isdisk = wholedisk;

	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);

	devid_str_free(devidstr);

	return (data.dd_found);

}

/*

 * This function is called when we receive a devfs add event.  This can be

 * either a disk event or a lofi event, and the behavior is slightly different

 * depending on which it is.

 */

static int

zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi)

{

	char *devpath, *devname;

	char path[PATH_MAX], realpath[PATH_MAX];

	char *colon, *raw;

	int ret;

	/*

	 * The main unit of operation is the physical device path.  For disks,

	 * this is the device node, as all minor nodes are affected.  For lofi

	 * devices, this includes the minor path.  Unfortunately, this isn't

	 * represented in the DEV_PHYS_PATH for various reasons.

	 */

	if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath) != 0)

		return (-1);

	/*

	 * If this is a lofi device, then also get the minor instance name.

	 * Unfortunately, the current payload doesn't include an easy way to get

	 * this information.  So we cheat by resolving the 'dev_name' (which

	 * refers to the raw device) and taking the portion between ':(*),raw'.

	 */

	(void) strlcpy(realpath, devpath, sizeof (realpath));

	if (is_lofi) {

		if (nvlist_lookup_string(nvl, DEV_NAME,

		    &devname) == 0 &&

		    (ret = resolvepath(devname, path,

		    sizeof (path))) > 0) {

			path[ret] = '\0';

			colon = strchr(path, ':');

			if (colon != NULL)

				raw = strstr(colon + 1, ",raw");

			if (colon != NULL && raw != NULL) {

				*raw = '\0';

				(void) snprintf(realpath,

				    sizeof (realpath), "%s%s",

				    devpath, colon);

				*raw = ',';

			}

		}

	}

	/*

	 * Iterate over all vdevs with a matching devid, and then those with a

	 * matching /devices path.  For disks, we only want to pay attention to

	 * vdevs marked as whole disks.  For lofi, we don't care (because we're

	 * matching an exact minor name).

	 */

	if (!devid_iter(realpath, zfs_process_add, !is_lofi))

		(void) devpath_iter(realpath, zfs_process_add, !is_lofi);

	return (0);

}

/*

 * Called when we receive a VDEV_CHECK event, which indicates a device could not

 * be opened during initial pool open, but the autoreplace property was set on

 * the pool.  In this case, we treat it as if it were an add event.

 */

static int

zfs_deliver_check(nvlist_t *nvl)

{

	dev_data_t data = { 0 };

	if (nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID,

	    &data.dd_pool_guid) != 0 ||

	    nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID,

	    &data.dd_vdev_guid) != 0)

		return (0);

	data.dd_isdisk = B_TRUE;

	data.dd_func = zfs_process_add;

	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);

	return (0);

}

/*ARGSUSED*/

static int

zfs_deliver_event(sysevent_t *ev, int unused)

{

	const char *class = sysevent_get_class_name(ev);

	const char *subclass = sysevent_get_subclass_name(ev);

	nvlist_t *nvl;

	int ret;

	boolean_t is_lofi, is_check;

	if (strcmp(class, EC_DEV_ADD) == 0) {

		/*

		 * We're mainly interested in disk additions, but we also listen

		 * for new lofi devices, to allow for simplified testing.

		 */

		if (strcmp(subclass, ESC_DISK) == 0)

			is_lofi = B_FALSE;

		else if (strcmp(subclass, ESC_LOFI) == 0)

			is_lofi = B_TRUE;

		else

			return (0);

		is_check = B_FALSE;

	} else if (strcmp(class, EC_ZFS) == 0 &&

	    strcmp(subclass, ESC_ZFS_VDEV_CHECK) == 0) {

		/*

		 * This event signifies that a device failed to open during pool

		 * load, but the 'autoreplace' property was set, so we should

		 * pretend it's just been added.

		 */

		is_check = B_TRUE;

	} else {

		return (0);

	}

	if (sysevent_get_attr_list(ev, &nvl) != 0)

		return (-1);

	if (is_check)

		ret = zfs_deliver_check(nvl);

	else

		ret = zfs_deliver_add(nvl, is_lofi);

	nvlist_free(nvl);

	return (ret);

}

static struct slm_mod_ops zfs_mod_ops = {

	SE_MAJOR_VERSION, SE_MINOR_VERSION, 10, zfs_deliver_event

};

struct slm_mod_ops *

slm_init()

{

	if ((g_zfshdl = libzfs_init()) == NULL)

		return (NULL);

	return (&zfs_mod_ops);

}

void

slm_fini()

{

}