13d7072f8Seschrock /* 23d7072f8Seschrock * CDDL HEADER START 33d7072f8Seschrock * 43d7072f8Seschrock * The contents of this file are subject to the terms of the 53d7072f8Seschrock * Common Development and Distribution License (the "License"). 63d7072f8Seschrock * You may not use this file except in compliance with the License. 73d7072f8Seschrock * 83d7072f8Seschrock * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 93d7072f8Seschrock * or http://www.opensolaris.org/os/licensing. 103d7072f8Seschrock * See the License for the specific language governing permissions 113d7072f8Seschrock * and limitations under the License. 123d7072f8Seschrock * 133d7072f8Seschrock * When distributing Covered Code, include this CDDL HEADER in each 143d7072f8Seschrock * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 153d7072f8Seschrock * If applicable, add the following below this CDDL HEADER, with the 163d7072f8Seschrock * fields enclosed by brackets "[]" replaced with your own identifying 173d7072f8Seschrock * information: Portions Copyright [yyyy] [name of copyright owner] 183d7072f8Seschrock * 193d7072f8Seschrock * CDDL HEADER END 203d7072f8Seschrock */ 213d7072f8Seschrock /* 22b98131cfSEric Taylor * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 234263d13fSGeorge Wilson * Copyright (c) 2012 by Delphix. All rights reserved. 24cead1df3SHans Rosenfeld * Copyright 2016 Nexenta Systems, Inc. All rights reserved. 253d7072f8Seschrock */ 263d7072f8Seschrock 273d7072f8Seschrock /* 283d7072f8Seschrock * ZFS syseventd module. 293d7072f8Seschrock * 303d7072f8Seschrock * The purpose of this module is to identify when devices are added to the 313d7072f8Seschrock * system, and appropriately online or replace the affected vdevs. 323d7072f8Seschrock * 333d7072f8Seschrock * When a device is added to the system: 343d7072f8Seschrock * 353d7072f8Seschrock * 1. Search for any vdevs whose devid matches that of the newly added 363d7072f8Seschrock * device. 373d7072f8Seschrock * 383d7072f8Seschrock * 2. If no vdevs are found, then search for any vdevs whose devfs path 393d7072f8Seschrock * matches that of the new device. 403d7072f8Seschrock * 413d7072f8Seschrock * 3. If no vdevs match by either method, then ignore the event. 423d7072f8Seschrock * 433d7072f8Seschrock * 4. Attempt to online the device with a flag to indicate that it should 443d7072f8Seschrock * be unspared when resilvering completes. If this succeeds, then the 453d7072f8Seschrock * same device was inserted and we should continue normally. 463d7072f8Seschrock * 473d7072f8Seschrock * 5. If the pool does not have the 'autoreplace' property set, attempt to 483d7072f8Seschrock * online the device again without the unspare flag, which will 493d7072f8Seschrock * generate a FMA fault. 503d7072f8Seschrock * 513d7072f8Seschrock * 6. If the pool has the 'autoreplace' property set, and the matching vdev 523d7072f8Seschrock * is a whole disk, then label the new disk and attempt a 'zpool 533d7072f8Seschrock * replace'. 543d7072f8Seschrock * 553d7072f8Seschrock * The module responds to EC_DEV_ADD events for both disks and lofi devices, 563d7072f8Seschrock * with the latter used for testing. The special ESC_ZFS_VDEV_CHECK event 573d7072f8Seschrock * indicates that a device failed to open during pool load, but the autoreplace 583d7072f8Seschrock * property was set. In this case, we deferred the associated FMA fault until 593d7072f8Seschrock * our module had a chance to process the autoreplace logic. If the device 603d7072f8Seschrock * could not be replaced, then the second online attempt will trigger the FMA 613d7072f8Seschrock * fault that we skipped earlier. 623d7072f8Seschrock */ 633d7072f8Seschrock 643d7072f8Seschrock #include <alloca.h> 653d7072f8Seschrock #include <devid.h> 663d7072f8Seschrock #include <fcntl.h> 673d7072f8Seschrock #include <libnvpair.h> 683d7072f8Seschrock #include <libsysevent.h> 693d7072f8Seschrock #include <libzfs.h> 703d7072f8Seschrock #include <limits.h> 713d7072f8Seschrock #include <stdlib.h> 723d7072f8Seschrock #include <string.h> 733d7072f8Seschrock #include <syslog.h> 743c112a2bSEric Taylor #include <sys/list.h> 753d7072f8Seschrock #include <sys/sunddi.h> 763d7072f8Seschrock #include <sys/sysevent/eventdefs.h> 773d7072f8Seschrock #include <sys/sysevent/dev.h> 783c112a2bSEric Taylor #include <thread_pool.h> 793d7072f8Seschrock #include <unistd.h> 80b98131cfSEric Taylor #include "syseventd.h" 813d7072f8Seschrock 823d7072f8Seschrock #if defined(__i386) || defined(__amd64) 833d7072f8Seschrock #define PHYS_PATH ":q" 843d7072f8Seschrock #define RAW_SLICE "p0" 853d7072f8Seschrock #elif defined(__sparc) 863d7072f8Seschrock #define PHYS_PATH ":c" 873d7072f8Seschrock #define RAW_SLICE "s2" 883d7072f8Seschrock #else 893d7072f8Seschrock #error Unknown architecture 903d7072f8Seschrock #endif 913d7072f8Seschrock 923d7072f8Seschrock typedef void (*zfs_process_func_t)(zpool_handle_t *, nvlist_t *, boolean_t); 933d7072f8Seschrock 943d7072f8Seschrock libzfs_handle_t *g_zfshdl; 953c112a2bSEric Taylor list_t g_pool_list; 963c112a2bSEric Taylor tpool_t *g_tpool; 9737e3a0d8SEric Taylor boolean_t g_enumeration_done; 9837e3a0d8SEric Taylor thread_t g_zfs_tid; 993c112a2bSEric Taylor 1003c112a2bSEric Taylor typedef struct unavailpool { 1013c112a2bSEric Taylor zpool_handle_t *uap_zhp; 1023c112a2bSEric Taylor list_node_t uap_node; 1033c112a2bSEric Taylor } unavailpool_t; 1043c112a2bSEric Taylor 1053c112a2bSEric Taylor int 1063c112a2bSEric Taylor zfs_toplevel_state(zpool_handle_t *zhp) 1073c112a2bSEric Taylor { 1083c112a2bSEric Taylor nvlist_t *nvroot; 1093c112a2bSEric Taylor vdev_stat_t *vs; 1103c112a2bSEric Taylor unsigned int c; 1113c112a2bSEric Taylor 1123c112a2bSEric Taylor verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL), 1133c112a2bSEric Taylor ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 1143c112a2bSEric Taylor verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 1153c112a2bSEric Taylor (uint64_t **)&vs, &c) == 0); 1163c112a2bSEric Taylor return (vs->vs_state); 1173c112a2bSEric Taylor } 1183c112a2bSEric Taylor 1193c112a2bSEric Taylor static int 1203c112a2bSEric Taylor zfs_unavail_pool(zpool_handle_t *zhp, void *data) 1213c112a2bSEric Taylor { 1223c112a2bSEric Taylor if (zfs_toplevel_state(zhp) < VDEV_STATE_DEGRADED) { 1233c112a2bSEric Taylor unavailpool_t *uap; 1243c112a2bSEric Taylor uap = malloc(sizeof (unavailpool_t)); 1253c112a2bSEric Taylor uap->uap_zhp = zhp; 1263c112a2bSEric Taylor list_insert_tail((list_t *)data, uap); 1273c112a2bSEric Taylor } else { 1283c112a2bSEric Taylor zpool_close(zhp); 1293c112a2bSEric Taylor } 1303c112a2bSEric Taylor return (0); 1313c112a2bSEric Taylor } 1323d7072f8Seschrock 1333d7072f8Seschrock /* 1343d7072f8Seschrock * The device associated with the given vdev (either by devid or physical path) 1353d7072f8Seschrock * has been added to the system. If 'isdisk' is set, then we only attempt a 1363d7072f8Seschrock * replacement if it's a whole disk. This also implies that we should label the 1373d7072f8Seschrock * disk first. 1383d7072f8Seschrock * 1393d7072f8Seschrock * First, we attempt to online the device (making sure to undo any spare 1403d7072f8Seschrock * operation when finished). If this succeeds, then we're done. If it fails, 1413d7072f8Seschrock * and the new state is VDEV_CANT_OPEN, it indicates that the device was opened, 1423d7072f8Seschrock * but that the label was not what we expected. If the 'autoreplace' property 1433d7072f8Seschrock * is not set, then we relabel the disk (if specified), and attempt a 'zpool 1443d7072f8Seschrock * replace'. If the online is successful, but the new state is something else 1453d7072f8Seschrock * (REMOVED or FAULTED), it indicates that we're out of sync or in some sort of 1463d7072f8Seschrock * race, and we should avoid attempting to relabel the disk. 1473d7072f8Seschrock */ 1483d7072f8Seschrock static void 1493d7072f8Seschrock zfs_process_add(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t isdisk) 1503d7072f8Seschrock { 1513d7072f8Seschrock char *path; 1523d7072f8Seschrock vdev_state_t newstate; 1533d7072f8Seschrock nvlist_t *nvroot, *newvd; 1543d7072f8Seschrock uint64_t wholedisk = 0ULL; 155acd07c6bSYuri Pankov uint64_t offline = 0ULL; 156bf82a41bSeschrock char *physpath = NULL; 1573d7072f8Seschrock char rawpath[PATH_MAX], fullpath[PATH_MAX]; 158*7855d95bSToomas Soome zpool_boot_label_t boot_type; 159*7855d95bSToomas Soome uint64_t boot_size; 1603d7072f8Seschrock size_t len; 1613d7072f8Seschrock 1623d7072f8Seschrock if (nvlist_lookup_string(vdev, ZPOOL_CONFIG_PATH, &path) != 0) 1633d7072f8Seschrock return; 1643d7072f8Seschrock 165bf82a41bSeschrock (void) nvlist_lookup_string(vdev, ZPOOL_CONFIG_PHYS_PATH, &physpath); 1663d7072f8Seschrock (void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, &wholedisk); 167acd07c6bSYuri Pankov (void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_OFFLINE, &offline); 1683d7072f8Seschrock 1693d7072f8Seschrock /* 1703d7072f8Seschrock * We should have a way to online a device by guid. With the current 1713d7072f8Seschrock * interface, we are forced to chop off the 's0' for whole disks. 1723d7072f8Seschrock */ 1733d7072f8Seschrock (void) strlcpy(fullpath, path, sizeof (fullpath)); 1743d7072f8Seschrock if (wholedisk) 1753d7072f8Seschrock fullpath[strlen(fullpath) - 2] = '\0'; 1763d7072f8Seschrock 1773d7072f8Seschrock /* 1783d7072f8Seschrock * Attempt to online the device. It would be nice to online this by 1793d7072f8Seschrock * GUID, but the current interface only supports lookup by path. 1803d7072f8Seschrock */ 181acd07c6bSYuri Pankov if (offline || 182acd07c6bSYuri Pankov (zpool_vdev_online(zhp, fullpath, 1833d7072f8Seschrock ZFS_ONLINE_CHECKREMOVE | ZFS_ONLINE_UNSPARE, &newstate) == 0 && 184acd07c6bSYuri Pankov (newstate == VDEV_STATE_HEALTHY || 185acd07c6bSYuri Pankov newstate == VDEV_STATE_DEGRADED))) 1863d7072f8Seschrock return; 1873d7072f8Seschrock 1883d7072f8Seschrock /* 1893d7072f8Seschrock * If the pool doesn't have the autoreplace property set, then attempt a 1903d7072f8Seschrock * true online (without the unspare flag), which will trigger a FMA 1913d7072f8Seschrock * fault. 1923d7072f8Seschrock */ 193990b4856Slling if (!zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOREPLACE, NULL) || 1943d7072f8Seschrock (isdisk && !wholedisk)) { 1953d7072f8Seschrock (void) zpool_vdev_online(zhp, fullpath, ZFS_ONLINE_FORCEFAULT, 1963d7072f8Seschrock &newstate); 1973d7072f8Seschrock return; 1983d7072f8Seschrock } 1993d7072f8Seschrock 2003d7072f8Seschrock if (isdisk) { 2013d7072f8Seschrock /* 2023d7072f8Seschrock * If this is a request to label a whole disk, then attempt to 2033d7072f8Seschrock * write out the label. Before we can label the disk, we need 2043d7072f8Seschrock * access to a raw node. Ideally, we'd like to walk the devinfo 2053d7072f8Seschrock * tree and find a raw node from the corresponding parent node. 2063d7072f8Seschrock * This is overly complicated, and since we know how we labeled 2073d7072f8Seschrock * this device in the first place, we know it's save to switch 2083d7072f8Seschrock * from /dev/dsk to /dev/rdsk and append the backup slice. 209c5904d13Seschrock * 210c5904d13Seschrock * If any part of this process fails, then do a force online to 211c5904d13Seschrock * trigger a ZFS fault for the device (and any hot spare 212c5904d13Seschrock * replacement). 2133d7072f8Seschrock */ 2146401734dSWill Andrews if (strncmp(path, ZFS_DISK_ROOTD, 2156401734dSWill Andrews strlen(ZFS_DISK_ROOTD)) != 0) { 216c5904d13Seschrock (void) zpool_vdev_online(zhp, fullpath, 217c5904d13Seschrock ZFS_ONLINE_FORCEFAULT, &newstate); 2183d7072f8Seschrock return; 219c5904d13Seschrock } 2203d7072f8Seschrock 2213d7072f8Seschrock (void) strlcpy(rawpath, path + 9, sizeof (rawpath)); 2223d7072f8Seschrock len = strlen(rawpath); 2233d7072f8Seschrock rawpath[len - 2] = '\0'; 2243d7072f8Seschrock 225*7855d95bSToomas Soome if (zpool_is_bootable(zhp)) 226*7855d95bSToomas Soome boot_type = ZPOOL_COPY_BOOT_LABEL; 227*7855d95bSToomas Soome else 228*7855d95bSToomas Soome boot_type = ZPOOL_NO_BOOT_LABEL; 229*7855d95bSToomas Soome 230*7855d95bSToomas Soome boot_size = zpool_get_prop_int(zhp, ZPOOL_PROP_BOOTSIZE, NULL); 231*7855d95bSToomas Soome if (zpool_label_disk(g_zfshdl, zhp, rawpath, 232*7855d95bSToomas Soome boot_type, boot_size, NULL) != 0) { 233c5904d13Seschrock (void) zpool_vdev_online(zhp, fullpath, 234c5904d13Seschrock ZFS_ONLINE_FORCEFAULT, &newstate); 2353d7072f8Seschrock return; 236c5904d13Seschrock } 2373d7072f8Seschrock } 2383d7072f8Seschrock 2393d7072f8Seschrock /* 2403d7072f8Seschrock * Cosntruct the root vdev to pass to zpool_vdev_attach(). While adding 2413d7072f8Seschrock * the entire vdev structure is harmless, we construct a reduced set of 242bf82a41bSeschrock * path/physpath/wholedisk to keep it simple. 2433d7072f8Seschrock */ 2443d7072f8Seschrock if (nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) != 0) 2453d7072f8Seschrock return; 2463d7072f8Seschrock 2473d7072f8Seschrock if (nvlist_alloc(&newvd, NV_UNIQUE_NAME, 0) != 0) { 2483d7072f8Seschrock nvlist_free(nvroot); 2493d7072f8Seschrock return; 2503d7072f8Seschrock } 2513d7072f8Seschrock 2523d7072f8Seschrock if (nvlist_add_string(newvd, ZPOOL_CONFIG_TYPE, VDEV_TYPE_DISK) != 0 || 2533d7072f8Seschrock nvlist_add_string(newvd, ZPOOL_CONFIG_PATH, path) != 0 || 254bf82a41bSeschrock (physpath != NULL && nvlist_add_string(newvd, 255bf82a41bSeschrock ZPOOL_CONFIG_PHYS_PATH, physpath) != 0) || 2563d7072f8Seschrock nvlist_add_uint64(newvd, ZPOOL_CONFIG_WHOLE_DISK, wholedisk) != 0 || 2573d7072f8Seschrock nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) != 0 || 2583d7072f8Seschrock nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, &newvd, 2593d7072f8Seschrock 1) != 0) { 2603d7072f8Seschrock nvlist_free(newvd); 2613d7072f8Seschrock nvlist_free(nvroot); 2623d7072f8Seschrock return; 2633d7072f8Seschrock } 2643d7072f8Seschrock 2653d7072f8Seschrock nvlist_free(newvd); 2663d7072f8Seschrock 2673d7072f8Seschrock (void) zpool_vdev_attach(zhp, fullpath, path, nvroot, B_TRUE); 2683d7072f8Seschrock 2693d7072f8Seschrock nvlist_free(nvroot); 2703d7072f8Seschrock 2713d7072f8Seschrock } 2723d7072f8Seschrock 2733d7072f8Seschrock /* 2743d7072f8Seschrock * Utility functions to find a vdev matching given criteria. 2753d7072f8Seschrock */ 2763d7072f8Seschrock typedef struct dev_data { 2773d7072f8Seschrock const char *dd_compare; 2783d7072f8Seschrock const char *dd_prop; 2793d7072f8Seschrock zfs_process_func_t dd_func; 2803d7072f8Seschrock boolean_t dd_found; 2813d7072f8Seschrock boolean_t dd_isdisk; 2823d7072f8Seschrock uint64_t dd_pool_guid; 2833d7072f8Seschrock uint64_t dd_vdev_guid; 2843d7072f8Seschrock } dev_data_t; 2853d7072f8Seschrock 2863d7072f8Seschrock static void 2873d7072f8Seschrock zfs_iter_vdev(zpool_handle_t *zhp, nvlist_t *nvl, void *data) 2883d7072f8Seschrock { 2893d7072f8Seschrock dev_data_t *dp = data; 2903d7072f8Seschrock char *path; 2913d7072f8Seschrock uint_t c, children; 2923d7072f8Seschrock nvlist_t **child; 293b01c3b58Seschrock size_t len; 2943d7072f8Seschrock uint64_t guid; 2953d7072f8Seschrock 2963d7072f8Seschrock /* 2973d7072f8Seschrock * First iterate over any children. 2983d7072f8Seschrock */ 2993d7072f8Seschrock if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, 3003d7072f8Seschrock &child, &children) == 0) { 3013d7072f8Seschrock for (c = 0; c < children; c++) 3023d7072f8Seschrock zfs_iter_vdev(zhp, child[c], data); 3033d7072f8Seschrock return; 3043d7072f8Seschrock } 3053d7072f8Seschrock 3063d7072f8Seschrock if (dp->dd_vdev_guid != 0) { 3073d7072f8Seschrock if (nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_GUID, 3083d7072f8Seschrock &guid) != 0 || guid != dp->dd_vdev_guid) 3093d7072f8Seschrock return; 31014372834SHans Rosenfeld } else if (dp->dd_compare != NULL) { 311b01c3b58Seschrock len = strlen(dp->dd_compare); 312b01c3b58Seschrock 3133d7072f8Seschrock if (nvlist_lookup_string(nvl, dp->dd_prop, &path) != 0 || 3143d7072f8Seschrock strncmp(dp->dd_compare, path, len) != 0) 3153d7072f8Seschrock return; 3163d7072f8Seschrock 3173d7072f8Seschrock /* 3183d7072f8Seschrock * Normally, we want to have an exact match for the comparison 3193d7072f8Seschrock * string. However, we allow substring matches in the following 3203d7072f8Seschrock * cases: 3213d7072f8Seschrock * 3223d7072f8Seschrock * <path>: This is a devpath, and the target is one 3233d7072f8Seschrock * of its children. 3243d7072f8Seschrock * 3253d7072f8Seschrock * <path/> This is a devid for a whole disk, and 3263d7072f8Seschrock * the target is one of its children. 3273d7072f8Seschrock */ 3283d7072f8Seschrock if (path[len] != '\0' && path[len] != ':' && 3293d7072f8Seschrock path[len - 1] != '/') 3303d7072f8Seschrock return; 3313d7072f8Seschrock } 3323d7072f8Seschrock 3333d7072f8Seschrock (dp->dd_func)(zhp, nvl, dp->dd_isdisk); 3343d7072f8Seschrock } 3353d7072f8Seschrock 3363c112a2bSEric Taylor void 3373c112a2bSEric Taylor zfs_enable_ds(void *arg) 3383c112a2bSEric Taylor { 3393c112a2bSEric Taylor unavailpool_t *pool = (unavailpool_t *)arg; 3403c112a2bSEric Taylor 3413c112a2bSEric Taylor (void) zpool_enable_datasets(pool->uap_zhp, NULL, 0); 3423c112a2bSEric Taylor zpool_close(pool->uap_zhp); 3433c112a2bSEric Taylor free(pool); 3443c112a2bSEric Taylor } 3453c112a2bSEric Taylor 3463d7072f8Seschrock static int 3473d7072f8Seschrock zfs_iter_pool(zpool_handle_t *zhp, void *data) 3483d7072f8Seschrock { 3493d7072f8Seschrock nvlist_t *config, *nvl; 3503d7072f8Seschrock dev_data_t *dp = data; 3513d7072f8Seschrock uint64_t pool_guid; 3523c112a2bSEric Taylor unavailpool_t *pool; 3533d7072f8Seschrock 3543d7072f8Seschrock if ((config = zpool_get_config(zhp, NULL)) != NULL) { 3553d7072f8Seschrock if (dp->dd_pool_guid == 0 || 3563d7072f8Seschrock (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 3573d7072f8Seschrock &pool_guid) == 0 && pool_guid == dp->dd_pool_guid)) { 3583d7072f8Seschrock (void) nvlist_lookup_nvlist(config, 3593d7072f8Seschrock ZPOOL_CONFIG_VDEV_TREE, &nvl); 3603d7072f8Seschrock zfs_iter_vdev(zhp, nvl, data); 3613d7072f8Seschrock } 3623d7072f8Seschrock } 36337e3a0d8SEric Taylor if (g_enumeration_done) { 36437e3a0d8SEric Taylor for (pool = list_head(&g_pool_list); pool != NULL; 36537e3a0d8SEric Taylor pool = list_next(&g_pool_list, pool)) { 36637e3a0d8SEric Taylor 36737e3a0d8SEric Taylor if (strcmp(zpool_get_name(zhp), 36837e3a0d8SEric Taylor zpool_get_name(pool->uap_zhp))) 36937e3a0d8SEric Taylor continue; 37037e3a0d8SEric Taylor if (zfs_toplevel_state(zhp) >= VDEV_STATE_DEGRADED) { 37137e3a0d8SEric Taylor list_remove(&g_pool_list, pool); 37237e3a0d8SEric Taylor (void) tpool_dispatch(g_tpool, zfs_enable_ds, 37337e3a0d8SEric Taylor pool); 37437e3a0d8SEric Taylor break; 37537e3a0d8SEric Taylor } 3763c112a2bSEric Taylor } 3773c112a2bSEric Taylor } 3783d7072f8Seschrock 3793d7072f8Seschrock zpool_close(zhp); 3803d7072f8Seschrock return (0); 3813d7072f8Seschrock } 3823d7072f8Seschrock 3833d7072f8Seschrock /* 3843d7072f8Seschrock * Given a physical device path, iterate over all (pool, vdev) pairs which 3853d7072f8Seschrock * correspond to the given path. 3863d7072f8Seschrock */ 3873d7072f8Seschrock static boolean_t 3883d7072f8Seschrock devpath_iter(const char *devpath, zfs_process_func_t func, boolean_t wholedisk) 3893d7072f8Seschrock { 3903d7072f8Seschrock dev_data_t data = { 0 }; 3913d7072f8Seschrock 3923d7072f8Seschrock data.dd_compare = devpath; 3933d7072f8Seschrock data.dd_func = func; 3943d7072f8Seschrock data.dd_prop = ZPOOL_CONFIG_PHYS_PATH; 3953d7072f8Seschrock data.dd_found = B_FALSE; 3963d7072f8Seschrock data.dd_isdisk = wholedisk; 3973d7072f8Seschrock 3983d7072f8Seschrock (void) zpool_iter(g_zfshdl, zfs_iter_pool, &data); 3993d7072f8Seschrock 4003d7072f8Seschrock return (data.dd_found); 4013d7072f8Seschrock } 4023d7072f8Seschrock 4033d7072f8Seschrock /* 4043d7072f8Seschrock * Given a /devices path, lookup the corresponding devid for each minor node, 4053d7072f8Seschrock * and find any vdevs with matching devids. Doing this straight up would be 4063d7072f8Seschrock * rather inefficient, O(minor nodes * vdevs in system), so we take advantage of 4073d7072f8Seschrock * the fact that each devid ends with "/<minornode>". Once we find any valid 4083d7072f8Seschrock * minor node, we chop off the portion after the last slash, and then search for 4093d7072f8Seschrock * matching vdevs, which is O(vdevs in system). 4103d7072f8Seschrock */ 4113d7072f8Seschrock static boolean_t 4123d7072f8Seschrock devid_iter(const char *devpath, zfs_process_func_t func, boolean_t wholedisk) 4133d7072f8Seschrock { 4143d7072f8Seschrock size_t len = strlen(devpath) + sizeof ("/devices") + 4153d7072f8Seschrock sizeof (PHYS_PATH) - 1; 4163d7072f8Seschrock char *fullpath; 4173d7072f8Seschrock int fd; 4183d7072f8Seschrock ddi_devid_t devid; 4193d7072f8Seschrock char *devidstr, *fulldevid; 4203d7072f8Seschrock dev_data_t data = { 0 }; 4213d7072f8Seschrock 4223d7072f8Seschrock /* 4233d7072f8Seschrock * Try to open a known minor node. 4243d7072f8Seschrock */ 4253d7072f8Seschrock fullpath = alloca(len); 4263d7072f8Seschrock (void) snprintf(fullpath, len, "/devices%s%s", devpath, PHYS_PATH); 4273d7072f8Seschrock if ((fd = open(fullpath, O_RDONLY)) < 0) 4283d7072f8Seschrock return (B_FALSE); 4293d7072f8Seschrock 4303d7072f8Seschrock /* 4313d7072f8Seschrock * Determine the devid as a string, with no trailing slash for the minor 4323d7072f8Seschrock * node. 4333d7072f8Seschrock */ 4343d7072f8Seschrock if (devid_get(fd, &devid) != 0) { 4353d7072f8Seschrock (void) close(fd); 4363d7072f8Seschrock return (B_FALSE); 4373d7072f8Seschrock } 4383d7072f8Seschrock (void) close(fd); 4393d7072f8Seschrock 4403d7072f8Seschrock if ((devidstr = devid_str_encode(devid, NULL)) == NULL) { 4413d7072f8Seschrock devid_free(devid); 4423d7072f8Seschrock return (B_FALSE); 4433d7072f8Seschrock } 4443d7072f8Seschrock 4453d7072f8Seschrock len = strlen(devidstr) + 2; 4463d7072f8Seschrock fulldevid = alloca(len); 4473d7072f8Seschrock (void) snprintf(fulldevid, len, "%s/", devidstr); 4483d7072f8Seschrock 4493d7072f8Seschrock data.dd_compare = fulldevid; 4503d7072f8Seschrock data.dd_func = func; 4513d7072f8Seschrock data.dd_prop = ZPOOL_CONFIG_DEVID; 4523d7072f8Seschrock data.dd_found = B_FALSE; 4533d7072f8Seschrock data.dd_isdisk = wholedisk; 4543d7072f8Seschrock 4553d7072f8Seschrock (void) zpool_iter(g_zfshdl, zfs_iter_pool, &data); 4563d7072f8Seschrock 4573d7072f8Seschrock devid_str_free(devidstr); 45825085d90SEric Taylor devid_free(devid); 4593d7072f8Seschrock 4603d7072f8Seschrock return (data.dd_found); 4613d7072f8Seschrock } 4623d7072f8Seschrock 4633d7072f8Seschrock /* 4643d7072f8Seschrock * This function is called when we receive a devfs add event. This can be 4653d7072f8Seschrock * either a disk event or a lofi event, and the behavior is slightly different 4663d7072f8Seschrock * depending on which it is. 4673d7072f8Seschrock */ 4683d7072f8Seschrock static int 4693d7072f8Seschrock zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi) 4703d7072f8Seschrock { 4713d7072f8Seschrock char *devpath, *devname; 4723d7072f8Seschrock char path[PATH_MAX], realpath[PATH_MAX]; 4733d7072f8Seschrock char *colon, *raw; 4743d7072f8Seschrock int ret; 4753d7072f8Seschrock 4763d7072f8Seschrock /* 4773d7072f8Seschrock * The main unit of operation is the physical device path. For disks, 4783d7072f8Seschrock * this is the device node, as all minor nodes are affected. For lofi 4793d7072f8Seschrock * devices, this includes the minor path. Unfortunately, this isn't 4803d7072f8Seschrock * represented in the DEV_PHYS_PATH for various reasons. 4813d7072f8Seschrock */ 4823d7072f8Seschrock if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath) != 0) 4833d7072f8Seschrock return (-1); 4843d7072f8Seschrock 4853d7072f8Seschrock /* 4863d7072f8Seschrock * If this is a lofi device, then also get the minor instance name. 4873d7072f8Seschrock * Unfortunately, the current payload doesn't include an easy way to get 4883d7072f8Seschrock * this information. So we cheat by resolving the 'dev_name' (which 4893d7072f8Seschrock * refers to the raw device) and taking the portion between ':(*),raw'. 4903d7072f8Seschrock */ 4913d7072f8Seschrock (void) strlcpy(realpath, devpath, sizeof (realpath)); 4923d7072f8Seschrock if (is_lofi) { 4933d7072f8Seschrock if (nvlist_lookup_string(nvl, DEV_NAME, 4943d7072f8Seschrock &devname) == 0 && 4953d7072f8Seschrock (ret = resolvepath(devname, path, 4963d7072f8Seschrock sizeof (path))) > 0) { 4973d7072f8Seschrock path[ret] = '\0'; 4983d7072f8Seschrock colon = strchr(path, ':'); 4993d7072f8Seschrock if (colon != NULL) 5003d7072f8Seschrock raw = strstr(colon + 1, ",raw"); 5013d7072f8Seschrock if (colon != NULL && raw != NULL) { 5023d7072f8Seschrock *raw = '\0'; 5033d7072f8Seschrock (void) snprintf(realpath, 5043d7072f8Seschrock sizeof (realpath), "%s%s", 5053d7072f8Seschrock devpath, colon); 5063d7072f8Seschrock *raw = ','; 5073d7072f8Seschrock } 5083d7072f8Seschrock } 5093d7072f8Seschrock } 5103d7072f8Seschrock 5113d7072f8Seschrock /* 5123d7072f8Seschrock * Iterate over all vdevs with a matching devid, and then those with a 5133d7072f8Seschrock * matching /devices path. For disks, we only want to pay attention to 5143d7072f8Seschrock * vdevs marked as whole disks. For lofi, we don't care (because we're 5153d7072f8Seschrock * matching an exact minor name). 5163d7072f8Seschrock */ 5173d7072f8Seschrock if (!devid_iter(realpath, zfs_process_add, !is_lofi)) 5183d7072f8Seschrock (void) devpath_iter(realpath, zfs_process_add, !is_lofi); 5193d7072f8Seschrock 5203d7072f8Seschrock return (0); 5213d7072f8Seschrock } 5223d7072f8Seschrock 5233d7072f8Seschrock /* 5243d7072f8Seschrock * Called when we receive a VDEV_CHECK event, which indicates a device could not 5253d7072f8Seschrock * be opened during initial pool open, but the autoreplace property was set on 5263d7072f8Seschrock * the pool. In this case, we treat it as if it were an add event. 5273d7072f8Seschrock */ 5283d7072f8Seschrock static int 5293d7072f8Seschrock zfs_deliver_check(nvlist_t *nvl) 5303d7072f8Seschrock { 5313d7072f8Seschrock dev_data_t data = { 0 }; 5323d7072f8Seschrock 5333d7072f8Seschrock if (nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID, 5343d7072f8Seschrock &data.dd_pool_guid) != 0 || 5353d7072f8Seschrock nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, 536efb4a871SYuri Pankov &data.dd_vdev_guid) != 0 || 537efb4a871SYuri Pankov data.dd_vdev_guid == 0) 5383d7072f8Seschrock return (0); 5393d7072f8Seschrock 5403d7072f8Seschrock data.dd_isdisk = B_TRUE; 5413d7072f8Seschrock data.dd_func = zfs_process_add; 5423d7072f8Seschrock 5433d7072f8Seschrock (void) zpool_iter(g_zfshdl, zfs_iter_pool, &data); 5443d7072f8Seschrock 5453d7072f8Seschrock return (0); 5463d7072f8Seschrock } 5473d7072f8Seschrock 548b98131cfSEric Taylor #define DEVICE_PREFIX "/devices" 549b98131cfSEric Taylor 550b98131cfSEric Taylor static int 551b98131cfSEric Taylor zfsdle_vdev_online(zpool_handle_t *zhp, void *data) 552b98131cfSEric Taylor { 553b98131cfSEric Taylor char *devname = data; 554b98131cfSEric Taylor boolean_t avail_spare, l2cache; 555b98131cfSEric Taylor vdev_state_t newstate; 556b98131cfSEric Taylor nvlist_t *tgt; 557b98131cfSEric Taylor 558b98131cfSEric Taylor syseventd_print(9, "zfsdle_vdev_online: searching for %s in pool %s\n", 559b98131cfSEric Taylor devname, zpool_get_name(zhp)); 560b98131cfSEric Taylor 561b98131cfSEric Taylor if ((tgt = zpool_find_vdev_by_physpath(zhp, devname, 562b98131cfSEric Taylor &avail_spare, &l2cache, NULL)) != NULL) { 563b98131cfSEric Taylor char *path, fullpath[MAXPATHLEN]; 564b98131cfSEric Taylor uint64_t wholedisk = 0ULL; 565b98131cfSEric Taylor 566b98131cfSEric Taylor verify(nvlist_lookup_string(tgt, ZPOOL_CONFIG_PATH, 567b98131cfSEric Taylor &path) == 0); 568b98131cfSEric Taylor verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_WHOLE_DISK, 569b98131cfSEric Taylor &wholedisk) == 0); 570b98131cfSEric Taylor 571b98131cfSEric Taylor (void) strlcpy(fullpath, path, sizeof (fullpath)); 5724263d13fSGeorge Wilson if (wholedisk) { 573b98131cfSEric Taylor fullpath[strlen(fullpath) - 2] = '\0'; 574b98131cfSEric Taylor 5754263d13fSGeorge Wilson /* 5764263d13fSGeorge Wilson * We need to reopen the pool associated with this 5774263d13fSGeorge Wilson * device so that the kernel can update the size 5784263d13fSGeorge Wilson * of the expanded device. 5794263d13fSGeorge Wilson */ 5804263d13fSGeorge Wilson (void) zpool_reopen(zhp); 5814263d13fSGeorge Wilson } 5824263d13fSGeorge Wilson 583b98131cfSEric Taylor if (zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) { 584b98131cfSEric Taylor syseventd_print(9, "zfsdle_vdev_online: setting device" 585b98131cfSEric Taylor " device %s to ONLINE state in pool %s.\n", 586b98131cfSEric Taylor fullpath, zpool_get_name(zhp)); 587b98131cfSEric Taylor if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL) 588b98131cfSEric Taylor (void) zpool_vdev_online(zhp, fullpath, 0, 589b98131cfSEric Taylor &newstate); 590b98131cfSEric Taylor } 59125085d90SEric Taylor zpool_close(zhp); 592b98131cfSEric Taylor return (1); 593b98131cfSEric Taylor } 59425085d90SEric Taylor zpool_close(zhp); 595b98131cfSEric Taylor return (0); 596b98131cfSEric Taylor } 597b98131cfSEric Taylor 59814372834SHans Rosenfeld /* 59914372834SHans Rosenfeld * This function is called for each vdev of a pool for which any of the 60014372834SHans Rosenfeld * following events was recieved: 60114372834SHans Rosenfeld * - ESC_ZFS_vdev_add 60214372834SHans Rosenfeld * - ESC_ZFS_vdev_attach 60314372834SHans Rosenfeld * - ESC_ZFS_vdev_clear 60414372834SHans Rosenfeld * - ESC_ZFS_vdev_online 60514372834SHans Rosenfeld * - ESC_ZFS_pool_create 60614372834SHans Rosenfeld * - ESC_ZFS_pool_import 60714372834SHans Rosenfeld * It will update the vdevs FRU property if it is out of date. 60814372834SHans Rosenfeld */ 60914372834SHans Rosenfeld /*ARGSUSED2*/ 61014372834SHans Rosenfeld static void 61114372834SHans Rosenfeld zfs_update_vdev_fru(zpool_handle_t *zhp, nvlist_t *vdev, boolean_t isdisk) 61214372834SHans Rosenfeld { 61314372834SHans Rosenfeld char *devpath, *cptr, *oldfru = NULL; 61414372834SHans Rosenfeld const char *newfru; 61514372834SHans Rosenfeld uint64_t vdev_guid; 61614372834SHans Rosenfeld 61714372834SHans Rosenfeld (void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_GUID, &vdev_guid); 61814372834SHans Rosenfeld (void) nvlist_lookup_string(vdev, ZPOOL_CONFIG_PHYS_PATH, &devpath); 61914372834SHans Rosenfeld (void) nvlist_lookup_string(vdev, ZPOOL_CONFIG_FRU, &oldfru); 62014372834SHans Rosenfeld 62114372834SHans Rosenfeld /* remove :<slice> from devpath */ 62214372834SHans Rosenfeld cptr = strrchr(devpath, ':'); 62314372834SHans Rosenfeld if (cptr != NULL) 62414372834SHans Rosenfeld *cptr = '\0'; 62514372834SHans Rosenfeld 62614372834SHans Rosenfeld newfru = libzfs_fru_lookup(g_zfshdl, devpath); 62714372834SHans Rosenfeld if (newfru == NULL) { 62814372834SHans Rosenfeld syseventd_print(9, "zfs_update_vdev_fru: no FRU for %s\n", 62914372834SHans Rosenfeld devpath); 63014372834SHans Rosenfeld return; 63114372834SHans Rosenfeld } 63214372834SHans Rosenfeld 63314372834SHans Rosenfeld /* do nothing if the FRU hasn't changed */ 63414372834SHans Rosenfeld if (oldfru != NULL && libzfs_fru_compare(g_zfshdl, oldfru, newfru)) { 63514372834SHans Rosenfeld syseventd_print(9, "zfs_update_vdev_fru: FRU unchanged\n"); 63614372834SHans Rosenfeld return; 63714372834SHans Rosenfeld } 63814372834SHans Rosenfeld 63914372834SHans Rosenfeld syseventd_print(9, "zfs_update_vdev_fru: devpath = %s\n", devpath); 64014372834SHans Rosenfeld syseventd_print(9, "zfs_update_vdev_fru: FRU = %s\n", newfru); 64114372834SHans Rosenfeld 64214372834SHans Rosenfeld (void) zpool_fru_set(zhp, vdev_guid, newfru); 64314372834SHans Rosenfeld } 64414372834SHans Rosenfeld 64514372834SHans Rosenfeld /* 64614372834SHans Rosenfeld * This function handles the following events: 64714372834SHans Rosenfeld * - ESC_ZFS_vdev_add 64814372834SHans Rosenfeld * - ESC_ZFS_vdev_attach 64914372834SHans Rosenfeld * - ESC_ZFS_vdev_clear 65014372834SHans Rosenfeld * - ESC_ZFS_vdev_online 65114372834SHans Rosenfeld * - ESC_ZFS_pool_create 65214372834SHans Rosenfeld * - ESC_ZFS_pool_import 65314372834SHans Rosenfeld * It will iterate over the pool vdevs to update the FRU property. 65414372834SHans Rosenfeld */ 65514372834SHans Rosenfeld int 65614372834SHans Rosenfeld zfs_deliver_update(nvlist_t *nvl) 65714372834SHans Rosenfeld { 65814372834SHans Rosenfeld dev_data_t dd = { 0 }; 65914372834SHans Rosenfeld char *pname; 66014372834SHans Rosenfeld zpool_handle_t *zhp; 66114372834SHans Rosenfeld nvlist_t *config, *vdev; 66214372834SHans Rosenfeld 66314372834SHans Rosenfeld if (nvlist_lookup_string(nvl, "pool_name", &pname) != 0) { 66414372834SHans Rosenfeld syseventd_print(9, "zfs_deliver_update: no pool name\n"); 66514372834SHans Rosenfeld return (-1); 66614372834SHans Rosenfeld } 66714372834SHans Rosenfeld 66814372834SHans Rosenfeld /* 66914372834SHans Rosenfeld * If this event was triggered by a pool export or destroy we cannot 67014372834SHans Rosenfeld * open the pool. This is not an error, just return 0 as we don't care 67114372834SHans Rosenfeld * about these events. 67214372834SHans Rosenfeld */ 67314372834SHans Rosenfeld zhp = zpool_open_canfail(g_zfshdl, pname); 67414372834SHans Rosenfeld if (zhp == NULL) 67514372834SHans Rosenfeld return (0); 67614372834SHans Rosenfeld 67714372834SHans Rosenfeld config = zpool_get_config(zhp, NULL); 67814372834SHans Rosenfeld if (config == NULL) { 67914372834SHans Rosenfeld syseventd_print(9, "zfs_deliver_update: " 68014372834SHans Rosenfeld "failed to get pool config for %s\n", pname); 68114372834SHans Rosenfeld zpool_close(zhp); 68214372834SHans Rosenfeld return (-1); 68314372834SHans Rosenfeld } 68414372834SHans Rosenfeld 68514372834SHans Rosenfeld if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &vdev) != 0) { 68614372834SHans Rosenfeld syseventd_print(0, "zfs_deliver_update: " 68714372834SHans Rosenfeld "failed to get vdev tree for %s\n", pname); 68814372834SHans Rosenfeld zpool_close(zhp); 68914372834SHans Rosenfeld return (-1); 69014372834SHans Rosenfeld } 69114372834SHans Rosenfeld 69214372834SHans Rosenfeld libzfs_fru_refresh(g_zfshdl); 69314372834SHans Rosenfeld 69414372834SHans Rosenfeld dd.dd_func = zfs_update_vdev_fru; 69514372834SHans Rosenfeld zfs_iter_vdev(zhp, vdev, &dd); 69614372834SHans Rosenfeld 69714372834SHans Rosenfeld zpool_close(zhp); 69814372834SHans Rosenfeld return (0); 69914372834SHans Rosenfeld } 70014372834SHans Rosenfeld 701b98131cfSEric Taylor int 702b98131cfSEric Taylor zfs_deliver_dle(nvlist_t *nvl) 703b98131cfSEric Taylor { 704b98131cfSEric Taylor char *devname; 705b98131cfSEric Taylor if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devname) != 0) { 706b98131cfSEric Taylor syseventd_print(9, "zfs_deliver_event: no physpath\n"); 707b98131cfSEric Taylor return (-1); 708b98131cfSEric Taylor } 709b98131cfSEric Taylor if (strncmp(devname, DEVICE_PREFIX, strlen(DEVICE_PREFIX)) != 0) { 710b98131cfSEric Taylor syseventd_print(9, "zfs_deliver_event: invalid " 711b98131cfSEric Taylor "device '%s'", devname); 712b98131cfSEric Taylor return (-1); 713b98131cfSEric Taylor } 714b98131cfSEric Taylor 715b98131cfSEric Taylor /* 716b98131cfSEric Taylor * We try to find the device using the physical 717b98131cfSEric Taylor * path that has been supplied. We need to strip off 718b98131cfSEric Taylor * the /devices prefix before starting our search. 719b98131cfSEric Taylor */ 720b98131cfSEric Taylor devname += strlen(DEVICE_PREFIX); 721b98131cfSEric Taylor if (zpool_iter(g_zfshdl, zfsdle_vdev_online, devname) != 1) { 722b98131cfSEric Taylor syseventd_print(9, "zfs_deliver_event: device '%s' not" 723b98131cfSEric Taylor " found\n", devname); 724b98131cfSEric Taylor return (1); 725b98131cfSEric Taylor } 726b98131cfSEric Taylor return (0); 727b98131cfSEric Taylor } 728b98131cfSEric Taylor 729b98131cfSEric Taylor 7303d7072f8Seschrock /*ARGSUSED*/ 7313d7072f8Seschrock static int 7323d7072f8Seschrock zfs_deliver_event(sysevent_t *ev, int unused) 7333d7072f8Seschrock { 7343d7072f8Seschrock const char *class = sysevent_get_class_name(ev); 7353d7072f8Seschrock const char *subclass = sysevent_get_subclass_name(ev); 7363d7072f8Seschrock nvlist_t *nvl; 7373d7072f8Seschrock int ret; 73814372834SHans Rosenfeld boolean_t is_lofi = B_FALSE, is_check = B_FALSE; 73914372834SHans Rosenfeld boolean_t is_dle = B_FALSE, is_update = B_FALSE; 7403d7072f8Seschrock 7413d7072f8Seschrock if (strcmp(class, EC_DEV_ADD) == 0) { 7423d7072f8Seschrock /* 7433d7072f8Seschrock * We're mainly interested in disk additions, but we also listen 7443d7072f8Seschrock * for new lofi devices, to allow for simplified testing. 7453d7072f8Seschrock */ 7463d7072f8Seschrock if (strcmp(subclass, ESC_DISK) == 0) 7473d7072f8Seschrock is_lofi = B_FALSE; 7483d7072f8Seschrock else if (strcmp(subclass, ESC_LOFI) == 0) 7493d7072f8Seschrock is_lofi = B_TRUE; 7503d7072f8Seschrock else 7513d7072f8Seschrock return (0); 7523d7072f8Seschrock 7533d7072f8Seschrock is_check = B_FALSE; 75414372834SHans Rosenfeld } else if (strcmp(class, EC_ZFS) == 0) { 75514372834SHans Rosenfeld if (strcmp(subclass, ESC_ZFS_VDEV_CHECK) == 0) { 75614372834SHans Rosenfeld /* 75714372834SHans Rosenfeld * This event signifies that a device failed to open 75814372834SHans Rosenfeld * during pool load, but the 'autoreplace' property was 75914372834SHans Rosenfeld * set, so we should pretend it's just been added. 76014372834SHans Rosenfeld */ 76114372834SHans Rosenfeld is_check = B_TRUE; 76214372834SHans Rosenfeld } else if ((strcmp(subclass, ESC_ZFS_VDEV_ADD) == 0) || 76314372834SHans Rosenfeld (strcmp(subclass, ESC_ZFS_VDEV_ATTACH) == 0) || 76414372834SHans Rosenfeld (strcmp(subclass, ESC_ZFS_VDEV_CLEAR) == 0) || 76514372834SHans Rosenfeld (strcmp(subclass, ESC_ZFS_VDEV_ONLINE) == 0) || 76614372834SHans Rosenfeld (strcmp(subclass, ESC_ZFS_POOL_CREATE) == 0) || 76714372834SHans Rosenfeld (strcmp(subclass, ESC_ZFS_POOL_IMPORT) == 0)) { 76814372834SHans Rosenfeld /* 76914372834SHans Rosenfeld * When we receive these events we check the pool 77014372834SHans Rosenfeld * configuration and update the vdev FRUs if necessary. 77114372834SHans Rosenfeld */ 77214372834SHans Rosenfeld is_update = B_TRUE; 77314372834SHans Rosenfeld } 774b98131cfSEric Taylor } else if (strcmp(class, EC_DEV_STATUS) == 0 && 775b98131cfSEric Taylor strcmp(subclass, ESC_DEV_DLE) == 0) { 776b98131cfSEric Taylor is_dle = B_TRUE; 7773d7072f8Seschrock } else { 7783d7072f8Seschrock return (0); 7793d7072f8Seschrock } 7803d7072f8Seschrock 7813d7072f8Seschrock if (sysevent_get_attr_list(ev, &nvl) != 0) 7823d7072f8Seschrock return (-1); 7833d7072f8Seschrock 784b98131cfSEric Taylor if (is_dle) 785b98131cfSEric Taylor ret = zfs_deliver_dle(nvl); 78614372834SHans Rosenfeld else if (is_update) 78714372834SHans Rosenfeld ret = zfs_deliver_update(nvl); 788b98131cfSEric Taylor else if (is_check) 7893d7072f8Seschrock ret = zfs_deliver_check(nvl); 7903d7072f8Seschrock else 7913d7072f8Seschrock ret = zfs_deliver_add(nvl, is_lofi); 7923d7072f8Seschrock 7933d7072f8Seschrock nvlist_free(nvl); 7943d7072f8Seschrock return (ret); 7953d7072f8Seschrock } 7963d7072f8Seschrock 79737e3a0d8SEric Taylor /*ARGSUSED*/ 79837e3a0d8SEric Taylor void * 79937e3a0d8SEric Taylor zfs_enum_pools(void *arg) 80037e3a0d8SEric Taylor { 80137e3a0d8SEric Taylor (void) zpool_iter(g_zfshdl, zfs_unavail_pool, (void *)&g_pool_list); 80237e3a0d8SEric Taylor if (!list_is_empty(&g_pool_list)) 80337e3a0d8SEric Taylor g_tpool = tpool_create(1, sysconf(_SC_NPROCESSORS_ONLN), 80437e3a0d8SEric Taylor 0, NULL); 80537e3a0d8SEric Taylor g_enumeration_done = B_TRUE; 80637e3a0d8SEric Taylor return (NULL); 80737e3a0d8SEric Taylor } 80837e3a0d8SEric Taylor 8093d7072f8Seschrock static struct slm_mod_ops zfs_mod_ops = { 8103d7072f8Seschrock SE_MAJOR_VERSION, SE_MINOR_VERSION, 10, zfs_deliver_event 8113d7072f8Seschrock }; 8123d7072f8Seschrock 8133d7072f8Seschrock struct slm_mod_ops * 8143d7072f8Seschrock slm_init() 8153d7072f8Seschrock { 8163d7072f8Seschrock if ((g_zfshdl = libzfs_init()) == NULL) 8173d7072f8Seschrock return (NULL); 81837e3a0d8SEric Taylor /* 81937e3a0d8SEric Taylor * collect a list of unavailable pools (asynchronously, 82037e3a0d8SEric Taylor * since this can take a while) 82137e3a0d8SEric Taylor */ 8223c112a2bSEric Taylor list_create(&g_pool_list, sizeof (struct unavailpool), 8233c112a2bSEric Taylor offsetof(struct unavailpool, uap_node)); 82437e3a0d8SEric Taylor if (thr_create(NULL, 0, zfs_enum_pools, NULL, 0, &g_zfs_tid) != 0) 82537e3a0d8SEric Taylor return (NULL); 8263d7072f8Seschrock return (&zfs_mod_ops); 8273d7072f8Seschrock } 8283d7072f8Seschrock 8293d7072f8Seschrock void 8303d7072f8Seschrock slm_fini() 8313d7072f8Seschrock { 8323c112a2bSEric Taylor unavailpool_t *pool; 8333c112a2bSEric Taylor 834cead1df3SHans Rosenfeld (void) thr_join(g_zfs_tid, NULL, NULL); 83537e3a0d8SEric Taylor if (g_tpool != NULL) { 8363c112a2bSEric Taylor tpool_wait(g_tpool); 8373c112a2bSEric Taylor tpool_destroy(g_tpool); 8383c112a2bSEric Taylor } 8393c112a2bSEric Taylor while ((pool = (list_head(&g_pool_list))) != NULL) { 8403c112a2bSEric Taylor list_remove(&g_pool_list, pool); 8413c112a2bSEric Taylor zpool_close(pool->uap_zhp); 8423c112a2bSEric Taylor free(pool); 8433c112a2bSEric Taylor } 8443c112a2bSEric Taylor list_destroy(&g_pool_list); 84525085d90SEric Taylor libzfs_fini(g_zfshdl); 8463d7072f8Seschrock } 847