1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 2199653d4eSeschrock 22fa9e4066Sahrens /* 2398d1cbfeSGeorge Wilson * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 241b497ab8SAdam H. Leventhal * Copyright (c) 2011, 2014 by Delphix. All rights reserved. 25b8289d24SDaniil Lunev * Copyright (c) 2013, 2014, Nexenta Systems, Inc. All rights reserved. 26*bc9014e6SJustin Gibbs * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved. 275aeb9474SGarrett D'Amore */ 28fa9e4066Sahrens 29fa9e4066Sahrens /* 303e30c24aSWill Andrews * SPA: Storage Pool Allocator 313e30c24aSWill Andrews * 32fa9e4066Sahrens * This file contains all the routines used when modifying on-disk SPA state. 33fa9e4066Sahrens * This includes opening, importing, destroying, exporting a pool, and syncing a 34fa9e4066Sahrens * pool. 35fa9e4066Sahrens */ 36fa9e4066Sahrens 37fa9e4066Sahrens #include <sys/zfs_context.h> 38ea8dc4b6Seschrock #include <sys/fm/fs/zfs.h> 39fa9e4066Sahrens #include <sys/spa_impl.h> 40fa9e4066Sahrens #include <sys/zio.h> 41fa9e4066Sahrens #include <sys/zio_checksum.h> 42fa9e4066Sahrens #include <sys/dmu.h> 43fa9e4066Sahrens #include <sys/dmu_tx.h> 44fa9e4066Sahrens #include <sys/zap.h> 45fa9e4066Sahrens #include <sys/zil.h> 46b24ab676SJeff Bonwick #include <sys/ddt.h> 47fa9e4066Sahrens #include <sys/vdev_impl.h> 48fa9e4066Sahrens #include <sys/metaslab.h> 4988ecc943SGeorge Wilson #include <sys/metaslab_impl.h> 50fa9e4066Sahrens #include <sys/uberblock_impl.h> 51fa9e4066Sahrens #include <sys/txg.h> 52fa9e4066Sahrens #include <sys/avl.h> 53fa9e4066Sahrens #include <sys/dmu_traverse.h> 54b1b8ab34Slling #include <sys/dmu_objset.h> 55fa9e4066Sahrens #include <sys/unique.h> 56fa9e4066Sahrens #include <sys/dsl_pool.h> 57b1b8ab34Slling #include <sys/dsl_dataset.h> 58fa9e4066Sahrens #include <sys/dsl_dir.h> 59fa9e4066Sahrens #include <sys/dsl_prop.h> 60b1b8ab34Slling #include <sys/dsl_synctask.h> 61fa9e4066Sahrens #include <sys/fs/zfs.h> 62fa94a07fSbrendan #include <sys/arc.h> 63fa9e4066Sahrens #include <sys/callb.h> 6495173954Sek #include <sys/systeminfo.h> 65e7cbe64fSgw #include <sys/spa_boot.h> 66573ca77eSGeorge Wilson #include <sys/zfs_ioctl.h> 673f9d6ad7SLin Ling #include <sys/dsl_scan.h> 68ad135b5dSChristopher Siden #include <sys/zfeature.h> 693b2aab18SMatthew Ahrens #include <sys/dsl_destroy.h> 70fa9e4066Sahrens 715679c89fSjv #ifdef _KERNEL 72dedec472SJack Meng #include <sys/bootprops.h> 7335a5a358SJonathan Adams #include <sys/callb.h> 7435a5a358SJonathan Adams #include <sys/cpupart.h> 7535a5a358SJonathan Adams #include <sys/pool.h> 7635a5a358SJonathan Adams #include <sys/sysdc.h> 7735a5a358SJonathan Adams #include <sys/zone.h> 785679c89fSjv #endif /* _KERNEL */ 795679c89fSjv 80990b4856Slling #include "zfs_prop.h" 81b7b97454Sperrin #include "zfs_comutil.h" 82990b4856Slling 833cb69f73SWill Andrews /* 843cb69f73SWill Andrews * The interval, in seconds, at which failed configuration cache file writes 853cb69f73SWill Andrews * should be retried. 863cb69f73SWill Andrews */ 873cb69f73SWill Andrews static int zfs_ccw_retry_interval = 300; 883cb69f73SWill Andrews 8935a5a358SJonathan Adams typedef enum zti_modes { 90ec94d322SAdam Leventhal ZTI_MODE_FIXED, /* value is # of threads (min 1) */ 91ec94d322SAdam Leventhal ZTI_MODE_BATCH, /* cpu-intensive; value is ignored */ 92ec94d322SAdam Leventhal ZTI_MODE_NULL, /* don't create a taskq */ 93ec94d322SAdam Leventhal ZTI_NMODES 9435a5a358SJonathan Adams } zti_modes_t; 95416e0cd8Sek 96ec94d322SAdam Leventhal #define ZTI_P(n, q) { ZTI_MODE_FIXED, (n), (q) } 97ec94d322SAdam Leventhal #define ZTI_BATCH { ZTI_MODE_BATCH, 0, 1 } 98ec94d322SAdam Leventhal #define ZTI_NULL { ZTI_MODE_NULL, 0, 0 } 992e0c549eSJonathan Adams 100ec94d322SAdam Leventhal #define ZTI_N(n) ZTI_P(n, 1) 101ec94d322SAdam Leventhal #define ZTI_ONE ZTI_N(1) 1022e0c549eSJonathan Adams 1032e0c549eSJonathan Adams typedef struct zio_taskq_info { 104ec94d322SAdam Leventhal zti_modes_t zti_mode; 10580eb36f2SGeorge Wilson uint_t zti_value; 106ec94d322SAdam Leventhal uint_t zti_count; 1072e0c549eSJonathan Adams } zio_taskq_info_t; 1082e0c549eSJonathan Adams 1092e0c549eSJonathan Adams static const char *const zio_taskq_types[ZIO_TASKQ_TYPES] = { 11035a5a358SJonathan Adams "issue", "issue_high", "intr", "intr_high" 1112e0c549eSJonathan Adams }; 1122e0c549eSJonathan Adams 11380eb36f2SGeorge Wilson /* 114ec94d322SAdam Leventhal * This table defines the taskq settings for each ZFS I/O type. When 115ec94d322SAdam Leventhal * initializing a pool, we use this table to create an appropriately sized 116ec94d322SAdam Leventhal * taskq. Some operations are low volume and therefore have a small, static 117ec94d322SAdam Leventhal * number of threads assigned to their taskqs using the ZTI_N(#) or ZTI_ONE 118ec94d322SAdam Leventhal * macros. Other operations process a large amount of data; the ZTI_BATCH 119ec94d322SAdam Leventhal * macro causes us to create a taskq oriented for throughput. Some operations 120ec94d322SAdam Leventhal * are so high frequency and short-lived that the taskq itself can become a a 121ec94d322SAdam Leventhal * point of lock contention. The ZTI_P(#, #) macro indicates that we need an 122ec94d322SAdam Leventhal * additional degree of parallelism specified by the number of threads per- 123ec94d322SAdam Leventhal * taskq and the number of taskqs; when dispatching an event in this case, the 124ec94d322SAdam Leventhal * particular taskq is chosen at random. 125ec94d322SAdam Leventhal * 126ec94d322SAdam Leventhal * The different taskq priorities are to handle the different contexts (issue 127ec94d322SAdam Leventhal * and interrupt) and then to reserve threads for ZIO_PRIORITY_NOW I/Os that 128ec94d322SAdam Leventhal * need to be handled with minimum delay. 12980eb36f2SGeorge Wilson */ 13080eb36f2SGeorge Wilson const zio_taskq_info_t zio_taskqs[ZIO_TYPES][ZIO_TASKQ_TYPES] = { 13180eb36f2SGeorge Wilson /* ISSUE ISSUE_HIGH INTR INTR_HIGH */ 132ec94d322SAdam Leventhal { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* NULL */ 1331b497ab8SAdam H. Leventhal { ZTI_N(8), ZTI_NULL, ZTI_P(12, 8), ZTI_NULL }, /* READ */ 134ec94d322SAdam Leventhal { ZTI_BATCH, ZTI_N(5), ZTI_N(8), ZTI_N(5) }, /* WRITE */ 135ec94d322SAdam Leventhal { ZTI_P(12, 8), ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* FREE */ 136ec94d322SAdam Leventhal { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* CLAIM */ 137ec94d322SAdam Leventhal { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* IOCTL */ 1382e0c549eSJonathan Adams }; 1392e0c549eSJonathan Adams 1403b2aab18SMatthew Ahrens static void spa_sync_version(void *arg, dmu_tx_t *tx); 1413b2aab18SMatthew Ahrens static void spa_sync_props(void *arg, dmu_tx_t *tx); 14289a89ebfSlling static boolean_t spa_has_active_shared_spare(spa_t *spa); 1431195e687SMark J Musante static int spa_load_impl(spa_t *spa, uint64_t, nvlist_t *config, 1441195e687SMark J Musante spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig, 1451195e687SMark J Musante char **ereport); 146cb04b873SMark J Musante static void spa_vdev_resilver_done(spa_t *spa); 147990b4856Slling 14869962b56SMatthew Ahrens uint_t zio_taskq_batch_pct = 75; /* 1 thread per cpu in pset */ 14935a5a358SJonathan Adams id_t zio_taskq_psrset_bind = PS_NONE; 15035a5a358SJonathan Adams boolean_t zio_taskq_sysdc = B_TRUE; /* use SDC scheduling class */ 15135a5a358SJonathan Adams uint_t zio_taskq_basedc = 80; /* base duty cycle */ 15235a5a358SJonathan Adams 15335a5a358SJonathan Adams boolean_t spa_create_process = B_TRUE; /* no process ==> no sysdc */ 15401f55e48SGeorge Wilson extern int zfs_sync_pass_deferred_free; 15535a5a358SJonathan Adams 15635a5a358SJonathan Adams /* 15735a5a358SJonathan Adams * This (illegal) pool name is used when temporarily importing a spa_t in order 15835a5a358SJonathan Adams * to get the vdev stats associated with the imported devices. 15935a5a358SJonathan Adams */ 16035a5a358SJonathan Adams #define TRYIMPORT_NAME "$import" 16135a5a358SJonathan Adams 162990b4856Slling /* 163990b4856Slling * ========================================================================== 164990b4856Slling * SPA properties routines 165990b4856Slling * ========================================================================== 166990b4856Slling */ 167990b4856Slling 168990b4856Slling /* 169990b4856Slling * Add a (source=src, propname=propval) list to an nvlist. 170990b4856Slling */ 1719d82f4f6Slling static void 172990b4856Slling spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval, 173990b4856Slling uint64_t intval, zprop_source_t src) 174990b4856Slling { 175990b4856Slling const char *propname = zpool_prop_to_name(prop); 176990b4856Slling nvlist_t *propval; 177990b4856Slling 1789d82f4f6Slling VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0); 1799d82f4f6Slling VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0); 180990b4856Slling 1819d82f4f6Slling if (strval != NULL) 1829d82f4f6Slling VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0); 1839d82f4f6Slling else 1849d82f4f6Slling VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0); 185990b4856Slling 1869d82f4f6Slling VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0); 187990b4856Slling nvlist_free(propval); 188990b4856Slling } 189990b4856Slling 190990b4856Slling /* 191990b4856Slling * Get property values from the spa configuration. 192990b4856Slling */ 1939d82f4f6Slling static void 194990b4856Slling spa_prop_get_config(spa_t *spa, nvlist_t **nvp) 195990b4856Slling { 1964263d13fSGeorge Wilson vdev_t *rvd = spa->spa_root_vdev; 197ad135b5dSChristopher Siden dsl_pool_t *pool = spa->spa_dsl_pool; 1982e4c9986SGeorge Wilson uint64_t size, alloc, cap, version; 199990b4856Slling zprop_source_t src = ZPROP_SRC_NONE; 200c5904d13Seschrock spa_config_dirent_t *dp; 2012e4c9986SGeorge Wilson metaslab_class_t *mc = spa_normal_class(spa); 202990b4856Slling 203e14bb325SJeff Bonwick ASSERT(MUTEX_HELD(&spa->spa_props_lock)); 204e14bb325SJeff Bonwick 2054263d13fSGeorge Wilson if (rvd != NULL) { 206485bbbf5SGeorge Wilson alloc = metaslab_class_get_alloc(spa_normal_class(spa)); 207b24ab676SJeff Bonwick size = metaslab_class_get_space(spa_normal_class(spa)); 208379c004dSEric Schrock spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src); 209379c004dSEric Schrock spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src); 210485bbbf5SGeorge Wilson spa_prop_add_list(*nvp, ZPOOL_PROP_ALLOCATED, NULL, alloc, src); 211485bbbf5SGeorge Wilson spa_prop_add_list(*nvp, ZPOOL_PROP_FREE, NULL, 212485bbbf5SGeorge Wilson size - alloc, src); 2134263d13fSGeorge Wilson 2142e4c9986SGeorge Wilson spa_prop_add_list(*nvp, ZPOOL_PROP_FRAGMENTATION, NULL, 2152e4c9986SGeorge Wilson metaslab_class_fragmentation(mc), src); 2162e4c9986SGeorge Wilson spa_prop_add_list(*nvp, ZPOOL_PROP_EXPANDSZ, NULL, 2172e4c9986SGeorge Wilson metaslab_class_expandable_space(mc), src); 218f9af39baSGeorge Wilson spa_prop_add_list(*nvp, ZPOOL_PROP_READONLY, NULL, 219f9af39baSGeorge Wilson (spa_mode(spa) == FREAD), src); 220379c004dSEric Schrock 221485bbbf5SGeorge Wilson cap = (size == 0) ? 0 : (alloc * 100 / size); 222379c004dSEric Schrock spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src); 223379c004dSEric Schrock 224b24ab676SJeff Bonwick spa_prop_add_list(*nvp, ZPOOL_PROP_DEDUPRATIO, NULL, 225b24ab676SJeff Bonwick ddt_get_pool_dedup_ratio(spa), src); 226b24ab676SJeff Bonwick 227379c004dSEric Schrock spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL, 2284263d13fSGeorge Wilson rvd->vdev_state, src); 229379c004dSEric Schrock 230379c004dSEric Schrock version = spa_version(spa); 231379c004dSEric Schrock if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION)) 232379c004dSEric Schrock src = ZPROP_SRC_DEFAULT; 233379c004dSEric Schrock else 234379c004dSEric Schrock src = ZPROP_SRC_LOCAL; 235379c004dSEric Schrock spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src); 236379c004dSEric Schrock } 237990b4856Slling 238ad135b5dSChristopher Siden if (pool != NULL) { 239ad135b5dSChristopher Siden /* 240ad135b5dSChristopher Siden * The $FREE directory was introduced in SPA_VERSION_DEADLISTS, 241ad135b5dSChristopher Siden * when opening pools before this version freedir will be NULL. 242ad135b5dSChristopher Siden */ 2437fd05ac4SMatthew Ahrens if (pool->dp_free_dir != NULL) { 244ad135b5dSChristopher Siden spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING, NULL, 245c1379625SJustin T. Gibbs dsl_dir_phys(pool->dp_free_dir)->dd_used_bytes, 246c1379625SJustin T. Gibbs src); 247ad135b5dSChristopher Siden } else { 248ad135b5dSChristopher Siden spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING, 249ad135b5dSChristopher Siden NULL, 0, src); 250ad135b5dSChristopher Siden } 2517fd05ac4SMatthew Ahrens 2527fd05ac4SMatthew Ahrens if (pool->dp_leak_dir != NULL) { 2537fd05ac4SMatthew Ahrens spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED, NULL, 254c1379625SJustin T. Gibbs dsl_dir_phys(pool->dp_leak_dir)->dd_used_bytes, 255c1379625SJustin T. Gibbs src); 2567fd05ac4SMatthew Ahrens } else { 2577fd05ac4SMatthew Ahrens spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED, 2587fd05ac4SMatthew Ahrens NULL, 0, src); 2597fd05ac4SMatthew Ahrens } 260ad135b5dSChristopher Siden } 261ad135b5dSChristopher Siden 2629d82f4f6Slling spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src); 263990b4856Slling 2648704186eSDan McDonald if (spa->spa_comment != NULL) { 2658704186eSDan McDonald spa_prop_add_list(*nvp, ZPOOL_PROP_COMMENT, spa->spa_comment, 2668704186eSDan McDonald 0, ZPROP_SRC_LOCAL); 2678704186eSDan McDonald } 2688704186eSDan McDonald 2699d82f4f6Slling if (spa->spa_root != NULL) 2709d82f4f6Slling spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root, 2719d82f4f6Slling 0, ZPROP_SRC_LOCAL); 272990b4856Slling 273b5152584SMatthew Ahrens if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) { 274b5152584SMatthew Ahrens spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL, 275b5152584SMatthew Ahrens MIN(zfs_max_recordsize, SPA_MAXBLOCKSIZE), ZPROP_SRC_NONE); 276b5152584SMatthew Ahrens } else { 277b5152584SMatthew Ahrens spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL, 278b5152584SMatthew Ahrens SPA_OLD_MAXBLOCKSIZE, ZPROP_SRC_NONE); 279b5152584SMatthew Ahrens } 280b5152584SMatthew Ahrens 281c5904d13Seschrock if ((dp = list_head(&spa->spa_config_list)) != NULL) { 282c5904d13Seschrock if (dp->scd_path == NULL) { 2839d82f4f6Slling spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, 284c5904d13Seschrock "none", 0, ZPROP_SRC_LOCAL); 285c5904d13Seschrock } else if (strcmp(dp->scd_path, spa_config_path) != 0) { 2869d82f4f6Slling spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, 287c5904d13Seschrock dp->scd_path, 0, ZPROP_SRC_LOCAL); 2882f8aaab3Seschrock } 2892f8aaab3Seschrock } 290990b4856Slling } 291990b4856Slling 292990b4856Slling /* 293990b4856Slling * Get zpool property values. 294990b4856Slling */ 295990b4856Slling int 296990b4856Slling spa_prop_get(spa_t *spa, nvlist_t **nvp) 297990b4856Slling { 298b24ab676SJeff Bonwick objset_t *mos = spa->spa_meta_objset; 299990b4856Slling zap_cursor_t zc; 300990b4856Slling zap_attribute_t za; 301990b4856Slling int err; 302990b4856Slling 3039d82f4f6Slling VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); 304990b4856Slling 305e14bb325SJeff Bonwick mutex_enter(&spa->spa_props_lock); 306e14bb325SJeff Bonwick 307990b4856Slling /* 308990b4856Slling * Get properties from the spa config. 309990b4856Slling */ 3109d82f4f6Slling spa_prop_get_config(spa, nvp); 311990b4856Slling 312990b4856Slling /* If no pool property object, no more prop to get. */ 313afee20e4SGeorge Wilson if (mos == NULL || spa->spa_pool_props_object == 0) { 314990b4856Slling mutex_exit(&spa->spa_props_lock); 315990b4856Slling return (0); 316990b4856Slling } 317990b4856Slling 318990b4856Slling /* 319990b4856Slling * Get properties from the MOS pool property object. 320990b4856Slling */ 321990b4856Slling for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object); 322990b4856Slling (err = zap_cursor_retrieve(&zc, &za)) == 0; 323990b4856Slling zap_cursor_advance(&zc)) { 324990b4856Slling uint64_t intval = 0; 325990b4856Slling char *strval = NULL; 326990b4856Slling zprop_source_t src = ZPROP_SRC_DEFAULT; 327990b4856Slling zpool_prop_t prop; 328990b4856Slling 329990b4856Slling if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL) 330990b4856Slling continue; 331990b4856Slling 332990b4856Slling switch (za.za_integer_length) { 333990b4856Slling case 8: 334990b4856Slling /* integer property */ 335990b4856Slling if (za.za_first_integer != 336990b4856Slling zpool_prop_default_numeric(prop)) 337990b4856Slling src = ZPROP_SRC_LOCAL; 338990b4856Slling 339990b4856Slling if (prop == ZPOOL_PROP_BOOTFS) { 340990b4856Slling dsl_pool_t *dp; 341990b4856Slling dsl_dataset_t *ds = NULL; 342990b4856Slling 343990b4856Slling dp = spa_get_dsl(spa); 3443b2aab18SMatthew Ahrens dsl_pool_config_enter(dp, FTAG); 345745cd3c5Smaybee if (err = dsl_dataset_hold_obj(dp, 346745cd3c5Smaybee za.za_first_integer, FTAG, &ds)) { 3473b2aab18SMatthew Ahrens dsl_pool_config_exit(dp, FTAG); 348990b4856Slling break; 349990b4856Slling } 350990b4856Slling 351990b4856Slling strval = kmem_alloc( 352990b4856Slling MAXNAMELEN + strlen(MOS_DIR_NAME) + 1, 353990b4856Slling KM_SLEEP); 354990b4856Slling dsl_dataset_name(ds, strval); 355745cd3c5Smaybee dsl_dataset_rele(ds, FTAG); 3563b2aab18SMatthew Ahrens dsl_pool_config_exit(dp, FTAG); 357990b4856Slling } else { 358990b4856Slling strval = NULL; 359990b4856Slling intval = za.za_first_integer; 360990b4856Slling } 361990b4856Slling 3629d82f4f6Slling spa_prop_add_list(*nvp, prop, strval, intval, src); 363990b4856Slling 364990b4856Slling if (strval != NULL) 365990b4856Slling kmem_free(strval, 366990b4856Slling MAXNAMELEN + strlen(MOS_DIR_NAME) + 1); 367990b4856Slling 368990b4856Slling break; 369990b4856Slling 370990b4856Slling case 1: 371990b4856Slling /* string property */ 372990b4856Slling strval = kmem_alloc(za.za_num_integers, KM_SLEEP); 373990b4856Slling err = zap_lookup(mos, spa->spa_pool_props_object, 374990b4856Slling za.za_name, 1, za.za_num_integers, strval); 375990b4856Slling if (err) { 376990b4856Slling kmem_free(strval, za.za_num_integers); 377990b4856Slling break; 378990b4856Slling } 3799d82f4f6Slling spa_prop_add_list(*nvp, prop, strval, 0, src); 380990b4856Slling kmem_free(strval, za.za_num_integers); 381990b4856Slling break; 382990b4856Slling 383990b4856Slling default: 384990b4856Slling break; 385990b4856Slling } 386990b4856Slling } 387990b4856Slling zap_cursor_fini(&zc); 388990b4856Slling mutex_exit(&spa->spa_props_lock); 389990b4856Slling out: 390990b4856Slling if (err && err != ENOENT) { 391990b4856Slling nvlist_free(*nvp); 3929d82f4f6Slling *nvp = NULL; 393990b4856Slling return (err); 394990b4856Slling } 395990b4856Slling 396990b4856Slling return (0); 397990b4856Slling } 398990b4856Slling 399990b4856Slling /* 400990b4856Slling * Validate the given pool properties nvlist and modify the list 401990b4856Slling * for the property values to be set. 402990b4856Slling */ 403990b4856Slling static int 404990b4856Slling spa_prop_validate(spa_t *spa, nvlist_t *props) 405990b4856Slling { 406990b4856Slling nvpair_t *elem; 407990b4856Slling int error = 0, reset_bootfs = 0; 408d5285caeSGeorge Wilson uint64_t objnum = 0; 409ad135b5dSChristopher Siden boolean_t has_feature = B_FALSE; 410990b4856Slling 411990b4856Slling elem = NULL; 412990b4856Slling while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { 413990b4856Slling uint64_t intval; 414ad135b5dSChristopher Siden char *strval, *slash, *check, *fname; 415ad135b5dSChristopher Siden const char *propname = nvpair_name(elem); 416ad135b5dSChristopher Siden zpool_prop_t prop = zpool_name_to_prop(propname); 417ad135b5dSChristopher Siden 418ad135b5dSChristopher Siden switch (prop) { 419ad135b5dSChristopher Siden case ZPROP_INVAL: 420ad135b5dSChristopher Siden if (!zpool_prop_feature(propname)) { 421be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 422ad135b5dSChristopher Siden break; 423ad135b5dSChristopher Siden } 424990b4856Slling 425ad135b5dSChristopher Siden /* 426ad135b5dSChristopher Siden * Sanitize the input. 427ad135b5dSChristopher Siden */ 428ad135b5dSChristopher Siden if (nvpair_type(elem) != DATA_TYPE_UINT64) { 429be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 430ad135b5dSChristopher Siden break; 431ad135b5dSChristopher Siden } 432990b4856Slling 433ad135b5dSChristopher Siden if (nvpair_value_uint64(elem, &intval) != 0) { 434be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 435ad135b5dSChristopher Siden break; 436ad135b5dSChristopher Siden } 437ad135b5dSChristopher Siden 438ad135b5dSChristopher Siden if (intval != 0) { 439be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 440ad135b5dSChristopher Siden break; 441ad135b5dSChristopher Siden } 442ad135b5dSChristopher Siden 443ad135b5dSChristopher Siden fname = strchr(propname, '@') + 1; 444ad135b5dSChristopher Siden if (zfeature_lookup_name(fname, NULL) != 0) { 445be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 446ad135b5dSChristopher Siden break; 447ad135b5dSChristopher Siden } 448ad135b5dSChristopher Siden 449ad135b5dSChristopher Siden has_feature = B_TRUE; 450ad135b5dSChristopher Siden break; 451990b4856Slling 452990b4856Slling case ZPOOL_PROP_VERSION: 453990b4856Slling error = nvpair_value_uint64(elem, &intval); 454990b4856Slling if (!error && 455ad135b5dSChristopher Siden (intval < spa_version(spa) || 456ad135b5dSChristopher Siden intval > SPA_VERSION_BEFORE_FEATURES || 457ad135b5dSChristopher Siden has_feature)) 458be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 459990b4856Slling break; 460990b4856Slling 461990b4856Slling case ZPOOL_PROP_DELEGATION: 462990b4856Slling case ZPOOL_PROP_AUTOREPLACE: 463d5b5bb25SRich Morris case ZPOOL_PROP_LISTSNAPS: 464573ca77eSGeorge Wilson case ZPOOL_PROP_AUTOEXPAND: 465990b4856Slling error = nvpair_value_uint64(elem, &intval); 466990b4856Slling if (!error && intval > 1) 467be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 468990b4856Slling break; 469990b4856Slling 470990b4856Slling case ZPOOL_PROP_BOOTFS: 47125f89ee2SJeff Bonwick /* 47225f89ee2SJeff Bonwick * If the pool version is less than SPA_VERSION_BOOTFS, 47325f89ee2SJeff Bonwick * or the pool is still being created (version == 0), 47425f89ee2SJeff Bonwick * the bootfs property cannot be set. 47525f89ee2SJeff Bonwick */ 476990b4856Slling if (spa_version(spa) < SPA_VERSION_BOOTFS) { 477be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 478990b4856Slling break; 479990b4856Slling } 480990b4856Slling 481990b4856Slling /* 48215e6edf1Sgw * Make sure the vdev config is bootable 483990b4856Slling */ 48415e6edf1Sgw if (!vdev_is_bootable(spa->spa_root_vdev)) { 485be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 486990b4856Slling break; 487990b4856Slling } 488990b4856Slling 489990b4856Slling reset_bootfs = 1; 490990b4856Slling 491990b4856Slling error = nvpair_value_string(elem, &strval); 492990b4856Slling 493990b4856Slling if (!error) { 494ad135b5dSChristopher Siden objset_t *os; 495b5152584SMatthew Ahrens uint64_t propval; 49615e6edf1Sgw 497990b4856Slling if (strval == NULL || strval[0] == '\0') { 498990b4856Slling objnum = zpool_prop_default_numeric( 499990b4856Slling ZPOOL_PROP_BOOTFS); 500990b4856Slling break; 501990b4856Slling } 502990b4856Slling 503503ad85cSMatthew Ahrens if (error = dmu_objset_hold(strval, FTAG, &os)) 504990b4856Slling break; 50515e6edf1Sgw 506b5152584SMatthew Ahrens /* 507b5152584SMatthew Ahrens * Must be ZPL, and its property settings 508b5152584SMatthew Ahrens * must be supported by GRUB (compression 509b5152584SMatthew Ahrens * is not gzip, and large blocks are not used). 510b5152584SMatthew Ahrens */ 511503ad85cSMatthew Ahrens 512503ad85cSMatthew Ahrens if (dmu_objset_type(os) != DMU_OST_ZFS) { 513be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 5143b2aab18SMatthew Ahrens } else if ((error = 5153b2aab18SMatthew Ahrens dsl_prop_get_int_ds(dmu_objset_ds(os), 51615e6edf1Sgw zfs_prop_to_name(ZFS_PROP_COMPRESSION), 517b5152584SMatthew Ahrens &propval)) == 0 && 518b5152584SMatthew Ahrens !BOOTFS_COMPRESS_VALID(propval)) { 519b5152584SMatthew Ahrens error = SET_ERROR(ENOTSUP); 520b5152584SMatthew Ahrens } else if ((error = 521b5152584SMatthew Ahrens dsl_prop_get_int_ds(dmu_objset_ds(os), 522b5152584SMatthew Ahrens zfs_prop_to_name(ZFS_PROP_RECORDSIZE), 523b5152584SMatthew Ahrens &propval)) == 0 && 524b5152584SMatthew Ahrens propval > SPA_OLD_MAXBLOCKSIZE) { 525be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 52615e6edf1Sgw } else { 52715e6edf1Sgw objnum = dmu_objset_id(os); 52815e6edf1Sgw } 529503ad85cSMatthew Ahrens dmu_objset_rele(os, FTAG); 530990b4856Slling } 531990b4856Slling break; 532e14bb325SJeff Bonwick 5330a4e9518Sgw case ZPOOL_PROP_FAILUREMODE: 5340a4e9518Sgw error = nvpair_value_uint64(elem, &intval); 5350a4e9518Sgw if (!error && (intval < ZIO_FAILURE_MODE_WAIT || 5360a4e9518Sgw intval > ZIO_FAILURE_MODE_PANIC)) 537be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 5380a4e9518Sgw 5390a4e9518Sgw /* 5400a4e9518Sgw * This is a special case which only occurs when 5410a4e9518Sgw * the pool has completely failed. This allows 5420a4e9518Sgw * the user to change the in-core failmode property 5430a4e9518Sgw * without syncing it out to disk (I/Os might 5440a4e9518Sgw * currently be blocked). We do this by returning 5450a4e9518Sgw * EIO to the caller (spa_prop_set) to trick it 5460a4e9518Sgw * into thinking we encountered a property validation 5470a4e9518Sgw * error. 5480a4e9518Sgw */ 549e14bb325SJeff Bonwick if (!error && spa_suspended(spa)) { 5500a4e9518Sgw spa->spa_failmode = intval; 551be6fd75aSMatthew Ahrens error = SET_ERROR(EIO); 5520a4e9518Sgw } 5530a4e9518Sgw break; 5542f8aaab3Seschrock 5552f8aaab3Seschrock case ZPOOL_PROP_CACHEFILE: 5562f8aaab3Seschrock if ((error = nvpair_value_string(elem, &strval)) != 0) 5572f8aaab3Seschrock break; 5582f8aaab3Seschrock 5592f8aaab3Seschrock if (strval[0] == '\0') 5602f8aaab3Seschrock break; 5612f8aaab3Seschrock 5622f8aaab3Seschrock if (strcmp(strval, "none") == 0) 5632f8aaab3Seschrock break; 5642f8aaab3Seschrock 5652f8aaab3Seschrock if (strval[0] != '/') { 566be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 5672f8aaab3Seschrock break; 5682f8aaab3Seschrock } 5692f8aaab3Seschrock 5702f8aaab3Seschrock slash = strrchr(strval, '/'); 5712f8aaab3Seschrock ASSERT(slash != NULL); 5722f8aaab3Seschrock 5732f8aaab3Seschrock if (slash[1] == '\0' || strcmp(slash, "/.") == 0 || 5742f8aaab3Seschrock strcmp(slash, "/..") == 0) 575be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 5762f8aaab3Seschrock break; 577b24ab676SJeff Bonwick 5788704186eSDan McDonald case ZPOOL_PROP_COMMENT: 5798704186eSDan McDonald if ((error = nvpair_value_string(elem, &strval)) != 0) 5808704186eSDan McDonald break; 5818704186eSDan McDonald for (check = strval; *check != '\0'; check++) { 5828704186eSDan McDonald /* 5838704186eSDan McDonald * The kernel doesn't have an easy isprint() 5848704186eSDan McDonald * check. For this kernel check, we merely 5858704186eSDan McDonald * check ASCII apart from DEL. Fix this if 5868704186eSDan McDonald * there is an easy-to-use kernel isprint(). 5878704186eSDan McDonald */ 5888704186eSDan McDonald if (*check >= 0x7f) { 589be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 5908704186eSDan McDonald break; 5918704186eSDan McDonald } 5928704186eSDan McDonald check++; 5938704186eSDan McDonald } 5948704186eSDan McDonald if (strlen(strval) > ZPROP_MAX_COMMENT) 5958704186eSDan McDonald error = E2BIG; 5968704186eSDan McDonald break; 5978704186eSDan McDonald 598b24ab676SJeff Bonwick case ZPOOL_PROP_DEDUPDITTO: 599b24ab676SJeff Bonwick if (spa_version(spa) < SPA_VERSION_DEDUP) 600be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 601b24ab676SJeff Bonwick else 602b24ab676SJeff Bonwick error = nvpair_value_uint64(elem, &intval); 603b24ab676SJeff Bonwick if (error == 0 && 604b24ab676SJeff Bonwick intval != 0 && intval < ZIO_DEDUPDITTO_MIN) 605be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 606b24ab676SJeff Bonwick break; 607990b4856Slling } 608990b4856Slling 609990b4856Slling if (error) 610990b4856Slling break; 611990b4856Slling } 612990b4856Slling 613990b4856Slling if (!error && reset_bootfs) { 614990b4856Slling error = nvlist_remove(props, 615990b4856Slling zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING); 616990b4856Slling 617990b4856Slling if (!error) { 618990b4856Slling error = nvlist_add_uint64(props, 619990b4856Slling zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum); 620990b4856Slling } 621990b4856Slling } 622990b4856Slling 623990b4856Slling return (error); 624990b4856Slling } 625990b4856Slling 626379c004dSEric Schrock void 627379c004dSEric Schrock spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync) 628379c004dSEric Schrock { 629379c004dSEric Schrock char *cachefile; 630379c004dSEric Schrock spa_config_dirent_t *dp; 631379c004dSEric Schrock 632379c004dSEric Schrock if (nvlist_lookup_string(nvp, zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 633379c004dSEric Schrock &cachefile) != 0) 634379c004dSEric Schrock return; 635379c004dSEric Schrock 636379c004dSEric Schrock dp = kmem_alloc(sizeof (spa_config_dirent_t), 637379c004dSEric Schrock KM_SLEEP); 638379c004dSEric Schrock 639379c004dSEric Schrock if (cachefile[0] == '\0') 640379c004dSEric Schrock dp->scd_path = spa_strdup(spa_config_path); 641379c004dSEric Schrock else if (strcmp(cachefile, "none") == 0) 642379c004dSEric Schrock dp->scd_path = NULL; 643379c004dSEric Schrock else 644379c004dSEric Schrock dp->scd_path = spa_strdup(cachefile); 645379c004dSEric Schrock 646379c004dSEric Schrock list_insert_head(&spa->spa_config_list, dp); 647379c004dSEric Schrock if (need_sync) 648379c004dSEric Schrock spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 649379c004dSEric Schrock } 650379c004dSEric Schrock 651990b4856Slling int 652990b4856Slling spa_prop_set(spa_t *spa, nvlist_t *nvp) 653990b4856Slling { 654990b4856Slling int error; 655ad135b5dSChristopher Siden nvpair_t *elem = NULL; 656379c004dSEric Schrock boolean_t need_sync = B_FALSE; 657990b4856Slling 658990b4856Slling if ((error = spa_prop_validate(spa, nvp)) != 0) 659990b4856Slling return (error); 660990b4856Slling 661379c004dSEric Schrock while ((elem = nvlist_next_nvpair(nvp, elem)) != NULL) { 662ad135b5dSChristopher Siden zpool_prop_t prop = zpool_name_to_prop(nvpair_name(elem)); 663379c004dSEric Schrock 664f9af39baSGeorge Wilson if (prop == ZPOOL_PROP_CACHEFILE || 665f9af39baSGeorge Wilson prop == ZPOOL_PROP_ALTROOT || 666f9af39baSGeorge Wilson prop == ZPOOL_PROP_READONLY) 667379c004dSEric Schrock continue; 668379c004dSEric Schrock 669ad135b5dSChristopher Siden if (prop == ZPOOL_PROP_VERSION || prop == ZPROP_INVAL) { 670ad135b5dSChristopher Siden uint64_t ver; 671ad135b5dSChristopher Siden 672ad135b5dSChristopher Siden if (prop == ZPOOL_PROP_VERSION) { 673ad135b5dSChristopher Siden VERIFY(nvpair_value_uint64(elem, &ver) == 0); 674ad135b5dSChristopher Siden } else { 675ad135b5dSChristopher Siden ASSERT(zpool_prop_feature(nvpair_name(elem))); 676ad135b5dSChristopher Siden ver = SPA_VERSION_FEATURES; 677ad135b5dSChristopher Siden need_sync = B_TRUE; 678ad135b5dSChristopher Siden } 679ad135b5dSChristopher Siden 680ad135b5dSChristopher Siden /* Save time if the version is already set. */ 681ad135b5dSChristopher Siden if (ver == spa_version(spa)) 682ad135b5dSChristopher Siden continue; 683ad135b5dSChristopher Siden 684ad135b5dSChristopher Siden /* 685ad135b5dSChristopher Siden * In addition to the pool directory object, we might 686ad135b5dSChristopher Siden * create the pool properties object, the features for 687ad135b5dSChristopher Siden * read object, the features for write object, or the 688ad135b5dSChristopher Siden * feature descriptions object. 689ad135b5dSChristopher Siden */ 6903b2aab18SMatthew Ahrens error = dsl_sync_task(spa->spa_name, NULL, 6917d46dc6cSMatthew Ahrens spa_sync_version, &ver, 6927d46dc6cSMatthew Ahrens 6, ZFS_SPACE_CHECK_RESERVED); 693ad135b5dSChristopher Siden if (error) 694ad135b5dSChristopher Siden return (error); 695ad135b5dSChristopher Siden continue; 696ad135b5dSChristopher Siden } 697ad135b5dSChristopher Siden 698379c004dSEric Schrock need_sync = B_TRUE; 699379c004dSEric Schrock break; 700379c004dSEric Schrock } 701379c004dSEric Schrock 702ad135b5dSChristopher Siden if (need_sync) { 7033b2aab18SMatthew Ahrens return (dsl_sync_task(spa->spa_name, NULL, spa_sync_props, 7047d46dc6cSMatthew Ahrens nvp, 6, ZFS_SPACE_CHECK_RESERVED)); 705ad135b5dSChristopher Siden } 706ad135b5dSChristopher Siden 707ad135b5dSChristopher Siden return (0); 708990b4856Slling } 709990b4856Slling 710990b4856Slling /* 711990b4856Slling * If the bootfs property value is dsobj, clear it. 712990b4856Slling */ 713990b4856Slling void 714990b4856Slling spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx) 715990b4856Slling { 716990b4856Slling if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) { 717990b4856Slling VERIFY(zap_remove(spa->spa_meta_objset, 718990b4856Slling spa->spa_pool_props_object, 719990b4856Slling zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0); 720990b4856Slling spa->spa_bootfs = 0; 721990b4856Slling } 722990b4856Slling } 723990b4856Slling 724dfbb9432SGeorge Wilson /*ARGSUSED*/ 725dfbb9432SGeorge Wilson static int 7263b2aab18SMatthew Ahrens spa_change_guid_check(void *arg, dmu_tx_t *tx) 727dfbb9432SGeorge Wilson { 7283b2aab18SMatthew Ahrens uint64_t *newguid = arg; 7293b2aab18SMatthew Ahrens spa_t *spa = dmu_tx_pool(tx)->dp_spa; 730dfbb9432SGeorge Wilson vdev_t *rvd = spa->spa_root_vdev; 731dfbb9432SGeorge Wilson uint64_t vdev_state; 732dfbb9432SGeorge Wilson 733dfbb9432SGeorge Wilson spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 734dfbb9432SGeorge Wilson vdev_state = rvd->vdev_state; 735dfbb9432SGeorge Wilson spa_config_exit(spa, SCL_STATE, FTAG); 736dfbb9432SGeorge Wilson 737dfbb9432SGeorge Wilson if (vdev_state != VDEV_STATE_HEALTHY) 738be6fd75aSMatthew Ahrens return (SET_ERROR(ENXIO)); 739dfbb9432SGeorge Wilson 740dfbb9432SGeorge Wilson ASSERT3U(spa_guid(spa), !=, *newguid); 741dfbb9432SGeorge Wilson 742dfbb9432SGeorge Wilson return (0); 743dfbb9432SGeorge Wilson } 744dfbb9432SGeorge Wilson 745dfbb9432SGeorge Wilson static void 7463b2aab18SMatthew Ahrens spa_change_guid_sync(void *arg, dmu_tx_t *tx) 747dfbb9432SGeorge Wilson { 7483b2aab18SMatthew Ahrens uint64_t *newguid = arg; 7493b2aab18SMatthew Ahrens spa_t *spa = dmu_tx_pool(tx)->dp_spa; 750dfbb9432SGeorge Wilson uint64_t oldguid; 751dfbb9432SGeorge Wilson vdev_t *rvd = spa->spa_root_vdev; 752dfbb9432SGeorge Wilson 753dfbb9432SGeorge Wilson oldguid = spa_guid(spa); 754dfbb9432SGeorge Wilson 755dfbb9432SGeorge Wilson spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 756dfbb9432SGeorge Wilson rvd->vdev_guid = *newguid; 757dfbb9432SGeorge Wilson rvd->vdev_guid_sum += (*newguid - oldguid); 758dfbb9432SGeorge Wilson vdev_config_dirty(rvd); 759dfbb9432SGeorge Wilson spa_config_exit(spa, SCL_STATE, FTAG); 760dfbb9432SGeorge Wilson 76120128a08SGeorge Wilson spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu", 762dfbb9432SGeorge Wilson oldguid, *newguid); 763dfbb9432SGeorge Wilson } 764dfbb9432SGeorge Wilson 765e9103aaeSGarrett D'Amore /* 766e9103aaeSGarrett D'Amore * Change the GUID for the pool. This is done so that we can later 767e9103aaeSGarrett D'Amore * re-import a pool built from a clone of our own vdevs. We will modify 768e9103aaeSGarrett D'Amore * the root vdev's guid, our own pool guid, and then mark all of our 769e9103aaeSGarrett D'Amore * vdevs dirty. Note that we must make sure that all our vdevs are 770e9103aaeSGarrett D'Amore * online when we do this, or else any vdevs that weren't present 771e9103aaeSGarrett D'Amore * would be orphaned from our pool. We are also going to issue a 772e9103aaeSGarrett D'Amore * sysevent to update any watchers. 773e9103aaeSGarrett D'Amore */ 774e9103aaeSGarrett D'Amore int 775e9103aaeSGarrett D'Amore spa_change_guid(spa_t *spa) 776e9103aaeSGarrett D'Amore { 777dfbb9432SGeorge Wilson int error; 778dfbb9432SGeorge Wilson uint64_t guid; 779e9103aaeSGarrett D'Amore 7802c1e2b44SGeorge Wilson mutex_enter(&spa->spa_vdev_top_lock); 781dfbb9432SGeorge Wilson mutex_enter(&spa_namespace_lock); 782dfbb9432SGeorge Wilson guid = spa_generate_guid(NULL); 783e9103aaeSGarrett D'Amore 7843b2aab18SMatthew Ahrens error = dsl_sync_task(spa->spa_name, spa_change_guid_check, 7857d46dc6cSMatthew Ahrens spa_change_guid_sync, &guid, 5, ZFS_SPACE_CHECK_RESERVED); 786e9103aaeSGarrett D'Amore 787dfbb9432SGeorge Wilson if (error == 0) { 788dfbb9432SGeorge Wilson spa_config_sync(spa, B_FALSE, B_TRUE); 789dfbb9432SGeorge Wilson spa_event_notify(spa, NULL, ESC_ZFS_POOL_REGUID); 790dfbb9432SGeorge Wilson } 791e9103aaeSGarrett D'Amore 792dfbb9432SGeorge Wilson mutex_exit(&spa_namespace_lock); 7932c1e2b44SGeorge Wilson mutex_exit(&spa->spa_vdev_top_lock); 794e9103aaeSGarrett D'Amore 795dfbb9432SGeorge Wilson return (error); 796e9103aaeSGarrett D'Amore } 797e9103aaeSGarrett D'Amore 798fa9e4066Sahrens /* 799fa9e4066Sahrens * ========================================================================== 800fa9e4066Sahrens * SPA state manipulation (open/create/destroy/import/export) 801fa9e4066Sahrens * ========================================================================== 802fa9e4066Sahrens */ 803fa9e4066Sahrens 804ea8dc4b6Seschrock static int 805ea8dc4b6Seschrock spa_error_entry_compare(const void *a, const void *b) 806ea8dc4b6Seschrock { 807ea8dc4b6Seschrock spa_error_entry_t *sa = (spa_error_entry_t *)a; 808ea8dc4b6Seschrock spa_error_entry_t *sb = (spa_error_entry_t *)b; 809ea8dc4b6Seschrock int ret; 810ea8dc4b6Seschrock 811ea8dc4b6Seschrock ret = bcmp(&sa->se_bookmark, &sb->se_bookmark, 8127802d7bfSMatthew Ahrens sizeof (zbookmark_phys_t)); 813ea8dc4b6Seschrock 814ea8dc4b6Seschrock if (ret < 0) 815ea8dc4b6Seschrock return (-1); 816ea8dc4b6Seschrock else if (ret > 0) 817ea8dc4b6Seschrock return (1); 818ea8dc4b6Seschrock else 819ea8dc4b6Seschrock return (0); 820ea8dc4b6Seschrock } 821ea8dc4b6Seschrock 822ea8dc4b6Seschrock /* 823ea8dc4b6Seschrock * Utility function which retrieves copies of the current logs and 824ea8dc4b6Seschrock * re-initializes them in the process. 825ea8dc4b6Seschrock */ 826ea8dc4b6Seschrock void 827ea8dc4b6Seschrock spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub) 828ea8dc4b6Seschrock { 829ea8dc4b6Seschrock ASSERT(MUTEX_HELD(&spa->spa_errlist_lock)); 830ea8dc4b6Seschrock 831ea8dc4b6Seschrock bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t)); 832ea8dc4b6Seschrock bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t)); 833ea8dc4b6Seschrock 834ea8dc4b6Seschrock avl_create(&spa->spa_errlist_scrub, 835ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 836ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 837ea8dc4b6Seschrock avl_create(&spa->spa_errlist_last, 838ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 839ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 840ea8dc4b6Seschrock } 841ea8dc4b6Seschrock 842ec94d322SAdam Leventhal static void 843ec94d322SAdam Leventhal spa_taskqs_init(spa_t *spa, zio_type_t t, zio_taskq_type_t q) 844fa9e4066Sahrens { 845ec94d322SAdam Leventhal const zio_taskq_info_t *ztip = &zio_taskqs[t][q]; 846ec94d322SAdam Leventhal enum zti_modes mode = ztip->zti_mode; 847ec94d322SAdam Leventhal uint_t value = ztip->zti_value; 848ec94d322SAdam Leventhal uint_t count = ztip->zti_count; 849ec94d322SAdam Leventhal spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 850ec94d322SAdam Leventhal char name[32]; 8515aeb9474SGarrett D'Amore uint_t flags = 0; 85235a5a358SJonathan Adams boolean_t batch = B_FALSE; 853fa9e4066Sahrens 854ec94d322SAdam Leventhal if (mode == ZTI_MODE_NULL) { 855ec94d322SAdam Leventhal tqs->stqs_count = 0; 856ec94d322SAdam Leventhal tqs->stqs_taskq = NULL; 857ec94d322SAdam Leventhal return; 858ec94d322SAdam Leventhal } 859fa9e4066Sahrens 860ec94d322SAdam Leventhal ASSERT3U(count, >, 0); 861fa9e4066Sahrens 862ec94d322SAdam Leventhal tqs->stqs_count = count; 863ec94d322SAdam Leventhal tqs->stqs_taskq = kmem_alloc(count * sizeof (taskq_t *), KM_SLEEP); 86435a5a358SJonathan Adams 86569962b56SMatthew Ahrens switch (mode) { 86669962b56SMatthew Ahrens case ZTI_MODE_FIXED: 86769962b56SMatthew Ahrens ASSERT3U(value, >=, 1); 86869962b56SMatthew Ahrens value = MAX(value, 1); 86969962b56SMatthew Ahrens break; 870ec94d322SAdam Leventhal 87169962b56SMatthew Ahrens case ZTI_MODE_BATCH: 87269962b56SMatthew Ahrens batch = B_TRUE; 87369962b56SMatthew Ahrens flags |= TASKQ_THREADS_CPU_PCT; 87469962b56SMatthew Ahrens value = zio_taskq_batch_pct; 87569962b56SMatthew Ahrens break; 876ec94d322SAdam Leventhal 87769962b56SMatthew Ahrens default: 87869962b56SMatthew Ahrens panic("unrecognized mode for %s_%s taskq (%u:%u) in " 87969962b56SMatthew Ahrens "spa_activate()", 88069962b56SMatthew Ahrens zio_type_name[t], zio_taskq_types[q], mode, value); 88169962b56SMatthew Ahrens break; 88269962b56SMatthew Ahrens } 883ec94d322SAdam Leventhal 88469962b56SMatthew Ahrens for (uint_t i = 0; i < count; i++) { 88569962b56SMatthew Ahrens taskq_t *tq; 886ec94d322SAdam Leventhal 887ec94d322SAdam Leventhal if (count > 1) { 888ec94d322SAdam Leventhal (void) snprintf(name, sizeof (name), "%s_%s_%u", 889ec94d322SAdam Leventhal zio_type_name[t], zio_taskq_types[q], i); 890ec94d322SAdam Leventhal } else { 891ec94d322SAdam Leventhal (void) snprintf(name, sizeof (name), "%s_%s", 892ec94d322SAdam Leventhal zio_type_name[t], zio_taskq_types[q]); 893ec94d322SAdam Leventhal } 894ec94d322SAdam Leventhal 895ec94d322SAdam Leventhal if (zio_taskq_sysdc && spa->spa_proc != &p0) { 896ec94d322SAdam Leventhal if (batch) 897ec94d322SAdam Leventhal flags |= TASKQ_DC_BATCH; 898ec94d322SAdam Leventhal 899ec94d322SAdam Leventhal tq = taskq_create_sysdc(name, value, 50, INT_MAX, 900ec94d322SAdam Leventhal spa->spa_proc, zio_taskq_basedc, flags); 901ec94d322SAdam Leventhal } else { 90269962b56SMatthew Ahrens pri_t pri = maxclsyspri; 90369962b56SMatthew Ahrens /* 90469962b56SMatthew Ahrens * The write issue taskq can be extremely CPU 90569962b56SMatthew Ahrens * intensive. Run it at slightly lower priority 90669962b56SMatthew Ahrens * than the other taskqs. 90769962b56SMatthew Ahrens */ 90869962b56SMatthew Ahrens if (t == ZIO_TYPE_WRITE && q == ZIO_TASKQ_ISSUE) 90969962b56SMatthew Ahrens pri--; 91069962b56SMatthew Ahrens 91169962b56SMatthew Ahrens tq = taskq_create_proc(name, value, pri, 50, 912ec94d322SAdam Leventhal INT_MAX, spa->spa_proc, flags); 913ec94d322SAdam Leventhal } 914ec94d322SAdam Leventhal 915ec94d322SAdam Leventhal tqs->stqs_taskq[i] = tq; 916ec94d322SAdam Leventhal } 917ec94d322SAdam Leventhal } 918ec94d322SAdam Leventhal 919ec94d322SAdam Leventhal static void 920ec94d322SAdam Leventhal spa_taskqs_fini(spa_t *spa, zio_type_t t, zio_taskq_type_t q) 921ec94d322SAdam Leventhal { 922ec94d322SAdam Leventhal spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 923ec94d322SAdam Leventhal 924ec94d322SAdam Leventhal if (tqs->stqs_taskq == NULL) { 925ec94d322SAdam Leventhal ASSERT0(tqs->stqs_count); 926ec94d322SAdam Leventhal return; 927ec94d322SAdam Leventhal } 928ec94d322SAdam Leventhal 929ec94d322SAdam Leventhal for (uint_t i = 0; i < tqs->stqs_count; i++) { 930ec94d322SAdam Leventhal ASSERT3P(tqs->stqs_taskq[i], !=, NULL); 931ec94d322SAdam Leventhal taskq_destroy(tqs->stqs_taskq[i]); 93235a5a358SJonathan Adams } 93335a5a358SJonathan Adams 934ec94d322SAdam Leventhal kmem_free(tqs->stqs_taskq, tqs->stqs_count * sizeof (taskq_t *)); 935ec94d322SAdam Leventhal tqs->stqs_taskq = NULL; 936ec94d322SAdam Leventhal } 93735a5a358SJonathan Adams 938ec94d322SAdam Leventhal /* 939ec94d322SAdam Leventhal * Dispatch a task to the appropriate taskq for the ZFS I/O type and priority. 940ec94d322SAdam Leventhal * Note that a type may have multiple discrete taskqs to avoid lock contention 941ec94d322SAdam Leventhal * on the taskq itself. In that case we choose which taskq at random by using 942ec94d322SAdam Leventhal * the low bits of gethrtime(). 943ec94d322SAdam Leventhal */ 944ec94d322SAdam Leventhal void 945ec94d322SAdam Leventhal spa_taskq_dispatch_ent(spa_t *spa, zio_type_t t, zio_taskq_type_t q, 946ec94d322SAdam Leventhal task_func_t *func, void *arg, uint_t flags, taskq_ent_t *ent) 947ec94d322SAdam Leventhal { 948ec94d322SAdam Leventhal spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 949ec94d322SAdam Leventhal taskq_t *tq; 950ec94d322SAdam Leventhal 951ec94d322SAdam Leventhal ASSERT3P(tqs->stqs_taskq, !=, NULL); 952ec94d322SAdam Leventhal ASSERT3U(tqs->stqs_count, !=, 0); 953ec94d322SAdam Leventhal 954ec94d322SAdam Leventhal if (tqs->stqs_count == 1) { 955ec94d322SAdam Leventhal tq = tqs->stqs_taskq[0]; 956ec94d322SAdam Leventhal } else { 957ec94d322SAdam Leventhal tq = tqs->stqs_taskq[gethrtime() % tqs->stqs_count]; 95835a5a358SJonathan Adams } 959ec94d322SAdam Leventhal 960ec94d322SAdam Leventhal taskq_dispatch_ent(tq, func, arg, flags, ent); 96135a5a358SJonathan Adams } 96235a5a358SJonathan Adams 96335a5a358SJonathan Adams static void 96435a5a358SJonathan Adams spa_create_zio_taskqs(spa_t *spa) 96535a5a358SJonathan Adams { 966e14bb325SJeff Bonwick for (int t = 0; t < ZIO_TYPES; t++) { 967e14bb325SJeff Bonwick for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { 968ec94d322SAdam Leventhal spa_taskqs_init(spa, t, q); 96935a5a358SJonathan Adams } 97035a5a358SJonathan Adams } 97135a5a358SJonathan Adams } 97235a5a358SJonathan Adams 97335a5a358SJonathan Adams #ifdef _KERNEL 97435a5a358SJonathan Adams static void 97535a5a358SJonathan Adams spa_thread(void *arg) 97635a5a358SJonathan Adams { 97735a5a358SJonathan Adams callb_cpr_t cprinfo; 9782e0c549eSJonathan Adams 97935a5a358SJonathan Adams spa_t *spa = arg; 98035a5a358SJonathan Adams user_t *pu = PTOU(curproc); 9812e0c549eSJonathan Adams 98235a5a358SJonathan Adams CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr, 98335a5a358SJonathan Adams spa->spa_name); 9842e0c549eSJonathan Adams 98535a5a358SJonathan Adams ASSERT(curproc != &p0); 98635a5a358SJonathan Adams (void) snprintf(pu->u_psargs, sizeof (pu->u_psargs), 98735a5a358SJonathan Adams "zpool-%s", spa->spa_name); 98835a5a358SJonathan Adams (void) strlcpy(pu->u_comm, pu->u_psargs, sizeof (pu->u_comm)); 9892e0c549eSJonathan Adams 99035a5a358SJonathan Adams /* bind this thread to the requested psrset */ 99135a5a358SJonathan Adams if (zio_taskq_psrset_bind != PS_NONE) { 99235a5a358SJonathan Adams pool_lock(); 99335a5a358SJonathan Adams mutex_enter(&cpu_lock); 99435a5a358SJonathan Adams mutex_enter(&pidlock); 99535a5a358SJonathan Adams mutex_enter(&curproc->p_lock); 99680eb36f2SGeorge Wilson 99735a5a358SJonathan Adams if (cpupart_bind_thread(curthread, zio_taskq_psrset_bind, 99835a5a358SJonathan Adams 0, NULL, NULL) == 0) { 99935a5a358SJonathan Adams curthread->t_bind_pset = zio_taskq_psrset_bind; 100035a5a358SJonathan Adams } else { 100135a5a358SJonathan Adams cmn_err(CE_WARN, 100235a5a358SJonathan Adams "Couldn't bind process for zfs pool \"%s\" to " 100335a5a358SJonathan Adams "pset %d\n", spa->spa_name, zio_taskq_psrset_bind); 100435a5a358SJonathan Adams } 100535a5a358SJonathan Adams 100635a5a358SJonathan Adams mutex_exit(&curproc->p_lock); 100735a5a358SJonathan Adams mutex_exit(&pidlock); 100835a5a358SJonathan Adams mutex_exit(&cpu_lock); 100935a5a358SJonathan Adams pool_unlock(); 101035a5a358SJonathan Adams } 101135a5a358SJonathan Adams 101235a5a358SJonathan Adams if (zio_taskq_sysdc) { 101335a5a358SJonathan Adams sysdc_thread_enter(curthread, 100, 0); 101435a5a358SJonathan Adams } 101535a5a358SJonathan Adams 101635a5a358SJonathan Adams spa->spa_proc = curproc; 101735a5a358SJonathan Adams spa->spa_did = curthread->t_did; 101835a5a358SJonathan Adams 101935a5a358SJonathan Adams spa_create_zio_taskqs(spa); 102035a5a358SJonathan Adams 102135a5a358SJonathan Adams mutex_enter(&spa->spa_proc_lock); 102235a5a358SJonathan Adams ASSERT(spa->spa_proc_state == SPA_PROC_CREATED); 102335a5a358SJonathan Adams 102435a5a358SJonathan Adams spa->spa_proc_state = SPA_PROC_ACTIVE; 102535a5a358SJonathan Adams cv_broadcast(&spa->spa_proc_cv); 102635a5a358SJonathan Adams 102735a5a358SJonathan Adams CALLB_CPR_SAFE_BEGIN(&cprinfo); 102835a5a358SJonathan Adams while (spa->spa_proc_state == SPA_PROC_ACTIVE) 102935a5a358SJonathan Adams cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock); 103035a5a358SJonathan Adams CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock); 103135a5a358SJonathan Adams 103235a5a358SJonathan Adams ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE); 103335a5a358SJonathan Adams spa->spa_proc_state = SPA_PROC_GONE; 103435a5a358SJonathan Adams spa->spa_proc = &p0; 103535a5a358SJonathan Adams cv_broadcast(&spa->spa_proc_cv); 103635a5a358SJonathan Adams CALLB_CPR_EXIT(&cprinfo); /* drops spa_proc_lock */ 103735a5a358SJonathan Adams 103835a5a358SJonathan Adams mutex_enter(&curproc->p_lock); 103935a5a358SJonathan Adams lwp_exit(); 104035a5a358SJonathan Adams } 104135a5a358SJonathan Adams #endif 104235a5a358SJonathan Adams 104335a5a358SJonathan Adams /* 104435a5a358SJonathan Adams * Activate an uninitialized pool. 104535a5a358SJonathan Adams */ 104635a5a358SJonathan Adams static void 104735a5a358SJonathan Adams spa_activate(spa_t *spa, int mode) 104835a5a358SJonathan Adams { 104935a5a358SJonathan Adams ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 105035a5a358SJonathan Adams 105135a5a358SJonathan Adams spa->spa_state = POOL_STATE_ACTIVE; 105235a5a358SJonathan Adams spa->spa_mode = mode; 105335a5a358SJonathan Adams 105435a5a358SJonathan Adams spa->spa_normal_class = metaslab_class_create(spa, zfs_metaslab_ops); 105535a5a358SJonathan Adams spa->spa_log_class = metaslab_class_create(spa, zfs_metaslab_ops); 105635a5a358SJonathan Adams 105735a5a358SJonathan Adams /* Try to create a covering process */ 105835a5a358SJonathan Adams mutex_enter(&spa->spa_proc_lock); 105935a5a358SJonathan Adams ASSERT(spa->spa_proc_state == SPA_PROC_NONE); 106035a5a358SJonathan Adams ASSERT(spa->spa_proc == &p0); 106135a5a358SJonathan Adams spa->spa_did = 0; 106235a5a358SJonathan Adams 106335a5a358SJonathan Adams /* Only create a process if we're going to be around a while. */ 106435a5a358SJonathan Adams if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) { 106535a5a358SJonathan Adams if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri, 106635a5a358SJonathan Adams NULL, 0) == 0) { 106735a5a358SJonathan Adams spa->spa_proc_state = SPA_PROC_CREATED; 106835a5a358SJonathan Adams while (spa->spa_proc_state == SPA_PROC_CREATED) { 106935a5a358SJonathan Adams cv_wait(&spa->spa_proc_cv, 107035a5a358SJonathan Adams &spa->spa_proc_lock); 10712e0c549eSJonathan Adams } 107235a5a358SJonathan Adams ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE); 107335a5a358SJonathan Adams ASSERT(spa->spa_proc != &p0); 107435a5a358SJonathan Adams ASSERT(spa->spa_did != 0); 107535a5a358SJonathan Adams } else { 107635a5a358SJonathan Adams #ifdef _KERNEL 107735a5a358SJonathan Adams cmn_err(CE_WARN, 107835a5a358SJonathan Adams "Couldn't create process for zfs pool \"%s\"\n", 107935a5a358SJonathan Adams spa->spa_name); 108035a5a358SJonathan Adams #endif 1081e14bb325SJeff Bonwick } 1082fa9e4066Sahrens } 108335a5a358SJonathan Adams mutex_exit(&spa->spa_proc_lock); 108435a5a358SJonathan Adams 108535a5a358SJonathan Adams /* If we didn't create a process, we need to create our taskqs. */ 108635a5a358SJonathan Adams if (spa->spa_proc == &p0) { 108735a5a358SJonathan Adams spa_create_zio_taskqs(spa); 108835a5a358SJonathan Adams } 1089fa9e4066Sahrens 1090e14bb325SJeff Bonwick list_create(&spa->spa_config_dirty_list, sizeof (vdev_t), 1091e14bb325SJeff Bonwick offsetof(vdev_t, vdev_config_dirty_node)); 1092*bc9014e6SJustin Gibbs list_create(&spa->spa_evicting_os_list, sizeof (objset_t), 1093*bc9014e6SJustin Gibbs offsetof(objset_t, os_evicting_node)); 1094e14bb325SJeff Bonwick list_create(&spa->spa_state_dirty_list, sizeof (vdev_t), 1095e14bb325SJeff Bonwick offsetof(vdev_t, vdev_state_dirty_node)); 1096fa9e4066Sahrens 1097fa9e4066Sahrens txg_list_create(&spa->spa_vdev_txg_list, 1098fa9e4066Sahrens offsetof(struct vdev, vdev_txg_node)); 1099ea8dc4b6Seschrock 1100ea8dc4b6Seschrock avl_create(&spa->spa_errlist_scrub, 1101ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 1102ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 1103ea8dc4b6Seschrock avl_create(&spa->spa_errlist_last, 1104ea8dc4b6Seschrock spa_error_entry_compare, sizeof (spa_error_entry_t), 1105ea8dc4b6Seschrock offsetof(spa_error_entry_t, se_avl)); 1106fa9e4066Sahrens } 1107fa9e4066Sahrens 1108fa9e4066Sahrens /* 1109fa9e4066Sahrens * Opposite of spa_activate(). 1110fa9e4066Sahrens */ 1111fa9e4066Sahrens static void 1112fa9e4066Sahrens spa_deactivate(spa_t *spa) 1113fa9e4066Sahrens { 1114fa9e4066Sahrens ASSERT(spa->spa_sync_on == B_FALSE); 1115fa9e4066Sahrens ASSERT(spa->spa_dsl_pool == NULL); 1116fa9e4066Sahrens ASSERT(spa->spa_root_vdev == NULL); 111725f89ee2SJeff Bonwick ASSERT(spa->spa_async_zio_root == NULL); 1118fa9e4066Sahrens ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED); 1119fa9e4066Sahrens 1120*bc9014e6SJustin Gibbs spa_evicting_os_wait(spa); 1121*bc9014e6SJustin Gibbs 1122fa9e4066Sahrens txg_list_destroy(&spa->spa_vdev_txg_list); 1123fa9e4066Sahrens 1124e14bb325SJeff Bonwick list_destroy(&spa->spa_config_dirty_list); 1125*bc9014e6SJustin Gibbs list_destroy(&spa->spa_evicting_os_list); 1126e14bb325SJeff Bonwick list_destroy(&spa->spa_state_dirty_list); 1127fa9e4066Sahrens 1128e14bb325SJeff Bonwick for (int t = 0; t < ZIO_TYPES; t++) { 1129e14bb325SJeff Bonwick for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { 1130ec94d322SAdam Leventhal spa_taskqs_fini(spa, t, q); 1131e14bb325SJeff Bonwick } 1132fa9e4066Sahrens } 1133fa9e4066Sahrens 1134fa9e4066Sahrens metaslab_class_destroy(spa->spa_normal_class); 1135fa9e4066Sahrens spa->spa_normal_class = NULL; 1136fa9e4066Sahrens 11378654d025Sperrin metaslab_class_destroy(spa->spa_log_class); 11388654d025Sperrin spa->spa_log_class = NULL; 11398654d025Sperrin 1140ea8dc4b6Seschrock /* 1141ea8dc4b6Seschrock * If this was part of an import or the open otherwise failed, we may 1142ea8dc4b6Seschrock * still have errors left in the queues. Empty them just in case. 1143ea8dc4b6Seschrock */ 1144ea8dc4b6Seschrock spa_errlog_drain(spa); 1145ea8dc4b6Seschrock 1146ea8dc4b6Seschrock avl_destroy(&spa->spa_errlist_scrub); 1147ea8dc4b6Seschrock avl_destroy(&spa->spa_errlist_last); 1148ea8dc4b6Seschrock 1149fa9e4066Sahrens spa->spa_state = POOL_STATE_UNINITIALIZED; 115035a5a358SJonathan Adams 115135a5a358SJonathan Adams mutex_enter(&spa->spa_proc_lock); 115235a5a358SJonathan Adams if (spa->spa_proc_state != SPA_PROC_NONE) { 115335a5a358SJonathan Adams ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE); 115435a5a358SJonathan Adams spa->spa_proc_state = SPA_PROC_DEACTIVATE; 115535a5a358SJonathan Adams cv_broadcast(&spa->spa_proc_cv); 115635a5a358SJonathan Adams while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) { 115735a5a358SJonathan Adams ASSERT(spa->spa_proc != &p0); 115835a5a358SJonathan Adams cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock); 115935a5a358SJonathan Adams } 116035a5a358SJonathan Adams ASSERT(spa->spa_proc_state == SPA_PROC_GONE); 116135a5a358SJonathan Adams spa->spa_proc_state = SPA_PROC_NONE; 116235a5a358SJonathan Adams } 116335a5a358SJonathan Adams ASSERT(spa->spa_proc == &p0); 116435a5a358SJonathan Adams mutex_exit(&spa->spa_proc_lock); 116535a5a358SJonathan Adams 116635a5a358SJonathan Adams /* 116735a5a358SJonathan Adams * We want to make sure spa_thread() has actually exited the ZFS 116835a5a358SJonathan Adams * module, so that the module can't be unloaded out from underneath 116935a5a358SJonathan Adams * it. 117035a5a358SJonathan Adams */ 117135a5a358SJonathan Adams if (spa->spa_did != 0) { 117235a5a358SJonathan Adams thread_join(spa->spa_did); 117335a5a358SJonathan Adams spa->spa_did = 0; 117435a5a358SJonathan Adams } 1175fa9e4066Sahrens } 1176fa9e4066Sahrens 1177fa9e4066Sahrens /* 1178fa9e4066Sahrens * Verify a pool configuration, and construct the vdev tree appropriately. This 1179fa9e4066Sahrens * will create all the necessary vdevs in the appropriate layout, with each vdev 1180fa9e4066Sahrens * in the CLOSED state. This will prep the pool before open/creation/import. 1181fa9e4066Sahrens * All vdev validation is done by the vdev_alloc() routine. 1182fa9e4066Sahrens */ 118399653d4eSeschrock static int 118499653d4eSeschrock spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, 118599653d4eSeschrock uint_t id, int atype) 1186fa9e4066Sahrens { 1187fa9e4066Sahrens nvlist_t **child; 1188573ca77eSGeorge Wilson uint_t children; 118999653d4eSeschrock int error; 1190fa9e4066Sahrens 119199653d4eSeschrock if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0) 119299653d4eSeschrock return (error); 1193fa9e4066Sahrens 119499653d4eSeschrock if ((*vdp)->vdev_ops->vdev_op_leaf) 119599653d4eSeschrock return (0); 1196fa9e4066Sahrens 1197e14bb325SJeff Bonwick error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1198e14bb325SJeff Bonwick &child, &children); 1199e14bb325SJeff Bonwick 1200e14bb325SJeff Bonwick if (error == ENOENT) 1201e14bb325SJeff Bonwick return (0); 1202e14bb325SJeff Bonwick 1203e14bb325SJeff Bonwick if (error) { 120499653d4eSeschrock vdev_free(*vdp); 120599653d4eSeschrock *vdp = NULL; 1206be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 1207fa9e4066Sahrens } 1208fa9e4066Sahrens 1209573ca77eSGeorge Wilson for (int c = 0; c < children; c++) { 121099653d4eSeschrock vdev_t *vd; 121199653d4eSeschrock if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c, 121299653d4eSeschrock atype)) != 0) { 121399653d4eSeschrock vdev_free(*vdp); 121499653d4eSeschrock *vdp = NULL; 121599653d4eSeschrock return (error); 1216fa9e4066Sahrens } 1217fa9e4066Sahrens } 1218fa9e4066Sahrens 121999653d4eSeschrock ASSERT(*vdp != NULL); 122099653d4eSeschrock 122199653d4eSeschrock return (0); 1222fa9e4066Sahrens } 1223fa9e4066Sahrens 1224fa9e4066Sahrens /* 1225fa9e4066Sahrens * Opposite of spa_load(). 1226fa9e4066Sahrens */ 1227fa9e4066Sahrens static void 1228fa9e4066Sahrens spa_unload(spa_t *spa) 1229fa9e4066Sahrens { 123099653d4eSeschrock int i; 123199653d4eSeschrock 1232e14bb325SJeff Bonwick ASSERT(MUTEX_HELD(&spa_namespace_lock)); 1233e14bb325SJeff Bonwick 1234ea8dc4b6Seschrock /* 1235ea8dc4b6Seschrock * Stop async tasks. 1236ea8dc4b6Seschrock */ 1237ea8dc4b6Seschrock spa_async_suspend(spa); 1238ea8dc4b6Seschrock 1239fa9e4066Sahrens /* 1240fa9e4066Sahrens * Stop syncing. 1241fa9e4066Sahrens */ 1242fa9e4066Sahrens if (spa->spa_sync_on) { 1243fa9e4066Sahrens txg_sync_stop(spa->spa_dsl_pool); 1244fa9e4066Sahrens spa->spa_sync_on = B_FALSE; 1245fa9e4066Sahrens } 1246fa9e4066Sahrens 1247fa9e4066Sahrens /* 1248e14bb325SJeff Bonwick * Wait for any outstanding async I/O to complete. 1249fa9e4066Sahrens */ 125054d692b7SGeorge Wilson if (spa->spa_async_zio_root != NULL) { 12516f834bc1SMatthew Ahrens for (int i = 0; i < max_ncpus; i++) 12526f834bc1SMatthew Ahrens (void) zio_wait(spa->spa_async_zio_root[i]); 12536f834bc1SMatthew Ahrens kmem_free(spa->spa_async_zio_root, max_ncpus * sizeof (void *)); 125454d692b7SGeorge Wilson spa->spa_async_zio_root = NULL; 125554d692b7SGeorge Wilson } 1256fa9e4066Sahrens 1257cde58dbcSMatthew Ahrens bpobj_close(&spa->spa_deferred_bpobj); 1258cde58dbcSMatthew Ahrens 12590713e232SGeorge Wilson spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 12600713e232SGeorge Wilson 12610713e232SGeorge Wilson /* 12620713e232SGeorge Wilson * Close all vdevs. 12630713e232SGeorge Wilson */ 12640713e232SGeorge Wilson if (spa->spa_root_vdev) 12650713e232SGeorge Wilson vdev_free(spa->spa_root_vdev); 12660713e232SGeorge Wilson ASSERT(spa->spa_root_vdev == NULL); 12670713e232SGeorge Wilson 1268fa9e4066Sahrens /* 1269fa9e4066Sahrens * Close the dsl pool. 1270fa9e4066Sahrens */ 1271fa9e4066Sahrens if (spa->spa_dsl_pool) { 1272fa9e4066Sahrens dsl_pool_close(spa->spa_dsl_pool); 1273fa9e4066Sahrens spa->spa_dsl_pool = NULL; 1274afee20e4SGeorge Wilson spa->spa_meta_objset = NULL; 1275fa9e4066Sahrens } 1276fa9e4066Sahrens 1277b24ab676SJeff Bonwick ddt_unload(spa); 1278b24ab676SJeff Bonwick 12798ad4d6ddSJeff Bonwick 12808ad4d6ddSJeff Bonwick /* 12818ad4d6ddSJeff Bonwick * Drop and purge level 2 cache 12828ad4d6ddSJeff Bonwick */ 12838ad4d6ddSJeff Bonwick spa_l2cache_drop(spa); 12848ad4d6ddSJeff Bonwick 1285fa94a07fSbrendan for (i = 0; i < spa->spa_spares.sav_count; i++) 1286fa94a07fSbrendan vdev_free(spa->spa_spares.sav_vdevs[i]); 1287fa94a07fSbrendan if (spa->spa_spares.sav_vdevs) { 1288fa94a07fSbrendan kmem_free(spa->spa_spares.sav_vdevs, 1289fa94a07fSbrendan spa->spa_spares.sav_count * sizeof (void *)); 1290fa94a07fSbrendan spa->spa_spares.sav_vdevs = NULL; 129199653d4eSeschrock } 1292fa94a07fSbrendan if (spa->spa_spares.sav_config) { 1293fa94a07fSbrendan nvlist_free(spa->spa_spares.sav_config); 1294fa94a07fSbrendan spa->spa_spares.sav_config = NULL; 1295fa94a07fSbrendan } 12962ce8af81SEric Schrock spa->spa_spares.sav_count = 0; 1297fa94a07fSbrendan 1298cd0837ccSGeorge Wilson for (i = 0; i < spa->spa_l2cache.sav_count; i++) { 1299cd0837ccSGeorge Wilson vdev_clear_stats(spa->spa_l2cache.sav_vdevs[i]); 1300fa94a07fSbrendan vdev_free(spa->spa_l2cache.sav_vdevs[i]); 1301cd0837ccSGeorge Wilson } 1302fa94a07fSbrendan if (spa->spa_l2cache.sav_vdevs) { 1303fa94a07fSbrendan kmem_free(spa->spa_l2cache.sav_vdevs, 1304fa94a07fSbrendan spa->spa_l2cache.sav_count * sizeof (void *)); 1305fa94a07fSbrendan spa->spa_l2cache.sav_vdevs = NULL; 1306fa94a07fSbrendan } 1307fa94a07fSbrendan if (spa->spa_l2cache.sav_config) { 1308fa94a07fSbrendan nvlist_free(spa->spa_l2cache.sav_config); 1309fa94a07fSbrendan spa->spa_l2cache.sav_config = NULL; 131099653d4eSeschrock } 13112ce8af81SEric Schrock spa->spa_l2cache.sav_count = 0; 131299653d4eSeschrock 1313ea8dc4b6Seschrock spa->spa_async_suspended = 0; 13148ad4d6ddSJeff Bonwick 13158704186eSDan McDonald if (spa->spa_comment != NULL) { 13168704186eSDan McDonald spa_strfree(spa->spa_comment); 13178704186eSDan McDonald spa->spa_comment = NULL; 13188704186eSDan McDonald } 13198704186eSDan McDonald 13208ad4d6ddSJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 1321fa9e4066Sahrens } 1322fa9e4066Sahrens 132399653d4eSeschrock /* 132499653d4eSeschrock * Load (or re-load) the current list of vdevs describing the active spares for 132599653d4eSeschrock * this pool. When this is called, we have some form of basic information in 1326fa94a07fSbrendan * 'spa_spares.sav_config'. We parse this into vdevs, try to open them, and 1327fa94a07fSbrendan * then re-generate a more complete list including status information. 132899653d4eSeschrock */ 132999653d4eSeschrock static void 133099653d4eSeschrock spa_load_spares(spa_t *spa) 133199653d4eSeschrock { 133299653d4eSeschrock nvlist_t **spares; 133399653d4eSeschrock uint_t nspares; 133499653d4eSeschrock int i; 133539c23413Seschrock vdev_t *vd, *tvd; 133699653d4eSeschrock 1337e14bb325SJeff Bonwick ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 1338e14bb325SJeff Bonwick 133999653d4eSeschrock /* 134099653d4eSeschrock * First, close and free any existing spare vdevs. 134199653d4eSeschrock */ 1342fa94a07fSbrendan for (i = 0; i < spa->spa_spares.sav_count; i++) { 1343fa94a07fSbrendan vd = spa->spa_spares.sav_vdevs[i]; 134439c23413Seschrock 134539c23413Seschrock /* Undo the call to spa_activate() below */ 1346c5904d13Seschrock if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, 1347c5904d13Seschrock B_FALSE)) != NULL && tvd->vdev_isspare) 134839c23413Seschrock spa_spare_remove(tvd); 134939c23413Seschrock vdev_close(vd); 135039c23413Seschrock vdev_free(vd); 135199653d4eSeschrock } 135239c23413Seschrock 1353fa94a07fSbrendan if (spa->spa_spares.sav_vdevs) 1354fa94a07fSbrendan kmem_free(spa->spa_spares.sav_vdevs, 1355fa94a07fSbrendan spa->spa_spares.sav_count * sizeof (void *)); 135699653d4eSeschrock 1357fa94a07fSbrendan if (spa->spa_spares.sav_config == NULL) 135899653d4eSeschrock nspares = 0; 135999653d4eSeschrock else 1360fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 136199653d4eSeschrock ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 136299653d4eSeschrock 1363fa94a07fSbrendan spa->spa_spares.sav_count = (int)nspares; 1364fa94a07fSbrendan spa->spa_spares.sav_vdevs = NULL; 136599653d4eSeschrock 136699653d4eSeschrock if (nspares == 0) 136799653d4eSeschrock return; 136899653d4eSeschrock 136999653d4eSeschrock /* 137099653d4eSeschrock * Construct the array of vdevs, opening them to get status in the 137139c23413Seschrock * process. For each spare, there is potentially two different vdev_t 137239c23413Seschrock * structures associated with it: one in the list of spares (used only 137339c23413Seschrock * for basic validation purposes) and one in the active vdev 137439c23413Seschrock * configuration (if it's spared in). During this phase we open and 137539c23413Seschrock * validate each vdev on the spare list. If the vdev also exists in the 137639c23413Seschrock * active configuration, then we also mark this vdev as an active spare. 137799653d4eSeschrock */ 1378fa94a07fSbrendan spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *), 1379fa94a07fSbrendan KM_SLEEP); 1380fa94a07fSbrendan for (i = 0; i < spa->spa_spares.sav_count; i++) { 138199653d4eSeschrock VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0, 138299653d4eSeschrock VDEV_ALLOC_SPARE) == 0); 138399653d4eSeschrock ASSERT(vd != NULL); 138499653d4eSeschrock 1385fa94a07fSbrendan spa->spa_spares.sav_vdevs[i] = vd; 138699653d4eSeschrock 1387c5904d13Seschrock if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, 1388c5904d13Seschrock B_FALSE)) != NULL) { 138939c23413Seschrock if (!tvd->vdev_isspare) 139039c23413Seschrock spa_spare_add(tvd); 139139c23413Seschrock 139239c23413Seschrock /* 139339c23413Seschrock * We only mark the spare active if we were successfully 139439c23413Seschrock * able to load the vdev. Otherwise, importing a pool 139539c23413Seschrock * with a bad active spare would result in strange 139639c23413Seschrock * behavior, because multiple pool would think the spare 139739c23413Seschrock * is actively in use. 139839c23413Seschrock * 139939c23413Seschrock * There is a vulnerability here to an equally bizarre 140039c23413Seschrock * circumstance, where a dead active spare is later 140139c23413Seschrock * brought back to life (onlined or otherwise). Given 140239c23413Seschrock * the rarity of this scenario, and the extra complexity 140339c23413Seschrock * it adds, we ignore the possibility. 140439c23413Seschrock */ 140539c23413Seschrock if (!vdev_is_dead(tvd)) 140639c23413Seschrock spa_spare_activate(tvd); 140739c23413Seschrock } 140839c23413Seschrock 1409e14bb325SJeff Bonwick vd->vdev_top = vd; 14106809eb4eSEric Schrock vd->vdev_aux = &spa->spa_spares; 1411e14bb325SJeff Bonwick 141299653d4eSeschrock if (vdev_open(vd) != 0) 141399653d4eSeschrock continue; 141499653d4eSeschrock 1415fa94a07fSbrendan if (vdev_validate_aux(vd) == 0) 1416fa94a07fSbrendan spa_spare_add(vd); 141799653d4eSeschrock } 141899653d4eSeschrock 141999653d4eSeschrock /* 142099653d4eSeschrock * Recompute the stashed list of spares, with status information 142199653d4eSeschrock * this time. 142299653d4eSeschrock */ 1423fa94a07fSbrendan VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES, 142499653d4eSeschrock DATA_TYPE_NVLIST_ARRAY) == 0); 142599653d4eSeschrock 1426fa94a07fSbrendan spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *), 1427fa94a07fSbrendan KM_SLEEP); 1428fa94a07fSbrendan for (i = 0; i < spa->spa_spares.sav_count; i++) 1429fa94a07fSbrendan spares[i] = vdev_config_generate(spa, 14303f9d6ad7SLin Ling spa->spa_spares.sav_vdevs[i], B_TRUE, VDEV_CONFIG_SPARE); 1431fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 1432fa94a07fSbrendan ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0); 1433fa94a07fSbrendan for (i = 0; i < spa->spa_spares.sav_count; i++) 143499653d4eSeschrock nvlist_free(spares[i]); 1435fa94a07fSbrendan kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *)); 1436fa94a07fSbrendan } 1437fa94a07fSbrendan 1438fa94a07fSbrendan /* 1439fa94a07fSbrendan * Load (or re-load) the current list of vdevs describing the active l2cache for 1440fa94a07fSbrendan * this pool. When this is called, we have some form of basic information in 1441fa94a07fSbrendan * 'spa_l2cache.sav_config'. We parse this into vdevs, try to open them, and 1442fa94a07fSbrendan * then re-generate a more complete list including status information. 1443fa94a07fSbrendan * Devices which are already active have their details maintained, and are 1444fa94a07fSbrendan * not re-opened. 1445fa94a07fSbrendan */ 1446fa94a07fSbrendan static void 1447fa94a07fSbrendan spa_load_l2cache(spa_t *spa) 1448fa94a07fSbrendan { 1449fa94a07fSbrendan nvlist_t **l2cache; 1450fa94a07fSbrendan uint_t nl2cache; 1451fa94a07fSbrendan int i, j, oldnvdevs; 1452573ca77eSGeorge Wilson uint64_t guid; 1453fa94a07fSbrendan vdev_t *vd, **oldvdevs, **newvdevs; 1454fa94a07fSbrendan spa_aux_vdev_t *sav = &spa->spa_l2cache; 1455fa94a07fSbrendan 1456e14bb325SJeff Bonwick ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 1457e14bb325SJeff Bonwick 1458fa94a07fSbrendan if (sav->sav_config != NULL) { 1459fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, 1460fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 1461fa94a07fSbrendan newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP); 1462fa94a07fSbrendan } else { 1463fa94a07fSbrendan nl2cache = 0; 1464d5285caeSGeorge Wilson newvdevs = NULL; 1465fa94a07fSbrendan } 1466fa94a07fSbrendan 1467fa94a07fSbrendan oldvdevs = sav->sav_vdevs; 1468fa94a07fSbrendan oldnvdevs = sav->sav_count; 1469fa94a07fSbrendan sav->sav_vdevs = NULL; 1470fa94a07fSbrendan sav->sav_count = 0; 1471fa94a07fSbrendan 1472fa94a07fSbrendan /* 1473fa94a07fSbrendan * Process new nvlist of vdevs. 1474fa94a07fSbrendan */ 1475fa94a07fSbrendan for (i = 0; i < nl2cache; i++) { 1476fa94a07fSbrendan VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID, 1477fa94a07fSbrendan &guid) == 0); 1478fa94a07fSbrendan 1479fa94a07fSbrendan newvdevs[i] = NULL; 1480fa94a07fSbrendan for (j = 0; j < oldnvdevs; j++) { 1481fa94a07fSbrendan vd = oldvdevs[j]; 1482fa94a07fSbrendan if (vd != NULL && guid == vd->vdev_guid) { 1483fa94a07fSbrendan /* 1484fa94a07fSbrendan * Retain previous vdev for add/remove ops. 1485fa94a07fSbrendan */ 1486fa94a07fSbrendan newvdevs[i] = vd; 1487fa94a07fSbrendan oldvdevs[j] = NULL; 1488fa94a07fSbrendan break; 1489fa94a07fSbrendan } 1490fa94a07fSbrendan } 1491fa94a07fSbrendan 1492fa94a07fSbrendan if (newvdevs[i] == NULL) { 1493fa94a07fSbrendan /* 1494fa94a07fSbrendan * Create new vdev 1495fa94a07fSbrendan */ 1496fa94a07fSbrendan VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0, 1497fa94a07fSbrendan VDEV_ALLOC_L2CACHE) == 0); 1498fa94a07fSbrendan ASSERT(vd != NULL); 1499fa94a07fSbrendan newvdevs[i] = vd; 1500fa94a07fSbrendan 1501fa94a07fSbrendan /* 1502fa94a07fSbrendan * Commit this vdev as an l2cache device, 1503fa94a07fSbrendan * even if it fails to open. 1504fa94a07fSbrendan */ 1505fa94a07fSbrendan spa_l2cache_add(vd); 1506fa94a07fSbrendan 1507c5904d13Seschrock vd->vdev_top = vd; 1508c5904d13Seschrock vd->vdev_aux = sav; 1509c5904d13Seschrock 1510c5904d13Seschrock spa_l2cache_activate(vd); 1511c5904d13Seschrock 1512fa94a07fSbrendan if (vdev_open(vd) != 0) 1513fa94a07fSbrendan continue; 1514fa94a07fSbrendan 1515fa94a07fSbrendan (void) vdev_validate_aux(vd); 1516fa94a07fSbrendan 1517573ca77eSGeorge Wilson if (!vdev_is_dead(vd)) 1518573ca77eSGeorge Wilson l2arc_add_vdev(spa, vd); 1519fa94a07fSbrendan } 1520fa94a07fSbrendan } 1521fa94a07fSbrendan 1522fa94a07fSbrendan /* 1523fa94a07fSbrendan * Purge vdevs that were dropped 1524fa94a07fSbrendan */ 1525fa94a07fSbrendan for (i = 0; i < oldnvdevs; i++) { 1526fa94a07fSbrendan uint64_t pool; 1527fa94a07fSbrendan 1528fa94a07fSbrendan vd = oldvdevs[i]; 1529fa94a07fSbrendan if (vd != NULL) { 1530cd0837ccSGeorge Wilson ASSERT(vd->vdev_isl2cache); 1531cd0837ccSGeorge Wilson 15328ad4d6ddSJeff Bonwick if (spa_l2cache_exists(vd->vdev_guid, &pool) && 15338ad4d6ddSJeff Bonwick pool != 0ULL && l2arc_vdev_present(vd)) 1534fa94a07fSbrendan l2arc_remove_vdev(vd); 1535cd0837ccSGeorge Wilson vdev_clear_stats(vd); 1536cd0837ccSGeorge Wilson vdev_free(vd); 1537fa94a07fSbrendan } 1538fa94a07fSbrendan } 1539fa94a07fSbrendan 1540fa94a07fSbrendan if (oldvdevs) 1541fa94a07fSbrendan kmem_free(oldvdevs, oldnvdevs * sizeof (void *)); 1542fa94a07fSbrendan 1543fa94a07fSbrendan if (sav->sav_config == NULL) 1544fa94a07fSbrendan goto out; 1545fa94a07fSbrendan 1546fa94a07fSbrendan sav->sav_vdevs = newvdevs; 1547fa94a07fSbrendan sav->sav_count = (int)nl2cache; 1548fa94a07fSbrendan 1549fa94a07fSbrendan /* 1550fa94a07fSbrendan * Recompute the stashed list of l2cache devices, with status 1551fa94a07fSbrendan * information this time. 1552fa94a07fSbrendan */ 1553fa94a07fSbrendan VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE, 1554fa94a07fSbrendan DATA_TYPE_NVLIST_ARRAY) == 0); 1555fa94a07fSbrendan 1556fa94a07fSbrendan l2cache = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); 1557fa94a07fSbrendan for (i = 0; i < sav->sav_count; i++) 1558fa94a07fSbrendan l2cache[i] = vdev_config_generate(spa, 15593f9d6ad7SLin Ling sav->sav_vdevs[i], B_TRUE, VDEV_CONFIG_L2CACHE); 1560fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(sav->sav_config, 1561fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0); 1562fa94a07fSbrendan out: 1563fa94a07fSbrendan for (i = 0; i < sav->sav_count; i++) 1564fa94a07fSbrendan nvlist_free(l2cache[i]); 1565fa94a07fSbrendan if (sav->sav_count) 1566fa94a07fSbrendan kmem_free(l2cache, sav->sav_count * sizeof (void *)); 156799653d4eSeschrock } 156899653d4eSeschrock 156999653d4eSeschrock static int 157099653d4eSeschrock load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value) 157199653d4eSeschrock { 157299653d4eSeschrock dmu_buf_t *db; 157399653d4eSeschrock char *packed = NULL; 157499653d4eSeschrock size_t nvsize = 0; 157599653d4eSeschrock int error; 157699653d4eSeschrock *value = NULL; 157799653d4eSeschrock 157899653d4eSeschrock VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); 157999653d4eSeschrock nvsize = *(uint64_t *)db->db_data; 158099653d4eSeschrock dmu_buf_rele(db, FTAG); 158199653d4eSeschrock 158299653d4eSeschrock packed = kmem_alloc(nvsize, KM_SLEEP); 15837bfdf011SNeil Perrin error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed, 15847bfdf011SNeil Perrin DMU_READ_PREFETCH); 158599653d4eSeschrock if (error == 0) 158699653d4eSeschrock error = nvlist_unpack(packed, nvsize, value, 0); 158799653d4eSeschrock kmem_free(packed, nvsize); 158899653d4eSeschrock 158999653d4eSeschrock return (error); 159099653d4eSeschrock } 159199653d4eSeschrock 15923d7072f8Seschrock /* 15933d7072f8Seschrock * Checks to see if the given vdev could not be opened, in which case we post a 15943d7072f8Seschrock * sysevent to notify the autoreplace code that the device has been removed. 15953d7072f8Seschrock */ 15963d7072f8Seschrock static void 15973d7072f8Seschrock spa_check_removed(vdev_t *vd) 15983d7072f8Seschrock { 1599573ca77eSGeorge Wilson for (int c = 0; c < vd->vdev_children; c++) 16003d7072f8Seschrock spa_check_removed(vd->vdev_child[c]); 16013d7072f8Seschrock 1602efb4a871SYuri Pankov if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd) && 1603efb4a871SYuri Pankov !vd->vdev_ishole) { 16043d7072f8Seschrock zfs_post_autoreplace(vd->vdev_spa, vd); 16053d7072f8Seschrock spa_event_notify(vd->vdev_spa, vd, ESC_ZFS_VDEV_CHECK); 16063d7072f8Seschrock } 16073d7072f8Seschrock } 16083d7072f8Seschrock 1609e6ca193dSGeorge Wilson /* 16104b964adaSGeorge Wilson * Validate the current config against the MOS config 1611e6ca193dSGeorge Wilson */ 16124b964adaSGeorge Wilson static boolean_t 16134b964adaSGeorge Wilson spa_config_valid(spa_t *spa, nvlist_t *config) 1614e6ca193dSGeorge Wilson { 16154b964adaSGeorge Wilson vdev_t *mrvd, *rvd = spa->spa_root_vdev; 16164b964adaSGeorge Wilson nvlist_t *nv; 16174b964adaSGeorge Wilson 16184b964adaSGeorge Wilson VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nv) == 0); 16194b964adaSGeorge Wilson 16204b964adaSGeorge Wilson spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 16214b964adaSGeorge Wilson VERIFY(spa_config_parse(spa, &mrvd, nv, NULL, 0, VDEV_ALLOC_LOAD) == 0); 16224b964adaSGeorge Wilson 16234b964adaSGeorge Wilson ASSERT3U(rvd->vdev_children, ==, mrvd->vdev_children); 1624e6ca193dSGeorge Wilson 162588ecc943SGeorge Wilson /* 16264b964adaSGeorge Wilson * If we're doing a normal import, then build up any additional 16274b964adaSGeorge Wilson * diagnostic information about missing devices in this config. 16284b964adaSGeorge Wilson * We'll pass this up to the user for further processing. 162988ecc943SGeorge Wilson */ 16304b964adaSGeorge Wilson if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) { 16314b964adaSGeorge Wilson nvlist_t **child, *nv; 16324b964adaSGeorge Wilson uint64_t idx = 0; 16334b964adaSGeorge Wilson 16344b964adaSGeorge Wilson child = kmem_alloc(rvd->vdev_children * sizeof (nvlist_t **), 16354b964adaSGeorge Wilson KM_SLEEP); 16364b964adaSGeorge Wilson VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0); 1637e6ca193dSGeorge Wilson 16384b964adaSGeorge Wilson for (int c = 0; c < rvd->vdev_children; c++) { 16394b964adaSGeorge Wilson vdev_t *tvd = rvd->vdev_child[c]; 16404b964adaSGeorge Wilson vdev_t *mtvd = mrvd->vdev_child[c]; 16414b964adaSGeorge Wilson 16424b964adaSGeorge Wilson if (tvd->vdev_ops == &vdev_missing_ops && 16434b964adaSGeorge Wilson mtvd->vdev_ops != &vdev_missing_ops && 16444b964adaSGeorge Wilson mtvd->vdev_islog) 16454b964adaSGeorge Wilson child[idx++] = vdev_config_generate(spa, mtvd, 16464b964adaSGeorge Wilson B_FALSE, 0); 16474b964adaSGeorge Wilson } 16484b964adaSGeorge Wilson 16494b964adaSGeorge Wilson if (idx) { 16504b964adaSGeorge Wilson VERIFY(nvlist_add_nvlist_array(nv, 16514b964adaSGeorge Wilson ZPOOL_CONFIG_CHILDREN, child, idx) == 0); 16524b964adaSGeorge Wilson VERIFY(nvlist_add_nvlist(spa->spa_load_info, 16534b964adaSGeorge Wilson ZPOOL_CONFIG_MISSING_DEVICES, nv) == 0); 16544b964adaSGeorge Wilson 16554b964adaSGeorge Wilson for (int i = 0; i < idx; i++) 16564b964adaSGeorge Wilson nvlist_free(child[i]); 16574b964adaSGeorge Wilson } 16584b964adaSGeorge Wilson nvlist_free(nv); 16594b964adaSGeorge Wilson kmem_free(child, rvd->vdev_children * sizeof (char **)); 16604b964adaSGeorge Wilson } 16614b964adaSGeorge Wilson 16624b964adaSGeorge Wilson /* 16634b964adaSGeorge Wilson * Compare the root vdev tree with the information we have 16644b964adaSGeorge Wilson * from the MOS config (mrvd). Check each top-level vdev 16654b964adaSGeorge Wilson * with the corresponding MOS config top-level (mtvd). 16664b964adaSGeorge Wilson */ 166788ecc943SGeorge Wilson for (int c = 0; c < rvd->vdev_children; c++) { 16684b964adaSGeorge Wilson vdev_t *tvd = rvd->vdev_child[c]; 16694b964adaSGeorge Wilson vdev_t *mtvd = mrvd->vdev_child[c]; 16704b964adaSGeorge Wilson 16714b964adaSGeorge Wilson /* 16724b964adaSGeorge Wilson * Resolve any "missing" vdevs in the current configuration. 16734b964adaSGeorge Wilson * If we find that the MOS config has more accurate information 16744b964adaSGeorge Wilson * about the top-level vdev then use that vdev instead. 16754b964adaSGeorge Wilson */ 16764b964adaSGeorge Wilson if (tvd->vdev_ops == &vdev_missing_ops && 16774b964adaSGeorge Wilson mtvd->vdev_ops != &vdev_missing_ops) { 16784b964adaSGeorge Wilson 16794b964adaSGeorge Wilson if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) 16804b964adaSGeorge Wilson continue; 16814b964adaSGeorge Wilson 16824b964adaSGeorge Wilson /* 16834b964adaSGeorge Wilson * Device specific actions. 16844b964adaSGeorge Wilson */ 16854b964adaSGeorge Wilson if (mtvd->vdev_islog) { 16864b964adaSGeorge Wilson spa_set_log_state(spa, SPA_LOG_CLEAR); 16874b964adaSGeorge Wilson } else { 16884b964adaSGeorge Wilson /* 16894b964adaSGeorge Wilson * XXX - once we have 'readonly' pool 16904b964adaSGeorge Wilson * support we should be able to handle 16914b964adaSGeorge Wilson * missing data devices by transitioning 16924b964adaSGeorge Wilson * the pool to readonly. 16934b964adaSGeorge Wilson */ 16944b964adaSGeorge Wilson continue; 16954b964adaSGeorge Wilson } 16964b964adaSGeorge Wilson 16974b964adaSGeorge Wilson /* 16984b964adaSGeorge Wilson * Swap the missing vdev with the data we were 16994b964adaSGeorge Wilson * able to obtain from the MOS config. 17004b964adaSGeorge Wilson */ 17014b964adaSGeorge Wilson vdev_remove_child(rvd, tvd); 17024b964adaSGeorge Wilson vdev_remove_child(mrvd, mtvd); 17034b964adaSGeorge Wilson 17044b964adaSGeorge Wilson vdev_add_child(rvd, mtvd); 17054b964adaSGeorge Wilson vdev_add_child(mrvd, tvd); 17064b964adaSGeorge Wilson 17074b964adaSGeorge Wilson spa_config_exit(spa, SCL_ALL, FTAG); 17084b964adaSGeorge Wilson vdev_load(mtvd); 17094b964adaSGeorge Wilson spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 17104b964adaSGeorge Wilson 17114b964adaSGeorge Wilson vdev_reopen(rvd); 17124b964adaSGeorge Wilson } else if (mtvd->vdev_islog) { 17134b964adaSGeorge Wilson /* 17144b964adaSGeorge Wilson * Load the slog device's state from the MOS config 17154b964adaSGeorge Wilson * since it's possible that the label does not 17164b964adaSGeorge Wilson * contain the most up-to-date information. 17174b964adaSGeorge Wilson */ 17184b964adaSGeorge Wilson vdev_load_log_state(tvd, mtvd); 17194b964adaSGeorge Wilson vdev_reopen(tvd); 17204b964adaSGeorge Wilson } 1721e6ca193dSGeorge Wilson } 17224b964adaSGeorge Wilson vdev_free(mrvd); 172388ecc943SGeorge Wilson spa_config_exit(spa, SCL_ALL, FTAG); 17244b964adaSGeorge Wilson 17254b964adaSGeorge Wilson /* 17264b964adaSGeorge Wilson * Ensure we were able to validate the config. 17274b964adaSGeorge Wilson */ 17284b964adaSGeorge Wilson return (rvd->vdev_guid_sum == spa->spa_uberblock.ub_guid_sum); 1729e6ca193dSGeorge Wilson } 1730e6ca193dSGeorge Wilson 1731b87f3af3Sperrin /* 1732b87f3af3Sperrin * Check for missing log devices 1733b87f3af3Sperrin */ 17343b2aab18SMatthew Ahrens static boolean_t 1735b87f3af3Sperrin spa_check_logs(spa_t *spa) 1736b87f3af3Sperrin { 17373b2aab18SMatthew Ahrens boolean_t rv = B_FALSE; 17383b2aab18SMatthew Ahrens 1739b87f3af3Sperrin switch (spa->spa_log_state) { 1740b87f3af3Sperrin case SPA_LOG_MISSING: 1741b87f3af3Sperrin /* need to recheck in case slog has been restored */ 1742b87f3af3Sperrin case SPA_LOG_UNKNOWN: 17433b2aab18SMatthew Ahrens rv = (dmu_objset_find(spa->spa_name, zil_check_log_chain, 17443b2aab18SMatthew Ahrens NULL, DS_FIND_CHILDREN) != 0); 17453b2aab18SMatthew Ahrens if (rv) 17461195e687SMark J Musante spa_set_log_state(spa, SPA_LOG_MISSING); 1747b87f3af3Sperrin break; 1748b87f3af3Sperrin } 17493b2aab18SMatthew Ahrens return (rv); 1750b87f3af3Sperrin } 1751b87f3af3Sperrin 17521195e687SMark J Musante static boolean_t 17531195e687SMark J Musante spa_passivate_log(spa_t *spa) 17541195e687SMark J Musante { 17551195e687SMark J Musante vdev_t *rvd = spa->spa_root_vdev; 17561195e687SMark J Musante boolean_t slog_found = B_FALSE; 17571195e687SMark J Musante 17581195e687SMark J Musante ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER)); 17591195e687SMark J Musante 17601195e687SMark J Musante if (!spa_has_slogs(spa)) 17611195e687SMark J Musante return (B_FALSE); 17621195e687SMark J Musante 17631195e687SMark J Musante for (int c = 0; c < rvd->vdev_children; c++) { 17641195e687SMark J Musante vdev_t *tvd = rvd->vdev_child[c]; 17651195e687SMark J Musante metaslab_group_t *mg = tvd->vdev_mg; 17661195e687SMark J Musante 17671195e687SMark J Musante if (tvd->vdev_islog) { 17681195e687SMark J Musante metaslab_group_passivate(mg); 17691195e687SMark J Musante slog_found = B_TRUE; 17701195e687SMark J Musante } 17711195e687SMark J Musante } 17721195e687SMark J Musante 17731195e687SMark J Musante return (slog_found); 17741195e687SMark J Musante } 17751195e687SMark J Musante 17761195e687SMark J Musante static void 17771195e687SMark J Musante spa_activate_log(spa_t *spa) 17781195e687SMark J Musante { 17791195e687SMark J Musante vdev_t *rvd = spa->spa_root_vdev; 17801195e687SMark J Musante 17811195e687SMark J Musante ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER)); 17821195e687SMark J Musante 17831195e687SMark J Musante for (int c = 0; c < rvd->vdev_children; c++) { 17841195e687SMark J Musante vdev_t *tvd = rvd->vdev_child[c]; 17851195e687SMark J Musante metaslab_group_t *mg = tvd->vdev_mg; 17861195e687SMark J Musante 17871195e687SMark J Musante if (tvd->vdev_islog) 17881195e687SMark J Musante metaslab_group_activate(mg); 17891195e687SMark J Musante } 17901195e687SMark J Musante } 17911195e687SMark J Musante 17921195e687SMark J Musante int 17931195e687SMark J Musante spa_offline_log(spa_t *spa) 17941195e687SMark J Musante { 17953b2aab18SMatthew Ahrens int error; 17961195e687SMark J Musante 17973b2aab18SMatthew Ahrens error = dmu_objset_find(spa_name(spa), zil_vdev_offline, 17983b2aab18SMatthew Ahrens NULL, DS_FIND_CHILDREN); 17993b2aab18SMatthew Ahrens if (error == 0) { 18001195e687SMark J Musante /* 18011195e687SMark J Musante * We successfully offlined the log device, sync out the 18021195e687SMark J Musante * current txg so that the "stubby" block can be removed 18031195e687SMark J Musante * by zil_sync(). 18041195e687SMark J Musante */ 18051195e687SMark J Musante txg_wait_synced(spa->spa_dsl_pool, 0); 18061195e687SMark J Musante } 18071195e687SMark J Musante return (error); 18081195e687SMark J Musante } 18091195e687SMark J Musante 1810b693757aSEric Schrock static void 1811b693757aSEric Schrock spa_aux_check_removed(spa_aux_vdev_t *sav) 1812b693757aSEric Schrock { 1813b24ab676SJeff Bonwick for (int i = 0; i < sav->sav_count; i++) 1814b693757aSEric Schrock spa_check_removed(sav->sav_vdevs[i]); 1815b693757aSEric Schrock } 1816b693757aSEric Schrock 1817b24ab676SJeff Bonwick void 1818b24ab676SJeff Bonwick spa_claim_notify(zio_t *zio) 1819b24ab676SJeff Bonwick { 1820b24ab676SJeff Bonwick spa_t *spa = zio->io_spa; 1821b24ab676SJeff Bonwick 1822b24ab676SJeff Bonwick if (zio->io_error) 1823b24ab676SJeff Bonwick return; 1824b24ab676SJeff Bonwick 1825b24ab676SJeff Bonwick mutex_enter(&spa->spa_props_lock); /* any mutex will do */ 1826b24ab676SJeff Bonwick if (spa->spa_claim_max_txg < zio->io_bp->blk_birth) 1827b24ab676SJeff Bonwick spa->spa_claim_max_txg = zio->io_bp->blk_birth; 1828b24ab676SJeff Bonwick mutex_exit(&spa->spa_props_lock); 1829b24ab676SJeff Bonwick } 1830b24ab676SJeff Bonwick 1831468c413aSTim Haley typedef struct spa_load_error { 1832c8ee1847SVictor Latushkin uint64_t sle_meta_count; 1833468c413aSTim Haley uint64_t sle_data_count; 1834468c413aSTim Haley } spa_load_error_t; 1835468c413aSTim Haley 1836468c413aSTim Haley static void 1837468c413aSTim Haley spa_load_verify_done(zio_t *zio) 1838468c413aSTim Haley { 1839468c413aSTim Haley blkptr_t *bp = zio->io_bp; 1840468c413aSTim Haley spa_load_error_t *sle = zio->io_private; 1841468c413aSTim Haley dmu_object_type_t type = BP_GET_TYPE(bp); 1842468c413aSTim Haley int error = zio->io_error; 1843e42d2059SMatthew Ahrens spa_t *spa = zio->io_spa; 1844468c413aSTim Haley 1845468c413aSTim Haley if (error) { 1846ad135b5dSChristopher Siden if ((BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type)) && 1847468c413aSTim Haley type != DMU_OT_INTENT_LOG) 18481a5e258fSJosef 'Jeff' Sipek atomic_inc_64(&sle->sle_meta_count); 1849468c413aSTim Haley else 18501a5e258fSJosef 'Jeff' Sipek atomic_inc_64(&sle->sle_data_count); 1851468c413aSTim Haley } 1852468c413aSTim Haley zio_data_buf_free(zio->io_data, zio->io_size); 1853e42d2059SMatthew Ahrens 1854e42d2059SMatthew Ahrens mutex_enter(&spa->spa_scrub_lock); 1855e42d2059SMatthew Ahrens spa->spa_scrub_inflight--; 1856e42d2059SMatthew Ahrens cv_broadcast(&spa->spa_scrub_io_cv); 1857e42d2059SMatthew Ahrens mutex_exit(&spa->spa_scrub_lock); 1858468c413aSTim Haley } 1859468c413aSTim Haley 1860e42d2059SMatthew Ahrens /* 1861e42d2059SMatthew Ahrens * Maximum number of concurrent scrub i/os to create while verifying 1862e42d2059SMatthew Ahrens * a pool while importing it. 1863e42d2059SMatthew Ahrens */ 1864e42d2059SMatthew Ahrens int spa_load_verify_maxinflight = 10000; 1865e42d2059SMatthew Ahrens boolean_t spa_load_verify_metadata = B_TRUE; 1866e42d2059SMatthew Ahrens boolean_t spa_load_verify_data = B_TRUE; 1867e42d2059SMatthew Ahrens 1868468c413aSTim Haley /*ARGSUSED*/ 1869468c413aSTim Haley static int 1870b24ab676SJeff Bonwick spa_load_verify_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 18717802d7bfSMatthew Ahrens const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg) 1872468c413aSTim Haley { 1873e42d2059SMatthew Ahrens if (BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp)) 1874e42d2059SMatthew Ahrens return (0); 1875e42d2059SMatthew Ahrens /* 1876e42d2059SMatthew Ahrens * Note: normally this routine will not be called if 1877e42d2059SMatthew Ahrens * spa_load_verify_metadata is not set. However, it may be useful 1878e42d2059SMatthew Ahrens * to manually set the flag after the traversal has begun. 1879e42d2059SMatthew Ahrens */ 1880e42d2059SMatthew Ahrens if (!spa_load_verify_metadata) 1881e42d2059SMatthew Ahrens return (0); 1882e42d2059SMatthew Ahrens if (BP_GET_BUFC_TYPE(bp) == ARC_BUFC_DATA && !spa_load_verify_data) 1883e42d2059SMatthew Ahrens return (0); 1884468c413aSTim Haley 1885e42d2059SMatthew Ahrens zio_t *rio = arg; 1886e42d2059SMatthew Ahrens size_t size = BP_GET_PSIZE(bp); 1887e42d2059SMatthew Ahrens void *data = zio_data_buf_alloc(size); 1888e42d2059SMatthew Ahrens 1889e42d2059SMatthew Ahrens mutex_enter(&spa->spa_scrub_lock); 1890e42d2059SMatthew Ahrens while (spa->spa_scrub_inflight >= spa_load_verify_maxinflight) 1891e42d2059SMatthew Ahrens cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 1892e42d2059SMatthew Ahrens spa->spa_scrub_inflight++; 1893e42d2059SMatthew Ahrens mutex_exit(&spa->spa_scrub_lock); 1894e42d2059SMatthew Ahrens 1895e42d2059SMatthew Ahrens zio_nowait(zio_read(rio, spa, bp, data, size, 1896e42d2059SMatthew Ahrens spa_load_verify_done, rio->io_private, ZIO_PRIORITY_SCRUB, 1897e42d2059SMatthew Ahrens ZIO_FLAG_SPECULATIVE | ZIO_FLAG_CANFAIL | 1898e42d2059SMatthew Ahrens ZIO_FLAG_SCRUB | ZIO_FLAG_RAW, zb)); 1899468c413aSTim Haley return (0); 1900468c413aSTim Haley } 1901468c413aSTim Haley 1902468c413aSTim Haley static int 1903468c413aSTim Haley spa_load_verify(spa_t *spa) 1904468c413aSTim Haley { 1905468c413aSTim Haley zio_t *rio; 1906468c413aSTim Haley spa_load_error_t sle = { 0 }; 1907468c413aSTim Haley zpool_rewind_policy_t policy; 1908468c413aSTim Haley boolean_t verify_ok = B_FALSE; 1909e42d2059SMatthew Ahrens int error = 0; 1910468c413aSTim Haley 1911c8ee1847SVictor Latushkin zpool_get_rewind_policy(spa->spa_config, &policy); 1912c8ee1847SVictor Latushkin 1913c8ee1847SVictor Latushkin if (policy.zrp_request & ZPOOL_NEVER_REWIND) 1914c8ee1847SVictor Latushkin return (0); 1915c8ee1847SVictor Latushkin 1916468c413aSTim Haley rio = zio_root(spa, NULL, &sle, 1917468c413aSTim Haley ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE); 1918468c413aSTim Haley 1919e42d2059SMatthew Ahrens if (spa_load_verify_metadata) { 1920e42d2059SMatthew Ahrens error = traverse_pool(spa, spa->spa_verify_min_txg, 1921e42d2059SMatthew Ahrens TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA, 1922e42d2059SMatthew Ahrens spa_load_verify_cb, rio); 1923e42d2059SMatthew Ahrens } 1924468c413aSTim Haley 1925468c413aSTim Haley (void) zio_wait(rio); 1926468c413aSTim Haley 1927c8ee1847SVictor Latushkin spa->spa_load_meta_errors = sle.sle_meta_count; 1928468c413aSTim Haley spa->spa_load_data_errors = sle.sle_data_count; 1929468c413aSTim Haley 1930c8ee1847SVictor Latushkin if (!error && sle.sle_meta_count <= policy.zrp_maxmeta && 1931468c413aSTim Haley sle.sle_data_count <= policy.zrp_maxdata) { 19324b964adaSGeorge Wilson int64_t loss = 0; 19334b964adaSGeorge Wilson 1934468c413aSTim Haley verify_ok = B_TRUE; 1935468c413aSTim Haley spa->spa_load_txg = spa->spa_uberblock.ub_txg; 1936468c413aSTim Haley spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp; 19374b964adaSGeorge Wilson 19384b964adaSGeorge Wilson loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts; 19394b964adaSGeorge Wilson VERIFY(nvlist_add_uint64(spa->spa_load_info, 19404b964adaSGeorge Wilson ZPOOL_CONFIG_LOAD_TIME, spa->spa_load_txg_ts) == 0); 19414b964adaSGeorge Wilson VERIFY(nvlist_add_int64(spa->spa_load_info, 19424b964adaSGeorge Wilson ZPOOL_CONFIG_REWIND_TIME, loss) == 0); 19434b964adaSGeorge Wilson VERIFY(nvlist_add_uint64(spa->spa_load_info, 19444b964adaSGeorge Wilson ZPOOL_CONFIG_LOAD_DATA_ERRORS, sle.sle_data_count) == 0); 1945a33cae98STim Haley } else { 1946a33cae98STim Haley spa->spa_load_max_txg = spa->spa_uberblock.ub_txg; 1947468c413aSTim Haley } 1948468c413aSTim Haley 1949468c413aSTim Haley if (error) { 1950468c413aSTim Haley if (error != ENXIO && error != EIO) 1951be6fd75aSMatthew Ahrens error = SET_ERROR(EIO); 1952468c413aSTim Haley return (error); 1953468c413aSTim Haley } 1954468c413aSTim Haley 1955468c413aSTim Haley return (verify_ok ? 0 : EIO); 1956468c413aSTim Haley } 1957468c413aSTim Haley 19581195e687SMark J Musante /* 19591195e687SMark J Musante * Find a value in the pool props object. 19601195e687SMark J Musante */ 19611195e687SMark J Musante static void 19621195e687SMark J Musante spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val) 19631195e687SMark J Musante { 19641195e687SMark J Musante (void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object, 19651195e687SMark J Musante zpool_prop_to_name(prop), sizeof (uint64_t), 1, val); 19661195e687SMark J Musante } 19671195e687SMark J Musante 19681195e687SMark J Musante /* 19691195e687SMark J Musante * Find a value in the pool directory object. 19701195e687SMark J Musante */ 19711195e687SMark J Musante static int 19721195e687SMark J Musante spa_dir_prop(spa_t *spa, const char *name, uint64_t *val) 19731195e687SMark J Musante { 19741195e687SMark J Musante return (zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 19751195e687SMark J Musante name, sizeof (uint64_t), 1, val)); 19761195e687SMark J Musante } 19771195e687SMark J Musante 19781195e687SMark J Musante static int 19791195e687SMark J Musante spa_vdev_err(vdev_t *vdev, vdev_aux_t aux, int err) 19801195e687SMark J Musante { 19811195e687SMark J Musante vdev_set_state(vdev, B_TRUE, VDEV_STATE_CANT_OPEN, aux); 19821195e687SMark J Musante return (err); 19831195e687SMark J Musante } 19841195e687SMark J Musante 19851195e687SMark J Musante /* 19861195e687SMark J Musante * Fix up config after a partly-completed split. This is done with the 19871195e687SMark J Musante * ZPOOL_CONFIG_SPLIT nvlist. Both the splitting pool and the split-off 19881195e687SMark J Musante * pool have that entry in their config, but only the splitting one contains 19891195e687SMark J Musante * a list of all the guids of the vdevs that are being split off. 19901195e687SMark J Musante * 19911195e687SMark J Musante * This function determines what to do with that list: either rejoin 19921195e687SMark J Musante * all the disks to the pool, or complete the splitting process. To attempt 19931195e687SMark J Musante * the rejoin, each disk that is offlined is marked online again, and 19941195e687SMark J Musante * we do a reopen() call. If the vdev label for every disk that was 19951195e687SMark J Musante * marked online indicates it was successfully split off (VDEV_AUX_SPLIT_POOL) 19961195e687SMark J Musante * then we call vdev_split() on each disk, and complete the split. 19971195e687SMark J Musante * 1998d41c4376SMark J Musante * Otherwise we leave the config alone, with all the vdevs in place in 1999d41c4376SMark J Musante * the original pool. 20001195e687SMark J Musante */ 20011195e687SMark J Musante static void 20021195e687SMark J Musante spa_try_repair(spa_t *spa, nvlist_t *config) 20031195e687SMark J Musante { 20041195e687SMark J Musante uint_t extracted; 20051195e687SMark J Musante uint64_t *glist; 20061195e687SMark J Musante uint_t i, gcount; 20071195e687SMark J Musante nvlist_t *nvl; 20081195e687SMark J Musante vdev_t **vd; 20091195e687SMark J Musante boolean_t attempt_reopen; 20101195e687SMark J Musante 20111195e687SMark J Musante if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) != 0) 20121195e687SMark J Musante return; 20131195e687SMark J Musante 20141195e687SMark J Musante /* check that the config is complete */ 20151195e687SMark J Musante if (nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 20161195e687SMark J Musante &glist, &gcount) != 0) 20171195e687SMark J Musante return; 20181195e687SMark J Musante 20191195e687SMark J Musante vd = kmem_zalloc(gcount * sizeof (vdev_t *), KM_SLEEP); 20201195e687SMark J Musante 20211195e687SMark J Musante /* attempt to online all the vdevs & validate */ 20221195e687SMark J Musante attempt_reopen = B_TRUE; 20231195e687SMark J Musante for (i = 0; i < gcount; i++) { 20241195e687SMark J Musante if (glist[i] == 0) /* vdev is hole */ 20251195e687SMark J Musante continue; 20261195e687SMark J Musante 20271195e687SMark J Musante vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE); 20281195e687SMark J Musante if (vd[i] == NULL) { 20291195e687SMark J Musante /* 20301195e687SMark J Musante * Don't bother attempting to reopen the disks; 20311195e687SMark J Musante * just do the split. 20321195e687SMark J Musante */ 20331195e687SMark J Musante attempt_reopen = B_FALSE; 20341195e687SMark J Musante } else { 20351195e687SMark J Musante /* attempt to re-online it */ 20361195e687SMark J Musante vd[i]->vdev_offline = B_FALSE; 20371195e687SMark J Musante } 20381195e687SMark J Musante } 20391195e687SMark J Musante 20401195e687SMark J Musante if (attempt_reopen) { 20411195e687SMark J Musante vdev_reopen(spa->spa_root_vdev); 20421195e687SMark J Musante 20431195e687SMark J Musante /* check each device to see what state it's in */ 20441195e687SMark J Musante for (extracted = 0, i = 0; i < gcount; i++) { 20451195e687SMark J Musante if (vd[i] != NULL && 20461195e687SMark J Musante vd[i]->vdev_stat.vs_aux != VDEV_AUX_SPLIT_POOL) 20471195e687SMark J Musante break; 20481195e687SMark J Musante ++extracted; 20491195e687SMark J Musante } 20501195e687SMark J Musante } 20511195e687SMark J Musante 20521195e687SMark J Musante /* 20531195e687SMark J Musante * If every disk has been moved to the new pool, or if we never 20541195e687SMark J Musante * even attempted to look at them, then we split them off for 20551195e687SMark J Musante * good. 20561195e687SMark J Musante */ 20571195e687SMark J Musante if (!attempt_reopen || gcount == extracted) { 20581195e687SMark J Musante for (i = 0; i < gcount; i++) 20591195e687SMark J Musante if (vd[i] != NULL) 20601195e687SMark J Musante vdev_split(vd[i]); 20611195e687SMark J Musante vdev_reopen(spa->spa_root_vdev); 20621195e687SMark J Musante } 20631195e687SMark J Musante 20641195e687SMark J Musante kmem_free(vd, gcount * sizeof (vdev_t *)); 20651195e687SMark J Musante } 20661195e687SMark J Musante 20671195e687SMark J Musante static int 20681195e687SMark J Musante spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type, 20691195e687SMark J Musante boolean_t mosconfig) 20701195e687SMark J Musante { 20711195e687SMark J Musante nvlist_t *config = spa->spa_config; 20721195e687SMark J Musante char *ereport = FM_EREPORT_ZFS_POOL; 20738704186eSDan McDonald char *comment; 20741195e687SMark J Musante int error; 20751195e687SMark J Musante uint64_t pool_guid; 20761195e687SMark J Musante nvlist_t *nvl; 20771195e687SMark J Musante 20781195e687SMark J Musante if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) 2079be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 20801195e687SMark J Musante 20818704186eSDan McDonald ASSERT(spa->spa_comment == NULL); 20828704186eSDan McDonald if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0) 20838704186eSDan McDonald spa->spa_comment = spa_strdup(comment); 20848704186eSDan McDonald 20851195e687SMark J Musante /* 20861195e687SMark J Musante * Versioning wasn't explicitly added to the label until later, so if 20871195e687SMark J Musante * it's not present treat it as the initial version. 20881195e687SMark J Musante */ 20891195e687SMark J Musante if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 20901195e687SMark J Musante &spa->spa_ubsync.ub_version) != 0) 20911195e687SMark J Musante spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL; 20921195e687SMark J Musante 20931195e687SMark J Musante (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, 20941195e687SMark J Musante &spa->spa_config_txg); 20951195e687SMark J Musante 20961195e687SMark J Musante if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) && 20971195e687SMark J Musante spa_guid_exists(pool_guid, 0)) { 2098be6fd75aSMatthew Ahrens error = SET_ERROR(EEXIST); 20991195e687SMark J Musante } else { 2100e9103aaeSGarrett D'Amore spa->spa_config_guid = pool_guid; 21011195e687SMark J Musante 21021195e687SMark J Musante if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, 21031195e687SMark J Musante &nvl) == 0) { 21041195e687SMark J Musante VERIFY(nvlist_dup(nvl, &spa->spa_config_splitting, 21051195e687SMark J Musante KM_SLEEP) == 0); 21061195e687SMark J Musante } 21071195e687SMark J Musante 2108ad135b5dSChristopher Siden nvlist_free(spa->spa_load_info); 2109ad135b5dSChristopher Siden spa->spa_load_info = fnvlist_alloc(); 2110ad135b5dSChristopher Siden 211111027bc7STim Haley gethrestime(&spa->spa_loaded_ts); 21121195e687SMark J Musante error = spa_load_impl(spa, pool_guid, config, state, type, 21131195e687SMark J Musante mosconfig, &ereport); 21141195e687SMark J Musante } 21151195e687SMark J Musante 2116*bc9014e6SJustin Gibbs /* 2117*bc9014e6SJustin Gibbs * Don't count references from objsets that are already closed 2118*bc9014e6SJustin Gibbs * and are making their way through the eviction process. 2119*bc9014e6SJustin Gibbs */ 2120*bc9014e6SJustin Gibbs spa_evicting_os_wait(spa); 21211195e687SMark J Musante spa->spa_minref = refcount_count(&spa->spa_refcount); 212211027bc7STim Haley if (error) { 212311027bc7STim Haley if (error != EEXIST) { 212411027bc7STim Haley spa->spa_loaded_ts.tv_sec = 0; 212511027bc7STim Haley spa->spa_loaded_ts.tv_nsec = 0; 212611027bc7STim Haley } 212711027bc7STim Haley if (error != EBADF) { 212811027bc7STim Haley zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0); 212911027bc7STim Haley } 213011027bc7STim Haley } 21311195e687SMark J Musante spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE; 21321195e687SMark J Musante spa->spa_ena = 0; 21331195e687SMark J Musante 21341195e687SMark J Musante return (error); 21351195e687SMark J Musante } 21361195e687SMark J Musante 2137fa9e4066Sahrens /* 2138fa9e4066Sahrens * Load an existing storage pool, using the pool's builtin spa_config as a 2139ea8dc4b6Seschrock * source of configuration information. 2140fa9e4066Sahrens */ 2141fa9e4066Sahrens static int 21421195e687SMark J Musante spa_load_impl(spa_t *spa, uint64_t pool_guid, nvlist_t *config, 21431195e687SMark J Musante spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig, 21441195e687SMark J Musante char **ereport) 2145fa9e4066Sahrens { 2146fa9e4066Sahrens int error = 0; 2147871a9500SMark J Musante nvlist_t *nvroot = NULL; 2148ad135b5dSChristopher Siden nvlist_t *label; 2149fa9e4066Sahrens vdev_t *rvd; 2150fa9e4066Sahrens uberblock_t *ub = &spa->spa_uberblock; 21514b964adaSGeorge Wilson uint64_t children, config_cache_txg = spa->spa_config_txg; 21528ad4d6ddSJeff Bonwick int orig_mode = spa->spa_mode; 21531195e687SMark J Musante int parse; 2154cde58dbcSMatthew Ahrens uint64_t obj; 2155ad135b5dSChristopher Siden boolean_t missing_feat_write = B_FALSE; 2156fa9e4066Sahrens 21578ad4d6ddSJeff Bonwick /* 21588ad4d6ddSJeff Bonwick * If this is an untrusted config, access the pool in read-only mode. 21598ad4d6ddSJeff Bonwick * This prevents things like resilvering recently removed devices. 21608ad4d6ddSJeff Bonwick */ 21618ad4d6ddSJeff Bonwick if (!mosconfig) 21628ad4d6ddSJeff Bonwick spa->spa_mode = FREAD; 21638ad4d6ddSJeff Bonwick 2164e14bb325SJeff Bonwick ASSERT(MUTEX_HELD(&spa_namespace_lock)); 2165e14bb325SJeff Bonwick 2166ea8dc4b6Seschrock spa->spa_load_state = state; 21670373e76bSbonwick 21681195e687SMark J Musante if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot)) 2169be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 2170fa9e4066Sahrens 21711195e687SMark J Musante parse = (type == SPA_IMPORT_EXISTING ? 21721195e687SMark J Musante VDEV_ALLOC_LOAD : VDEV_ALLOC_SPLIT); 2173b5989ec7Seschrock 217454d692b7SGeorge Wilson /* 217554d692b7SGeorge Wilson * Create "The Godfather" zio to hold all async IOs 217654d692b7SGeorge Wilson */ 21776f834bc1SMatthew Ahrens spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *), 21786f834bc1SMatthew Ahrens KM_SLEEP); 21796f834bc1SMatthew Ahrens for (int i = 0; i < max_ncpus; i++) { 21806f834bc1SMatthew Ahrens spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL, 21816f834bc1SMatthew Ahrens ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | 21826f834bc1SMatthew Ahrens ZIO_FLAG_GODFATHER); 21836f834bc1SMatthew Ahrens } 218454d692b7SGeorge Wilson 2185fa9e4066Sahrens /* 218699653d4eSeschrock * Parse the configuration into a vdev tree. We explicitly set the 218799653d4eSeschrock * value that will be returned by spa_version() since parsing the 218899653d4eSeschrock * configuration requires knowing the version number. 2189fa9e4066Sahrens */ 2190e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 21911195e687SMark J Musante error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, parse); 2192e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 2193fa9e4066Sahrens 219499653d4eSeschrock if (error != 0) 21951195e687SMark J Musante return (error); 2196fa9e4066Sahrens 21970e34b6a7Sbonwick ASSERT(spa->spa_root_vdev == rvd); 21981195e687SMark J Musante 21991195e687SMark J Musante if (type != SPA_IMPORT_ASSEMBLE) { 22001195e687SMark J Musante ASSERT(spa_guid(spa) == pool_guid); 22011195e687SMark J Musante } 2202fa9e4066Sahrens 2203fa9e4066Sahrens /* 2204fa9e4066Sahrens * Try to open all vdevs, loading each label in the process. 2205fa9e4066Sahrens */ 2206e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 22070bf246f5Smc error = vdev_open(rvd); 2208e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 22090bf246f5Smc if (error != 0) 22101195e687SMark J Musante return (error); 2211fa9e4066Sahrens 2212560e6e96Seschrock /* 221377e3a39cSMark J Musante * We need to validate the vdev labels against the configuration that 221477e3a39cSMark J Musante * we have in hand, which is dependent on the setting of mosconfig. If 221577e3a39cSMark J Musante * mosconfig is true then we're validating the vdev labels based on 22161195e687SMark J Musante * that config. Otherwise, we're validating against the cached config 221777e3a39cSMark J Musante * (zpool.cache) that was read when we loaded the zfs module, and then 221877e3a39cSMark J Musante * later we will recursively call spa_load() and validate against 221977e3a39cSMark J Musante * the vdev config. 22201195e687SMark J Musante * 22211195e687SMark J Musante * If we're assembling a new pool that's been split off from an 22221195e687SMark J Musante * existing pool, the labels haven't yet been updated so we skip 22231195e687SMark J Musante * validation for now. 2224560e6e96Seschrock */ 22251195e687SMark J Musante if (type != SPA_IMPORT_ASSEMBLE) { 22261195e687SMark J Musante spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2227d7f601efSGeorge Wilson error = vdev_validate(rvd, mosconfig); 22281195e687SMark J Musante spa_config_exit(spa, SCL_ALL, FTAG); 2229560e6e96Seschrock 22301195e687SMark J Musante if (error != 0) 22311195e687SMark J Musante return (error); 22321195e687SMark J Musante 22331195e687SMark J Musante if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) 2234be6fd75aSMatthew Ahrens return (SET_ERROR(ENXIO)); 2235560e6e96Seschrock } 2236560e6e96Seschrock 2237fa9e4066Sahrens /* 2238fa9e4066Sahrens * Find the best uberblock. 2239fa9e4066Sahrens */ 2240ad135b5dSChristopher Siden vdev_uberblock_load(rvd, ub, &label); 2241fa9e4066Sahrens 2242fa9e4066Sahrens /* 2243fa9e4066Sahrens * If we weren't able to find a single valid uberblock, return failure. 2244fa9e4066Sahrens */ 2245ad135b5dSChristopher Siden if (ub->ub_txg == 0) { 2246ad135b5dSChristopher Siden nvlist_free(label); 22471195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, ENXIO)); 2248ad135b5dSChristopher Siden } 2249ea8dc4b6Seschrock 2250ea8dc4b6Seschrock /* 2251ad135b5dSChristopher Siden * If the pool has an unsupported version we can't open it. 2252ea8dc4b6Seschrock */ 2253ad135b5dSChristopher Siden if (!SPA_VERSION_IS_SUPPORTED(ub->ub_version)) { 2254ad135b5dSChristopher Siden nvlist_free(label); 22551195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_VERSION_NEWER, ENOTSUP)); 2256ad135b5dSChristopher Siden } 2257ad135b5dSChristopher Siden 2258ad135b5dSChristopher Siden if (ub->ub_version >= SPA_VERSION_FEATURES) { 2259ad135b5dSChristopher Siden nvlist_t *features; 2260ad135b5dSChristopher Siden 2261ad135b5dSChristopher Siden /* 2262ad135b5dSChristopher Siden * If we weren't able to find what's necessary for reading the 2263ad135b5dSChristopher Siden * MOS in the label, return failure. 2264ad135b5dSChristopher Siden */ 2265ad135b5dSChristopher Siden if (label == NULL || nvlist_lookup_nvlist(label, 2266ad135b5dSChristopher Siden ZPOOL_CONFIG_FEATURES_FOR_READ, &features) != 0) { 2267ad135b5dSChristopher Siden nvlist_free(label); 2268ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 2269ad135b5dSChristopher Siden ENXIO)); 2270ad135b5dSChristopher Siden } 2271ad135b5dSChristopher Siden 2272ad135b5dSChristopher Siden /* 2273ad135b5dSChristopher Siden * Update our in-core representation with the definitive values 2274ad135b5dSChristopher Siden * from the label. 2275ad135b5dSChristopher Siden */ 2276ad135b5dSChristopher Siden nvlist_free(spa->spa_label_features); 2277ad135b5dSChristopher Siden VERIFY(nvlist_dup(features, &spa->spa_label_features, 0) == 0); 2278ad135b5dSChristopher Siden } 2279ad135b5dSChristopher Siden 2280ad135b5dSChristopher Siden nvlist_free(label); 2281ad135b5dSChristopher Siden 2282ad135b5dSChristopher Siden /* 2283ad135b5dSChristopher Siden * Look through entries in the label nvlist's features_for_read. If 2284ad135b5dSChristopher Siden * there is a feature listed there which we don't understand then we 2285ad135b5dSChristopher Siden * cannot open a pool. 2286ad135b5dSChristopher Siden */ 2287ad135b5dSChristopher Siden if (ub->ub_version >= SPA_VERSION_FEATURES) { 2288ad135b5dSChristopher Siden nvlist_t *unsup_feat; 2289ad135b5dSChristopher Siden 2290ad135b5dSChristopher Siden VERIFY(nvlist_alloc(&unsup_feat, NV_UNIQUE_NAME, KM_SLEEP) == 2291ad135b5dSChristopher Siden 0); 2292ad135b5dSChristopher Siden 2293ad135b5dSChristopher Siden for (nvpair_t *nvp = nvlist_next_nvpair(spa->spa_label_features, 2294ad135b5dSChristopher Siden NULL); nvp != NULL; 2295ad135b5dSChristopher Siden nvp = nvlist_next_nvpair(spa->spa_label_features, nvp)) { 2296ad135b5dSChristopher Siden if (!zfeature_is_supported(nvpair_name(nvp))) { 2297ad135b5dSChristopher Siden VERIFY(nvlist_add_string(unsup_feat, 2298ad135b5dSChristopher Siden nvpair_name(nvp), "") == 0); 2299ad135b5dSChristopher Siden } 2300ad135b5dSChristopher Siden } 2301ad135b5dSChristopher Siden 2302ad135b5dSChristopher Siden if (!nvlist_empty(unsup_feat)) { 2303ad135b5dSChristopher Siden VERIFY(nvlist_add_nvlist(spa->spa_load_info, 2304ad135b5dSChristopher Siden ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat) == 0); 2305ad135b5dSChristopher Siden nvlist_free(unsup_feat); 2306ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT, 2307ad135b5dSChristopher Siden ENOTSUP)); 2308ad135b5dSChristopher Siden } 2309ad135b5dSChristopher Siden 2310ad135b5dSChristopher Siden nvlist_free(unsup_feat); 2311ad135b5dSChristopher Siden } 2312fa9e4066Sahrens 2313fa9e4066Sahrens /* 2314fa9e4066Sahrens * If the vdev guid sum doesn't match the uberblock, we have an 23154b964adaSGeorge Wilson * incomplete configuration. We first check to see if the pool 23164b964adaSGeorge Wilson * is aware of the complete config (i.e ZPOOL_CONFIG_VDEV_CHILDREN). 23174b964adaSGeorge Wilson * If it is, defer the vdev_guid_sum check till later so we 23184b964adaSGeorge Wilson * can handle missing vdevs. 2319fa9e4066Sahrens */ 23204b964adaSGeorge Wilson if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN, 23214b964adaSGeorge Wilson &children) != 0 && mosconfig && type != SPA_IMPORT_ASSEMBLE && 23221195e687SMark J Musante rvd->vdev_guid_sum != ub->ub_guid_sum) 23231195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, ENXIO)); 23241195e687SMark J Musante 23251195e687SMark J Musante if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) { 23261195e687SMark J Musante spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 23271195e687SMark J Musante spa_try_repair(spa, config); 23281195e687SMark J Musante spa_config_exit(spa, SCL_ALL, FTAG); 23291195e687SMark J Musante nvlist_free(spa->spa_config_splitting); 23301195e687SMark J Musante spa->spa_config_splitting = NULL; 2331fa9e4066Sahrens } 2332fa9e4066Sahrens 2333fa9e4066Sahrens /* 2334fa9e4066Sahrens * Initialize internal SPA structures. 2335fa9e4066Sahrens */ 2336fa9e4066Sahrens spa->spa_state = POOL_STATE_ACTIVE; 2337fa9e4066Sahrens spa->spa_ubsync = spa->spa_uberblock; 2338468c413aSTim Haley spa->spa_verify_min_txg = spa->spa_extreme_rewind ? 2339c8ee1847SVictor Latushkin TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1; 2340468c413aSTim Haley spa->spa_first_txg = spa->spa_last_ubsync_txg ? 2341468c413aSTim Haley spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1; 2342b24ab676SJeff Bonwick spa->spa_claim_max_txg = spa->spa_first_txg; 23433f9d6ad7SLin Ling spa->spa_prev_software_version = ub->ub_software_version; 2344b24ab676SJeff Bonwick 2345ad135b5dSChristopher Siden error = dsl_pool_init(spa, spa->spa_first_txg, &spa->spa_dsl_pool); 23461195e687SMark J Musante if (error) 23471195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2348fa9e4066Sahrens spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset; 2349fa9e4066Sahrens 23501195e687SMark J Musante if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object) != 0) 23511195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2352fa9e4066Sahrens 2353ad135b5dSChristopher Siden if (spa_version(spa) >= SPA_VERSION_FEATURES) { 2354ad135b5dSChristopher Siden boolean_t missing_feat_read = B_FALSE; 235557221772SChristopher Siden nvlist_t *unsup_feat, *enabled_feat; 2356ad135b5dSChristopher Siden 2357ad135b5dSChristopher Siden if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_READ, 2358ad135b5dSChristopher Siden &spa->spa_feat_for_read_obj) != 0) { 2359ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2360ad135b5dSChristopher Siden } 2361ad135b5dSChristopher Siden 2362ad135b5dSChristopher Siden if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_WRITE, 2363ad135b5dSChristopher Siden &spa->spa_feat_for_write_obj) != 0) { 2364ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2365ad135b5dSChristopher Siden } 2366ad135b5dSChristopher Siden 2367ad135b5dSChristopher Siden if (spa_dir_prop(spa, DMU_POOL_FEATURE_DESCRIPTIONS, 2368ad135b5dSChristopher Siden &spa->spa_feat_desc_obj) != 0) { 2369ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2370ad135b5dSChristopher Siden } 2371ad135b5dSChristopher Siden 237257221772SChristopher Siden enabled_feat = fnvlist_alloc(); 237357221772SChristopher Siden unsup_feat = fnvlist_alloc(); 2374ad135b5dSChristopher Siden 23752acef22dSMatthew Ahrens if (!spa_features_check(spa, B_FALSE, 237657221772SChristopher Siden unsup_feat, enabled_feat)) 2377ad135b5dSChristopher Siden missing_feat_read = B_TRUE; 2378ad135b5dSChristopher Siden 2379ad135b5dSChristopher Siden if (spa_writeable(spa) || state == SPA_LOAD_TRYIMPORT) { 23802acef22dSMatthew Ahrens if (!spa_features_check(spa, B_TRUE, 238157221772SChristopher Siden unsup_feat, enabled_feat)) { 2382ad135b5dSChristopher Siden missing_feat_write = B_TRUE; 238357221772SChristopher Siden } 2384ad135b5dSChristopher Siden } 2385ad135b5dSChristopher Siden 238657221772SChristopher Siden fnvlist_add_nvlist(spa->spa_load_info, 238757221772SChristopher Siden ZPOOL_CONFIG_ENABLED_FEAT, enabled_feat); 238857221772SChristopher Siden 2389ad135b5dSChristopher Siden if (!nvlist_empty(unsup_feat)) { 239057221772SChristopher Siden fnvlist_add_nvlist(spa->spa_load_info, 239157221772SChristopher Siden ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat); 2392ad135b5dSChristopher Siden } 2393ad135b5dSChristopher Siden 239457221772SChristopher Siden fnvlist_free(enabled_feat); 239557221772SChristopher Siden fnvlist_free(unsup_feat); 2396ad135b5dSChristopher Siden 2397ad135b5dSChristopher Siden if (!missing_feat_read) { 2398ad135b5dSChristopher Siden fnvlist_add_boolean(spa->spa_load_info, 2399ad135b5dSChristopher Siden ZPOOL_CONFIG_CAN_RDONLY); 2400ad135b5dSChristopher Siden } 2401ad135b5dSChristopher Siden 2402ad135b5dSChristopher Siden /* 2403ad135b5dSChristopher Siden * If the state is SPA_LOAD_TRYIMPORT, our objective is 2404ad135b5dSChristopher Siden * twofold: to determine whether the pool is available for 2405ad135b5dSChristopher Siden * import in read-write mode and (if it is not) whether the 2406ad135b5dSChristopher Siden * pool is available for import in read-only mode. If the pool 2407ad135b5dSChristopher Siden * is available for import in read-write mode, it is displayed 2408ad135b5dSChristopher Siden * as available in userland; if it is not available for import 2409ad135b5dSChristopher Siden * in read-only mode, it is displayed as unavailable in 2410ad135b5dSChristopher Siden * userland. If the pool is available for import in read-only 2411ad135b5dSChristopher Siden * mode but not read-write mode, it is displayed as unavailable 2412ad135b5dSChristopher Siden * in userland with a special note that the pool is actually 2413ad135b5dSChristopher Siden * available for open in read-only mode. 2414ad135b5dSChristopher Siden * 2415ad135b5dSChristopher Siden * As a result, if the state is SPA_LOAD_TRYIMPORT and we are 2416ad135b5dSChristopher Siden * missing a feature for write, we must first determine whether 2417ad135b5dSChristopher Siden * the pool can be opened read-only before returning to 2418ad135b5dSChristopher Siden * userland in order to know whether to display the 2419ad135b5dSChristopher Siden * abovementioned note. 2420ad135b5dSChristopher Siden */ 2421ad135b5dSChristopher Siden if (missing_feat_read || (missing_feat_write && 2422ad135b5dSChristopher Siden spa_writeable(spa))) { 2423ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT, 2424ad135b5dSChristopher Siden ENOTSUP)); 2425ad135b5dSChristopher Siden } 242643466aaeSMax Grossman 242743466aaeSMax Grossman /* 242843466aaeSMax Grossman * Load refcounts for ZFS features from disk into an in-memory 242943466aaeSMax Grossman * cache during SPA initialization. 243043466aaeSMax Grossman */ 243143466aaeSMax Grossman for (spa_feature_t i = 0; i < SPA_FEATURES; i++) { 243243466aaeSMax Grossman uint64_t refcount; 243343466aaeSMax Grossman 243443466aaeSMax Grossman error = feature_get_refcount_from_disk(spa, 243543466aaeSMax Grossman &spa_feature_table[i], &refcount); 243643466aaeSMax Grossman if (error == 0) { 243743466aaeSMax Grossman spa->spa_feat_refcount_cache[i] = refcount; 243843466aaeSMax Grossman } else if (error == ENOTSUP) { 243943466aaeSMax Grossman spa->spa_feat_refcount_cache[i] = 244043466aaeSMax Grossman SPA_FEATURE_DISABLED; 244143466aaeSMax Grossman } else { 244243466aaeSMax Grossman return (spa_vdev_err(rvd, 244343466aaeSMax Grossman VDEV_AUX_CORRUPT_DATA, EIO)); 244443466aaeSMax Grossman } 244543466aaeSMax Grossman } 244643466aaeSMax Grossman } 244743466aaeSMax Grossman 244843466aaeSMax Grossman if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) { 244943466aaeSMax Grossman if (spa_dir_prop(spa, DMU_POOL_FEATURE_ENABLED_TXG, 24505d7b4d43SMatthew Ahrens &spa->spa_feat_enabled_txg_obj) != 0) 245143466aaeSMax Grossman return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2452ad135b5dSChristopher Siden } 2453ad135b5dSChristopher Siden 2454ad135b5dSChristopher Siden spa->spa_is_initializing = B_TRUE; 2455ad135b5dSChristopher Siden error = dsl_pool_open(spa->spa_dsl_pool); 2456ad135b5dSChristopher Siden spa->spa_is_initializing = B_FALSE; 2457ad135b5dSChristopher Siden if (error != 0) 2458ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2459ad135b5dSChristopher Siden 2460fa9e4066Sahrens if (!mosconfig) { 246195173954Sek uint64_t hostid; 2462871a9500SMark J Musante nvlist_t *policy = NULL, *nvconfig; 2463871a9500SMark J Musante 2464871a9500SMark J Musante if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0) 2465871a9500SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2466fa9e4066Sahrens 246788ecc943SGeorge Wilson if (!spa_is_root(spa) && nvlist_lookup_uint64(nvconfig, 246877650510SLin Ling ZPOOL_CONFIG_HOSTID, &hostid) == 0) { 246995173954Sek char *hostname; 247095173954Sek unsigned long myhostid = 0; 247195173954Sek 247288ecc943SGeorge Wilson VERIFY(nvlist_lookup_string(nvconfig, 247395173954Sek ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); 247495173954Sek 24755679c89fSjv #ifdef _KERNEL 24765679c89fSjv myhostid = zone_get_hostid(NULL); 24775679c89fSjv #else /* _KERNEL */ 24785679c89fSjv /* 24795679c89fSjv * We're emulating the system's hostid in userland, so 24805679c89fSjv * we can't use zone_get_hostid(). 24815679c89fSjv */ 248295173954Sek (void) ddi_strtoul(hw_serial, NULL, 10, &myhostid); 24835679c89fSjv #endif /* _KERNEL */ 248417194a52Slling if (hostid != 0 && myhostid != 0 && 24855679c89fSjv hostid != myhostid) { 2486871a9500SMark J Musante nvlist_free(nvconfig); 248795173954Sek cmn_err(CE_WARN, "pool '%s' could not be " 248895173954Sek "loaded as it was last accessed by " 248977650510SLin Ling "another system (host: %s hostid: 0x%lx). " 2490654b400cSJoshua M. Clulow "See: http://illumos.org/msg/ZFS-8000-EY", 2491e14bb325SJeff Bonwick spa_name(spa), hostname, 249295173954Sek (unsigned long)hostid); 2493be6fd75aSMatthew Ahrens return (SET_ERROR(EBADF)); 249495173954Sek } 249595173954Sek } 2496c8ee1847SVictor Latushkin if (nvlist_lookup_nvlist(spa->spa_config, 2497c8ee1847SVictor Latushkin ZPOOL_REWIND_POLICY, &policy) == 0) 2498c8ee1847SVictor Latushkin VERIFY(nvlist_add_nvlist(nvconfig, 2499c8ee1847SVictor Latushkin ZPOOL_REWIND_POLICY, policy) == 0); 250095173954Sek 250188ecc943SGeorge Wilson spa_config_set(spa, nvconfig); 2502fa9e4066Sahrens spa_unload(spa); 2503fa9e4066Sahrens spa_deactivate(spa); 25048ad4d6ddSJeff Bonwick spa_activate(spa, orig_mode); 2505fa9e4066Sahrens 25061195e687SMark J Musante return (spa_load(spa, state, SPA_IMPORT_EXISTING, B_TRUE)); 2507fa9e4066Sahrens } 2508fa9e4066Sahrens 2509cde58dbcSMatthew Ahrens if (spa_dir_prop(spa, DMU_POOL_SYNC_BPOBJ, &obj) != 0) 2510cde58dbcSMatthew Ahrens return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2511cde58dbcSMatthew Ahrens error = bpobj_open(&spa->spa_deferred_bpobj, spa->spa_meta_objset, obj); 2512cde58dbcSMatthew Ahrens if (error != 0) 25131195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2514fa9e4066Sahrens 251599653d4eSeschrock /* 251699653d4eSeschrock * Load the bit that tells us to use the new accounting function 251799653d4eSeschrock * (raid-z deflation). If we have an older pool, this will not 251899653d4eSeschrock * be present. 251999653d4eSeschrock */ 25201195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate); 25211195e687SMark J Musante if (error != 0 && error != ENOENT) 25221195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 252399653d4eSeschrock 25243f9d6ad7SLin Ling error = spa_dir_prop(spa, DMU_POOL_CREATION_VERSION, 25253f9d6ad7SLin Ling &spa->spa_creation_version); 25263f9d6ad7SLin Ling if (error != 0 && error != ENOENT) 25273f9d6ad7SLin Ling return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 25283f9d6ad7SLin Ling 2529fa9e4066Sahrens /* 2530ea8dc4b6Seschrock * Load the persistent error log. If we have an older pool, this will 2531ea8dc4b6Seschrock * not be present. 2532fa9e4066Sahrens */ 25331195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last); 25341195e687SMark J Musante if (error != 0 && error != ENOENT) 25351195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2536ea8dc4b6Seschrock 25371195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB, 25381195e687SMark J Musante &spa->spa_errlog_scrub); 25391195e687SMark J Musante if (error != 0 && error != ENOENT) 25401195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2541ea8dc4b6Seschrock 254206eeb2adSek /* 254306eeb2adSek * Load the history object. If we have an older pool, this 254406eeb2adSek * will not be present. 254506eeb2adSek */ 25461195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history); 25471195e687SMark J Musante if (error != 0 && error != ENOENT) 25481195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 25491195e687SMark J Musante 25501195e687SMark J Musante /* 25511195e687SMark J Musante * If we're assembling the pool from the split-off vdevs of 25521195e687SMark J Musante * an existing pool, we don't want to attach the spares & cache 25531195e687SMark J Musante * devices. 25541195e687SMark J Musante */ 255506eeb2adSek 255699653d4eSeschrock /* 255799653d4eSeschrock * Load any hot spares for this pool. 255899653d4eSeschrock */ 25591195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object); 25601195e687SMark J Musante if (error != 0 && error != ENOENT) 25611195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 25621195e687SMark J Musante if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 2563e7437265Sahrens ASSERT(spa_version(spa) >= SPA_VERSION_SPARES); 2564fa94a07fSbrendan if (load_nvlist(spa, spa->spa_spares.sav_object, 25651195e687SMark J Musante &spa->spa_spares.sav_config) != 0) 25661195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 256799653d4eSeschrock 2568e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 256999653d4eSeschrock spa_load_spares(spa); 2570e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 25711195e687SMark J Musante } else if (error == 0) { 25721195e687SMark J Musante spa->spa_spares.sav_sync = B_TRUE; 257399653d4eSeschrock } 257499653d4eSeschrock 2575fa94a07fSbrendan /* 2576fa94a07fSbrendan * Load any level 2 ARC devices for this pool. 2577fa94a07fSbrendan */ 25781195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_L2CACHE, 2579fa94a07fSbrendan &spa->spa_l2cache.sav_object); 25801195e687SMark J Musante if (error != 0 && error != ENOENT) 25811195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 25821195e687SMark J Musante if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 2583fa94a07fSbrendan ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE); 2584fa94a07fSbrendan if (load_nvlist(spa, spa->spa_l2cache.sav_object, 25851195e687SMark J Musante &spa->spa_l2cache.sav_config) != 0) 25861195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2587fa94a07fSbrendan 2588e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2589fa94a07fSbrendan spa_load_l2cache(spa); 2590e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 25911195e687SMark J Musante } else if (error == 0) { 25921195e687SMark J Musante spa->spa_l2cache.sav_sync = B_TRUE; 2593fa94a07fSbrendan } 2594fa94a07fSbrendan 2595990b4856Slling spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 2596ecd6cf80Smarks 25971195e687SMark J Musante error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object); 25981195e687SMark J Musante if (error && error != ENOENT) 25991195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2600b1b8ab34Slling 2601b1b8ab34Slling if (error == 0) { 26021195e687SMark J Musante uint64_t autoreplace; 26031195e687SMark J Musante 26041195e687SMark J Musante spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs); 26051195e687SMark J Musante spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace); 26061195e687SMark J Musante spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation); 26071195e687SMark J Musante spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode); 26081195e687SMark J Musante spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand); 26091195e687SMark J Musante spa_prop_find(spa, ZPOOL_PROP_DEDUPDITTO, 26101195e687SMark J Musante &spa->spa_dedup_ditto); 26111195e687SMark J Musante 2612b693757aSEric Schrock spa->spa_autoreplace = (autoreplace != 0); 2613b1b8ab34Slling } 2614b1b8ab34Slling 26153d7072f8Seschrock /* 26163d7072f8Seschrock * If the 'autoreplace' property is set, then post a resource notifying 26173d7072f8Seschrock * the ZFS DE that it should not issue any faults for unopenable 26183d7072f8Seschrock * devices. We also iterate over the vdevs, and post a sysevent for any 26193d7072f8Seschrock * unopenable vdevs so that the normal autoreplace handler can take 26203d7072f8Seschrock * over. 26213d7072f8Seschrock */ 2622b693757aSEric Schrock if (spa->spa_autoreplace && state != SPA_LOAD_TRYIMPORT) { 26233d7072f8Seschrock spa_check_removed(spa->spa_root_vdev); 2624b693757aSEric Schrock /* 2625b693757aSEric Schrock * For the import case, this is done in spa_import(), because 2626b693757aSEric Schrock * at this point we're using the spare definitions from 2627b693757aSEric Schrock * the MOS config, not necessarily from the userland config. 2628b693757aSEric Schrock */ 2629b693757aSEric Schrock if (state != SPA_LOAD_IMPORT) { 2630b693757aSEric Schrock spa_aux_check_removed(&spa->spa_spares); 2631b693757aSEric Schrock spa_aux_check_removed(&spa->spa_l2cache); 2632b693757aSEric Schrock } 2633b693757aSEric Schrock } 26343d7072f8Seschrock 2635ea8dc4b6Seschrock /* 2636560e6e96Seschrock * Load the vdev state for all toplevel vdevs. 2637ea8dc4b6Seschrock */ 2638560e6e96Seschrock vdev_load(rvd); 26390373e76bSbonwick 2640fa9e4066Sahrens /* 2641fa9e4066Sahrens * Propagate the leaf DTLs we just loaded all the way up the tree. 2642fa9e4066Sahrens */ 2643e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 2644fa9e4066Sahrens vdev_dtl_reassess(rvd, 0, 0, B_FALSE); 2645e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 2646fa9e4066Sahrens 2647b24ab676SJeff Bonwick /* 2648b24ab676SJeff Bonwick * Load the DDTs (dedup tables). 2649b24ab676SJeff Bonwick */ 2650b24ab676SJeff Bonwick error = ddt_load(spa); 26511195e687SMark J Musante if (error != 0) 26521195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2653b24ab676SJeff Bonwick 2654485bbbf5SGeorge Wilson spa_update_dspace(spa); 2655485bbbf5SGeorge Wilson 2656b24ab676SJeff Bonwick /* 26574b964adaSGeorge Wilson * Validate the config, using the MOS config to fill in any 26584b964adaSGeorge Wilson * information which might be missing. If we fail to validate 26594b964adaSGeorge Wilson * the config then declare the pool unfit for use. If we're 26604b964adaSGeorge Wilson * assembling a pool from a split, the log is not transferred 26614b964adaSGeorge Wilson * over. 2662b24ab676SJeff Bonwick */ 26631195e687SMark J Musante if (type != SPA_IMPORT_ASSEMBLE) { 2664871a9500SMark J Musante nvlist_t *nvconfig; 2665871a9500SMark J Musante 2666871a9500SMark J Musante if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0) 2667871a9500SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 2668871a9500SMark J Musante 26694b964adaSGeorge Wilson if (!spa_config_valid(spa, nvconfig)) { 26704b964adaSGeorge Wilson nvlist_free(nvconfig); 26714b964adaSGeorge Wilson return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, 26724b964adaSGeorge Wilson ENXIO)); 26734b964adaSGeorge Wilson } 26741195e687SMark J Musante nvlist_free(nvconfig); 26751195e687SMark J Musante 26764b964adaSGeorge Wilson /* 2677ad135b5dSChristopher Siden * Now that we've validated the config, check the state of the 26784b964adaSGeorge Wilson * root vdev. If it can't be opened, it indicates one or 26794b964adaSGeorge Wilson * more toplevel vdevs are faulted. 26804b964adaSGeorge Wilson */ 26814b964adaSGeorge Wilson if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) 2682be6fd75aSMatthew Ahrens return (SET_ERROR(ENXIO)); 26834b964adaSGeorge Wilson 26841195e687SMark J Musante if (spa_check_logs(spa)) { 26851195e687SMark J Musante *ereport = FM_EREPORT_ZFS_LOG_REPLAY; 26861195e687SMark J Musante return (spa_vdev_err(rvd, VDEV_AUX_BAD_LOG, ENXIO)); 26871195e687SMark J Musante } 2688b24ab676SJeff Bonwick } 2689b24ab676SJeff Bonwick 2690ad135b5dSChristopher Siden if (missing_feat_write) { 2691ad135b5dSChristopher Siden ASSERT(state == SPA_LOAD_TRYIMPORT); 2692ad135b5dSChristopher Siden 2693ad135b5dSChristopher Siden /* 2694ad135b5dSChristopher Siden * At this point, we know that we can open the pool in 2695ad135b5dSChristopher Siden * read-only mode but not read-write mode. We now have enough 2696ad135b5dSChristopher Siden * information and can return to userland. 2697ad135b5dSChristopher Siden */ 2698ad135b5dSChristopher Siden return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT, ENOTSUP)); 2699ad135b5dSChristopher Siden } 2700ad135b5dSChristopher Siden 27014b964adaSGeorge Wilson /* 27024b964adaSGeorge Wilson * We've successfully opened the pool, verify that we're ready 27034b964adaSGeorge Wilson * to start pushing transactions. 27044b964adaSGeorge Wilson */ 27054b964adaSGeorge Wilson if (state != SPA_LOAD_TRYIMPORT) { 27064b964adaSGeorge Wilson if (error = spa_load_verify(spa)) 27074b964adaSGeorge Wilson return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 27084b964adaSGeorge Wilson error)); 27094b964adaSGeorge Wilson } 27104b964adaSGeorge Wilson 2711468c413aSTim Haley if (spa_writeable(spa) && (state == SPA_LOAD_RECOVER || 2712468c413aSTim Haley spa->spa_load_max_txg == UINT64_MAX)) { 27135dabedeeSbonwick dmu_tx_t *tx; 27140373e76bSbonwick int need_update = B_FALSE; 27158ad4d6ddSJeff Bonwick 27168ad4d6ddSJeff Bonwick ASSERT(state != SPA_LOAD_TRYIMPORT); 27175dabedeeSbonwick 27180373e76bSbonwick /* 27190373e76bSbonwick * Claim log blocks that haven't been committed yet. 27200373e76bSbonwick * This must all happen in a single txg. 2721b24ab676SJeff Bonwick * Note: spa_claim_max_txg is updated by spa_claim_notify(), 2722b24ab676SJeff Bonwick * invoked from zil_claim_log_block()'s i/o done callback. 2723468c413aSTim Haley * Price of rollback is that we abandon the log. 27240373e76bSbonwick */ 2725b24ab676SJeff Bonwick spa->spa_claiming = B_TRUE; 2726b24ab676SJeff Bonwick 27275dabedeeSbonwick tx = dmu_tx_create_assigned(spa_get_dsl(spa), 2728fa9e4066Sahrens spa_first_txg(spa)); 2729e14bb325SJeff Bonwick (void) dmu_objset_find(spa_name(spa), 27300b69c2f0Sahrens zil_claim, tx, DS_FIND_CHILDREN); 2731fa9e4066Sahrens dmu_tx_commit(tx); 2732fa9e4066Sahrens 2733b24ab676SJeff Bonwick spa->spa_claiming = B_FALSE; 2734b24ab676SJeff Bonwick 27351195e687SMark J Musante spa_set_log_state(spa, SPA_LOG_GOOD); 2736fa9e4066Sahrens spa->spa_sync_on = B_TRUE; 2737fa9e4066Sahrens txg_sync_start(spa->spa_dsl_pool); 2738fa9e4066Sahrens 2739fa9e4066Sahrens /* 2740b24ab676SJeff Bonwick * Wait for all claims to sync. We sync up to the highest 2741b24ab676SJeff Bonwick * claimed log block birth time so that claimed log blocks 2742b24ab676SJeff Bonwick * don't appear to be from the future. spa_claim_max_txg 2743b24ab676SJeff Bonwick * will have been set for us by either zil_check_log_chain() 2744b24ab676SJeff Bonwick * (invoked from spa_check_logs()) or zil_claim() above. 2745fa9e4066Sahrens */ 2746b24ab676SJeff Bonwick txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg); 27470e34b6a7Sbonwick 27480e34b6a7Sbonwick /* 27490373e76bSbonwick * If the config cache is stale, or we have uninitialized 27500373e76bSbonwick * metaslabs (see spa_vdev_add()), then update the config. 2751bc758434SLin Ling * 27524b964adaSGeorge Wilson * If this is a verbatim import, trust the current 2753bc758434SLin Ling * in-core spa_config and update the disk labels. 27540e34b6a7Sbonwick */ 27550373e76bSbonwick if (config_cache_txg != spa->spa_config_txg || 27564b964adaSGeorge Wilson state == SPA_LOAD_IMPORT || 27574b964adaSGeorge Wilson state == SPA_LOAD_RECOVER || 27584b964adaSGeorge Wilson (spa->spa_import_flags & ZFS_IMPORT_VERBATIM)) 27590373e76bSbonwick need_update = B_TRUE; 27600373e76bSbonwick 27618ad4d6ddSJeff Bonwick for (int c = 0; c < rvd->vdev_children; c++) 27620373e76bSbonwick if (rvd->vdev_child[c]->vdev_ms_array == 0) 27630373e76bSbonwick need_update = B_TRUE; 27640e34b6a7Sbonwick 27650e34b6a7Sbonwick /* 27660373e76bSbonwick * Update the config cache asychronously in case we're the 27670373e76bSbonwick * root pool, in which case the config cache isn't writable yet. 27680e34b6a7Sbonwick */ 27690373e76bSbonwick if (need_update) 27700373e76bSbonwick spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 27718ad4d6ddSJeff Bonwick 27728ad4d6ddSJeff Bonwick /* 27738ad4d6ddSJeff Bonwick * Check all DTLs to see if anything needs resilvering. 27748ad4d6ddSJeff Bonwick */ 27753f9d6ad7SLin Ling if (!dsl_scan_resilvering(spa->spa_dsl_pool) && 27763f9d6ad7SLin Ling vdev_resilver_needed(rvd, NULL, NULL)) 27778ad4d6ddSJeff Bonwick spa_async_request(spa, SPA_ASYNC_RESILVER); 2778503ad85cSMatthew Ahrens 27794445fffbSMatthew Ahrens /* 27804445fffbSMatthew Ahrens * Log the fact that we booted up (so that we can detect if 27814445fffbSMatthew Ahrens * we rebooted in the middle of an operation). 27824445fffbSMatthew Ahrens */ 27834445fffbSMatthew Ahrens spa_history_log_version(spa, "open"); 27844445fffbSMatthew Ahrens 2785503ad85cSMatthew Ahrens /* 2786503ad85cSMatthew Ahrens * Delete any inconsistent datasets. 2787503ad85cSMatthew Ahrens */ 2788503ad85cSMatthew Ahrens (void) dmu_objset_find(spa_name(spa), 2789503ad85cSMatthew Ahrens dsl_destroy_inconsistent, NULL, DS_FIND_CHILDREN); 2790ca45db41SChris Kirby 2791ca45db41SChris Kirby /* 2792ca45db41SChris Kirby * Clean up any stale temporary dataset userrefs. 2793ca45db41SChris Kirby */ 2794ca45db41SChris Kirby dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool); 2795fa9e4066Sahrens } 2796fa9e4066Sahrens 27971195e687SMark J Musante return (0); 2798fa9e4066Sahrens } 2799fa9e4066Sahrens 2800468c413aSTim Haley static int 2801468c413aSTim Haley spa_load_retry(spa_t *spa, spa_load_state_t state, int mosconfig) 2802468c413aSTim Haley { 2803f9af39baSGeorge Wilson int mode = spa->spa_mode; 2804f9af39baSGeorge Wilson 2805468c413aSTim Haley spa_unload(spa); 2806468c413aSTim Haley spa_deactivate(spa); 2807468c413aSTim Haley 2808e42d2059SMatthew Ahrens spa->spa_load_max_txg = spa->spa_uberblock.ub_txg - 1; 2809468c413aSTim Haley 2810f9af39baSGeorge Wilson spa_activate(spa, mode); 2811468c413aSTim Haley spa_async_suspend(spa); 2812468c413aSTim Haley 28131195e687SMark J Musante return (spa_load(spa, state, SPA_IMPORT_EXISTING, mosconfig)); 2814468c413aSTim Haley } 2815468c413aSTim Haley 2816ad135b5dSChristopher Siden /* 2817ad135b5dSChristopher Siden * If spa_load() fails this function will try loading prior txg's. If 2818ad135b5dSChristopher Siden * 'state' is SPA_LOAD_RECOVER and one of these loads succeeds the pool 2819ad135b5dSChristopher Siden * will be rewound to that txg. If 'state' is not SPA_LOAD_RECOVER this 2820ad135b5dSChristopher Siden * function will not rewind the pool and will return the same error as 2821ad135b5dSChristopher Siden * spa_load(). 2822ad135b5dSChristopher Siden */ 2823468c413aSTim Haley static int 2824468c413aSTim Haley spa_load_best(spa_t *spa, spa_load_state_t state, int mosconfig, 2825c8ee1847SVictor Latushkin uint64_t max_request, int rewind_flags) 2826468c413aSTim Haley { 2827ad135b5dSChristopher Siden nvlist_t *loadinfo = NULL; 2828468c413aSTim Haley nvlist_t *config = NULL; 2829468c413aSTim Haley int load_error, rewind_error; 2830c8ee1847SVictor Latushkin uint64_t safe_rewind_txg; 2831468c413aSTim Haley uint64_t min_txg; 2832468c413aSTim Haley 2833a33cae98STim Haley if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) { 2834468c413aSTim Haley spa->spa_load_max_txg = spa->spa_load_txg; 28351195e687SMark J Musante spa_set_log_state(spa, SPA_LOG_CLEAR); 2836a33cae98STim Haley } else { 2837468c413aSTim Haley spa->spa_load_max_txg = max_request; 2838e42d2059SMatthew Ahrens if (max_request != UINT64_MAX) 2839e42d2059SMatthew Ahrens spa->spa_extreme_rewind = B_TRUE; 2840a33cae98STim Haley } 2841468c413aSTim Haley 28421195e687SMark J Musante load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING, 28431195e687SMark J Musante mosconfig); 2844468c413aSTim Haley if (load_error == 0) 2845468c413aSTim Haley return (0); 2846468c413aSTim Haley 2847468c413aSTim Haley if (spa->spa_root_vdev != NULL) 2848468c413aSTim Haley config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 2849468c413aSTim Haley 2850468c413aSTim Haley spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg; 2851468c413aSTim Haley spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp; 2852468c413aSTim Haley 2853c8ee1847SVictor Latushkin if (rewind_flags & ZPOOL_NEVER_REWIND) { 2854468c413aSTim Haley nvlist_free(config); 2855468c413aSTim Haley return (load_error); 2856468c413aSTim Haley } 2857468c413aSTim Haley 2858ad135b5dSChristopher Siden if (state == SPA_LOAD_RECOVER) { 2859ad135b5dSChristopher Siden /* Price of rolling back is discarding txgs, including log */ 28601195e687SMark J Musante spa_set_log_state(spa, SPA_LOG_CLEAR); 2861ad135b5dSChristopher Siden } else { 2862ad135b5dSChristopher Siden /* 2863ad135b5dSChristopher Siden * If we aren't rolling back save the load info from our first 2864ad135b5dSChristopher Siden * import attempt so that we can restore it after attempting 2865ad135b5dSChristopher Siden * to rewind. 2866ad135b5dSChristopher Siden */ 2867ad135b5dSChristopher Siden loadinfo = spa->spa_load_info; 2868ad135b5dSChristopher Siden spa->spa_load_info = fnvlist_alloc(); 2869ad135b5dSChristopher Siden } 2870468c413aSTim Haley 2871c8ee1847SVictor Latushkin spa->spa_load_max_txg = spa->spa_last_ubsync_txg; 2872c8ee1847SVictor Latushkin safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE; 2873c8ee1847SVictor Latushkin min_txg = (rewind_flags & ZPOOL_EXTREME_REWIND) ? 2874c8ee1847SVictor Latushkin TXG_INITIAL : safe_rewind_txg; 2875468c413aSTim Haley 2876c8ee1847SVictor Latushkin /* 2877c8ee1847SVictor Latushkin * Continue as long as we're finding errors, we're still within 2878c8ee1847SVictor Latushkin * the acceptable rewind range, and we're still finding uberblocks 2879c8ee1847SVictor Latushkin */ 2880c8ee1847SVictor Latushkin while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg && 2881c8ee1847SVictor Latushkin spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) { 2882c8ee1847SVictor Latushkin if (spa->spa_load_max_txg < safe_rewind_txg) 2883468c413aSTim Haley spa->spa_extreme_rewind = B_TRUE; 2884468c413aSTim Haley rewind_error = spa_load_retry(spa, state, mosconfig); 2885468c413aSTim Haley } 2886468c413aSTim Haley 2887468c413aSTim Haley spa->spa_extreme_rewind = B_FALSE; 2888468c413aSTim Haley spa->spa_load_max_txg = UINT64_MAX; 2889468c413aSTim Haley 2890468c413aSTim Haley if (config && (rewind_error || state != SPA_LOAD_RECOVER)) 2891468c413aSTim Haley spa_config_set(spa, config); 2892468c413aSTim Haley 2893ad135b5dSChristopher Siden if (state == SPA_LOAD_RECOVER) { 2894ad135b5dSChristopher Siden ASSERT3P(loadinfo, ==, NULL); 2895ad135b5dSChristopher Siden return (rewind_error); 2896ad135b5dSChristopher Siden } else { 2897ad135b5dSChristopher Siden /* Store the rewind info as part of the initial load info */ 2898ad135b5dSChristopher Siden fnvlist_add_nvlist(loadinfo, ZPOOL_CONFIG_REWIND_INFO, 2899ad135b5dSChristopher Siden spa->spa_load_info); 2900ad135b5dSChristopher Siden 2901ad135b5dSChristopher Siden /* Restore the initial load info */ 2902ad135b5dSChristopher Siden fnvlist_free(spa->spa_load_info); 2903ad135b5dSChristopher Siden spa->spa_load_info = loadinfo; 2904ad135b5dSChristopher Siden 2905ad135b5dSChristopher Siden return (load_error); 2906ad135b5dSChristopher Siden } 2907468c413aSTim Haley } 2908468c413aSTim Haley 2909fa9e4066Sahrens /* 2910fa9e4066Sahrens * Pool Open/Import 2911fa9e4066Sahrens * 2912fa9e4066Sahrens * The import case is identical to an open except that the configuration is sent 2913fa9e4066Sahrens * down from userland, instead of grabbed from the configuration cache. For the 2914fa9e4066Sahrens * case of an open, the pool configuration will exist in the 29153d7072f8Seschrock * POOL_STATE_UNINITIALIZED state. 2916fa9e4066Sahrens * 2917fa9e4066Sahrens * The stats information (gen/count/ustats) is used to gather vdev statistics at 2918fa9e4066Sahrens * the same time open the pool, without having to keep around the spa_t in some 2919fa9e4066Sahrens * ambiguous state. 2920fa9e4066Sahrens */ 2921fa9e4066Sahrens static int 2922468c413aSTim Haley spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t *nvpolicy, 2923468c413aSTim Haley nvlist_t **config) 2924fa9e4066Sahrens { 2925fa9e4066Sahrens spa_t *spa; 29264b964adaSGeorge Wilson spa_load_state_t state = SPA_LOAD_OPEN; 2927fa9e4066Sahrens int error; 2928fa9e4066Sahrens int locked = B_FALSE; 2929fa9e4066Sahrens 2930fa9e4066Sahrens *spapp = NULL; 2931fa9e4066Sahrens 2932fa9e4066Sahrens /* 2933fa9e4066Sahrens * As disgusting as this is, we need to support recursive calls to this 2934fa9e4066Sahrens * function because dsl_dir_open() is called during spa_load(), and ends 2935fa9e4066Sahrens * up calling spa_open() again. The real fix is to figure out how to 2936fa9e4066Sahrens * avoid dsl_dir_open() calling this in the first place. 2937fa9e4066Sahrens */ 2938fa9e4066Sahrens if (mutex_owner(&spa_namespace_lock) != curthread) { 2939fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 2940fa9e4066Sahrens locked = B_TRUE; 2941fa9e4066Sahrens } 2942fa9e4066Sahrens 2943fa9e4066Sahrens if ((spa = spa_lookup(pool)) == NULL) { 2944fa9e4066Sahrens if (locked) 2945fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 2946be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 2947fa9e4066Sahrens } 2948468c413aSTim Haley 2949fa9e4066Sahrens if (spa->spa_state == POOL_STATE_UNINITIALIZED) { 29504b44c88cSTim Haley zpool_rewind_policy_t policy; 29514b44c88cSTim Haley 29524b44c88cSTim Haley zpool_get_rewind_policy(nvpolicy ? nvpolicy : spa->spa_config, 29534b44c88cSTim Haley &policy); 29544b44c88cSTim Haley if (policy.zrp_request & ZPOOL_DO_REWIND) 29554b44c88cSTim Haley state = SPA_LOAD_RECOVER; 2956fa9e4066Sahrens 29578ad4d6ddSJeff Bonwick spa_activate(spa, spa_mode_global); 2958fa9e4066Sahrens 2959468c413aSTim Haley if (state != SPA_LOAD_RECOVER) 2960468c413aSTim Haley spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 2961468c413aSTim Haley 2962468c413aSTim Haley error = spa_load_best(spa, state, B_FALSE, policy.zrp_txg, 2963c8ee1847SVictor Latushkin policy.zrp_request); 2964fa9e4066Sahrens 2965fa9e4066Sahrens if (error == EBADF) { 2966fa9e4066Sahrens /* 2967560e6e96Seschrock * If vdev_validate() returns failure (indicated by 2968560e6e96Seschrock * EBADF), it indicates that one of the vdevs indicates 2969560e6e96Seschrock * that the pool has been exported or destroyed. If 2970560e6e96Seschrock * this is the case, the config cache is out of sync and 2971560e6e96Seschrock * we should remove the pool from the namespace. 2972fa9e4066Sahrens */ 2973fa9e4066Sahrens spa_unload(spa); 2974fa9e4066Sahrens spa_deactivate(spa); 2975c5904d13Seschrock spa_config_sync(spa, B_TRUE, B_TRUE); 2976fa9e4066Sahrens spa_remove(spa); 2977fa9e4066Sahrens if (locked) 2978fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 2979be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 2980ea8dc4b6Seschrock } 2981ea8dc4b6Seschrock 2982ea8dc4b6Seschrock if (error) { 2983fa9e4066Sahrens /* 2984fa9e4066Sahrens * We can't open the pool, but we still have useful 2985fa9e4066Sahrens * information: the state of each vdev after the 2986fa9e4066Sahrens * attempted vdev_open(). Return this to the user. 2987fa9e4066Sahrens */ 29884b964adaSGeorge Wilson if (config != NULL && spa->spa_config) { 2989468c413aSTim Haley VERIFY(nvlist_dup(spa->spa_config, config, 2990468c413aSTim Haley KM_SLEEP) == 0); 29914b964adaSGeorge Wilson VERIFY(nvlist_add_nvlist(*config, 29924b964adaSGeorge Wilson ZPOOL_CONFIG_LOAD_INFO, 29934b964adaSGeorge Wilson spa->spa_load_info) == 0); 29944b964adaSGeorge Wilson } 2995fa9e4066Sahrens spa_unload(spa); 2996fa9e4066Sahrens spa_deactivate(spa); 2997468c413aSTim Haley spa->spa_last_open_failed = error; 2998fa9e4066Sahrens if (locked) 2999fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 3000fa9e4066Sahrens *spapp = NULL; 3001fa9e4066Sahrens return (error); 3002fa9e4066Sahrens } 3003fa9e4066Sahrens } 3004fa9e4066Sahrens 3005fa9e4066Sahrens spa_open_ref(spa, tag); 30063d7072f8Seschrock 3007468c413aSTim Haley if (config != NULL) 3008468c413aSTim Haley *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 3009468c413aSTim Haley 30104b964adaSGeorge Wilson /* 30114b964adaSGeorge Wilson * If we've recovered the pool, pass back any information we 30124b964adaSGeorge Wilson * gathered while doing the load. 30134b964adaSGeorge Wilson */ 30144b964adaSGeorge Wilson if (state == SPA_LOAD_RECOVER) { 30154b964adaSGeorge Wilson VERIFY(nvlist_add_nvlist(*config, ZPOOL_CONFIG_LOAD_INFO, 30164b964adaSGeorge Wilson spa->spa_load_info) == 0); 30174b964adaSGeorge Wilson } 30184b964adaSGeorge Wilson 3019a33cae98STim Haley if (locked) { 3020a33cae98STim Haley spa->spa_last_open_failed = 0; 3021a33cae98STim Haley spa->spa_last_ubsync_txg = 0; 3022a33cae98STim Haley spa->spa_load_txg = 0; 3023fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 3024a33cae98STim Haley } 3025fa9e4066Sahrens 3026fa9e4066Sahrens *spapp = spa; 3027fa9e4066Sahrens 3028fa9e4066Sahrens return (0); 3029fa9e4066Sahrens } 3030fa9e4066Sahrens 3031468c413aSTim Haley int 3032468c413aSTim Haley spa_open_rewind(const char *name, spa_t **spapp, void *tag, nvlist_t *policy, 3033468c413aSTim Haley nvlist_t **config) 3034468c413aSTim Haley { 3035468c413aSTim Haley return (spa_open_common(name, spapp, tag, policy, config)); 3036468c413aSTim Haley } 3037468c413aSTim Haley 3038fa9e4066Sahrens int 3039fa9e4066Sahrens spa_open(const char *name, spa_t **spapp, void *tag) 3040fa9e4066Sahrens { 3041468c413aSTim Haley return (spa_open_common(name, spapp, tag, NULL, NULL)); 3042fa9e4066Sahrens } 3043fa9e4066Sahrens 3044ea8dc4b6Seschrock /* 3045ea8dc4b6Seschrock * Lookup the given spa_t, incrementing the inject count in the process, 3046ea8dc4b6Seschrock * preventing it from being exported or destroyed. 3047ea8dc4b6Seschrock */ 3048ea8dc4b6Seschrock spa_t * 3049ea8dc4b6Seschrock spa_inject_addref(char *name) 3050ea8dc4b6Seschrock { 3051ea8dc4b6Seschrock spa_t *spa; 3052ea8dc4b6Seschrock 3053ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 3054ea8dc4b6Seschrock if ((spa = spa_lookup(name)) == NULL) { 3055ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 3056ea8dc4b6Seschrock return (NULL); 3057ea8dc4b6Seschrock } 3058ea8dc4b6Seschrock spa->spa_inject_ref++; 3059ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 3060ea8dc4b6Seschrock 3061ea8dc4b6Seschrock return (spa); 3062ea8dc4b6Seschrock } 3063ea8dc4b6Seschrock 3064ea8dc4b6Seschrock void 3065ea8dc4b6Seschrock spa_inject_delref(spa_t *spa) 3066ea8dc4b6Seschrock { 3067ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 3068ea8dc4b6Seschrock spa->spa_inject_ref--; 3069ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 3070ea8dc4b6Seschrock } 3071ea8dc4b6Seschrock 3072fa94a07fSbrendan /* 3073fa94a07fSbrendan * Add spares device information to the nvlist. 3074fa94a07fSbrendan */ 307599653d4eSeschrock static void 307699653d4eSeschrock spa_add_spares(spa_t *spa, nvlist_t *config) 307799653d4eSeschrock { 307899653d4eSeschrock nvlist_t **spares; 307999653d4eSeschrock uint_t i, nspares; 308099653d4eSeschrock nvlist_t *nvroot; 308199653d4eSeschrock uint64_t guid; 308299653d4eSeschrock vdev_stat_t *vs; 308399653d4eSeschrock uint_t vsc; 308439c23413Seschrock uint64_t pool; 308599653d4eSeschrock 30866809eb4eSEric Schrock ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 30876809eb4eSEric Schrock 3088fa94a07fSbrendan if (spa->spa_spares.sav_count == 0) 308999653d4eSeschrock return; 309099653d4eSeschrock 309199653d4eSeschrock VERIFY(nvlist_lookup_nvlist(config, 309299653d4eSeschrock ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 3093fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 309499653d4eSeschrock ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 309599653d4eSeschrock if (nspares != 0) { 309699653d4eSeschrock VERIFY(nvlist_add_nvlist_array(nvroot, 309799653d4eSeschrock ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 309899653d4eSeschrock VERIFY(nvlist_lookup_nvlist_array(nvroot, 309999653d4eSeschrock ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); 310099653d4eSeschrock 310199653d4eSeschrock /* 310299653d4eSeschrock * Go through and find any spares which have since been 310399653d4eSeschrock * repurposed as an active spare. If this is the case, update 310499653d4eSeschrock * their status appropriately. 310599653d4eSeschrock */ 310699653d4eSeschrock for (i = 0; i < nspares; i++) { 310799653d4eSeschrock VERIFY(nvlist_lookup_uint64(spares[i], 310899653d4eSeschrock ZPOOL_CONFIG_GUID, &guid) == 0); 310989a89ebfSlling if (spa_spare_exists(guid, &pool, NULL) && 311089a89ebfSlling pool != 0ULL) { 311199653d4eSeschrock VERIFY(nvlist_lookup_uint64_array( 31123f9d6ad7SLin Ling spares[i], ZPOOL_CONFIG_VDEV_STATS, 311399653d4eSeschrock (uint64_t **)&vs, &vsc) == 0); 311499653d4eSeschrock vs->vs_state = VDEV_STATE_CANT_OPEN; 311599653d4eSeschrock vs->vs_aux = VDEV_AUX_SPARED; 311699653d4eSeschrock } 311799653d4eSeschrock } 311899653d4eSeschrock } 311999653d4eSeschrock } 312099653d4eSeschrock 3121fa94a07fSbrendan /* 3122fa94a07fSbrendan * Add l2cache device information to the nvlist, including vdev stats. 3123fa94a07fSbrendan */ 3124fa94a07fSbrendan static void 3125fa94a07fSbrendan spa_add_l2cache(spa_t *spa, nvlist_t *config) 3126fa94a07fSbrendan { 3127fa94a07fSbrendan nvlist_t **l2cache; 3128fa94a07fSbrendan uint_t i, j, nl2cache; 3129fa94a07fSbrendan nvlist_t *nvroot; 3130fa94a07fSbrendan uint64_t guid; 3131fa94a07fSbrendan vdev_t *vd; 3132fa94a07fSbrendan vdev_stat_t *vs; 3133fa94a07fSbrendan uint_t vsc; 3134fa94a07fSbrendan 31356809eb4eSEric Schrock ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 31366809eb4eSEric Schrock 3137fa94a07fSbrendan if (spa->spa_l2cache.sav_count == 0) 3138fa94a07fSbrendan return; 3139fa94a07fSbrendan 3140fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist(config, 3141fa94a07fSbrendan ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 3142fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 3143fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 3144fa94a07fSbrendan if (nl2cache != 0) { 3145fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(nvroot, 3146fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 3147fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist_array(nvroot, 3148fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); 3149fa94a07fSbrendan 3150fa94a07fSbrendan /* 3151fa94a07fSbrendan * Update level 2 cache device stats. 3152fa94a07fSbrendan */ 3153fa94a07fSbrendan 3154fa94a07fSbrendan for (i = 0; i < nl2cache; i++) { 3155fa94a07fSbrendan VERIFY(nvlist_lookup_uint64(l2cache[i], 3156fa94a07fSbrendan ZPOOL_CONFIG_GUID, &guid) == 0); 3157fa94a07fSbrendan 3158fa94a07fSbrendan vd = NULL; 3159fa94a07fSbrendan for (j = 0; j < spa->spa_l2cache.sav_count; j++) { 3160fa94a07fSbrendan if (guid == 3161fa94a07fSbrendan spa->spa_l2cache.sav_vdevs[j]->vdev_guid) { 3162fa94a07fSbrendan vd = spa->spa_l2cache.sav_vdevs[j]; 3163fa94a07fSbrendan break; 3164fa94a07fSbrendan } 3165fa94a07fSbrendan } 3166fa94a07fSbrendan ASSERT(vd != NULL); 3167fa94a07fSbrendan 3168fa94a07fSbrendan VERIFY(nvlist_lookup_uint64_array(l2cache[i], 31693f9d6ad7SLin Ling ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc) 31703f9d6ad7SLin Ling == 0); 3171fa94a07fSbrendan vdev_get_stats(vd, vs); 3172fa94a07fSbrendan } 3173fa94a07fSbrendan } 3174fa94a07fSbrendan } 3175fa94a07fSbrendan 3176ad135b5dSChristopher Siden static void 3177ad135b5dSChristopher Siden spa_add_feature_stats(spa_t *spa, nvlist_t *config) 3178ad135b5dSChristopher Siden { 3179ad135b5dSChristopher Siden nvlist_t *features; 3180ad135b5dSChristopher Siden zap_cursor_t zc; 3181ad135b5dSChristopher Siden zap_attribute_t za; 3182ad135b5dSChristopher Siden 3183ad135b5dSChristopher Siden ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 3184ad135b5dSChristopher Siden VERIFY(nvlist_alloc(&features, NV_UNIQUE_NAME, KM_SLEEP) == 0); 3185ad135b5dSChristopher Siden 3186ad135b5dSChristopher Siden if (spa->spa_feat_for_read_obj != 0) { 3187ad135b5dSChristopher Siden for (zap_cursor_init(&zc, spa->spa_meta_objset, 3188ad135b5dSChristopher Siden spa->spa_feat_for_read_obj); 3189ad135b5dSChristopher Siden zap_cursor_retrieve(&zc, &za) == 0; 3190ad135b5dSChristopher Siden zap_cursor_advance(&zc)) { 3191ad135b5dSChristopher Siden ASSERT(za.za_integer_length == sizeof (uint64_t) && 3192ad135b5dSChristopher Siden za.za_num_integers == 1); 3193b420f3adSRichard Lowe VERIFY3U(0, ==, nvlist_add_uint64(features, za.za_name, 3194ad135b5dSChristopher Siden za.za_first_integer)); 3195ad135b5dSChristopher Siden } 3196ad135b5dSChristopher Siden zap_cursor_fini(&zc); 3197ad135b5dSChristopher Siden } 3198ad135b5dSChristopher Siden 3199ad135b5dSChristopher Siden if (spa->spa_feat_for_write_obj != 0) { 3200ad135b5dSChristopher Siden for (zap_cursor_init(&zc, spa->spa_meta_objset, 3201ad135b5dSChristopher Siden spa->spa_feat_for_write_obj); 3202ad135b5dSChristopher Siden zap_cursor_retrieve(&zc, &za) == 0; 3203ad135b5dSChristopher Siden zap_cursor_advance(&zc)) { 3204ad135b5dSChristopher Siden ASSERT(za.za_integer_length == sizeof (uint64_t) && 3205ad135b5dSChristopher Siden za.za_num_integers == 1); 3206b420f3adSRichard Lowe VERIFY3U(0, ==, nvlist_add_uint64(features, za.za_name, 3207ad135b5dSChristopher Siden za.za_first_integer)); 3208ad135b5dSChristopher Siden } 3209ad135b5dSChristopher Siden zap_cursor_fini(&zc); 3210ad135b5dSChristopher Siden } 3211ad135b5dSChristopher Siden 3212ad135b5dSChristopher Siden VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_FEATURE_STATS, 3213ad135b5dSChristopher Siden features) == 0); 3214ad135b5dSChristopher Siden nvlist_free(features); 3215ad135b5dSChristopher Siden } 3216ad135b5dSChristopher Siden 3217fa9e4066Sahrens int 3218ad135b5dSChristopher Siden spa_get_stats(const char *name, nvlist_t **config, 3219ad135b5dSChristopher Siden char *altroot, size_t buflen) 3220fa9e4066Sahrens { 3221fa9e4066Sahrens int error; 3222fa9e4066Sahrens spa_t *spa; 3223fa9e4066Sahrens 3224fa9e4066Sahrens *config = NULL; 3225468c413aSTim Haley error = spa_open_common(name, &spa, FTAG, NULL, config); 3226fa9e4066Sahrens 32276809eb4eSEric Schrock if (spa != NULL) { 32286809eb4eSEric Schrock /* 32296809eb4eSEric Schrock * This still leaves a window of inconsistency where the spares 32306809eb4eSEric Schrock * or l2cache devices could change and the config would be 32316809eb4eSEric Schrock * self-inconsistent. 32326809eb4eSEric Schrock */ 32336809eb4eSEric Schrock spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 3234ea8dc4b6Seschrock 32356809eb4eSEric Schrock if (*config != NULL) { 323611027bc7STim Haley uint64_t loadtimes[2]; 323711027bc7STim Haley 323811027bc7STim Haley loadtimes[0] = spa->spa_loaded_ts.tv_sec; 323911027bc7STim Haley loadtimes[1] = spa->spa_loaded_ts.tv_nsec; 324011027bc7STim Haley VERIFY(nvlist_add_uint64_array(*config, 324111027bc7STim Haley ZPOOL_CONFIG_LOADED_TIME, loadtimes, 2) == 0); 324211027bc7STim Haley 3243e14bb325SJeff Bonwick VERIFY(nvlist_add_uint64(*config, 32446809eb4eSEric Schrock ZPOOL_CONFIG_ERRCOUNT, 32456809eb4eSEric Schrock spa_get_errlog_size(spa)) == 0); 3246e14bb325SJeff Bonwick 32476809eb4eSEric Schrock if (spa_suspended(spa)) 32486809eb4eSEric Schrock VERIFY(nvlist_add_uint64(*config, 32496809eb4eSEric Schrock ZPOOL_CONFIG_SUSPENDED, 32506809eb4eSEric Schrock spa->spa_failmode) == 0); 32516809eb4eSEric Schrock 32526809eb4eSEric Schrock spa_add_spares(spa, *config); 32536809eb4eSEric Schrock spa_add_l2cache(spa, *config); 3254ad135b5dSChristopher Siden spa_add_feature_stats(spa, *config); 32556809eb4eSEric Schrock } 325699653d4eSeschrock } 325799653d4eSeschrock 3258ea8dc4b6Seschrock /* 3259ea8dc4b6Seschrock * We want to get the alternate root even for faulted pools, so we cheat 3260ea8dc4b6Seschrock * and call spa_lookup() directly. 3261ea8dc4b6Seschrock */ 3262ea8dc4b6Seschrock if (altroot) { 3263ea8dc4b6Seschrock if (spa == NULL) { 3264ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 3265ea8dc4b6Seschrock spa = spa_lookup(name); 3266ea8dc4b6Seschrock if (spa) 3267ea8dc4b6Seschrock spa_altroot(spa, altroot, buflen); 3268ea8dc4b6Seschrock else 3269ea8dc4b6Seschrock altroot[0] = '\0'; 3270ea8dc4b6Seschrock spa = NULL; 3271ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 3272ea8dc4b6Seschrock } else { 3273ea8dc4b6Seschrock spa_altroot(spa, altroot, buflen); 3274ea8dc4b6Seschrock } 3275ea8dc4b6Seschrock } 3276ea8dc4b6Seschrock 32776809eb4eSEric Schrock if (spa != NULL) { 32786809eb4eSEric Schrock spa_config_exit(spa, SCL_CONFIG, FTAG); 3279fa9e4066Sahrens spa_close(spa, FTAG); 32806809eb4eSEric Schrock } 3281fa9e4066Sahrens 3282fa9e4066Sahrens return (error); 3283fa9e4066Sahrens } 3284fa9e4066Sahrens 328599653d4eSeschrock /* 3286fa94a07fSbrendan * Validate that the auxiliary device array is well formed. We must have an 3287fa94a07fSbrendan * array of nvlists, each which describes a valid leaf vdev. If this is an 3288fa94a07fSbrendan * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be 3289fa94a07fSbrendan * specified, as long as they are well-formed. 329099653d4eSeschrock */ 329199653d4eSeschrock static int 3292fa94a07fSbrendan spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode, 3293fa94a07fSbrendan spa_aux_vdev_t *sav, const char *config, uint64_t version, 3294fa94a07fSbrendan vdev_labeltype_t label) 329599653d4eSeschrock { 3296fa94a07fSbrendan nvlist_t **dev; 3297fa94a07fSbrendan uint_t i, ndev; 329899653d4eSeschrock vdev_t *vd; 329999653d4eSeschrock int error; 330099653d4eSeschrock 3301e14bb325SJeff Bonwick ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 3302e14bb325SJeff Bonwick 330399653d4eSeschrock /* 3304fa94a07fSbrendan * It's acceptable to have no devs specified. 330599653d4eSeschrock */ 3306fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0) 330799653d4eSeschrock return (0); 330899653d4eSeschrock 3309fa94a07fSbrendan if (ndev == 0) 3310be6fd75aSMatthew Ahrens return (SET_ERROR(EINVAL)); 331199653d4eSeschrock 331299653d4eSeschrock /* 3313fa94a07fSbrendan * Make sure the pool is formatted with a version that supports this 3314fa94a07fSbrendan * device type. 331599653d4eSeschrock */ 3316fa94a07fSbrendan if (spa_version(spa) < version) 3317be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTSUP)); 331899653d4eSeschrock 331939c23413Seschrock /* 3320fa94a07fSbrendan * Set the pending device list so we correctly handle device in-use 332139c23413Seschrock * checking. 332239c23413Seschrock */ 3323fa94a07fSbrendan sav->sav_pending = dev; 3324fa94a07fSbrendan sav->sav_npending = ndev; 332539c23413Seschrock 3326fa94a07fSbrendan for (i = 0; i < ndev; i++) { 3327fa94a07fSbrendan if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0, 332899653d4eSeschrock mode)) != 0) 332939c23413Seschrock goto out; 333099653d4eSeschrock 333199653d4eSeschrock if (!vd->vdev_ops->vdev_op_leaf) { 333299653d4eSeschrock vdev_free(vd); 3333be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 333439c23413Seschrock goto out; 333599653d4eSeschrock } 333699653d4eSeschrock 3337fa94a07fSbrendan /* 3338e14bb325SJeff Bonwick * The L2ARC currently only supports disk devices in 3339e14bb325SJeff Bonwick * kernel context. For user-level testing, we allow it. 3340fa94a07fSbrendan */ 3341e14bb325SJeff Bonwick #ifdef _KERNEL 3342fa94a07fSbrendan if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) && 3343fa94a07fSbrendan strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) { 3344be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTBLK); 3345cd0837ccSGeorge Wilson vdev_free(vd); 3346fa94a07fSbrendan goto out; 3347fa94a07fSbrendan } 3348e14bb325SJeff Bonwick #endif 334999653d4eSeschrock vd->vdev_top = vd; 335099653d4eSeschrock 335139c23413Seschrock if ((error = vdev_open(vd)) == 0 && 3352fa94a07fSbrendan (error = vdev_label_init(vd, crtxg, label)) == 0) { 3353fa94a07fSbrendan VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID, 335439c23413Seschrock vd->vdev_guid) == 0); 335539c23413Seschrock } 335699653d4eSeschrock 335799653d4eSeschrock vdev_free(vd); 335839c23413Seschrock 3359fa94a07fSbrendan if (error && 3360fa94a07fSbrendan (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE)) 336139c23413Seschrock goto out; 336239c23413Seschrock else 336339c23413Seschrock error = 0; 336499653d4eSeschrock } 336599653d4eSeschrock 336639c23413Seschrock out: 3367fa94a07fSbrendan sav->sav_pending = NULL; 3368fa94a07fSbrendan sav->sav_npending = 0; 336939c23413Seschrock return (error); 337099653d4eSeschrock } 337199653d4eSeschrock 3372fa94a07fSbrendan static int 3373fa94a07fSbrendan spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode) 3374fa94a07fSbrendan { 3375fa94a07fSbrendan int error; 3376fa94a07fSbrendan 3377e14bb325SJeff Bonwick ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 3378e14bb325SJeff Bonwick 3379fa94a07fSbrendan if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode, 3380fa94a07fSbrendan &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES, 3381fa94a07fSbrendan VDEV_LABEL_SPARE)) != 0) { 3382fa94a07fSbrendan return (error); 3383fa94a07fSbrendan } 3384fa94a07fSbrendan 3385fa94a07fSbrendan return (spa_validate_aux_devs(spa, nvroot, crtxg, mode, 3386fa94a07fSbrendan &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE, 3387fa94a07fSbrendan VDEV_LABEL_L2CACHE)); 3388fa94a07fSbrendan } 3389fa94a07fSbrendan 3390fa94a07fSbrendan static void 3391fa94a07fSbrendan spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs, 3392fa94a07fSbrendan const char *config) 3393fa94a07fSbrendan { 3394fa94a07fSbrendan int i; 3395fa94a07fSbrendan 3396fa94a07fSbrendan if (sav->sav_config != NULL) { 3397fa94a07fSbrendan nvlist_t **olddevs; 3398fa94a07fSbrendan uint_t oldndevs; 3399fa94a07fSbrendan nvlist_t **newdevs; 3400fa94a07fSbrendan 3401fa94a07fSbrendan /* 3402fa94a07fSbrendan * Generate new dev list by concatentating with the 3403fa94a07fSbrendan * current dev list. 3404fa94a07fSbrendan */ 3405fa94a07fSbrendan VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config, 3406fa94a07fSbrendan &olddevs, &oldndevs) == 0); 3407fa94a07fSbrendan 3408fa94a07fSbrendan newdevs = kmem_alloc(sizeof (void *) * 3409fa94a07fSbrendan (ndevs + oldndevs), KM_SLEEP); 3410fa94a07fSbrendan for (i = 0; i < oldndevs; i++) 3411fa94a07fSbrendan VERIFY(nvlist_dup(olddevs[i], &newdevs[i], 3412fa94a07fSbrendan KM_SLEEP) == 0); 3413fa94a07fSbrendan for (i = 0; i < ndevs; i++) 3414fa94a07fSbrendan VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs], 3415fa94a07fSbrendan KM_SLEEP) == 0); 3416fa94a07fSbrendan 3417fa94a07fSbrendan VERIFY(nvlist_remove(sav->sav_config, config, 3418fa94a07fSbrendan DATA_TYPE_NVLIST_ARRAY) == 0); 3419fa94a07fSbrendan 3420fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(sav->sav_config, 3421fa94a07fSbrendan config, newdevs, ndevs + oldndevs) == 0); 3422fa94a07fSbrendan for (i = 0; i < oldndevs + ndevs; i++) 3423fa94a07fSbrendan nvlist_free(newdevs[i]); 3424fa94a07fSbrendan kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *)); 3425fa94a07fSbrendan } else { 3426fa94a07fSbrendan /* 3427fa94a07fSbrendan * Generate a new dev list. 3428fa94a07fSbrendan */ 3429fa94a07fSbrendan VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME, 3430fa94a07fSbrendan KM_SLEEP) == 0); 3431fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(sav->sav_config, config, 3432fa94a07fSbrendan devs, ndevs) == 0); 3433fa94a07fSbrendan } 3434fa94a07fSbrendan } 3435fa94a07fSbrendan 3436fa94a07fSbrendan /* 3437fa94a07fSbrendan * Stop and drop level 2 ARC devices 3438fa94a07fSbrendan */ 3439fa94a07fSbrendan void 3440fa94a07fSbrendan spa_l2cache_drop(spa_t *spa) 3441fa94a07fSbrendan { 3442fa94a07fSbrendan vdev_t *vd; 3443fa94a07fSbrendan int i; 3444fa94a07fSbrendan spa_aux_vdev_t *sav = &spa->spa_l2cache; 3445fa94a07fSbrendan 3446fa94a07fSbrendan for (i = 0; i < sav->sav_count; i++) { 3447fa94a07fSbrendan uint64_t pool; 3448fa94a07fSbrendan 3449fa94a07fSbrendan vd = sav->sav_vdevs[i]; 3450fa94a07fSbrendan ASSERT(vd != NULL); 3451fa94a07fSbrendan 34528ad4d6ddSJeff Bonwick if (spa_l2cache_exists(vd->vdev_guid, &pool) && 34538ad4d6ddSJeff Bonwick pool != 0ULL && l2arc_vdev_present(vd)) 3454fa94a07fSbrendan l2arc_remove_vdev(vd); 3455fa94a07fSbrendan } 3456fa94a07fSbrendan } 3457fa94a07fSbrendan 3458fa9e4066Sahrens /* 3459fa9e4066Sahrens * Pool Creation 3460fa9e4066Sahrens */ 3461fa9e4066Sahrens int 3462990b4856Slling spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props, 34634445fffbSMatthew Ahrens nvlist_t *zplprops) 3464fa9e4066Sahrens { 3465fa9e4066Sahrens spa_t *spa; 3466990b4856Slling char *altroot = NULL; 34670373e76bSbonwick vdev_t *rvd; 3468fa9e4066Sahrens dsl_pool_t *dp; 3469fa9e4066Sahrens dmu_tx_t *tx; 3470573ca77eSGeorge Wilson int error = 0; 3471fa9e4066Sahrens uint64_t txg = TXG_INITIAL; 3472fa94a07fSbrendan nvlist_t **spares, **l2cache; 3473fa94a07fSbrendan uint_t nspares, nl2cache; 3474cde58dbcSMatthew Ahrens uint64_t version, obj; 3475ad135b5dSChristopher Siden boolean_t has_features; 3476fa9e4066Sahrens 3477fa9e4066Sahrens /* 3478fa9e4066Sahrens * If this pool already exists, return failure. 3479fa9e4066Sahrens */ 3480fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 3481fa9e4066Sahrens if (spa_lookup(pool) != NULL) { 3482fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 3483be6fd75aSMatthew Ahrens return (SET_ERROR(EEXIST)); 3484fa9e4066Sahrens } 3485fa9e4066Sahrens 3486fa9e4066Sahrens /* 3487fa9e4066Sahrens * Allocate a new spa_t structure. 3488fa9e4066Sahrens */ 3489990b4856Slling (void) nvlist_lookup_string(props, 3490990b4856Slling zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 3491468c413aSTim Haley spa = spa_add(pool, NULL, altroot); 34928ad4d6ddSJeff Bonwick spa_activate(spa, spa_mode_global); 3493fa9e4066Sahrens 3494990b4856Slling if (props && (error = spa_prop_validate(spa, props))) { 3495990b4856Slling spa_deactivate(spa); 3496990b4856Slling spa_remove(spa); 3497c5904d13Seschrock mutex_exit(&spa_namespace_lock); 3498990b4856Slling return (error); 3499990b4856Slling } 3500990b4856Slling 3501ad135b5dSChristopher Siden has_features = B_FALSE; 3502ad135b5dSChristopher Siden for (nvpair_t *elem = nvlist_next_nvpair(props, NULL); 3503ad135b5dSChristopher Siden elem != NULL; elem = nvlist_next_nvpair(props, elem)) { 3504ad135b5dSChristopher Siden if (zpool_prop_feature(nvpair_name(elem))) 3505ad135b5dSChristopher Siden has_features = B_TRUE; 3506ad135b5dSChristopher Siden } 3507ad135b5dSChristopher Siden 3508ad135b5dSChristopher Siden if (has_features || nvlist_lookup_uint64(props, 3509ad135b5dSChristopher Siden zpool_prop_to_name(ZPOOL_PROP_VERSION), &version) != 0) { 3510990b4856Slling version = SPA_VERSION; 3511ad135b5dSChristopher Siden } 3512ad135b5dSChristopher Siden ASSERT(SPA_VERSION_IS_SUPPORTED(version)); 3513b24ab676SJeff Bonwick 3514b24ab676SJeff Bonwick spa->spa_first_txg = txg; 3515b24ab676SJeff Bonwick spa->spa_uberblock.ub_txg = txg - 1; 3516990b4856Slling spa->spa_uberblock.ub_version = version; 3517fa9e4066Sahrens spa->spa_ubsync = spa->spa_uberblock; 3518fa9e4066Sahrens 351954d692b7SGeorge Wilson /* 352054d692b7SGeorge Wilson * Create "The Godfather" zio to hold all async IOs 352154d692b7SGeorge Wilson */ 35226f834bc1SMatthew Ahrens spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *), 35236f834bc1SMatthew Ahrens KM_SLEEP); 35246f834bc1SMatthew Ahrens for (int i = 0; i < max_ncpus; i++) { 35256f834bc1SMatthew Ahrens spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL, 35266f834bc1SMatthew Ahrens ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | 35276f834bc1SMatthew Ahrens ZIO_FLAG_GODFATHER); 35286f834bc1SMatthew Ahrens } 352954d692b7SGeorge Wilson 35300373e76bSbonwick /* 35310373e76bSbonwick * Create the root vdev. 35320373e76bSbonwick */ 3533e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 35340373e76bSbonwick 353599653d4eSeschrock error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD); 35360373e76bSbonwick 353799653d4eSeschrock ASSERT(error != 0 || rvd != NULL); 353899653d4eSeschrock ASSERT(error != 0 || spa->spa_root_vdev == rvd); 35390373e76bSbonwick 3540b7b97454Sperrin if (error == 0 && !zfs_allocatable_devs(nvroot)) 3541be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 354299653d4eSeschrock 354399653d4eSeschrock if (error == 0 && 354499653d4eSeschrock (error = vdev_create(rvd, txg, B_FALSE)) == 0 && 3545fa94a07fSbrendan (error = spa_validate_aux(spa, nvroot, txg, 354699653d4eSeschrock VDEV_ALLOC_ADD)) == 0) { 3547573ca77eSGeorge Wilson for (int c = 0; c < rvd->vdev_children; c++) { 3548573ca77eSGeorge Wilson vdev_metaslab_set_size(rvd->vdev_child[c]); 3549573ca77eSGeorge Wilson vdev_expand(rvd->vdev_child[c], txg); 3550573ca77eSGeorge Wilson } 35510373e76bSbonwick } 35520373e76bSbonwick 3553e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 3554fa9e4066Sahrens 355599653d4eSeschrock if (error != 0) { 3556fa9e4066Sahrens spa_unload(spa); 3557fa9e4066Sahrens spa_deactivate(spa); 3558fa9e4066Sahrens spa_remove(spa); 3559fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 3560fa9e4066Sahrens return (error); 3561fa9e4066Sahrens } 3562fa9e4066Sahrens 356399653d4eSeschrock /* 356499653d4eSeschrock * Get the list of spares, if specified. 356599653d4eSeschrock */ 356699653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 356799653d4eSeschrock &spares, &nspares) == 0) { 3568fa94a07fSbrendan VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME, 356999653d4eSeschrock KM_SLEEP) == 0); 3570fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 357199653d4eSeschrock ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 3572e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 357399653d4eSeschrock spa_load_spares(spa); 3574e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 3575fa94a07fSbrendan spa->spa_spares.sav_sync = B_TRUE; 3576fa94a07fSbrendan } 3577fa94a07fSbrendan 3578fa94a07fSbrendan /* 3579fa94a07fSbrendan * Get the list of level 2 cache devices, if specified. 3580fa94a07fSbrendan */ 3581fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 3582fa94a07fSbrendan &l2cache, &nl2cache) == 0) { 3583fa94a07fSbrendan VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, 3584fa94a07fSbrendan NV_UNIQUE_NAME, KM_SLEEP) == 0); 3585fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 3586fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 3587e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3588fa94a07fSbrendan spa_load_l2cache(spa); 3589e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 3590fa94a07fSbrendan spa->spa_l2cache.sav_sync = B_TRUE; 359199653d4eSeschrock } 359299653d4eSeschrock 3593ad135b5dSChristopher Siden spa->spa_is_initializing = B_TRUE; 35940a48a24eStimh spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg); 3595fa9e4066Sahrens spa->spa_meta_objset = dp->dp_meta_objset; 3596ad135b5dSChristopher Siden spa->spa_is_initializing = B_FALSE; 3597fa9e4066Sahrens 3598485bbbf5SGeorge Wilson /* 3599485bbbf5SGeorge Wilson * Create DDTs (dedup tables). 3600485bbbf5SGeorge Wilson */ 3601485bbbf5SGeorge Wilson ddt_create(spa); 3602485bbbf5SGeorge Wilson 3603485bbbf5SGeorge Wilson spa_update_dspace(spa); 3604485bbbf5SGeorge Wilson 3605fa9e4066Sahrens tx = dmu_tx_create_assigned(dp, txg); 3606fa9e4066Sahrens 3607fa9e4066Sahrens /* 3608fa9e4066Sahrens * Create the pool config object. 3609fa9e4066Sahrens */ 3610fa9e4066Sahrens spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset, 3611f7991ba4STim Haley DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE, 3612fa9e4066Sahrens DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx); 3613fa9e4066Sahrens 3614ea8dc4b6Seschrock if (zap_add(spa->spa_meta_objset, 3615fa9e4066Sahrens DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, 3616ea8dc4b6Seschrock sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) { 3617ea8dc4b6Seschrock cmn_err(CE_PANIC, "failed to add pool config"); 3618ea8dc4b6Seschrock } 3619fa9e4066Sahrens 3620ad135b5dSChristopher Siden if (spa_version(spa) >= SPA_VERSION_FEATURES) 3621ad135b5dSChristopher Siden spa_feature_create_zap_objects(spa, tx); 3622ad135b5dSChristopher Siden 36233f9d6ad7SLin Ling if (zap_add(spa->spa_meta_objset, 36243f9d6ad7SLin Ling DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CREATION_VERSION, 36253f9d6ad7SLin Ling sizeof (uint64_t), 1, &version, tx) != 0) { 36263f9d6ad7SLin Ling cmn_err(CE_PANIC, "failed to add pool version"); 36273f9d6ad7SLin Ling } 36283f9d6ad7SLin Ling 3629990b4856Slling /* Newly created pools with the right version are always deflated. */ 3630990b4856Slling if (version >= SPA_VERSION_RAIDZ_DEFLATE) { 3631990b4856Slling spa->spa_deflate = TRUE; 3632990b4856Slling if (zap_add(spa->spa_meta_objset, 3633990b4856Slling DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 3634990b4856Slling sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) { 3635990b4856Slling cmn_err(CE_PANIC, "failed to add deflate"); 3636990b4856Slling } 363799653d4eSeschrock } 363899653d4eSeschrock 3639fa9e4066Sahrens /* 3640cde58dbcSMatthew Ahrens * Create the deferred-free bpobj. Turn off compression 3641fa9e4066Sahrens * because sync-to-convergence takes longer if the blocksize 3642fa9e4066Sahrens * keeps changing. 3643fa9e4066Sahrens */ 3644cde58dbcSMatthew Ahrens obj = bpobj_alloc(spa->spa_meta_objset, 1 << 14, tx); 3645cde58dbcSMatthew Ahrens dmu_object_set_compress(spa->spa_meta_objset, obj, 3646cde58dbcSMatthew Ahrens ZIO_COMPRESS_OFF, tx); 3647ea8dc4b6Seschrock if (zap_add(spa->spa_meta_objset, 3648cde58dbcSMatthew Ahrens DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPOBJ, 3649cde58dbcSMatthew Ahrens sizeof (uint64_t), 1, &obj, tx) != 0) { 3650cde58dbcSMatthew Ahrens cmn_err(CE_PANIC, "failed to add bpobj"); 3651ea8dc4b6Seschrock } 3652b420f3adSRichard Lowe VERIFY3U(0, ==, bpobj_open(&spa->spa_deferred_bpobj, 3653cde58dbcSMatthew Ahrens spa->spa_meta_objset, obj)); 3654fa9e4066Sahrens 365506eeb2adSek /* 365606eeb2adSek * Create the pool's history object. 365706eeb2adSek */ 3658990b4856Slling if (version >= SPA_VERSION_ZPOOL_HISTORY) 3659990b4856Slling spa_history_create_obj(spa, tx); 3660990b4856Slling 3661990b4856Slling /* 3662990b4856Slling * Set pool properties. 3663990b4856Slling */ 3664990b4856Slling spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS); 3665990b4856Slling spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 36660a4e9518Sgw spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE); 3667573ca77eSGeorge Wilson spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND); 3668b24ab676SJeff Bonwick 3669379c004dSEric Schrock if (props != NULL) { 3670379c004dSEric Schrock spa_configfile_set(spa, props, B_FALSE); 36713b2aab18SMatthew Ahrens spa_sync_props(props, tx); 3672379c004dSEric Schrock } 367306eeb2adSek 3674fa9e4066Sahrens dmu_tx_commit(tx); 3675fa9e4066Sahrens 3676fa9e4066Sahrens spa->spa_sync_on = B_TRUE; 3677fa9e4066Sahrens txg_sync_start(spa->spa_dsl_pool); 3678fa9e4066Sahrens 3679fa9e4066Sahrens /* 3680fa9e4066Sahrens * We explicitly wait for the first transaction to complete so that our 3681fa9e4066Sahrens * bean counters are appropriately updated. 3682fa9e4066Sahrens */ 3683fa9e4066Sahrens txg_wait_synced(spa->spa_dsl_pool, txg); 3684fa9e4066Sahrens 3685c5904d13Seschrock spa_config_sync(spa, B_FALSE, B_TRUE); 3686fa9e4066Sahrens 36874445fffbSMatthew Ahrens spa_history_log_version(spa, "create"); 3688228975ccSek 3689*bc9014e6SJustin Gibbs /* 3690*bc9014e6SJustin Gibbs * Don't count references from objsets that are already closed 3691*bc9014e6SJustin Gibbs * and are making their way through the eviction process. 3692*bc9014e6SJustin Gibbs */ 3693*bc9014e6SJustin Gibbs spa_evicting_os_wait(spa); 3694088f3894Sahrens spa->spa_minref = refcount_count(&spa->spa_refcount); 3695088f3894Sahrens 3696daaa36a7SGeorge Wilson mutex_exit(&spa_namespace_lock); 3697daaa36a7SGeorge Wilson 3698fa9e4066Sahrens return (0); 3699fa9e4066Sahrens } 3700fa9e4066Sahrens 3701e7cbe64fSgw #ifdef _KERNEL 3702e7cbe64fSgw /* 370321ecdf64SLin Ling * Get the root pool information from the root disk, then import the root pool 370421ecdf64SLin Ling * during the system boot up time. 3705e7cbe64fSgw */ 370621ecdf64SLin Ling extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **); 370721ecdf64SLin Ling 370821ecdf64SLin Ling static nvlist_t * 370921ecdf64SLin Ling spa_generate_rootconf(char *devpath, char *devid, uint64_t *guid) 3710e7cbe64fSgw { 371121ecdf64SLin Ling nvlist_t *config; 3712e7cbe64fSgw nvlist_t *nvtop, *nvroot; 3713e7cbe64fSgw uint64_t pgid; 3714e7cbe64fSgw 371521ecdf64SLin Ling if (vdev_disk_read_rootlabel(devpath, devid, &config) != 0) 371621ecdf64SLin Ling return (NULL); 371721ecdf64SLin Ling 3718e7cbe64fSgw /* 3719e7cbe64fSgw * Add this top-level vdev to the child array. 3720e7cbe64fSgw */ 372121ecdf64SLin Ling VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 372221ecdf64SLin Ling &nvtop) == 0); 372321ecdf64SLin Ling VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 372421ecdf64SLin Ling &pgid) == 0); 372521ecdf64SLin Ling VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, guid) == 0); 3726e7cbe64fSgw 3727e7cbe64fSgw /* 3728e7cbe64fSgw * Put this pool's top-level vdevs into a root vdev. 3729e7cbe64fSgw */ 3730e7cbe64fSgw VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); 373121ecdf64SLin Ling VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, 373221ecdf64SLin Ling VDEV_TYPE_ROOT) == 0); 3733e7cbe64fSgw VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0); 3734e7cbe64fSgw VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0); 3735e7cbe64fSgw VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 3736e7cbe64fSgw &nvtop, 1) == 0); 3737e7cbe64fSgw 3738e7cbe64fSgw /* 3739e7cbe64fSgw * Replace the existing vdev_tree with the new root vdev in 3740e7cbe64fSgw * this pool's configuration (remove the old, add the new). 3741e7cbe64fSgw */ 3742e7cbe64fSgw VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0); 3743e7cbe64fSgw nvlist_free(nvroot); 374421ecdf64SLin Ling return (config); 3745e7cbe64fSgw } 3746e7cbe64fSgw 3747e7cbe64fSgw /* 374821ecdf64SLin Ling * Walk the vdev tree and see if we can find a device with "better" 374921ecdf64SLin Ling * configuration. A configuration is "better" if the label on that 375021ecdf64SLin Ling * device has a more recent txg. 3751051aabe6Staylor */ 375221ecdf64SLin Ling static void 375321ecdf64SLin Ling spa_alt_rootvdev(vdev_t *vd, vdev_t **avd, uint64_t *txg) 3754051aabe6Staylor { 3755573ca77eSGeorge Wilson for (int c = 0; c < vd->vdev_children; c++) 375621ecdf64SLin Ling spa_alt_rootvdev(vd->vdev_child[c], avd, txg); 3757051aabe6Staylor 375821ecdf64SLin Ling if (vd->vdev_ops->vdev_op_leaf) { 375921ecdf64SLin Ling nvlist_t *label; 376021ecdf64SLin Ling uint64_t label_txg; 3761051aabe6Staylor 376221ecdf64SLin Ling if (vdev_disk_read_rootlabel(vd->vdev_physpath, vd->vdev_devid, 376321ecdf64SLin Ling &label) != 0) 376421ecdf64SLin Ling return; 3765051aabe6Staylor 376621ecdf64SLin Ling VERIFY(nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG, 376721ecdf64SLin Ling &label_txg) == 0); 3768051aabe6Staylor 376921ecdf64SLin Ling /* 377021ecdf64SLin Ling * Do we have a better boot device? 377121ecdf64SLin Ling */ 377221ecdf64SLin Ling if (label_txg > *txg) { 377321ecdf64SLin Ling *txg = label_txg; 377421ecdf64SLin Ling *avd = vd; 3775051aabe6Staylor } 377621ecdf64SLin Ling nvlist_free(label); 3777051aabe6Staylor } 3778051aabe6Staylor } 3779051aabe6Staylor 3780e7cbe64fSgw /* 3781e7cbe64fSgw * Import a root pool. 3782e7cbe64fSgw * 3783051aabe6Staylor * For x86. devpath_list will consist of devid and/or physpath name of 3784051aabe6Staylor * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a"). 3785051aabe6Staylor * The GRUB "findroot" command will return the vdev we should boot. 3786e7cbe64fSgw * 3787e7cbe64fSgw * For Sparc, devpath_list consists the physpath name of the booting device 3788e7cbe64fSgw * no matter the rootpool is a single device pool or a mirrored pool. 3789e7cbe64fSgw * e.g. 3790e7cbe64fSgw * "/pci@1f,0/ide@d/disk@0,0:a" 3791e7cbe64fSgw */ 3792e7cbe64fSgw int 3793051aabe6Staylor spa_import_rootpool(char *devpath, char *devid) 3794e7cbe64fSgw { 379521ecdf64SLin Ling spa_t *spa; 379621ecdf64SLin Ling vdev_t *rvd, *bvd, *avd = NULL; 379721ecdf64SLin Ling nvlist_t *config, *nvtop; 379821ecdf64SLin Ling uint64_t guid, txg; 3799e7cbe64fSgw char *pname; 3800e7cbe64fSgw int error; 3801e7cbe64fSgw 3802e7cbe64fSgw /* 380321ecdf64SLin Ling * Read the label from the boot device and generate a configuration. 3804e7cbe64fSgw */ 3805dedec472SJack Meng config = spa_generate_rootconf(devpath, devid, &guid); 3806dedec472SJack Meng #if defined(_OBP) && defined(_KERNEL) 3807dedec472SJack Meng if (config == NULL) { 3808dedec472SJack Meng if (strstr(devpath, "/iscsi/ssd") != NULL) { 3809dedec472SJack Meng /* iscsi boot */ 3810dedec472SJack Meng get_iscsi_bootpath_phy(devpath); 3811dedec472SJack Meng config = spa_generate_rootconf(devpath, devid, &guid); 3812dedec472SJack Meng } 3813dedec472SJack Meng } 3814dedec472SJack Meng #endif 3815dedec472SJack Meng if (config == NULL) { 3816ad135b5dSChristopher Siden cmn_err(CE_NOTE, "Cannot read the pool label from '%s'", 381721ecdf64SLin Ling devpath); 3818be6fd75aSMatthew Ahrens return (SET_ERROR(EIO)); 381921ecdf64SLin Ling } 3820e7cbe64fSgw 382121ecdf64SLin Ling VERIFY(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 382221ecdf64SLin Ling &pname) == 0); 382321ecdf64SLin Ling VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0); 3824e7cbe64fSgw 38256809eb4eSEric Schrock mutex_enter(&spa_namespace_lock); 38266809eb4eSEric Schrock if ((spa = spa_lookup(pname)) != NULL) { 38276809eb4eSEric Schrock /* 38286809eb4eSEric Schrock * Remove the existing root pool from the namespace so that we 38296809eb4eSEric Schrock * can replace it with the correct config we just read in. 38306809eb4eSEric Schrock */ 38316809eb4eSEric Schrock spa_remove(spa); 38326809eb4eSEric Schrock } 38336809eb4eSEric Schrock 3834468c413aSTim Haley spa = spa_add(pname, config, NULL); 38356809eb4eSEric Schrock spa->spa_is_root = B_TRUE; 38364b964adaSGeorge Wilson spa->spa_import_flags = ZFS_IMPORT_VERBATIM; 3837e7cbe64fSgw 383821ecdf64SLin Ling /* 383921ecdf64SLin Ling * Build up a vdev tree based on the boot device's label config. 384021ecdf64SLin Ling */ 384121ecdf64SLin Ling VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 384221ecdf64SLin Ling &nvtop) == 0); 384321ecdf64SLin Ling spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 384421ecdf64SLin Ling error = spa_config_parse(spa, &rvd, nvtop, NULL, 0, 384521ecdf64SLin Ling VDEV_ALLOC_ROOTPOOL); 384621ecdf64SLin Ling spa_config_exit(spa, SCL_ALL, FTAG); 384721ecdf64SLin Ling if (error) { 384821ecdf64SLin Ling mutex_exit(&spa_namespace_lock); 384921ecdf64SLin Ling nvlist_free(config); 385021ecdf64SLin Ling cmn_err(CE_NOTE, "Can not parse the config for pool '%s'", 385121ecdf64SLin Ling pname); 385221ecdf64SLin Ling return (error); 385321ecdf64SLin Ling } 385421ecdf64SLin Ling 385521ecdf64SLin Ling /* 385621ecdf64SLin Ling * Get the boot vdev. 385721ecdf64SLin Ling */ 385821ecdf64SLin Ling if ((bvd = vdev_lookup_by_guid(rvd, guid)) == NULL) { 385921ecdf64SLin Ling cmn_err(CE_NOTE, "Can not find the boot vdev for guid %llu", 386021ecdf64SLin Ling (u_longlong_t)guid); 3861be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT); 386221ecdf64SLin Ling goto out; 386321ecdf64SLin Ling } 3864e7cbe64fSgw 386521ecdf64SLin Ling /* 386621ecdf64SLin Ling * Determine if there is a better boot device. 386721ecdf64SLin Ling */ 386821ecdf64SLin Ling avd = bvd; 386921ecdf64SLin Ling spa_alt_rootvdev(rvd, &avd, &txg); 387021ecdf64SLin Ling if (avd != bvd) { 387121ecdf64SLin Ling cmn_err(CE_NOTE, "The boot device is 'degraded'. Please " 387221ecdf64SLin Ling "try booting from '%s'", avd->vdev_path); 3873be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 387421ecdf64SLin Ling goto out; 387521ecdf64SLin Ling } 3876e7cbe64fSgw 387721ecdf64SLin Ling /* 387821ecdf64SLin Ling * If the boot device is part of a spare vdev then ensure that 387921ecdf64SLin Ling * we're booting off the active spare. 388021ecdf64SLin Ling */ 388121ecdf64SLin Ling if (bvd->vdev_parent->vdev_ops == &vdev_spare_ops && 388221ecdf64SLin Ling !bvd->vdev_isspare) { 388321ecdf64SLin Ling cmn_err(CE_NOTE, "The boot device is currently spared. Please " 388421ecdf64SLin Ling "try booting from '%s'", 3885cb04b873SMark J Musante bvd->vdev_parent-> 3886cb04b873SMark J Musante vdev_child[bvd->vdev_parent->vdev_children - 1]->vdev_path); 3887be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 388821ecdf64SLin Ling goto out; 388921ecdf64SLin Ling } 389021ecdf64SLin Ling 389121ecdf64SLin Ling error = 0; 389221ecdf64SLin Ling out: 389321ecdf64SLin Ling spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 389421ecdf64SLin Ling vdev_free(rvd); 389521ecdf64SLin Ling spa_config_exit(spa, SCL_ALL, FTAG); 389621ecdf64SLin Ling mutex_exit(&spa_namespace_lock); 389721ecdf64SLin Ling 389821ecdf64SLin Ling nvlist_free(config); 3899e7cbe64fSgw return (error); 3900e7cbe64fSgw } 390121ecdf64SLin Ling 3902e7cbe64fSgw #endif 3903e7cbe64fSgw 39046809eb4eSEric Schrock /* 39056809eb4eSEric Schrock * Import a non-root pool into the system. 39066809eb4eSEric Schrock */ 3907c5904d13Seschrock int 39084b964adaSGeorge Wilson spa_import(const char *pool, nvlist_t *config, nvlist_t *props, uint64_t flags) 3909c5904d13Seschrock { 39106809eb4eSEric Schrock spa_t *spa; 39116809eb4eSEric Schrock char *altroot = NULL; 3912468c413aSTim Haley spa_load_state_t state = SPA_LOAD_IMPORT; 3913468c413aSTim Haley zpool_rewind_policy_t policy; 3914f9af39baSGeorge Wilson uint64_t mode = spa_mode_global; 3915f9af39baSGeorge Wilson uint64_t readonly = B_FALSE; 39166809eb4eSEric Schrock int error; 39176809eb4eSEric Schrock nvlist_t *nvroot; 39186809eb4eSEric Schrock nvlist_t **spares, **l2cache; 39196809eb4eSEric Schrock uint_t nspares, nl2cache; 39206809eb4eSEric Schrock 39216809eb4eSEric Schrock /* 39226809eb4eSEric Schrock * If a pool with this name exists, return failure. 39236809eb4eSEric Schrock */ 39246809eb4eSEric Schrock mutex_enter(&spa_namespace_lock); 39251195e687SMark J Musante if (spa_lookup(pool) != NULL) { 39266809eb4eSEric Schrock mutex_exit(&spa_namespace_lock); 3927be6fd75aSMatthew Ahrens return (SET_ERROR(EEXIST)); 39286809eb4eSEric Schrock } 39296809eb4eSEric Schrock 39306809eb4eSEric Schrock /* 39316809eb4eSEric Schrock * Create and initialize the spa structure. 39326809eb4eSEric Schrock */ 39336809eb4eSEric Schrock (void) nvlist_lookup_string(props, 39346809eb4eSEric Schrock zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 3935f9af39baSGeorge Wilson (void) nvlist_lookup_uint64(props, 3936f9af39baSGeorge Wilson zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly); 3937f9af39baSGeorge Wilson if (readonly) 3938f9af39baSGeorge Wilson mode = FREAD; 3939468c413aSTim Haley spa = spa_add(pool, config, altroot); 39404b964adaSGeorge Wilson spa->spa_import_flags = flags; 39414b964adaSGeorge Wilson 39424b964adaSGeorge Wilson /* 39434b964adaSGeorge Wilson * Verbatim import - Take a pool and insert it into the namespace 39444b964adaSGeorge Wilson * as if it had been loaded at boot. 39454b964adaSGeorge Wilson */ 39464b964adaSGeorge Wilson if (spa->spa_import_flags & ZFS_IMPORT_VERBATIM) { 39474b964adaSGeorge Wilson if (props != NULL) 39484b964adaSGeorge Wilson spa_configfile_set(spa, props, B_FALSE); 39494b964adaSGeorge Wilson 39504b964adaSGeorge Wilson spa_config_sync(spa, B_FALSE, B_TRUE); 39514b964adaSGeorge Wilson 39524b964adaSGeorge Wilson mutex_exit(&spa_namespace_lock); 39534b964adaSGeorge Wilson return (0); 39544b964adaSGeorge Wilson } 39554b964adaSGeorge Wilson 3956f9af39baSGeorge Wilson spa_activate(spa, mode); 39576809eb4eSEric Schrock 395825f89ee2SJeff Bonwick /* 395925f89ee2SJeff Bonwick * Don't start async tasks until we know everything is healthy. 396025f89ee2SJeff Bonwick */ 396125f89ee2SJeff Bonwick spa_async_suspend(spa); 396225f89ee2SJeff Bonwick 39634b964adaSGeorge Wilson zpool_get_rewind_policy(config, &policy); 39644b964adaSGeorge Wilson if (policy.zrp_request & ZPOOL_DO_REWIND) 39654b964adaSGeorge Wilson state = SPA_LOAD_RECOVER; 39664b964adaSGeorge Wilson 39676809eb4eSEric Schrock /* 39686809eb4eSEric Schrock * Pass off the heavy lifting to spa_load(). Pass TRUE for mosconfig 39696809eb4eSEric Schrock * because the user-supplied config is actually the one to trust when 39706809eb4eSEric Schrock * doing an import. 39716809eb4eSEric Schrock */ 3972468c413aSTim Haley if (state != SPA_LOAD_RECOVER) 3973468c413aSTim Haley spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 39744b964adaSGeorge Wilson 3975468c413aSTim Haley error = spa_load_best(spa, state, B_TRUE, policy.zrp_txg, 3976c8ee1847SVictor Latushkin policy.zrp_request); 3977468c413aSTim Haley 3978468c413aSTim Haley /* 39794b964adaSGeorge Wilson * Propagate anything learned while loading the pool and pass it 39804b964adaSGeorge Wilson * back to caller (i.e. rewind info, missing devices, etc). 3981468c413aSTim Haley */ 39824b964adaSGeorge Wilson VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, 39834b964adaSGeorge Wilson spa->spa_load_info) == 0); 39846809eb4eSEric Schrock 39856809eb4eSEric Schrock spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 39866809eb4eSEric Schrock /* 39876809eb4eSEric Schrock * Toss any existing sparelist, as it doesn't have any validity 39886809eb4eSEric Schrock * anymore, and conflicts with spa_has_spare(). 39896809eb4eSEric Schrock */ 39906809eb4eSEric Schrock if (spa->spa_spares.sav_config) { 39916809eb4eSEric Schrock nvlist_free(spa->spa_spares.sav_config); 39926809eb4eSEric Schrock spa->spa_spares.sav_config = NULL; 39936809eb4eSEric Schrock spa_load_spares(spa); 39946809eb4eSEric Schrock } 39956809eb4eSEric Schrock if (spa->spa_l2cache.sav_config) { 39966809eb4eSEric Schrock nvlist_free(spa->spa_l2cache.sav_config); 39976809eb4eSEric Schrock spa->spa_l2cache.sav_config = NULL; 39986809eb4eSEric Schrock spa_load_l2cache(spa); 39996809eb4eSEric Schrock } 40006809eb4eSEric Schrock 40016809eb4eSEric Schrock VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 40026809eb4eSEric Schrock &nvroot) == 0); 40036809eb4eSEric Schrock if (error == 0) 40046809eb4eSEric Schrock error = spa_validate_aux(spa, nvroot, -1ULL, 40056809eb4eSEric Schrock VDEV_ALLOC_SPARE); 40066809eb4eSEric Schrock if (error == 0) 40076809eb4eSEric Schrock error = spa_validate_aux(spa, nvroot, -1ULL, 40086809eb4eSEric Schrock VDEV_ALLOC_L2CACHE); 40096809eb4eSEric Schrock spa_config_exit(spa, SCL_ALL, FTAG); 40106809eb4eSEric Schrock 40116809eb4eSEric Schrock if (props != NULL) 40126809eb4eSEric Schrock spa_configfile_set(spa, props, B_FALSE); 40136809eb4eSEric Schrock 40146809eb4eSEric Schrock if (error != 0 || (props && spa_writeable(spa) && 40156809eb4eSEric Schrock (error = spa_prop_set(spa, props)))) { 40166809eb4eSEric Schrock spa_unload(spa); 40176809eb4eSEric Schrock spa_deactivate(spa); 40186809eb4eSEric Schrock spa_remove(spa); 40196809eb4eSEric Schrock mutex_exit(&spa_namespace_lock); 40206809eb4eSEric Schrock return (error); 40216809eb4eSEric Schrock } 40226809eb4eSEric Schrock 4023955ef359SLin Ling spa_async_resume(spa); 4024955ef359SLin Ling 40256809eb4eSEric Schrock /* 40266809eb4eSEric Schrock * Override any spares and level 2 cache devices as specified by 40276809eb4eSEric Schrock * the user, as these may have correct device names/devids, etc. 40286809eb4eSEric Schrock */ 40296809eb4eSEric Schrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 40306809eb4eSEric Schrock &spares, &nspares) == 0) { 40316809eb4eSEric Schrock if (spa->spa_spares.sav_config) 40326809eb4eSEric Schrock VERIFY(nvlist_remove(spa->spa_spares.sav_config, 40336809eb4eSEric Schrock ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0); 40346809eb4eSEric Schrock else 40356809eb4eSEric Schrock VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, 40366809eb4eSEric Schrock NV_UNIQUE_NAME, KM_SLEEP) == 0); 40376809eb4eSEric Schrock VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, 40386809eb4eSEric Schrock ZPOOL_CONFIG_SPARES, spares, nspares) == 0); 40396809eb4eSEric Schrock spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 40406809eb4eSEric Schrock spa_load_spares(spa); 40416809eb4eSEric Schrock spa_config_exit(spa, SCL_ALL, FTAG); 40426809eb4eSEric Schrock spa->spa_spares.sav_sync = B_TRUE; 40436809eb4eSEric Schrock } 40446809eb4eSEric Schrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 40456809eb4eSEric Schrock &l2cache, &nl2cache) == 0) { 40466809eb4eSEric Schrock if (spa->spa_l2cache.sav_config) 40476809eb4eSEric Schrock VERIFY(nvlist_remove(spa->spa_l2cache.sav_config, 40486809eb4eSEric Schrock ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0); 40496809eb4eSEric Schrock else 40506809eb4eSEric Schrock VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, 40516809eb4eSEric Schrock NV_UNIQUE_NAME, KM_SLEEP) == 0); 40526809eb4eSEric Schrock VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 40536809eb4eSEric Schrock ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); 40546809eb4eSEric Schrock spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 40556809eb4eSEric Schrock spa_load_l2cache(spa); 40566809eb4eSEric Schrock spa_config_exit(spa, SCL_ALL, FTAG); 40576809eb4eSEric Schrock spa->spa_l2cache.sav_sync = B_TRUE; 40586809eb4eSEric Schrock } 40596809eb4eSEric Schrock 4060b693757aSEric Schrock /* 4061b693757aSEric Schrock * Check for any removed devices. 4062b693757aSEric Schrock */ 4063b693757aSEric Schrock if (spa->spa_autoreplace) { 4064b693757aSEric Schrock spa_aux_check_removed(&spa->spa_spares); 4065b693757aSEric Schrock spa_aux_check_removed(&spa->spa_l2cache); 4066b693757aSEric Schrock } 4067b693757aSEric Schrock 40686809eb4eSEric Schrock if (spa_writeable(spa)) { 40696809eb4eSEric Schrock /* 40706809eb4eSEric Schrock * Update the config cache to include the newly-imported pool. 40716809eb4eSEric Schrock */ 4072bc758434SLin Ling spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 40736809eb4eSEric Schrock } 40746809eb4eSEric Schrock 4075573ca77eSGeorge Wilson /* 4076573ca77eSGeorge Wilson * It's possible that the pool was expanded while it was exported. 4077573ca77eSGeorge Wilson * We kick off an async task to handle this for us. 4078573ca77eSGeorge Wilson */ 4079573ca77eSGeorge Wilson spa_async_request(spa, SPA_ASYNC_AUTOEXPAND); 4080573ca77eSGeorge Wilson 40816809eb4eSEric Schrock mutex_exit(&spa_namespace_lock); 40824445fffbSMatthew Ahrens spa_history_log_version(spa, "import"); 40836809eb4eSEric Schrock 40846809eb4eSEric Schrock return (0); 4085c5904d13Seschrock } 4086c5904d13Seschrock 4087fa9e4066Sahrens nvlist_t * 4088fa9e4066Sahrens spa_tryimport(nvlist_t *tryconfig) 4089fa9e4066Sahrens { 4090fa9e4066Sahrens nvlist_t *config = NULL; 4091fa9e4066Sahrens char *poolname; 4092fa9e4066Sahrens spa_t *spa; 4093fa9e4066Sahrens uint64_t state; 40947b7154beSLin Ling int error; 4095fa9e4066Sahrens 4096fa9e4066Sahrens if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) 4097fa9e4066Sahrens return (NULL); 4098fa9e4066Sahrens 4099fa9e4066Sahrens if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state)) 4100fa9e4066Sahrens return (NULL); 4101fa9e4066Sahrens 4102fa9e4066Sahrens /* 41030373e76bSbonwick * Create and initialize the spa structure. 4104fa9e4066Sahrens */ 41050373e76bSbonwick mutex_enter(&spa_namespace_lock); 4106468c413aSTim Haley spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL); 41078ad4d6ddSJeff Bonwick spa_activate(spa, FREAD); 4108fa9e4066Sahrens 4109fa9e4066Sahrens /* 41100373e76bSbonwick * Pass off the heavy lifting to spa_load(). 4111ecc2d604Sbonwick * Pass TRUE for mosconfig because the user-supplied config 4112ecc2d604Sbonwick * is actually the one to trust when doing an import. 4113fa9e4066Sahrens */ 41141195e687SMark J Musante error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING, B_TRUE); 4115fa9e4066Sahrens 4116fa9e4066Sahrens /* 4117fa9e4066Sahrens * If 'tryconfig' was at least parsable, return the current config. 4118fa9e4066Sahrens */ 4119fa9e4066Sahrens if (spa->spa_root_vdev != NULL) { 4120fa9e4066Sahrens config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 4121fa9e4066Sahrens VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, 4122fa9e4066Sahrens poolname) == 0); 4123fa9e4066Sahrens VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 4124fa9e4066Sahrens state) == 0); 412595173954Sek VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP, 412695173954Sek spa->spa_uberblock.ub_timestamp) == 0); 4127ad135b5dSChristopher Siden VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, 4128ad135b5dSChristopher Siden spa->spa_load_info) == 0); 412999653d4eSeschrock 4130e7cbe64fSgw /* 4131e7cbe64fSgw * If the bootfs property exists on this pool then we 4132e7cbe64fSgw * copy it out so that external consumers can tell which 4133e7cbe64fSgw * pools are bootable. 4134e7cbe64fSgw */ 41357b7154beSLin Ling if ((!error || error == EEXIST) && spa->spa_bootfs) { 4136e7cbe64fSgw char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4137e7cbe64fSgw 4138e7cbe64fSgw /* 4139e7cbe64fSgw * We have to play games with the name since the 4140e7cbe64fSgw * pool was opened as TRYIMPORT_NAME. 4141e7cbe64fSgw */ 4142e14bb325SJeff Bonwick if (dsl_dsobj_to_dsname(spa_name(spa), 4143e7cbe64fSgw spa->spa_bootfs, tmpname) == 0) { 4144e7cbe64fSgw char *cp; 4145e7cbe64fSgw char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4146e7cbe64fSgw 4147e7cbe64fSgw cp = strchr(tmpname, '/'); 4148e7cbe64fSgw if (cp == NULL) { 4149e7cbe64fSgw (void) strlcpy(dsname, tmpname, 4150e7cbe64fSgw MAXPATHLEN); 4151e7cbe64fSgw } else { 4152e7cbe64fSgw (void) snprintf(dsname, MAXPATHLEN, 4153e7cbe64fSgw "%s/%s", poolname, ++cp); 4154e7cbe64fSgw } 4155e7cbe64fSgw VERIFY(nvlist_add_string(config, 4156e7cbe64fSgw ZPOOL_CONFIG_BOOTFS, dsname) == 0); 4157e7cbe64fSgw kmem_free(dsname, MAXPATHLEN); 4158e7cbe64fSgw } 4159e7cbe64fSgw kmem_free(tmpname, MAXPATHLEN); 4160e7cbe64fSgw } 4161e7cbe64fSgw 416299653d4eSeschrock /* 4163fa94a07fSbrendan * Add the list of hot spares and level 2 cache devices. 416499653d4eSeschrock */ 41656809eb4eSEric Schrock spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 416699653d4eSeschrock spa_add_spares(spa, config); 4167fa94a07fSbrendan spa_add_l2cache(spa, config); 41686809eb4eSEric Schrock spa_config_exit(spa, SCL_CONFIG, FTAG); 4169fa9e4066Sahrens } 4170fa9e4066Sahrens 4171fa9e4066Sahrens spa_unload(spa); 4172fa9e4066Sahrens spa_deactivate(spa); 4173fa9e4066Sahrens spa_remove(spa); 4174fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 4175fa9e4066Sahrens 4176fa9e4066Sahrens return (config); 4177fa9e4066Sahrens } 4178fa9e4066Sahrens 4179fa9e4066Sahrens /* 4180fa9e4066Sahrens * Pool export/destroy 4181fa9e4066Sahrens * 4182fa9e4066Sahrens * The act of destroying or exporting a pool is very simple. We make sure there 4183fa9e4066Sahrens * is no more pending I/O and any references to the pool are gone. Then, we 4184fa9e4066Sahrens * update the pool state and sync all the labels to disk, removing the 4185394ab0cbSGeorge Wilson * configuration from the cache afterwards. If the 'hardforce' flag is set, then 4186394ab0cbSGeorge Wilson * we don't sync the labels or remove the configuration cache. 4187fa9e4066Sahrens */ 4188fa9e4066Sahrens static int 418989a89ebfSlling spa_export_common(char *pool, int new_state, nvlist_t **oldconfig, 4190394ab0cbSGeorge Wilson boolean_t force, boolean_t hardforce) 4191fa9e4066Sahrens { 4192fa9e4066Sahrens spa_t *spa; 4193fa9e4066Sahrens 419444cd46caSbillm if (oldconfig) 419544cd46caSbillm *oldconfig = NULL; 419644cd46caSbillm 41978ad4d6ddSJeff Bonwick if (!(spa_mode_global & FWRITE)) 4198be6fd75aSMatthew Ahrens return (SET_ERROR(EROFS)); 4199fa9e4066Sahrens 4200fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 4201fa9e4066Sahrens if ((spa = spa_lookup(pool)) == NULL) { 4202fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 4203be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 4204fa9e4066Sahrens } 4205fa9e4066Sahrens 4206ea8dc4b6Seschrock /* 4207ea8dc4b6Seschrock * Put a hold on the pool, drop the namespace lock, stop async tasks, 4208ea8dc4b6Seschrock * reacquire the namespace lock, and see if we can export. 4209ea8dc4b6Seschrock */ 4210ea8dc4b6Seschrock spa_open_ref(spa, FTAG); 4211ea8dc4b6Seschrock mutex_exit(&spa_namespace_lock); 4212ea8dc4b6Seschrock spa_async_suspend(spa); 4213ea8dc4b6Seschrock mutex_enter(&spa_namespace_lock); 4214ea8dc4b6Seschrock spa_close(spa, FTAG); 4215ea8dc4b6Seschrock 4216fa9e4066Sahrens /* 4217fa9e4066Sahrens * The pool will be in core if it's openable, 4218fa9e4066Sahrens * in which case we can modify its state. 4219fa9e4066Sahrens */ 4220fa9e4066Sahrens if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) { 4221fa9e4066Sahrens /* 4222fa9e4066Sahrens * Objsets may be open only because they're dirty, so we 4223fa9e4066Sahrens * have to force it to sync before checking spa_refcnt. 4224fa9e4066Sahrens */ 4225fa9e4066Sahrens txg_wait_synced(spa->spa_dsl_pool, 0); 4226*bc9014e6SJustin Gibbs spa_evicting_os_wait(spa); 4227fa9e4066Sahrens 4228ea8dc4b6Seschrock /* 4229ea8dc4b6Seschrock * A pool cannot be exported or destroyed if there are active 4230ea8dc4b6Seschrock * references. If we are resetting a pool, allow references by 4231ea8dc4b6Seschrock * fault injection handlers. 4232ea8dc4b6Seschrock */ 4233ea8dc4b6Seschrock if (!spa_refcount_zero(spa) || 4234ea8dc4b6Seschrock (spa->spa_inject_ref != 0 && 4235ea8dc4b6Seschrock new_state != POOL_STATE_UNINITIALIZED)) { 4236ea8dc4b6Seschrock spa_async_resume(spa); 4237fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 4238be6fd75aSMatthew Ahrens return (SET_ERROR(EBUSY)); 4239fa9e4066Sahrens } 4240fa9e4066Sahrens 424189a89ebfSlling /* 424289a89ebfSlling * A pool cannot be exported if it has an active shared spare. 424389a89ebfSlling * This is to prevent other pools stealing the active spare 424489a89ebfSlling * from an exported pool. At user's own will, such pool can 424589a89ebfSlling * be forcedly exported. 424689a89ebfSlling */ 424789a89ebfSlling if (!force && new_state == POOL_STATE_EXPORTED && 424889a89ebfSlling spa_has_active_shared_spare(spa)) { 424989a89ebfSlling spa_async_resume(spa); 425089a89ebfSlling mutex_exit(&spa_namespace_lock); 4251be6fd75aSMatthew Ahrens return (SET_ERROR(EXDEV)); 425289a89ebfSlling } 425389a89ebfSlling 4254fa9e4066Sahrens /* 4255fa9e4066Sahrens * We want this to be reflected on every label, 4256fa9e4066Sahrens * so mark them all dirty. spa_unload() will do the 4257fa9e4066Sahrens * final sync that pushes these changes out. 4258fa9e4066Sahrens */ 4259394ab0cbSGeorge Wilson if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) { 4260e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4261ea8dc4b6Seschrock spa->spa_state = new_state; 42623f9d6ad7SLin Ling spa->spa_final_txg = spa_last_synced_txg(spa) + 42633f9d6ad7SLin Ling TXG_DEFER_SIZE + 1; 4264ea8dc4b6Seschrock vdev_config_dirty(spa->spa_root_vdev); 4265e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 4266ea8dc4b6Seschrock } 4267fa9e4066Sahrens } 4268fa9e4066Sahrens 42693d7072f8Seschrock spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY); 42703d7072f8Seschrock 4271fa9e4066Sahrens if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 4272fa9e4066Sahrens spa_unload(spa); 4273fa9e4066Sahrens spa_deactivate(spa); 4274fa9e4066Sahrens } 4275fa9e4066Sahrens 427644cd46caSbillm if (oldconfig && spa->spa_config) 427744cd46caSbillm VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0); 427844cd46caSbillm 4279ea8dc4b6Seschrock if (new_state != POOL_STATE_UNINITIALIZED) { 4280394ab0cbSGeorge Wilson if (!hardforce) 4281394ab0cbSGeorge Wilson spa_config_sync(spa, B_TRUE, B_TRUE); 4282ea8dc4b6Seschrock spa_remove(spa); 4283ea8dc4b6Seschrock } 4284fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 4285fa9e4066Sahrens 4286fa9e4066Sahrens return (0); 4287fa9e4066Sahrens } 4288fa9e4066Sahrens 4289fa9e4066Sahrens /* 4290fa9e4066Sahrens * Destroy a storage pool. 4291fa9e4066Sahrens */ 4292fa9e4066Sahrens int 4293fa9e4066Sahrens spa_destroy(char *pool) 4294fa9e4066Sahrens { 4295394ab0cbSGeorge Wilson return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL, 4296394ab0cbSGeorge Wilson B_FALSE, B_FALSE)); 4297fa9e4066Sahrens } 4298fa9e4066Sahrens 4299fa9e4066Sahrens /* 4300fa9e4066Sahrens * Export a storage pool. 4301fa9e4066Sahrens */ 4302fa9e4066Sahrens int 4303394ab0cbSGeorge Wilson spa_export(char *pool, nvlist_t **oldconfig, boolean_t force, 4304394ab0cbSGeorge Wilson boolean_t hardforce) 4305fa9e4066Sahrens { 4306394ab0cbSGeorge Wilson return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig, 4307394ab0cbSGeorge Wilson force, hardforce)); 4308fa9e4066Sahrens } 4309fa9e4066Sahrens 4310ea8dc4b6Seschrock /* 4311ea8dc4b6Seschrock * Similar to spa_export(), this unloads the spa_t without actually removing it 4312ea8dc4b6Seschrock * from the namespace in any way. 4313ea8dc4b6Seschrock */ 4314ea8dc4b6Seschrock int 4315ea8dc4b6Seschrock spa_reset(char *pool) 4316ea8dc4b6Seschrock { 431789a89ebfSlling return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL, 4318394ab0cbSGeorge Wilson B_FALSE, B_FALSE)); 4319ea8dc4b6Seschrock } 4320ea8dc4b6Seschrock 4321fa9e4066Sahrens /* 4322fa9e4066Sahrens * ========================================================================== 4323fa9e4066Sahrens * Device manipulation 4324fa9e4066Sahrens * ========================================================================== 4325fa9e4066Sahrens */ 4326fa9e4066Sahrens 4327fa9e4066Sahrens /* 43288654d025Sperrin * Add a device to a storage pool. 4329fa9e4066Sahrens */ 4330fa9e4066Sahrens int 4331fa9e4066Sahrens spa_vdev_add(spa_t *spa, nvlist_t *nvroot) 4332fa9e4066Sahrens { 433388ecc943SGeorge Wilson uint64_t txg, id; 43348ad4d6ddSJeff Bonwick int error; 4335fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 43360e34b6a7Sbonwick vdev_t *vd, *tvd; 4337fa94a07fSbrendan nvlist_t **spares, **l2cache; 4338fa94a07fSbrendan uint_t nspares, nl2cache; 4339fa9e4066Sahrens 4340f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 4341f9af39baSGeorge Wilson 4342fa9e4066Sahrens txg = spa_vdev_enter(spa); 4343fa9e4066Sahrens 434499653d4eSeschrock if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0, 434599653d4eSeschrock VDEV_ALLOC_ADD)) != 0) 434699653d4eSeschrock return (spa_vdev_exit(spa, NULL, txg, error)); 4347fa9e4066Sahrens 4348e14bb325SJeff Bonwick spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */ 434999653d4eSeschrock 4350fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares, 4351fa94a07fSbrendan &nspares) != 0) 435299653d4eSeschrock nspares = 0; 435399653d4eSeschrock 4354fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache, 4355fa94a07fSbrendan &nl2cache) != 0) 4356fa94a07fSbrendan nl2cache = 0; 4357fa94a07fSbrendan 4358e14bb325SJeff Bonwick if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) 4359fa9e4066Sahrens return (spa_vdev_exit(spa, vd, txg, EINVAL)); 4360fa9e4066Sahrens 4361e14bb325SJeff Bonwick if (vd->vdev_children != 0 && 4362e14bb325SJeff Bonwick (error = vdev_create(vd, txg, B_FALSE)) != 0) 4363e14bb325SJeff Bonwick return (spa_vdev_exit(spa, vd, txg, error)); 436499653d4eSeschrock 436539c23413Seschrock /* 4366fa94a07fSbrendan * We must validate the spares and l2cache devices after checking the 4367fa94a07fSbrendan * children. Otherwise, vdev_inuse() will blindly overwrite the spare. 436839c23413Seschrock */ 4369e14bb325SJeff Bonwick if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) 437039c23413Seschrock return (spa_vdev_exit(spa, vd, txg, error)); 437139c23413Seschrock 437239c23413Seschrock /* 437339c23413Seschrock * Transfer each new top-level vdev from vd to rvd. 437439c23413Seschrock */ 43758ad4d6ddSJeff Bonwick for (int c = 0; c < vd->vdev_children; c++) { 437688ecc943SGeorge Wilson 437788ecc943SGeorge Wilson /* 437888ecc943SGeorge Wilson * Set the vdev id to the first hole, if one exists. 437988ecc943SGeorge Wilson */ 438088ecc943SGeorge Wilson for (id = 0; id < rvd->vdev_children; id++) { 438188ecc943SGeorge Wilson if (rvd->vdev_child[id]->vdev_ishole) { 438288ecc943SGeorge Wilson vdev_free(rvd->vdev_child[id]); 438388ecc943SGeorge Wilson break; 438488ecc943SGeorge Wilson } 438588ecc943SGeorge Wilson } 438639c23413Seschrock tvd = vd->vdev_child[c]; 438739c23413Seschrock vdev_remove_child(vd, tvd); 438888ecc943SGeorge Wilson tvd->vdev_id = id; 438939c23413Seschrock vdev_add_child(rvd, tvd); 439039c23413Seschrock vdev_config_dirty(tvd); 439139c23413Seschrock } 439239c23413Seschrock 439399653d4eSeschrock if (nspares != 0) { 4394fa94a07fSbrendan spa_set_aux_vdevs(&spa->spa_spares, spares, nspares, 4395fa94a07fSbrendan ZPOOL_CONFIG_SPARES); 439699653d4eSeschrock spa_load_spares(spa); 4397fa94a07fSbrendan spa->spa_spares.sav_sync = B_TRUE; 4398fa94a07fSbrendan } 4399fa94a07fSbrendan 4400fa94a07fSbrendan if (nl2cache != 0) { 4401fa94a07fSbrendan spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache, 4402fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE); 4403fa94a07fSbrendan spa_load_l2cache(spa); 4404fa94a07fSbrendan spa->spa_l2cache.sav_sync = B_TRUE; 4405fa9e4066Sahrens } 4406fa9e4066Sahrens 4407fa9e4066Sahrens /* 44080e34b6a7Sbonwick * We have to be careful when adding new vdevs to an existing pool. 44090e34b6a7Sbonwick * If other threads start allocating from these vdevs before we 44100e34b6a7Sbonwick * sync the config cache, and we lose power, then upon reboot we may 44110e34b6a7Sbonwick * fail to open the pool because there are DVAs that the config cache 44120e34b6a7Sbonwick * can't translate. Therefore, we first add the vdevs without 44130e34b6a7Sbonwick * initializing metaslabs; sync the config cache (via spa_vdev_exit()); 44140373e76bSbonwick * and then let spa_config_update() initialize the new metaslabs. 44150e34b6a7Sbonwick * 44160e34b6a7Sbonwick * spa_load() checks for added-but-not-initialized vdevs, so that 44170e34b6a7Sbonwick * if we lose power at any point in this sequence, the remaining 44180e34b6a7Sbonwick * steps will be completed the next time we load the pool. 44190e34b6a7Sbonwick */ 44200373e76bSbonwick (void) spa_vdev_exit(spa, vd, txg, 0); 44210e34b6a7Sbonwick 44220373e76bSbonwick mutex_enter(&spa_namespace_lock); 44230373e76bSbonwick spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 44240373e76bSbonwick mutex_exit(&spa_namespace_lock); 4425fa9e4066Sahrens 44260373e76bSbonwick return (0); 4427fa9e4066Sahrens } 4428fa9e4066Sahrens 4429fa9e4066Sahrens /* 4430fa9e4066Sahrens * Attach a device to a mirror. The arguments are the path to any device 4431fa9e4066Sahrens * in the mirror, and the nvroot for the new device. If the path specifies 4432fa9e4066Sahrens * a device that is not mirrored, we automatically insert the mirror vdev. 4433fa9e4066Sahrens * 4434fa9e4066Sahrens * If 'replacing' is specified, the new device is intended to replace the 4435fa9e4066Sahrens * existing device; in this case the two devices are made into their own 44363d7072f8Seschrock * mirror using the 'replacing' vdev, which is functionally identical to 4437fa9e4066Sahrens * the mirror vdev (it actually reuses all the same ops) but has a few 4438fa9e4066Sahrens * extra rules: you can't attach to it after it's been created, and upon 4439fa9e4066Sahrens * completion of resilvering, the first disk (the one being replaced) 4440fa9e4066Sahrens * is automatically detached. 4441fa9e4066Sahrens */ 4442fa9e4066Sahrens int 4443ea8dc4b6Seschrock spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing) 4444fa9e4066Sahrens { 44453f9d6ad7SLin Ling uint64_t txg, dtl_max_txg; 4446fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 4447fa9e4066Sahrens vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd; 444899653d4eSeschrock vdev_ops_t *pvops; 44499b3f6b42SEric Kustarz char *oldvdpath, *newvdpath; 44509b3f6b42SEric Kustarz int newvd_isspare; 44519b3f6b42SEric Kustarz int error; 4452fa9e4066Sahrens 4453f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 4454f9af39baSGeorge Wilson 4455fa9e4066Sahrens txg = spa_vdev_enter(spa); 4456fa9e4066Sahrens 4457c5904d13Seschrock oldvd = spa_lookup_by_guid(spa, guid, B_FALSE); 4458fa9e4066Sahrens 4459fa9e4066Sahrens if (oldvd == NULL) 4460fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 4461fa9e4066Sahrens 44620e34b6a7Sbonwick if (!oldvd->vdev_ops->vdev_op_leaf) 44630e34b6a7Sbonwick return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 44640e34b6a7Sbonwick 4465fa9e4066Sahrens pvd = oldvd->vdev_parent; 4466fa9e4066Sahrens 446799653d4eSeschrock if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0, 4468cd0837ccSGeorge Wilson VDEV_ALLOC_ATTACH)) != 0) 44693d7072f8Seschrock return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 44703d7072f8Seschrock 44713d7072f8Seschrock if (newrootvd->vdev_children != 1) 4472fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 4473fa9e4066Sahrens 4474fa9e4066Sahrens newvd = newrootvd->vdev_child[0]; 4475fa9e4066Sahrens 4476fa9e4066Sahrens if (!newvd->vdev_ops->vdev_op_leaf) 4477fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 4478fa9e4066Sahrens 447999653d4eSeschrock if ((error = vdev_create(newrootvd, txg, replacing)) != 0) 4480fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, error)); 4481fa9e4066Sahrens 44828654d025Sperrin /* 44838654d025Sperrin * Spares can't replace logs 44848654d025Sperrin */ 4485ee0eb9f2SEric Schrock if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare) 44868654d025Sperrin return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 44878654d025Sperrin 448899653d4eSeschrock if (!replacing) { 448999653d4eSeschrock /* 449099653d4eSeschrock * For attach, the only allowable parent is a mirror or the root 449199653d4eSeschrock * vdev. 449299653d4eSeschrock */ 449399653d4eSeschrock if (pvd->vdev_ops != &vdev_mirror_ops && 449499653d4eSeschrock pvd->vdev_ops != &vdev_root_ops) 449599653d4eSeschrock return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 449699653d4eSeschrock 449799653d4eSeschrock pvops = &vdev_mirror_ops; 449899653d4eSeschrock } else { 449999653d4eSeschrock /* 450099653d4eSeschrock * Active hot spares can only be replaced by inactive hot 450199653d4eSeschrock * spares. 450299653d4eSeschrock */ 450399653d4eSeschrock if (pvd->vdev_ops == &vdev_spare_ops && 4504cb04b873SMark J Musante oldvd->vdev_isspare && 450599653d4eSeschrock !spa_has_spare(spa, newvd->vdev_guid)) 450699653d4eSeschrock return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 450799653d4eSeschrock 450899653d4eSeschrock /* 450999653d4eSeschrock * If the source is a hot spare, and the parent isn't already a 451099653d4eSeschrock * spare, then we want to create a new hot spare. Otherwise, we 451139c23413Seschrock * want to create a replacing vdev. The user is not allowed to 451239c23413Seschrock * attach to a spared vdev child unless the 'isspare' state is 451339c23413Seschrock * the same (spare replaces spare, non-spare replaces 451439c23413Seschrock * non-spare). 451599653d4eSeschrock */ 4516cb04b873SMark J Musante if (pvd->vdev_ops == &vdev_replacing_ops && 4517cb04b873SMark J Musante spa_version(spa) < SPA_VERSION_MULTI_REPLACE) { 451899653d4eSeschrock return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 4519cb04b873SMark J Musante } else if (pvd->vdev_ops == &vdev_spare_ops && 4520cb04b873SMark J Musante newvd->vdev_isspare != oldvd->vdev_isspare) { 452139c23413Seschrock return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 4522cb04b873SMark J Musante } 4523cb04b873SMark J Musante 4524cb04b873SMark J Musante if (newvd->vdev_isspare) 452599653d4eSeschrock pvops = &vdev_spare_ops; 452699653d4eSeschrock else 452799653d4eSeschrock pvops = &vdev_replacing_ops; 452899653d4eSeschrock } 452999653d4eSeschrock 45302a79c5feSlling /* 4531573ca77eSGeorge Wilson * Make sure the new device is big enough. 45322a79c5feSlling */ 4533573ca77eSGeorge Wilson if (newvd->vdev_asize < vdev_get_min_asize(oldvd)) 4534fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW)); 4535fa9e4066Sahrens 4536ecc2d604Sbonwick /* 4537ecc2d604Sbonwick * The new device cannot have a higher alignment requirement 4538ecc2d604Sbonwick * than the top-level vdev. 4539ecc2d604Sbonwick */ 4540ecc2d604Sbonwick if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift) 4541fa9e4066Sahrens return (spa_vdev_exit(spa, newrootvd, txg, EDOM)); 4542fa9e4066Sahrens 4543fa9e4066Sahrens /* 4544fa9e4066Sahrens * If this is an in-place replacement, update oldvd's path and devid 4545fa9e4066Sahrens * to make it distinguishable from newvd, and unopenable from now on. 4546fa9e4066Sahrens */ 4547fa9e4066Sahrens if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) { 4548fa9e4066Sahrens spa_strfree(oldvd->vdev_path); 4549fa9e4066Sahrens oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5, 4550fa9e4066Sahrens KM_SLEEP); 4551fa9e4066Sahrens (void) sprintf(oldvd->vdev_path, "%s/%s", 4552fa9e4066Sahrens newvd->vdev_path, "old"); 4553fa9e4066Sahrens if (oldvd->vdev_devid != NULL) { 4554fa9e4066Sahrens spa_strfree(oldvd->vdev_devid); 4555fa9e4066Sahrens oldvd->vdev_devid = NULL; 4556fa9e4066Sahrens } 4557fa9e4066Sahrens } 4558fa9e4066Sahrens 4559cb04b873SMark J Musante /* mark the device being resilvered */ 4560b4952e17SGeorge Wilson newvd->vdev_resilver_txg = txg; 4561cb04b873SMark J Musante 4562fa9e4066Sahrens /* 456399653d4eSeschrock * If the parent is not a mirror, or if we're replacing, insert the new 456499653d4eSeschrock * mirror/replacing/spare vdev above oldvd. 4565fa9e4066Sahrens */ 4566fa9e4066Sahrens if (pvd->vdev_ops != pvops) 4567fa9e4066Sahrens pvd = vdev_add_parent(oldvd, pvops); 4568fa9e4066Sahrens 4569fa9e4066Sahrens ASSERT(pvd->vdev_top->vdev_parent == rvd); 4570fa9e4066Sahrens ASSERT(pvd->vdev_ops == pvops); 4571fa9e4066Sahrens ASSERT(oldvd->vdev_parent == pvd); 4572fa9e4066Sahrens 4573fa9e4066Sahrens /* 4574fa9e4066Sahrens * Extract the new device from its root and add it to pvd. 4575fa9e4066Sahrens */ 4576fa9e4066Sahrens vdev_remove_child(newrootvd, newvd); 4577fa9e4066Sahrens newvd->vdev_id = pvd->vdev_children; 457888ecc943SGeorge Wilson newvd->vdev_crtxg = oldvd->vdev_crtxg; 4579fa9e4066Sahrens vdev_add_child(pvd, newvd); 4580fa9e4066Sahrens 4581fa9e4066Sahrens tvd = newvd->vdev_top; 4582fa9e4066Sahrens ASSERT(pvd->vdev_top == tvd); 4583fa9e4066Sahrens ASSERT(tvd->vdev_parent == rvd); 4584fa9e4066Sahrens 4585fa9e4066Sahrens vdev_config_dirty(tvd); 4586fa9e4066Sahrens 4587fa9e4066Sahrens /* 45883f9d6ad7SLin Ling * Set newvd's DTL to [TXG_INITIAL, dtl_max_txg) so that we account 45893f9d6ad7SLin Ling * for any dmu_sync-ed blocks. It will propagate upward when 45903f9d6ad7SLin Ling * spa_vdev_exit() calls vdev_dtl_reassess(). 4591fa9e4066Sahrens */ 45923f9d6ad7SLin Ling dtl_max_txg = txg + TXG_CONCURRENT_STATES; 4593fa9e4066Sahrens 45943f9d6ad7SLin Ling vdev_dtl_dirty(newvd, DTL_MISSING, TXG_INITIAL, 45953f9d6ad7SLin Ling dtl_max_txg - TXG_INITIAL); 4596fa9e4066Sahrens 45976809eb4eSEric Schrock if (newvd->vdev_isspare) { 459839c23413Seschrock spa_spare_activate(newvd); 45996809eb4eSEric Schrock spa_event_notify(spa, newvd, ESC_ZFS_VDEV_SPARE); 46006809eb4eSEric Schrock } 46016809eb4eSEric Schrock 4602e14bb325SJeff Bonwick oldvdpath = spa_strdup(oldvd->vdev_path); 4603e14bb325SJeff Bonwick newvdpath = spa_strdup(newvd->vdev_path); 46049b3f6b42SEric Kustarz newvd_isspare = newvd->vdev_isspare; 4605ea8dc4b6Seschrock 4606fa9e4066Sahrens /* 4607fa9e4066Sahrens * Mark newvd's DTL dirty in this txg. 4608fa9e4066Sahrens */ 4609ecc2d604Sbonwick vdev_dirty(tvd, VDD_DTL, newvd, txg); 4610fa9e4066Sahrens 46113f9d6ad7SLin Ling /* 46120713e232SGeorge Wilson * Schedule the resilver to restart in the future. We do this to 46130713e232SGeorge Wilson * ensure that dmu_sync-ed blocks have been stitched into the 46140713e232SGeorge Wilson * respective datasets. 46153f9d6ad7SLin Ling */ 46163f9d6ad7SLin Ling dsl_resilver_restart(spa->spa_dsl_pool, dtl_max_txg); 46173f9d6ad7SLin Ling 46183f9d6ad7SLin Ling /* 46193f9d6ad7SLin Ling * Commit the config 46203f9d6ad7SLin Ling */ 46213f9d6ad7SLin Ling (void) spa_vdev_exit(spa, newrootvd, dtl_max_txg, 0); 4622fa9e4066Sahrens 46234445fffbSMatthew Ahrens spa_history_log_internal(spa, "vdev attach", NULL, 46243f9d6ad7SLin Ling "%s vdev=%s %s vdev=%s", 4625c8e1f6d2SMark J Musante replacing && newvd_isspare ? "spare in" : 4626c8e1f6d2SMark J Musante replacing ? "replace" : "attach", newvdpath, 4627c8e1f6d2SMark J Musante replacing ? "for" : "to", oldvdpath); 46289b3f6b42SEric Kustarz 46299b3f6b42SEric Kustarz spa_strfree(oldvdpath); 46309b3f6b42SEric Kustarz spa_strfree(newvdpath); 46319b3f6b42SEric Kustarz 4632943e9869SLori Alt if (spa->spa_bootfs) 4633943e9869SLori Alt spa_event_notify(spa, newvd, ESC_ZFS_BOOTFS_VDEV_ATTACH); 4634943e9869SLori Alt 4635fa9e4066Sahrens return (0); 4636fa9e4066Sahrens } 4637fa9e4066Sahrens 4638fa9e4066Sahrens /* 4639fa9e4066Sahrens * Detach a device from a mirror or replacing vdev. 4640f7170741SWill Andrews * 4641fa9e4066Sahrens * If 'replace_done' is specified, only detach if the parent 4642fa9e4066Sahrens * is a replacing vdev. 4643fa9e4066Sahrens */ 4644fa9e4066Sahrens int 46458ad4d6ddSJeff Bonwick spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done) 4646fa9e4066Sahrens { 4647fa9e4066Sahrens uint64_t txg; 46488ad4d6ddSJeff Bonwick int error; 4649fa9e4066Sahrens vdev_t *rvd = spa->spa_root_vdev; 4650fa9e4066Sahrens vdev_t *vd, *pvd, *cvd, *tvd; 465199653d4eSeschrock boolean_t unspare = B_FALSE; 4652d5285caeSGeorge Wilson uint64_t unspare_guid = 0; 46531195e687SMark J Musante char *vdpath; 4654fa9e4066Sahrens 4655f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 4656f9af39baSGeorge Wilson 4657fa9e4066Sahrens txg = spa_vdev_enter(spa); 4658fa9e4066Sahrens 4659c5904d13Seschrock vd = spa_lookup_by_guid(spa, guid, B_FALSE); 4660fa9e4066Sahrens 4661fa9e4066Sahrens if (vd == NULL) 4662fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 4663fa9e4066Sahrens 46640e34b6a7Sbonwick if (!vd->vdev_ops->vdev_op_leaf) 46650e34b6a7Sbonwick return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 46660e34b6a7Sbonwick 4667fa9e4066Sahrens pvd = vd->vdev_parent; 4668fa9e4066Sahrens 46698ad4d6ddSJeff Bonwick /* 46708ad4d6ddSJeff Bonwick * If the parent/child relationship is not as expected, don't do it. 46718ad4d6ddSJeff Bonwick * Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing 46728ad4d6ddSJeff Bonwick * vdev that's replacing B with C. The user's intent in replacing 46738ad4d6ddSJeff Bonwick * is to go from M(A,B) to M(A,C). If the user decides to cancel 46748ad4d6ddSJeff Bonwick * the replace by detaching C, the expected behavior is to end up 46758ad4d6ddSJeff Bonwick * M(A,B). But suppose that right after deciding to detach C, 46768ad4d6ddSJeff Bonwick * the replacement of B completes. We would have M(A,C), and then 46778ad4d6ddSJeff Bonwick * ask to detach C, which would leave us with just A -- not what 46788ad4d6ddSJeff Bonwick * the user wanted. To prevent this, we make sure that the 46798ad4d6ddSJeff Bonwick * parent/child relationship hasn't changed -- in this example, 46808ad4d6ddSJeff Bonwick * that C's parent is still the replacing vdev R. 46818ad4d6ddSJeff Bonwick */ 46828ad4d6ddSJeff Bonwick if (pvd->vdev_guid != pguid && pguid != 0) 46838ad4d6ddSJeff Bonwick return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 46848ad4d6ddSJeff Bonwick 4685fa9e4066Sahrens /* 4686cb04b873SMark J Musante * Only 'replacing' or 'spare' vdevs can be replaced. 468799653d4eSeschrock */ 4688cb04b873SMark J Musante if (replace_done && pvd->vdev_ops != &vdev_replacing_ops && 4689cb04b873SMark J Musante pvd->vdev_ops != &vdev_spare_ops) 4690cb04b873SMark J Musante return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 469199653d4eSeschrock 469299653d4eSeschrock ASSERT(pvd->vdev_ops != &vdev_spare_ops || 4693e7437265Sahrens spa_version(spa) >= SPA_VERSION_SPARES); 4694fa9e4066Sahrens 4695fa9e4066Sahrens /* 469699653d4eSeschrock * Only mirror, replacing, and spare vdevs support detach. 4697fa9e4066Sahrens */ 4698fa9e4066Sahrens if (pvd->vdev_ops != &vdev_replacing_ops && 469999653d4eSeschrock pvd->vdev_ops != &vdev_mirror_ops && 470099653d4eSeschrock pvd->vdev_ops != &vdev_spare_ops) 4701fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 4702fa9e4066Sahrens 4703fa9e4066Sahrens /* 47048ad4d6ddSJeff Bonwick * If this device has the only valid copy of some data, 47058ad4d6ddSJeff Bonwick * we cannot safely detach it. 4706fa9e4066Sahrens */ 47078ad4d6ddSJeff Bonwick if (vdev_dtl_required(vd)) 4708fa9e4066Sahrens return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 4709fa9e4066Sahrens 47108ad4d6ddSJeff Bonwick ASSERT(pvd->vdev_children >= 2); 4711fa9e4066Sahrens 4712bf82a41bSeschrock /* 4713bf82a41bSeschrock * If we are detaching the second disk from a replacing vdev, then 4714bf82a41bSeschrock * check to see if we changed the original vdev's path to have "/old" 4715bf82a41bSeschrock * at the end in spa_vdev_attach(). If so, undo that change now. 4716bf82a41bSeschrock */ 4717cb04b873SMark J Musante if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id > 0 && 4718cb04b873SMark J Musante vd->vdev_path != NULL) { 4719cb04b873SMark J Musante size_t len = strlen(vd->vdev_path); 4720cb04b873SMark J Musante 4721cb04b873SMark J Musante for (int c = 0; c < pvd->vdev_children; c++) { 4722cb04b873SMark J Musante cvd = pvd->vdev_child[c]; 4723cb04b873SMark J Musante 4724cb04b873SMark J Musante if (cvd == vd || cvd->vdev_path == NULL) 4725cb04b873SMark J Musante continue; 4726cb04b873SMark J Musante 4727cb04b873SMark J Musante if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 && 4728cb04b873SMark J Musante strcmp(cvd->vdev_path + len, "/old") == 0) { 4729cb04b873SMark J Musante spa_strfree(cvd->vdev_path); 4730cb04b873SMark J Musante cvd->vdev_path = spa_strdup(vd->vdev_path); 4731cb04b873SMark J Musante break; 4732cb04b873SMark J Musante } 4733bf82a41bSeschrock } 4734bf82a41bSeschrock } 4735bf82a41bSeschrock 473699653d4eSeschrock /* 473799653d4eSeschrock * If we are detaching the original disk from a spare, then it implies 473899653d4eSeschrock * that the spare should become a real disk, and be removed from the 473999653d4eSeschrock * active spare list for the pool. 474099653d4eSeschrock */ 474199653d4eSeschrock if (pvd->vdev_ops == &vdev_spare_ops && 4742cb04b873SMark J Musante vd->vdev_id == 0 && 4743cb04b873SMark J Musante pvd->vdev_child[pvd->vdev_children - 1]->vdev_isspare) 474499653d4eSeschrock unspare = B_TRUE; 474599653d4eSeschrock 4746fa9e4066Sahrens /* 4747fa9e4066Sahrens * Erase the disk labels so the disk can be used for other things. 4748fa9e4066Sahrens * This must be done after all other error cases are handled, 4749fa9e4066Sahrens * but before we disembowel vd (so we can still do I/O to it). 4750fa9e4066Sahrens * But if we can't do it, don't treat the error as fatal -- 4751fa9e4066Sahrens * it may be that the unwritability of the disk is the reason 4752fa9e4066Sahrens * it's being detached! 4753fa9e4066Sahrens */ 475439c23413Seschrock error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 4755fa9e4066Sahrens 4756fa9e4066Sahrens /* 4757fa9e4066Sahrens * Remove vd from its parent and compact the parent's children. 4758fa9e4066Sahrens */ 4759fa9e4066Sahrens vdev_remove_child(pvd, vd); 4760fa9e4066Sahrens vdev_compact_children(pvd); 4761fa9e4066Sahrens 4762fa9e4066Sahrens /* 4763fa9e4066Sahrens * Remember one of the remaining children so we can get tvd below. 4764fa9e4066Sahrens */ 4765cb04b873SMark J Musante cvd = pvd->vdev_child[pvd->vdev_children - 1]; 4766fa9e4066Sahrens 476799653d4eSeschrock /* 476899653d4eSeschrock * If we need to remove the remaining child from the list of hot spares, 47698ad4d6ddSJeff Bonwick * do it now, marking the vdev as no longer a spare in the process. 47708ad4d6ddSJeff Bonwick * We must do this before vdev_remove_parent(), because that can 47718ad4d6ddSJeff Bonwick * change the GUID if it creates a new toplevel GUID. For a similar 47728ad4d6ddSJeff Bonwick * reason, we must remove the spare now, in the same txg as the detach; 47738ad4d6ddSJeff Bonwick * otherwise someone could attach a new sibling, change the GUID, and 47748ad4d6ddSJeff Bonwick * the subsequent attempt to spa_vdev_remove(unspare_guid) would fail. 477599653d4eSeschrock */ 477699653d4eSeschrock if (unspare) { 477799653d4eSeschrock ASSERT(cvd->vdev_isspare); 477839c23413Seschrock spa_spare_remove(cvd); 477999653d4eSeschrock unspare_guid = cvd->vdev_guid; 47808ad4d6ddSJeff Bonwick (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); 4781cb04b873SMark J Musante cvd->vdev_unspare = B_TRUE; 478299653d4eSeschrock } 478399653d4eSeschrock 4784fa9e4066Sahrens /* 4785fa9e4066Sahrens * If the parent mirror/replacing vdev only has one child, 4786fa9e4066Sahrens * the parent is no longer needed. Remove it from the tree. 4787fa9e4066Sahrens */ 4788cb04b873SMark J Musante if (pvd->vdev_children == 1) { 4789cb04b873SMark J Musante if (pvd->vdev_ops == &vdev_spare_ops) 4790cb04b873SMark J Musante cvd->vdev_unspare = B_FALSE; 4791fa9e4066Sahrens vdev_remove_parent(cvd); 4792cb04b873SMark J Musante } 4793cb04b873SMark J Musante 4794fa9e4066Sahrens 4795fa9e4066Sahrens /* 4796fa9e4066Sahrens * We don't set tvd until now because the parent we just removed 4797fa9e4066Sahrens * may have been the previous top-level vdev. 4798fa9e4066Sahrens */ 4799fa9e4066Sahrens tvd = cvd->vdev_top; 4800fa9e4066Sahrens ASSERT(tvd->vdev_parent == rvd); 4801fa9e4066Sahrens 4802fa9e4066Sahrens /* 480339c23413Seschrock * Reevaluate the parent vdev state. 4804fa9e4066Sahrens */ 48053d7072f8Seschrock vdev_propagate_state(cvd); 4806fa9e4066Sahrens 4807fa9e4066Sahrens /* 4808573ca77eSGeorge Wilson * If the 'autoexpand' property is set on the pool then automatically 4809573ca77eSGeorge Wilson * try to expand the size of the pool. For example if the device we 4810573ca77eSGeorge Wilson * just detached was smaller than the others, it may be possible to 4811573ca77eSGeorge Wilson * add metaslabs (i.e. grow the pool). We need to reopen the vdev 4812573ca77eSGeorge Wilson * first so that we can obtain the updated sizes of the leaf vdevs. 4813fa9e4066Sahrens */ 4814573ca77eSGeorge Wilson if (spa->spa_autoexpand) { 4815573ca77eSGeorge Wilson vdev_reopen(tvd); 4816573ca77eSGeorge Wilson vdev_expand(tvd, txg); 4817573ca77eSGeorge Wilson } 4818fa9e4066Sahrens 4819fa9e4066Sahrens vdev_config_dirty(tvd); 4820fa9e4066Sahrens 4821fa9e4066Sahrens /* 482239c23413Seschrock * Mark vd's DTL as dirty in this txg. vdev_dtl_sync() will see that 482339c23413Seschrock * vd->vdev_detached is set and free vd's DTL object in syncing context. 482439c23413Seschrock * But first make sure we're not on any *other* txg's DTL list, to 482539c23413Seschrock * prevent vd from being accessed after it's freed. 4826fa9e4066Sahrens */ 48271195e687SMark J Musante vdpath = spa_strdup(vd->vdev_path); 48288ad4d6ddSJeff Bonwick for (int t = 0; t < TXG_SIZE; t++) 4829fa9e4066Sahrens (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t); 4830ecc2d604Sbonwick vd->vdev_detached = B_TRUE; 4831ecc2d604Sbonwick vdev_dirty(tvd, VDD_DTL, vd, txg); 4832fa9e4066Sahrens 48333d7072f8Seschrock spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE); 48343d7072f8Seschrock 4835cb04b873SMark J Musante /* hang on to the spa before we release the lock */ 4836cb04b873SMark J Musante spa_open_ref(spa, FTAG); 4837cb04b873SMark J Musante 483899653d4eSeschrock error = spa_vdev_exit(spa, vd, txg, 0); 483999653d4eSeschrock 48404445fffbSMatthew Ahrens spa_history_log_internal(spa, "detach", NULL, 48411195e687SMark J Musante "vdev=%s", vdpath); 48421195e687SMark J Musante spa_strfree(vdpath); 48431195e687SMark J Musante 484499653d4eSeschrock /* 484539c23413Seschrock * If this was the removal of the original device in a hot spare vdev, 484639c23413Seschrock * then we want to go through and remove the device from the hot spare 484739c23413Seschrock * list of every other pool. 484899653d4eSeschrock */ 484999653d4eSeschrock if (unspare) { 4850cb04b873SMark J Musante spa_t *altspa = NULL; 4851cb04b873SMark J Musante 485299653d4eSeschrock mutex_enter(&spa_namespace_lock); 4853cb04b873SMark J Musante while ((altspa = spa_next(altspa)) != NULL) { 4854cb04b873SMark J Musante if (altspa->spa_state != POOL_STATE_ACTIVE || 4855cb04b873SMark J Musante altspa == spa) 485699653d4eSeschrock continue; 4857cb04b873SMark J Musante 4858cb04b873SMark J Musante spa_open_ref(altspa, FTAG); 48599af0a4dfSJeff Bonwick mutex_exit(&spa_namespace_lock); 4860cb04b873SMark J Musante (void) spa_vdev_remove(altspa, unspare_guid, B_TRUE); 48619af0a4dfSJeff Bonwick mutex_enter(&spa_namespace_lock); 4862cb04b873SMark J Musante spa_close(altspa, FTAG); 486399653d4eSeschrock } 486499653d4eSeschrock mutex_exit(&spa_namespace_lock); 4865cb04b873SMark J Musante 4866cb04b873SMark J Musante /* search the rest of the vdevs for spares to remove */ 4867cb04b873SMark J Musante spa_vdev_resilver_done(spa); 486899653d4eSeschrock } 486999653d4eSeschrock 4870cb04b873SMark J Musante /* all done with the spa; OK to release */ 4871cb04b873SMark J Musante mutex_enter(&spa_namespace_lock); 4872cb04b873SMark J Musante spa_close(spa, FTAG); 4873cb04b873SMark J Musante mutex_exit(&spa_namespace_lock); 4874cb04b873SMark J Musante 487599653d4eSeschrock return (error); 487699653d4eSeschrock } 487799653d4eSeschrock 48781195e687SMark J Musante /* 48791195e687SMark J Musante * Split a set of devices from their mirrors, and create a new pool from them. 48801195e687SMark J Musante */ 48811195e687SMark J Musante int 48821195e687SMark J Musante spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config, 48831195e687SMark J Musante nvlist_t *props, boolean_t exp) 48841195e687SMark J Musante { 48851195e687SMark J Musante int error = 0; 48861195e687SMark J Musante uint64_t txg, *glist; 48871195e687SMark J Musante spa_t *newspa; 48881195e687SMark J Musante uint_t c, children, lastlog; 48891195e687SMark J Musante nvlist_t **child, *nvl, *tmp; 48901195e687SMark J Musante dmu_tx_t *tx; 48911195e687SMark J Musante char *altroot = NULL; 48921195e687SMark J Musante vdev_t *rvd, **vml = NULL; /* vdev modify list */ 48931195e687SMark J Musante boolean_t activate_slog; 48941195e687SMark J Musante 4895f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 48961195e687SMark J Musante 48971195e687SMark J Musante txg = spa_vdev_enter(spa); 48981195e687SMark J Musante 48991195e687SMark J Musante /* clear the log and flush everything up to now */ 49001195e687SMark J Musante activate_slog = spa_passivate_log(spa); 49011195e687SMark J Musante (void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 49021195e687SMark J Musante error = spa_offline_log(spa); 49031195e687SMark J Musante txg = spa_vdev_config_enter(spa); 49041195e687SMark J Musante 49051195e687SMark J Musante if (activate_slog) 49061195e687SMark J Musante spa_activate_log(spa); 49071195e687SMark J Musante 49081195e687SMark J Musante if (error != 0) 49091195e687SMark J Musante return (spa_vdev_exit(spa, NULL, txg, error)); 49101195e687SMark J Musante 49111195e687SMark J Musante /* check new spa name before going any further */ 49121195e687SMark J Musante if (spa_lookup(newname) != NULL) 49131195e687SMark J Musante return (spa_vdev_exit(spa, NULL, txg, EEXIST)); 49141195e687SMark J Musante 49151195e687SMark J Musante /* 49161195e687SMark J Musante * scan through all the children to ensure they're all mirrors 49171195e687SMark J Musante */ 49181195e687SMark J Musante if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 || 49191195e687SMark J Musante nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child, 49201195e687SMark J Musante &children) != 0) 49211195e687SMark J Musante return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 49221195e687SMark J Musante 49231195e687SMark J Musante /* first, check to ensure we've got the right child count */ 49241195e687SMark J Musante rvd = spa->spa_root_vdev; 49251195e687SMark J Musante lastlog = 0; 49261195e687SMark J Musante for (c = 0; c < rvd->vdev_children; c++) { 49271195e687SMark J Musante vdev_t *vd = rvd->vdev_child[c]; 49281195e687SMark J Musante 49291195e687SMark J Musante /* don't count the holes & logs as children */ 49301195e687SMark J Musante if (vd->vdev_islog || vd->vdev_ishole) { 49311195e687SMark J Musante if (lastlog == 0) 49321195e687SMark J Musante lastlog = c; 49331195e687SMark J Musante continue; 49341195e687SMark J Musante } 49351195e687SMark J Musante 49361195e687SMark J Musante lastlog = 0; 49371195e687SMark J Musante } 49381195e687SMark J Musante if (children != (lastlog != 0 ? lastlog : rvd->vdev_children)) 49391195e687SMark J Musante return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 49401195e687SMark J Musante 49411195e687SMark J Musante /* next, ensure no spare or cache devices are part of the split */ 49421195e687SMark J Musante if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 || 49431195e687SMark J Musante nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0) 49441195e687SMark J Musante return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 49451195e687SMark J Musante 49461195e687SMark J Musante vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP); 49471195e687SMark J Musante glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP); 49481195e687SMark J Musante 49491195e687SMark J Musante /* then, loop over each vdev and validate it */ 49501195e687SMark J Musante for (c = 0; c < children; c++) { 49511195e687SMark J Musante uint64_t is_hole = 0; 49521195e687SMark J Musante 49531195e687SMark J Musante (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 49541195e687SMark J Musante &is_hole); 49551195e687SMark J Musante 49561195e687SMark J Musante if (is_hole != 0) { 49571195e687SMark J Musante if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole || 49581195e687SMark J Musante spa->spa_root_vdev->vdev_child[c]->vdev_islog) { 49591195e687SMark J Musante continue; 49601195e687SMark J Musante } else { 4961be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 49621195e687SMark J Musante break; 49631195e687SMark J Musante } 49641195e687SMark J Musante } 49651195e687SMark J Musante 49661195e687SMark J Musante /* which disk is going to be split? */ 49671195e687SMark J Musante if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID, 49681195e687SMark J Musante &glist[c]) != 0) { 4969be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 49701195e687SMark J Musante break; 49711195e687SMark J Musante } 49721195e687SMark J Musante 49731195e687SMark J Musante /* look it up in the spa */ 49741195e687SMark J Musante vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE); 49751195e687SMark J Musante if (vml[c] == NULL) { 4976be6fd75aSMatthew Ahrens error = SET_ERROR(ENODEV); 49771195e687SMark J Musante break; 49781195e687SMark J Musante } 49791195e687SMark J Musante 49801195e687SMark J Musante /* make sure there's nothing stopping the split */ 49811195e687SMark J Musante if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops || 49821195e687SMark J Musante vml[c]->vdev_islog || 49831195e687SMark J Musante vml[c]->vdev_ishole || 49841195e687SMark J Musante vml[c]->vdev_isspare || 49851195e687SMark J Musante vml[c]->vdev_isl2cache || 49861195e687SMark J Musante !vdev_writeable(vml[c]) || 4987d41c4376SMark J Musante vml[c]->vdev_children != 0 || 49881195e687SMark J Musante vml[c]->vdev_state != VDEV_STATE_HEALTHY || 49891195e687SMark J Musante c != spa->spa_root_vdev->vdev_child[c]->vdev_id) { 4990be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 49911195e687SMark J Musante break; 49921195e687SMark J Musante } 49931195e687SMark J Musante 49941195e687SMark J Musante if (vdev_dtl_required(vml[c])) { 4995be6fd75aSMatthew Ahrens error = SET_ERROR(EBUSY); 49961195e687SMark J Musante break; 49971195e687SMark J Musante } 49981195e687SMark J Musante 49991195e687SMark J Musante /* we need certain info from the top level */ 50001195e687SMark J Musante VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY, 50011195e687SMark J Musante vml[c]->vdev_top->vdev_ms_array) == 0); 50021195e687SMark J Musante VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT, 50031195e687SMark J Musante vml[c]->vdev_top->vdev_ms_shift) == 0); 50041195e687SMark J Musante VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE, 50051195e687SMark J Musante vml[c]->vdev_top->vdev_asize) == 0); 50061195e687SMark J Musante VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT, 50071195e687SMark J Musante vml[c]->vdev_top->vdev_ashift) == 0); 50081195e687SMark J Musante } 50091195e687SMark J Musante 50101195e687SMark J Musante if (error != 0) { 50111195e687SMark J Musante kmem_free(vml, children * sizeof (vdev_t *)); 50121195e687SMark J Musante kmem_free(glist, children * sizeof (uint64_t)); 50131195e687SMark J Musante return (spa_vdev_exit(spa, NULL, txg, error)); 50141195e687SMark J Musante } 50151195e687SMark J Musante 50161195e687SMark J Musante /* stop writers from using the disks */ 50171195e687SMark J Musante for (c = 0; c < children; c++) { 50181195e687SMark J Musante if (vml[c] != NULL) 50191195e687SMark J Musante vml[c]->vdev_offline = B_TRUE; 50201195e687SMark J Musante } 50211195e687SMark J Musante vdev_reopen(spa->spa_root_vdev); 50221195e687SMark J Musante 50231195e687SMark J Musante /* 50241195e687SMark J Musante * Temporarily record the splitting vdevs in the spa config. This 50251195e687SMark J Musante * will disappear once the config is regenerated. 50261195e687SMark J Musante */ 50271195e687SMark J Musante VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0); 50281195e687SMark J Musante VERIFY(nvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 50291195e687SMark J Musante glist, children) == 0); 50301195e687SMark J Musante kmem_free(glist, children * sizeof (uint64_t)); 50311195e687SMark J Musante 503298295d61SMark J Musante mutex_enter(&spa->spa_props_lock); 50331195e687SMark J Musante VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT, 50341195e687SMark J Musante nvl) == 0); 503598295d61SMark J Musante mutex_exit(&spa->spa_props_lock); 50361195e687SMark J Musante spa->spa_config_splitting = nvl; 50371195e687SMark J Musante vdev_config_dirty(spa->spa_root_vdev); 50381195e687SMark J Musante 50391195e687SMark J Musante /* configure and create the new pool */ 50401195e687SMark J Musante VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname) == 0); 50411195e687SMark J Musante VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 50421195e687SMark J Musante exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE) == 0); 50431195e687SMark J Musante VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, 50441195e687SMark J Musante spa_version(spa)) == 0); 50451195e687SMark J Musante VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG, 50461195e687SMark J Musante spa->spa_config_txg) == 0); 50471195e687SMark J Musante VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID, 50481195e687SMark J Musante spa_generate_guid(NULL)) == 0); 50491195e687SMark J Musante (void) nvlist_lookup_string(props, 50501195e687SMark J Musante zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 50511195e687SMark J Musante 5052d41c4376SMark J Musante /* add the new pool to the namespace */ 50531195e687SMark J Musante newspa = spa_add(newname, config, altroot); 50541195e687SMark J Musante newspa->spa_config_txg = spa->spa_config_txg; 50551195e687SMark J Musante spa_set_log_state(newspa, SPA_LOG_CLEAR); 50561195e687SMark J Musante 50571195e687SMark J Musante /* release the spa config lock, retaining the namespace lock */ 50581195e687SMark J Musante spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 50591195e687SMark J Musante 50601195e687SMark J Musante if (zio_injection_enabled) 50611195e687SMark J Musante zio_handle_panic_injection(spa, FTAG, 1); 50621195e687SMark J Musante 50631195e687SMark J Musante spa_activate(newspa, spa_mode_global); 50641195e687SMark J Musante spa_async_suspend(newspa); 50651195e687SMark J Musante 50661195e687SMark J Musante /* create the new pool from the disks of the original pool */ 50671195e687SMark J Musante error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE, B_TRUE); 50681195e687SMark J Musante if (error) 50691195e687SMark J Musante goto out; 50701195e687SMark J Musante 50711195e687SMark J Musante /* if that worked, generate a real config for the new pool */ 50721195e687SMark J Musante if (newspa->spa_root_vdev != NULL) { 50731195e687SMark J Musante VERIFY(nvlist_alloc(&newspa->spa_config_splitting, 50741195e687SMark J Musante NV_UNIQUE_NAME, KM_SLEEP) == 0); 50751195e687SMark J Musante VERIFY(nvlist_add_uint64(newspa->spa_config_splitting, 50761195e687SMark J Musante ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0); 50771195e687SMark J Musante spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL, 50781195e687SMark J Musante B_TRUE)); 50791195e687SMark J Musante } 50801195e687SMark J Musante 50811195e687SMark J Musante /* set the props */ 50821195e687SMark J Musante if (props != NULL) { 50831195e687SMark J Musante spa_configfile_set(newspa, props, B_FALSE); 50841195e687SMark J Musante error = spa_prop_set(newspa, props); 50851195e687SMark J Musante if (error) 50861195e687SMark J Musante goto out; 50871195e687SMark J Musante } 50881195e687SMark J Musante 50891195e687SMark J Musante /* flush everything */ 50901195e687SMark J Musante txg = spa_vdev_config_enter(newspa); 50911195e687SMark J Musante vdev_config_dirty(newspa->spa_root_vdev); 50921195e687SMark J Musante (void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG); 50931195e687SMark J Musante 50941195e687SMark J Musante if (zio_injection_enabled) 50951195e687SMark J Musante zio_handle_panic_injection(spa, FTAG, 2); 50961195e687SMark J Musante 50971195e687SMark J Musante spa_async_resume(newspa); 50981195e687SMark J Musante 50991195e687SMark J Musante /* finally, update the original pool's config */ 51001195e687SMark J Musante txg = spa_vdev_config_enter(spa); 51011195e687SMark J Musante tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); 51021195e687SMark J Musante error = dmu_tx_assign(tx, TXG_WAIT); 51031195e687SMark J Musante if (error != 0) 51041195e687SMark J Musante dmu_tx_abort(tx); 51051195e687SMark J Musante for (c = 0; c < children; c++) { 51061195e687SMark J Musante if (vml[c] != NULL) { 51071195e687SMark J Musante vdev_split(vml[c]); 51081195e687SMark J Musante if (error == 0) 51094445fffbSMatthew Ahrens spa_history_log_internal(spa, "detach", tx, 51104445fffbSMatthew Ahrens "vdev=%s", vml[c]->vdev_path); 51111195e687SMark J Musante vdev_free(vml[c]); 51121195e687SMark J Musante } 51131195e687SMark J Musante } 51141195e687SMark J Musante vdev_config_dirty(spa->spa_root_vdev); 51151195e687SMark J Musante spa->spa_config_splitting = NULL; 51161195e687SMark J Musante nvlist_free(nvl); 51171195e687SMark J Musante if (error == 0) 51181195e687SMark J Musante dmu_tx_commit(tx); 51191195e687SMark J Musante (void) spa_vdev_exit(spa, NULL, txg, 0); 51201195e687SMark J Musante 51211195e687SMark J Musante if (zio_injection_enabled) 51221195e687SMark J Musante zio_handle_panic_injection(spa, FTAG, 3); 51231195e687SMark J Musante 51241195e687SMark J Musante /* split is complete; log a history record */ 51254445fffbSMatthew Ahrens spa_history_log_internal(newspa, "split", NULL, 51264445fffbSMatthew Ahrens "from pool %s", spa_name(spa)); 51271195e687SMark J Musante 51281195e687SMark J Musante kmem_free(vml, children * sizeof (vdev_t *)); 51291195e687SMark J Musante 51301195e687SMark J Musante /* if we're not going to mount the filesystems in userland, export */ 51311195e687SMark J Musante if (exp) 51321195e687SMark J Musante error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL, 51331195e687SMark J Musante B_FALSE, B_FALSE); 51341195e687SMark J Musante 51351195e687SMark J Musante return (error); 51361195e687SMark J Musante 51371195e687SMark J Musante out: 51381195e687SMark J Musante spa_unload(newspa); 51391195e687SMark J Musante spa_deactivate(newspa); 51401195e687SMark J Musante spa_remove(newspa); 51411195e687SMark J Musante 51421195e687SMark J Musante txg = spa_vdev_config_enter(spa); 514398295d61SMark J Musante 514498295d61SMark J Musante /* re-online all offlined disks */ 514598295d61SMark J Musante for (c = 0; c < children; c++) { 514698295d61SMark J Musante if (vml[c] != NULL) 514798295d61SMark J Musante vml[c]->vdev_offline = B_FALSE; 514898295d61SMark J Musante } 514998295d61SMark J Musante vdev_reopen(spa->spa_root_vdev); 515098295d61SMark J Musante 51511195e687SMark J Musante nvlist_free(spa->spa_config_splitting); 51521195e687SMark J Musante spa->spa_config_splitting = NULL; 5153d41c4376SMark J Musante (void) spa_vdev_exit(spa, NULL, txg, error); 51541195e687SMark J Musante 51551195e687SMark J Musante kmem_free(vml, children * sizeof (vdev_t *)); 51561195e687SMark J Musante return (error); 51571195e687SMark J Musante } 51581195e687SMark J Musante 5159e14bb325SJeff Bonwick static nvlist_t * 5160e14bb325SJeff Bonwick spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid) 516199653d4eSeschrock { 5162e14bb325SJeff Bonwick for (int i = 0; i < count; i++) { 5163e14bb325SJeff Bonwick uint64_t guid; 516499653d4eSeschrock 5165e14bb325SJeff Bonwick VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID, 5166e14bb325SJeff Bonwick &guid) == 0); 516799653d4eSeschrock 5168e14bb325SJeff Bonwick if (guid == target_guid) 5169e14bb325SJeff Bonwick return (nvpp[i]); 517099653d4eSeschrock } 517199653d4eSeschrock 5172e14bb325SJeff Bonwick return (NULL); 5173fa94a07fSbrendan } 5174fa94a07fSbrendan 5175e14bb325SJeff Bonwick static void 5176e14bb325SJeff Bonwick spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count, 5177e14bb325SJeff Bonwick nvlist_t *dev_to_remove) 5178fa94a07fSbrendan { 5179e14bb325SJeff Bonwick nvlist_t **newdev = NULL; 5180fa94a07fSbrendan 5181e14bb325SJeff Bonwick if (count > 1) 5182e14bb325SJeff Bonwick newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP); 5183fa94a07fSbrendan 5184e14bb325SJeff Bonwick for (int i = 0, j = 0; i < count; i++) { 5185e14bb325SJeff Bonwick if (dev[i] == dev_to_remove) 5186e14bb325SJeff Bonwick continue; 5187e14bb325SJeff Bonwick VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0); 5188fa94a07fSbrendan } 5189fa94a07fSbrendan 5190e14bb325SJeff Bonwick VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0); 5191e14bb325SJeff Bonwick VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0); 5192fa94a07fSbrendan 5193e14bb325SJeff Bonwick for (int i = 0; i < count - 1; i++) 5194e14bb325SJeff Bonwick nvlist_free(newdev[i]); 5195fa94a07fSbrendan 5196e14bb325SJeff Bonwick if (count > 1) 5197e14bb325SJeff Bonwick kmem_free(newdev, (count - 1) * sizeof (void *)); 5198fa94a07fSbrendan } 5199fa94a07fSbrendan 520088ecc943SGeorge Wilson /* 520188ecc943SGeorge Wilson * Evacuate the device. 520288ecc943SGeorge Wilson */ 52033f9d6ad7SLin Ling static int 520488ecc943SGeorge Wilson spa_vdev_remove_evacuate(spa_t *spa, vdev_t *vd) 520588ecc943SGeorge Wilson { 520688ecc943SGeorge Wilson uint64_t txg; 52073f9d6ad7SLin Ling int error = 0; 520888ecc943SGeorge Wilson 520988ecc943SGeorge Wilson ASSERT(MUTEX_HELD(&spa_namespace_lock)); 521088ecc943SGeorge Wilson ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 5211b24ab676SJeff Bonwick ASSERT(vd == vd->vdev_top); 521288ecc943SGeorge Wilson 521388ecc943SGeorge Wilson /* 521488ecc943SGeorge Wilson * Evacuate the device. We don't hold the config lock as writer 521588ecc943SGeorge Wilson * since we need to do I/O but we do keep the 521688ecc943SGeorge Wilson * spa_namespace_lock held. Once this completes the device 521788ecc943SGeorge Wilson * should no longer have any blocks allocated on it. 521888ecc943SGeorge Wilson */ 521988ecc943SGeorge Wilson if (vd->vdev_islog) { 52203f9d6ad7SLin Ling if (vd->vdev_stat.vs_alloc != 0) 52213f9d6ad7SLin Ling error = spa_offline_log(spa); 5222a1521560SJeff Bonwick } else { 5223be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 522488ecc943SGeorge Wilson } 522588ecc943SGeorge Wilson 5226a1521560SJeff Bonwick if (error) 5227a1521560SJeff Bonwick return (error); 5228a1521560SJeff Bonwick 522988ecc943SGeorge Wilson /* 5230a1521560SJeff Bonwick * The evacuation succeeded. Remove any remaining MOS metadata 5231a1521560SJeff Bonwick * associated with this vdev, and wait for these changes to sync. 523288ecc943SGeorge Wilson */ 5233fb09f5aaSMadhav Suresh ASSERT0(vd->vdev_stat.vs_alloc); 523488ecc943SGeorge Wilson txg = spa_vdev_config_enter(spa); 523588ecc943SGeorge Wilson vd->vdev_removing = B_TRUE; 52360713e232SGeorge Wilson vdev_dirty_leaves(vd, VDD_DTL, txg); 523788ecc943SGeorge Wilson vdev_config_dirty(vd); 523888ecc943SGeorge Wilson spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 523988ecc943SGeorge Wilson 524088ecc943SGeorge Wilson return (0); 524188ecc943SGeorge Wilson } 524288ecc943SGeorge Wilson 524388ecc943SGeorge Wilson /* 524488ecc943SGeorge Wilson * Complete the removal by cleaning up the namespace. 524588ecc943SGeorge Wilson */ 52463f9d6ad7SLin Ling static void 5247a1521560SJeff Bonwick spa_vdev_remove_from_namespace(spa_t *spa, vdev_t *vd) 524888ecc943SGeorge Wilson { 524988ecc943SGeorge Wilson vdev_t *rvd = spa->spa_root_vdev; 525088ecc943SGeorge Wilson uint64_t id = vd->vdev_id; 525188ecc943SGeorge Wilson boolean_t last_vdev = (id == (rvd->vdev_children - 1)); 525288ecc943SGeorge Wilson 525388ecc943SGeorge Wilson ASSERT(MUTEX_HELD(&spa_namespace_lock)); 525488ecc943SGeorge Wilson ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 5255b24ab676SJeff Bonwick ASSERT(vd == vd->vdev_top); 525688ecc943SGeorge Wilson 52573f9d6ad7SLin Ling /* 52583f9d6ad7SLin Ling * Only remove any devices which are empty. 52593f9d6ad7SLin Ling */ 52603f9d6ad7SLin Ling if (vd->vdev_stat.vs_alloc != 0) 52613f9d6ad7SLin Ling return; 52623f9d6ad7SLin Ling 526388ecc943SGeorge Wilson (void) vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 5264b24ab676SJeff Bonwick 5265b24ab676SJeff Bonwick if (list_link_active(&vd->vdev_state_dirty_node)) 5266b24ab676SJeff Bonwick vdev_state_clean(vd); 5267b24ab676SJeff Bonwick if (list_link_active(&vd->vdev_config_dirty_node)) 5268b24ab676SJeff Bonwick vdev_config_clean(vd); 5269b24ab676SJeff Bonwick 527088ecc943SGeorge Wilson vdev_free(vd); 527188ecc943SGeorge Wilson 527288ecc943SGeorge Wilson if (last_vdev) { 527388ecc943SGeorge Wilson vdev_compact_children(rvd); 527488ecc943SGeorge Wilson } else { 527588ecc943SGeorge Wilson vd = vdev_alloc_common(spa, id, 0, &vdev_hole_ops); 527688ecc943SGeorge Wilson vdev_add_child(rvd, vd); 527788ecc943SGeorge Wilson } 5278fcbfa62bSLin Ling vdev_config_dirty(rvd); 5279fcbfa62bSLin Ling 5280fcbfa62bSLin Ling /* 5281fcbfa62bSLin Ling * Reassess the health of our root vdev. 5282fcbfa62bSLin Ling */ 5283fcbfa62bSLin Ling vdev_reopen(rvd); 528488ecc943SGeorge Wilson } 528588ecc943SGeorge Wilson 52863f9d6ad7SLin Ling /* 52873f9d6ad7SLin Ling * Remove a device from the pool - 52883f9d6ad7SLin Ling * 52893f9d6ad7SLin Ling * Removing a device from the vdev namespace requires several steps 52903f9d6ad7SLin Ling * and can take a significant amount of time. As a result we use 52913f9d6ad7SLin Ling * the spa_vdev_config_[enter/exit] functions which allow us to 52923f9d6ad7SLin Ling * grab and release the spa_config_lock while still holding the namespace 52933f9d6ad7SLin Ling * lock. During each step the configuration is synced out. 5294f7170741SWill Andrews * 5295f7170741SWill Andrews * Currently, this supports removing only hot spares, slogs, and level 2 ARC 5296f7170741SWill Andrews * devices. 5297fa94a07fSbrendan */ 5298fa94a07fSbrendan int 5299fa94a07fSbrendan spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare) 5300fa94a07fSbrendan { 5301fa94a07fSbrendan vdev_t *vd; 5302a1521560SJeff Bonwick metaslab_group_t *mg; 5303e14bb325SJeff Bonwick nvlist_t **spares, **l2cache, *nv; 53048ad4d6ddSJeff Bonwick uint64_t txg = 0; 530588ecc943SGeorge Wilson uint_t nspares, nl2cache; 5306fa94a07fSbrendan int error = 0; 53078ad4d6ddSJeff Bonwick boolean_t locked = MUTEX_HELD(&spa_namespace_lock); 5308fa94a07fSbrendan 5309f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 5310f9af39baSGeorge Wilson 53118ad4d6ddSJeff Bonwick if (!locked) 53128ad4d6ddSJeff Bonwick txg = spa_vdev_enter(spa); 5313fa94a07fSbrendan 5314c5904d13Seschrock vd = spa_lookup_by_guid(spa, guid, B_FALSE); 5315fa94a07fSbrendan 5316fa94a07fSbrendan if (spa->spa_spares.sav_vdevs != NULL && 5317fa94a07fSbrendan nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 5318e14bb325SJeff Bonwick ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 && 5319e14bb325SJeff Bonwick (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) { 5320e14bb325SJeff Bonwick /* 5321e14bb325SJeff Bonwick * Only remove the hot spare if it's not currently in use 5322e14bb325SJeff Bonwick * in this pool. 5323e14bb325SJeff Bonwick */ 5324e14bb325SJeff Bonwick if (vd == NULL || unspare) { 5325e14bb325SJeff Bonwick spa_vdev_remove_aux(spa->spa_spares.sav_config, 5326e14bb325SJeff Bonwick ZPOOL_CONFIG_SPARES, spares, nspares, nv); 5327e14bb325SJeff Bonwick spa_load_spares(spa); 5328e14bb325SJeff Bonwick spa->spa_spares.sav_sync = B_TRUE; 5329e14bb325SJeff Bonwick } else { 5330be6fd75aSMatthew Ahrens error = SET_ERROR(EBUSY); 5331e14bb325SJeff Bonwick } 5332e14bb325SJeff Bonwick } else if (spa->spa_l2cache.sav_vdevs != NULL && 5333fa94a07fSbrendan nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 5334e14bb325SJeff Bonwick ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 && 5335e14bb325SJeff Bonwick (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) { 5336e14bb325SJeff Bonwick /* 5337e14bb325SJeff Bonwick * Cache devices can always be removed. 5338e14bb325SJeff Bonwick */ 5339e14bb325SJeff Bonwick spa_vdev_remove_aux(spa->spa_l2cache.sav_config, 5340e14bb325SJeff Bonwick ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv); 5341fa94a07fSbrendan spa_load_l2cache(spa); 5342fa94a07fSbrendan spa->spa_l2cache.sav_sync = B_TRUE; 534388ecc943SGeorge Wilson } else if (vd != NULL && vd->vdev_islog) { 534488ecc943SGeorge Wilson ASSERT(!locked); 5345b24ab676SJeff Bonwick ASSERT(vd == vd->vdev_top); 534688ecc943SGeorge Wilson 5347a1521560SJeff Bonwick mg = vd->vdev_mg; 5348a1521560SJeff Bonwick 534988ecc943SGeorge Wilson /* 5350a1521560SJeff Bonwick * Stop allocating from this vdev. 535188ecc943SGeorge Wilson */ 5352a1521560SJeff Bonwick metaslab_group_passivate(mg); 535388ecc943SGeorge Wilson 5354b24ab676SJeff Bonwick /* 5355b24ab676SJeff Bonwick * Wait for the youngest allocations and frees to sync, 5356b24ab676SJeff Bonwick * and then wait for the deferral of those frees to finish. 5357b24ab676SJeff Bonwick */ 5358b24ab676SJeff Bonwick spa_vdev_config_exit(spa, NULL, 5359b24ab676SJeff Bonwick txg + TXG_CONCURRENT_STATES + TXG_DEFER_SIZE, 0, FTAG); 5360b24ab676SJeff Bonwick 5361a1521560SJeff Bonwick /* 5362a1521560SJeff Bonwick * Attempt to evacuate the vdev. 5363a1521560SJeff Bonwick */ 5364a1521560SJeff Bonwick error = spa_vdev_remove_evacuate(spa, vd); 5365a1521560SJeff Bonwick 536688ecc943SGeorge Wilson txg = spa_vdev_config_enter(spa); 536788ecc943SGeorge Wilson 5368a1521560SJeff Bonwick /* 5369a1521560SJeff Bonwick * If we couldn't evacuate the vdev, unwind. 5370a1521560SJeff Bonwick */ 5371a1521560SJeff Bonwick if (error) { 5372a1521560SJeff Bonwick metaslab_group_activate(mg); 5373a1521560SJeff Bonwick return (spa_vdev_exit(spa, NULL, txg, error)); 5374a1521560SJeff Bonwick } 5375a1521560SJeff Bonwick 5376a1521560SJeff Bonwick /* 5377a1521560SJeff Bonwick * Clean up the vdev namespace. 5378a1521560SJeff Bonwick */ 5379a1521560SJeff Bonwick spa_vdev_remove_from_namespace(spa, vd); 538088ecc943SGeorge Wilson 5381e14bb325SJeff Bonwick } else if (vd != NULL) { 5382e14bb325SJeff Bonwick /* 5383e14bb325SJeff Bonwick * Normal vdevs cannot be removed (yet). 5384e14bb325SJeff Bonwick */ 5385be6fd75aSMatthew Ahrens error = SET_ERROR(ENOTSUP); 5386e14bb325SJeff Bonwick } else { 5387e14bb325SJeff Bonwick /* 5388e14bb325SJeff Bonwick * There is no vdev of any kind with the specified guid. 5389e14bb325SJeff Bonwick */ 5390be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT); 5391fa94a07fSbrendan } 539299653d4eSeschrock 53938ad4d6ddSJeff Bonwick if (!locked) 53948ad4d6ddSJeff Bonwick return (spa_vdev_exit(spa, NULL, txg, error)); 53958ad4d6ddSJeff Bonwick 53968ad4d6ddSJeff Bonwick return (error); 5397fa9e4066Sahrens } 5398fa9e4066Sahrens 5399fa9e4066Sahrens /* 54003d7072f8Seschrock * Find any device that's done replacing, or a vdev marked 'unspare' that's 5401f7170741SWill Andrews * currently spared, so we can detach it. 5402fa9e4066Sahrens */ 5403ea8dc4b6Seschrock static vdev_t * 54043d7072f8Seschrock spa_vdev_resilver_done_hunt(vdev_t *vd) 5405fa9e4066Sahrens { 5406ea8dc4b6Seschrock vdev_t *newvd, *oldvd; 5407fa9e4066Sahrens 5408573ca77eSGeorge Wilson for (int c = 0; c < vd->vdev_children; c++) { 54093d7072f8Seschrock oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]); 5410ea8dc4b6Seschrock if (oldvd != NULL) 5411ea8dc4b6Seschrock return (oldvd); 5412ea8dc4b6Seschrock } 5413fa9e4066Sahrens 54143d7072f8Seschrock /* 5415cb04b873SMark J Musante * Check for a completed replacement. We always consider the first 5416cb04b873SMark J Musante * vdev in the list to be the oldest vdev, and the last one to be 5417cb04b873SMark J Musante * the newest (see spa_vdev_attach() for how that works). In 5418cb04b873SMark J Musante * the case where the newest vdev is faulted, we will not automatically 5419cb04b873SMark J Musante * remove it after a resilver completes. This is OK as it will require 5420cb04b873SMark J Musante * user intervention to determine which disk the admin wishes to keep. 54213d7072f8Seschrock */ 5422cb04b873SMark J Musante if (vd->vdev_ops == &vdev_replacing_ops) { 5423cb04b873SMark J Musante ASSERT(vd->vdev_children > 1); 5424cb04b873SMark J Musante 5425cb04b873SMark J Musante newvd = vd->vdev_child[vd->vdev_children - 1]; 5426ea8dc4b6Seschrock oldvd = vd->vdev_child[0]; 5427ea8dc4b6Seschrock 54288ad4d6ddSJeff Bonwick if (vdev_dtl_empty(newvd, DTL_MISSING) && 5429e69acc92SVictor Latushkin vdev_dtl_empty(newvd, DTL_OUTAGE) && 54308ad4d6ddSJeff Bonwick !vdev_dtl_required(oldvd)) 5431ea8dc4b6Seschrock return (oldvd); 5432fa9e4066Sahrens } 5433ea8dc4b6Seschrock 54343d7072f8Seschrock /* 54353d7072f8Seschrock * Check for a completed resilver with the 'unspare' flag set. 54363d7072f8Seschrock */ 5437cb04b873SMark J Musante if (vd->vdev_ops == &vdev_spare_ops) { 5438cb04b873SMark J Musante vdev_t *first = vd->vdev_child[0]; 5439cb04b873SMark J Musante vdev_t *last = vd->vdev_child[vd->vdev_children - 1]; 5440cb04b873SMark J Musante 5441cb04b873SMark J Musante if (last->vdev_unspare) { 5442cb04b873SMark J Musante oldvd = first; 5443cb04b873SMark J Musante newvd = last; 5444cb04b873SMark J Musante } else if (first->vdev_unspare) { 5445cb04b873SMark J Musante oldvd = last; 5446cb04b873SMark J Musante newvd = first; 5447cb04b873SMark J Musante } else { 5448cb04b873SMark J Musante oldvd = NULL; 5449cb04b873SMark J Musante } 54503d7072f8Seschrock 5451cb04b873SMark J Musante if (oldvd != NULL && 54528ad4d6ddSJeff Bonwick vdev_dtl_empty(newvd, DTL_MISSING) && 5453e69acc92SVictor Latushkin vdev_dtl_empty(newvd, DTL_OUTAGE) && 5454cb04b873SMark J Musante !vdev_dtl_required(oldvd)) 54553d7072f8Seschrock return (oldvd); 5456cb04b873SMark J Musante 5457cb04b873SMark J Musante /* 5458cb04b873SMark J Musante * If there are more than two spares attached to a disk, 5459cb04b873SMark J Musante * and those spares are not required, then we want to 5460cb04b873SMark J Musante * attempt to free them up now so that they can be used 5461cb04b873SMark J Musante * by other pools. Once we're back down to a single 5462cb04b873SMark J Musante * disk+spare, we stop removing them. 5463cb04b873SMark J Musante */ 5464cb04b873SMark J Musante if (vd->vdev_children > 2) { 5465cb04b873SMark J Musante newvd = vd->vdev_child[1]; 5466cb04b873SMark J Musante 5467cb04b873SMark J Musante if (newvd->vdev_isspare && last->vdev_isspare && 5468cb04b873SMark J Musante vdev_dtl_empty(last, DTL_MISSING) && 5469cb04b873SMark J Musante vdev_dtl_empty(last, DTL_OUTAGE) && 5470cb04b873SMark J Musante !vdev_dtl_required(newvd)) 5471cb04b873SMark J Musante return (newvd); 54723d7072f8Seschrock } 54733d7072f8Seschrock } 54743d7072f8Seschrock 5475ea8dc4b6Seschrock return (NULL); 5476fa9e4066Sahrens } 5477fa9e4066Sahrens 5478ea8dc4b6Seschrock static void 54793d7072f8Seschrock spa_vdev_resilver_done(spa_t *spa) 5480fa9e4066Sahrens { 54818ad4d6ddSJeff Bonwick vdev_t *vd, *pvd, *ppvd; 54828ad4d6ddSJeff Bonwick uint64_t guid, sguid, pguid, ppguid; 5483ea8dc4b6Seschrock 54848ad4d6ddSJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 5485ea8dc4b6Seschrock 54863d7072f8Seschrock while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) { 54878ad4d6ddSJeff Bonwick pvd = vd->vdev_parent; 54888ad4d6ddSJeff Bonwick ppvd = pvd->vdev_parent; 5489ea8dc4b6Seschrock guid = vd->vdev_guid; 54908ad4d6ddSJeff Bonwick pguid = pvd->vdev_guid; 54918ad4d6ddSJeff Bonwick ppguid = ppvd->vdev_guid; 54928ad4d6ddSJeff Bonwick sguid = 0; 549399653d4eSeschrock /* 549499653d4eSeschrock * If we have just finished replacing a hot spared device, then 549599653d4eSeschrock * we need to detach the parent's first child (the original hot 549699653d4eSeschrock * spare) as well. 549799653d4eSeschrock */ 5498cb04b873SMark J Musante if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0 && 5499cb04b873SMark J Musante ppvd->vdev_children == 2) { 550099653d4eSeschrock ASSERT(pvd->vdev_ops == &vdev_replacing_ops); 55018ad4d6ddSJeff Bonwick sguid = ppvd->vdev_child[1]->vdev_guid; 550299653d4eSeschrock } 5503b4952e17SGeorge Wilson ASSERT(vd->vdev_resilver_txg == 0 || !vdev_dtl_required(vd)); 5504b4952e17SGeorge Wilson 55058ad4d6ddSJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 55068ad4d6ddSJeff Bonwick if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0) 5507ea8dc4b6Seschrock return; 55088ad4d6ddSJeff Bonwick if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0) 550999653d4eSeschrock return; 55108ad4d6ddSJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 5511fa9e4066Sahrens } 5512fa9e4066Sahrens 55138ad4d6ddSJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 5514fa9e4066Sahrens } 5515fa9e4066Sahrens 5516c67d9675Seschrock /* 5517b3388e4fSEric Taylor * Update the stored path or FRU for this vdev. 5518c67d9675Seschrock */ 5519c67d9675Seschrock int 55206809eb4eSEric Schrock spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value, 55216809eb4eSEric Schrock boolean_t ispath) 5522c67d9675Seschrock { 5523c5904d13Seschrock vdev_t *vd; 5524208044b8SGeorge Wilson boolean_t sync = B_FALSE; 5525c67d9675Seschrock 5526f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 5527f9af39baSGeorge Wilson 5528b3388e4fSEric Taylor spa_vdev_state_enter(spa, SCL_ALL); 5529c67d9675Seschrock 55306809eb4eSEric Schrock if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 5531b3388e4fSEric Taylor return (spa_vdev_state_exit(spa, NULL, ENOENT)); 5532c67d9675Seschrock 55330e34b6a7Sbonwick if (!vd->vdev_ops->vdev_op_leaf) 5534b3388e4fSEric Taylor return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 55350e34b6a7Sbonwick 55366809eb4eSEric Schrock if (ispath) { 5537208044b8SGeorge Wilson if (strcmp(value, vd->vdev_path) != 0) { 5538208044b8SGeorge Wilson spa_strfree(vd->vdev_path); 5539208044b8SGeorge Wilson vd->vdev_path = spa_strdup(value); 5540208044b8SGeorge Wilson sync = B_TRUE; 5541208044b8SGeorge Wilson } 55426809eb4eSEric Schrock } else { 5543208044b8SGeorge Wilson if (vd->vdev_fru == NULL) { 5544208044b8SGeorge Wilson vd->vdev_fru = spa_strdup(value); 5545208044b8SGeorge Wilson sync = B_TRUE; 5546208044b8SGeorge Wilson } else if (strcmp(value, vd->vdev_fru) != 0) { 55476809eb4eSEric Schrock spa_strfree(vd->vdev_fru); 5548208044b8SGeorge Wilson vd->vdev_fru = spa_strdup(value); 5549208044b8SGeorge Wilson sync = B_TRUE; 5550208044b8SGeorge Wilson } 55516809eb4eSEric Schrock } 5552c67d9675Seschrock 5553208044b8SGeorge Wilson return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0)); 5554c67d9675Seschrock } 5555c67d9675Seschrock 55566809eb4eSEric Schrock int 55576809eb4eSEric Schrock spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath) 55586809eb4eSEric Schrock { 55596809eb4eSEric Schrock return (spa_vdev_set_common(spa, guid, newpath, B_TRUE)); 55606809eb4eSEric Schrock } 55616809eb4eSEric Schrock 55626809eb4eSEric Schrock int 55636809eb4eSEric Schrock spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru) 55646809eb4eSEric Schrock { 55656809eb4eSEric Schrock return (spa_vdev_set_common(spa, guid, newfru, B_FALSE)); 55666809eb4eSEric Schrock } 55676809eb4eSEric Schrock 5568fa9e4066Sahrens /* 5569fa9e4066Sahrens * ========================================================================== 55703f9d6ad7SLin Ling * SPA Scanning 5571fa9e4066Sahrens * ========================================================================== 5572fa9e4066Sahrens */ 5573fa9e4066Sahrens 5574ea8dc4b6Seschrock int 55753f9d6ad7SLin Ling spa_scan_stop(spa_t *spa) 5576fa9e4066Sahrens { 5577e14bb325SJeff Bonwick ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 55783f9d6ad7SLin Ling if (dsl_scan_resilvering(spa->spa_dsl_pool)) 5579be6fd75aSMatthew Ahrens return (SET_ERROR(EBUSY)); 55803f9d6ad7SLin Ling return (dsl_scan_cancel(spa->spa_dsl_pool)); 55813f9d6ad7SLin Ling } 5582bb8b5132Sek 55833f9d6ad7SLin Ling int 55843f9d6ad7SLin Ling spa_scan(spa_t *spa, pool_scan_func_t func) 55853f9d6ad7SLin Ling { 55863f9d6ad7SLin Ling ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 55873f9d6ad7SLin Ling 55883f9d6ad7SLin Ling if (func >= POOL_SCAN_FUNCS || func == POOL_SCAN_NONE) 5589be6fd75aSMatthew Ahrens return (SET_ERROR(ENOTSUP)); 5590fa9e4066Sahrens 5591fa9e4066Sahrens /* 5592088f3894Sahrens * If a resilver was requested, but there is no DTL on a 5593088f3894Sahrens * writeable leaf device, we have nothing to do. 5594fa9e4066Sahrens */ 55953f9d6ad7SLin Ling if (func == POOL_SCAN_RESILVER && 5596088f3894Sahrens !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) { 5597088f3894Sahrens spa_async_request(spa, SPA_ASYNC_RESILVER_DONE); 5598ea8dc4b6Seschrock return (0); 5599ea8dc4b6Seschrock } 5600fa9e4066Sahrens 56013f9d6ad7SLin Ling return (dsl_scan(spa->spa_dsl_pool, func)); 5602fa9e4066Sahrens } 5603fa9e4066Sahrens 5604ea8dc4b6Seschrock /* 5605ea8dc4b6Seschrock * ========================================================================== 5606ea8dc4b6Seschrock * SPA async task processing 5607ea8dc4b6Seschrock * ========================================================================== 5608ea8dc4b6Seschrock */ 5609ea8dc4b6Seschrock 5610ea8dc4b6Seschrock static void 56113d7072f8Seschrock spa_async_remove(spa_t *spa, vdev_t *vd) 5612fa9e4066Sahrens { 561349cf58c0SBrendan Gregg - Sun Microsystems if (vd->vdev_remove_wanted) { 561498d1cbfeSGeorge Wilson vd->vdev_remove_wanted = B_FALSE; 561598d1cbfeSGeorge Wilson vd->vdev_delayed_close = B_FALSE; 561649cf58c0SBrendan Gregg - Sun Microsystems vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE); 56171d713200SEric Schrock 56181d713200SEric Schrock /* 56191d713200SEric Schrock * We want to clear the stats, but we don't want to do a full 56201d713200SEric Schrock * vdev_clear() as that will cause us to throw away 56211d713200SEric Schrock * degraded/faulted state as well as attempt to reopen the 56221d713200SEric Schrock * device, all of which is a waste. 56231d713200SEric Schrock */ 56241d713200SEric Schrock vd->vdev_stat.vs_read_errors = 0; 56251d713200SEric Schrock vd->vdev_stat.vs_write_errors = 0; 56261d713200SEric Schrock vd->vdev_stat.vs_checksum_errors = 0; 56271d713200SEric Schrock 5628e14bb325SJeff Bonwick vdev_state_dirty(vd->vdev_top); 5629ea8dc4b6Seschrock } 563049cf58c0SBrendan Gregg - Sun Microsystems 5631e14bb325SJeff Bonwick for (int c = 0; c < vd->vdev_children; c++) 563249cf58c0SBrendan Gregg - Sun Microsystems spa_async_remove(spa, vd->vdev_child[c]); 5633ea8dc4b6Seschrock } 5634fa9e4066Sahrens 5635e14bb325SJeff Bonwick static void 5636e14bb325SJeff Bonwick spa_async_probe(spa_t *spa, vdev_t *vd) 5637e14bb325SJeff Bonwick { 5638e14bb325SJeff Bonwick if (vd->vdev_probe_wanted) { 563998d1cbfeSGeorge Wilson vd->vdev_probe_wanted = B_FALSE; 5640e14bb325SJeff Bonwick vdev_reopen(vd); /* vdev_open() does the actual probe */ 5641e14bb325SJeff Bonwick } 5642e14bb325SJeff Bonwick 5643e14bb325SJeff Bonwick for (int c = 0; c < vd->vdev_children; c++) 5644e14bb325SJeff Bonwick spa_async_probe(spa, vd->vdev_child[c]); 5645e14bb325SJeff Bonwick } 5646e14bb325SJeff Bonwick 5647573ca77eSGeorge Wilson static void 5648573ca77eSGeorge Wilson spa_async_autoexpand(spa_t *spa, vdev_t *vd) 5649573ca77eSGeorge Wilson { 5650573ca77eSGeorge Wilson sysevent_id_t eid; 5651573ca77eSGeorge Wilson nvlist_t *attr; 5652573ca77eSGeorge Wilson char *physpath; 5653573ca77eSGeorge Wilson 5654573ca77eSGeorge Wilson if (!spa->spa_autoexpand) 5655573ca77eSGeorge Wilson return; 5656573ca77eSGeorge Wilson 5657573ca77eSGeorge Wilson for (int c = 0; c < vd->vdev_children; c++) { 5658573ca77eSGeorge Wilson vdev_t *cvd = vd->vdev_child[c]; 5659573ca77eSGeorge Wilson spa_async_autoexpand(spa, cvd); 5660573ca77eSGeorge Wilson } 5661573ca77eSGeorge Wilson 5662573ca77eSGeorge Wilson if (!vd->vdev_ops->vdev_op_leaf || vd->vdev_physpath == NULL) 5663573ca77eSGeorge Wilson return; 5664573ca77eSGeorge Wilson 5665573ca77eSGeorge Wilson physpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 5666573ca77eSGeorge Wilson (void) snprintf(physpath, MAXPATHLEN, "/devices%s", vd->vdev_physpath); 5667573ca77eSGeorge Wilson 5668573ca77eSGeorge Wilson VERIFY(nvlist_alloc(&attr, NV_UNIQUE_NAME, KM_SLEEP) == 0); 5669573ca77eSGeorge Wilson VERIFY(nvlist_add_string(attr, DEV_PHYS_PATH, physpath) == 0); 5670573ca77eSGeorge Wilson 5671573ca77eSGeorge Wilson (void) ddi_log_sysevent(zfs_dip, SUNW_VENDOR, EC_DEV_STATUS, 5672573ca77eSGeorge Wilson ESC_DEV_DLE, attr, &eid, DDI_SLEEP); 5673573ca77eSGeorge Wilson 5674573ca77eSGeorge Wilson nvlist_free(attr); 5675573ca77eSGeorge Wilson kmem_free(physpath, MAXPATHLEN); 5676573ca77eSGeorge Wilson } 5677573ca77eSGeorge Wilson 5678ea8dc4b6Seschrock static void 5679ea8dc4b6Seschrock spa_async_thread(spa_t *spa) 5680ea8dc4b6Seschrock { 5681e14bb325SJeff Bonwick int tasks; 5682ea8dc4b6Seschrock 5683ea8dc4b6Seschrock ASSERT(spa->spa_sync_on); 5684ea8dc4b6Seschrock 5685ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 5686ea8dc4b6Seschrock tasks = spa->spa_async_tasks; 5687ea8dc4b6Seschrock spa->spa_async_tasks = 0; 5688ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 5689ea8dc4b6Seschrock 56900373e76bSbonwick /* 56910373e76bSbonwick * See if the config needs to be updated. 56920373e76bSbonwick */ 56930373e76bSbonwick if (tasks & SPA_ASYNC_CONFIG_UPDATE) { 5694b24ab676SJeff Bonwick uint64_t old_space, new_space; 5695573ca77eSGeorge Wilson 56960373e76bSbonwick mutex_enter(&spa_namespace_lock); 5697b24ab676SJeff Bonwick old_space = metaslab_class_get_space(spa_normal_class(spa)); 56980373e76bSbonwick spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 5699b24ab676SJeff Bonwick new_space = metaslab_class_get_space(spa_normal_class(spa)); 57000373e76bSbonwick mutex_exit(&spa_namespace_lock); 5701573ca77eSGeorge Wilson 5702573ca77eSGeorge Wilson /* 5703573ca77eSGeorge Wilson * If the pool grew as a result of the config update, 5704573ca77eSGeorge Wilson * then log an internal history event. 5705573ca77eSGeorge Wilson */ 5706b24ab676SJeff Bonwick if (new_space != old_space) { 57074445fffbSMatthew Ahrens spa_history_log_internal(spa, "vdev online", NULL, 5708c8e1f6d2SMark J Musante "pool '%s' size: %llu(+%llu)", 5709b24ab676SJeff Bonwick spa_name(spa), new_space, new_space - old_space); 5710573ca77eSGeorge Wilson } 57110373e76bSbonwick } 57120373e76bSbonwick 5713ea8dc4b6Seschrock /* 57143d7072f8Seschrock * See if any devices need to be marked REMOVED. 5715ea8dc4b6Seschrock */ 5716e14bb325SJeff Bonwick if (tasks & SPA_ASYNC_REMOVE) { 57178f18d1faSGeorge Wilson spa_vdev_state_enter(spa, SCL_NONE); 57183d7072f8Seschrock spa_async_remove(spa, spa->spa_root_vdev); 5719e14bb325SJeff Bonwick for (int i = 0; i < spa->spa_l2cache.sav_count; i++) 572049cf58c0SBrendan Gregg - Sun Microsystems spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]); 5721e14bb325SJeff Bonwick for (int i = 0; i < spa->spa_spares.sav_count; i++) 572249cf58c0SBrendan Gregg - Sun Microsystems spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]); 5723e14bb325SJeff Bonwick (void) spa_vdev_state_exit(spa, NULL, 0); 5724e14bb325SJeff Bonwick } 5725e14bb325SJeff Bonwick 5726573ca77eSGeorge Wilson if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) { 5727573ca77eSGeorge Wilson spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 5728573ca77eSGeorge Wilson spa_async_autoexpand(spa, spa->spa_root_vdev); 5729573ca77eSGeorge Wilson spa_config_exit(spa, SCL_CONFIG, FTAG); 5730573ca77eSGeorge Wilson } 5731573ca77eSGeorge Wilson 5732e14bb325SJeff Bonwick /* 5733e14bb325SJeff Bonwick * See if any devices need to be probed. 5734e14bb325SJeff Bonwick */ 5735e14bb325SJeff Bonwick if (tasks & SPA_ASYNC_PROBE) { 57368f18d1faSGeorge Wilson spa_vdev_state_enter(spa, SCL_NONE); 5737e14bb325SJeff Bonwick spa_async_probe(spa, spa->spa_root_vdev); 5738e14bb325SJeff Bonwick (void) spa_vdev_state_exit(spa, NULL, 0); 57393d7072f8Seschrock } 5740ea8dc4b6Seschrock 5741ea8dc4b6Seschrock /* 5742ea8dc4b6Seschrock * If any devices are done replacing, detach them. 5743ea8dc4b6Seschrock */ 57443d7072f8Seschrock if (tasks & SPA_ASYNC_RESILVER_DONE) 57453d7072f8Seschrock spa_vdev_resilver_done(spa); 5746fa9e4066Sahrens 5747ea8dc4b6Seschrock /* 5748ea8dc4b6Seschrock * Kick off a resilver. 5749ea8dc4b6Seschrock */ 5750088f3894Sahrens if (tasks & SPA_ASYNC_RESILVER) 57513f9d6ad7SLin Ling dsl_resilver_restart(spa->spa_dsl_pool, 0); 5752ea8dc4b6Seschrock 5753ea8dc4b6Seschrock /* 5754ea8dc4b6Seschrock * Let the world know that we're done. 5755ea8dc4b6Seschrock */ 5756ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 5757ea8dc4b6Seschrock spa->spa_async_thread = NULL; 5758ea8dc4b6Seschrock cv_broadcast(&spa->spa_async_cv); 5759ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 5760ea8dc4b6Seschrock thread_exit(); 5761ea8dc4b6Seschrock } 5762ea8dc4b6Seschrock 5763ea8dc4b6Seschrock void 5764ea8dc4b6Seschrock spa_async_suspend(spa_t *spa) 5765ea8dc4b6Seschrock { 5766ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 5767ea8dc4b6Seschrock spa->spa_async_suspended++; 5768ea8dc4b6Seschrock while (spa->spa_async_thread != NULL) 5769ea8dc4b6Seschrock cv_wait(&spa->spa_async_cv, &spa->spa_async_lock); 5770ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 5771ea8dc4b6Seschrock } 5772ea8dc4b6Seschrock 5773ea8dc4b6Seschrock void 5774ea8dc4b6Seschrock spa_async_resume(spa_t *spa) 5775ea8dc4b6Seschrock { 5776ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 5777ea8dc4b6Seschrock ASSERT(spa->spa_async_suspended != 0); 5778ea8dc4b6Seschrock spa->spa_async_suspended--; 5779ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 5780ea8dc4b6Seschrock } 5781ea8dc4b6Seschrock 57823cb69f73SWill Andrews static boolean_t 57833cb69f73SWill Andrews spa_async_tasks_pending(spa_t *spa) 57843cb69f73SWill Andrews { 57853cb69f73SWill Andrews uint_t non_config_tasks; 57863cb69f73SWill Andrews uint_t config_task; 57873cb69f73SWill Andrews boolean_t config_task_suspended; 57883cb69f73SWill Andrews 57893cb69f73SWill Andrews non_config_tasks = spa->spa_async_tasks & ~SPA_ASYNC_CONFIG_UPDATE; 57903cb69f73SWill Andrews config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE; 57913cb69f73SWill Andrews if (spa->spa_ccw_fail_time == 0) { 57923cb69f73SWill Andrews config_task_suspended = B_FALSE; 57933cb69f73SWill Andrews } else { 57943cb69f73SWill Andrews config_task_suspended = 57953cb69f73SWill Andrews (gethrtime() - spa->spa_ccw_fail_time) < 57963cb69f73SWill Andrews (zfs_ccw_retry_interval * NANOSEC); 57973cb69f73SWill Andrews } 57983cb69f73SWill Andrews 57993cb69f73SWill Andrews return (non_config_tasks || (config_task && !config_task_suspended)); 58003cb69f73SWill Andrews } 58013cb69f73SWill Andrews 5802ea8dc4b6Seschrock static void 5803ea8dc4b6Seschrock spa_async_dispatch(spa_t *spa) 5804ea8dc4b6Seschrock { 5805ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 58063cb69f73SWill Andrews if (spa_async_tasks_pending(spa) && 58073cb69f73SWill Andrews !spa->spa_async_suspended && 58080373e76bSbonwick spa->spa_async_thread == NULL && 58093cb69f73SWill Andrews rootdir != NULL) 5810ea8dc4b6Seschrock spa->spa_async_thread = thread_create(NULL, 0, 5811ea8dc4b6Seschrock spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri); 5812ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 5813ea8dc4b6Seschrock } 5814ea8dc4b6Seschrock 5815ea8dc4b6Seschrock void 5816ea8dc4b6Seschrock spa_async_request(spa_t *spa, int task) 5817ea8dc4b6Seschrock { 58183f9d6ad7SLin Ling zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task); 5819ea8dc4b6Seschrock mutex_enter(&spa->spa_async_lock); 5820ea8dc4b6Seschrock spa->spa_async_tasks |= task; 5821ea8dc4b6Seschrock mutex_exit(&spa->spa_async_lock); 5822fa9e4066Sahrens } 5823fa9e4066Sahrens 5824fa9e4066Sahrens /* 5825fa9e4066Sahrens * ========================================================================== 5826fa9e4066Sahrens * SPA syncing routines 5827fa9e4066Sahrens * ========================================================================== 5828fa9e4066Sahrens */ 5829fa9e4066Sahrens 5830cde58dbcSMatthew Ahrens static int 5831cde58dbcSMatthew Ahrens bpobj_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 5832cde58dbcSMatthew Ahrens { 5833cde58dbcSMatthew Ahrens bpobj_t *bpo = arg; 5834cde58dbcSMatthew Ahrens bpobj_enqueue(bpo, bp, tx); 5835cde58dbcSMatthew Ahrens return (0); 5836b24ab676SJeff Bonwick } 5837b24ab676SJeff Bonwick 5838cde58dbcSMatthew Ahrens static int 5839cde58dbcSMatthew Ahrens spa_free_sync_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 5840b24ab676SJeff Bonwick { 5841b24ab676SJeff Bonwick zio_t *zio = arg; 5842b24ab676SJeff Bonwick 5843b24ab676SJeff Bonwick zio_nowait(zio_free_sync(zio, zio->io_spa, dmu_tx_get_txg(tx), bp, 5844b24ab676SJeff Bonwick zio->io_flags)); 5845cde58dbcSMatthew Ahrens return (0); 5846fa9e4066Sahrens } 5847fa9e4066Sahrens 584869962b56SMatthew Ahrens /* 584969962b56SMatthew Ahrens * Note: this simple function is not inlined to make it easier to dtrace the 585069962b56SMatthew Ahrens * amount of time spent syncing frees. 585169962b56SMatthew Ahrens */ 585269962b56SMatthew Ahrens static void 585369962b56SMatthew Ahrens spa_sync_frees(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx) 585469962b56SMatthew Ahrens { 585569962b56SMatthew Ahrens zio_t *zio = zio_root(spa, NULL, NULL, 0); 585669962b56SMatthew Ahrens bplist_iterate(bpl, spa_free_sync_cb, zio, tx); 585769962b56SMatthew Ahrens VERIFY(zio_wait(zio) == 0); 585869962b56SMatthew Ahrens } 585969962b56SMatthew Ahrens 586069962b56SMatthew Ahrens /* 586169962b56SMatthew Ahrens * Note: this simple function is not inlined to make it easier to dtrace the 586269962b56SMatthew Ahrens * amount of time spent syncing deferred frees. 586369962b56SMatthew Ahrens */ 586469962b56SMatthew Ahrens static void 586569962b56SMatthew Ahrens spa_sync_deferred_frees(spa_t *spa, dmu_tx_t *tx) 586669962b56SMatthew Ahrens { 586769962b56SMatthew Ahrens zio_t *zio = zio_root(spa, NULL, NULL, 0); 586869962b56SMatthew Ahrens VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj, 586969962b56SMatthew Ahrens spa_free_sync_cb, zio, tx), ==, 0); 587069962b56SMatthew Ahrens VERIFY0(zio_wait(zio)); 587169962b56SMatthew Ahrens } 587269962b56SMatthew Ahrens 587369962b56SMatthew Ahrens 5874fa9e4066Sahrens static void 587599653d4eSeschrock spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx) 5876fa9e4066Sahrens { 5877fa9e4066Sahrens char *packed = NULL; 5878f7991ba4STim Haley size_t bufsize; 5879fa9e4066Sahrens size_t nvsize = 0; 5880fa9e4066Sahrens dmu_buf_t *db; 5881fa9e4066Sahrens 588299653d4eSeschrock VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0); 5883fa9e4066Sahrens 5884f7991ba4STim Haley /* 5885f7991ba4STim Haley * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration 588643466aaeSMax Grossman * information. This avoids the dmu_buf_will_dirty() path and 5887f7991ba4STim Haley * saves us a pre-read to get data we don't actually care about. 5888f7991ba4STim Haley */ 5889ad135b5dSChristopher Siden bufsize = P2ROUNDUP((uint64_t)nvsize, SPA_CONFIG_BLOCKSIZE); 5890f7991ba4STim Haley packed = kmem_alloc(bufsize, KM_SLEEP); 5891fa9e4066Sahrens 589299653d4eSeschrock VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR, 5893ea8dc4b6Seschrock KM_SLEEP) == 0); 5894f7991ba4STim Haley bzero(packed + nvsize, bufsize - nvsize); 5895fa9e4066Sahrens 5896f7991ba4STim Haley dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx); 5897fa9e4066Sahrens 5898f7991ba4STim Haley kmem_free(packed, bufsize); 5899fa9e4066Sahrens 590099653d4eSeschrock VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); 5901fa9e4066Sahrens dmu_buf_will_dirty(db, tx); 5902fa9e4066Sahrens *(uint64_t *)db->db_data = nvsize; 5903ea8dc4b6Seschrock dmu_buf_rele(db, FTAG); 5904fa9e4066Sahrens } 5905fa9e4066Sahrens 590699653d4eSeschrock static void 5907fa94a07fSbrendan spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx, 5908fa94a07fSbrendan const char *config, const char *entry) 590999653d4eSeschrock { 591099653d4eSeschrock nvlist_t *nvroot; 5911fa94a07fSbrendan nvlist_t **list; 591299653d4eSeschrock int i; 591399653d4eSeschrock 5914fa94a07fSbrendan if (!sav->sav_sync) 591599653d4eSeschrock return; 591699653d4eSeschrock 591799653d4eSeschrock /* 5918fa94a07fSbrendan * Update the MOS nvlist describing the list of available devices. 5919fa94a07fSbrendan * spa_validate_aux() will have already made sure this nvlist is 59203d7072f8Seschrock * valid and the vdevs are labeled appropriately. 592199653d4eSeschrock */ 5922fa94a07fSbrendan if (sav->sav_object == 0) { 5923fa94a07fSbrendan sav->sav_object = dmu_object_alloc(spa->spa_meta_objset, 5924fa94a07fSbrendan DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE, 5925fa94a07fSbrendan sizeof (uint64_t), tx); 592699653d4eSeschrock VERIFY(zap_update(spa->spa_meta_objset, 5927fa94a07fSbrendan DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1, 5928fa94a07fSbrendan &sav->sav_object, tx) == 0); 592999653d4eSeschrock } 593099653d4eSeschrock 593199653d4eSeschrock VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); 5932fa94a07fSbrendan if (sav->sav_count == 0) { 5933fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0); 593499653d4eSeschrock } else { 5935fa94a07fSbrendan list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); 5936fa94a07fSbrendan for (i = 0; i < sav->sav_count; i++) 5937fa94a07fSbrendan list[i] = vdev_config_generate(spa, sav->sav_vdevs[i], 59383f9d6ad7SLin Ling B_FALSE, VDEV_CONFIG_L2CACHE); 5939fa94a07fSbrendan VERIFY(nvlist_add_nvlist_array(nvroot, config, list, 5940fa94a07fSbrendan sav->sav_count) == 0); 5941fa94a07fSbrendan for (i = 0; i < sav->sav_count; i++) 5942fa94a07fSbrendan nvlist_free(list[i]); 5943fa94a07fSbrendan kmem_free(list, sav->sav_count * sizeof (void *)); 594499653d4eSeschrock } 594599653d4eSeschrock 5946fa94a07fSbrendan spa_sync_nvlist(spa, sav->sav_object, nvroot, tx); 594706eeb2adSek nvlist_free(nvroot); 594899653d4eSeschrock 5949fa94a07fSbrendan sav->sav_sync = B_FALSE; 595099653d4eSeschrock } 595199653d4eSeschrock 595299653d4eSeschrock static void 595399653d4eSeschrock spa_sync_config_object(spa_t *spa, dmu_tx_t *tx) 595499653d4eSeschrock { 595599653d4eSeschrock nvlist_t *config; 595699653d4eSeschrock 5957e14bb325SJeff Bonwick if (list_is_empty(&spa->spa_config_dirty_list)) 595899653d4eSeschrock return; 595999653d4eSeschrock 5960e14bb325SJeff Bonwick spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 5961e14bb325SJeff Bonwick 5962e14bb325SJeff Bonwick config = spa_config_generate(spa, spa->spa_root_vdev, 5963e14bb325SJeff Bonwick dmu_tx_get_txg(tx), B_FALSE); 5964e14bb325SJeff Bonwick 596525345e46SGeorge Wilson /* 596625345e46SGeorge Wilson * If we're upgrading the spa version then make sure that 596725345e46SGeorge Wilson * the config object gets updated with the correct version. 596825345e46SGeorge Wilson */ 596925345e46SGeorge Wilson if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version) 597025345e46SGeorge Wilson fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, 597125345e46SGeorge Wilson spa->spa_uberblock.ub_version); 597225345e46SGeorge Wilson 5973e14bb325SJeff Bonwick spa_config_exit(spa, SCL_STATE, FTAG); 597499653d4eSeschrock 597599653d4eSeschrock if (spa->spa_config_syncing) 597699653d4eSeschrock nvlist_free(spa->spa_config_syncing); 597799653d4eSeschrock spa->spa_config_syncing = config; 597899653d4eSeschrock 597999653d4eSeschrock spa_sync_nvlist(spa, spa->spa_config_object, config, tx); 598099653d4eSeschrock } 598199653d4eSeschrock 5982ad135b5dSChristopher Siden static void 59833b2aab18SMatthew Ahrens spa_sync_version(void *arg, dmu_tx_t *tx) 5984ad135b5dSChristopher Siden { 59853b2aab18SMatthew Ahrens uint64_t *versionp = arg; 59863b2aab18SMatthew Ahrens uint64_t version = *versionp; 59873b2aab18SMatthew Ahrens spa_t *spa = dmu_tx_pool(tx)->dp_spa; 5988ad135b5dSChristopher Siden 5989ad135b5dSChristopher Siden /* 5990ad135b5dSChristopher Siden * Setting the version is special cased when first creating the pool. 5991ad135b5dSChristopher Siden */ 5992ad135b5dSChristopher Siden ASSERT(tx->tx_txg != TXG_INITIAL); 5993ad135b5dSChristopher Siden 599462eae887SRichard Yao ASSERT(SPA_VERSION_IS_SUPPORTED(version)); 5995ad135b5dSChristopher Siden ASSERT(version >= spa_version(spa)); 5996ad135b5dSChristopher Siden 5997ad135b5dSChristopher Siden spa->spa_uberblock.ub_version = version; 5998ad135b5dSChristopher Siden vdev_config_dirty(spa->spa_root_vdev); 59994445fffbSMatthew Ahrens spa_history_log_internal(spa, "set", tx, "version=%lld", version); 6000ad135b5dSChristopher Siden } 6001ad135b5dSChristopher Siden 6002990b4856Slling /* 6003990b4856Slling * Set zpool properties. 6004990b4856Slling */ 6005b1b8ab34Slling static void 60063b2aab18SMatthew Ahrens spa_sync_props(void *arg, dmu_tx_t *tx) 6007b1b8ab34Slling { 60083b2aab18SMatthew Ahrens nvlist_t *nvp = arg; 60093b2aab18SMatthew Ahrens spa_t *spa = dmu_tx_pool(tx)->dp_spa; 6010b1b8ab34Slling objset_t *mos = spa->spa_meta_objset; 6011ad135b5dSChristopher Siden nvpair_t *elem = NULL; 6012b1b8ab34Slling 6013e14bb325SJeff Bonwick mutex_enter(&spa->spa_props_lock); 6014e14bb325SJeff Bonwick 6015990b4856Slling while ((elem = nvlist_next_nvpair(nvp, elem))) { 6016ad135b5dSChristopher Siden uint64_t intval; 6017ad135b5dSChristopher Siden char *strval, *fname; 6018ad135b5dSChristopher Siden zpool_prop_t prop; 6019ad135b5dSChristopher Siden const char *propname; 6020ad135b5dSChristopher Siden zprop_type_t proptype; 60212acef22dSMatthew Ahrens spa_feature_t fid; 6022ad135b5dSChristopher Siden 6023990b4856Slling switch (prop = zpool_name_to_prop(nvpair_name(elem))) { 6024ad135b5dSChristopher Siden case ZPROP_INVAL: 6025ad135b5dSChristopher Siden /* 6026ad135b5dSChristopher Siden * We checked this earlier in spa_prop_validate(). 6027ad135b5dSChristopher Siden */ 6028ad135b5dSChristopher Siden ASSERT(zpool_prop_feature(nvpair_name(elem))); 6029ad135b5dSChristopher Siden 6030ad135b5dSChristopher Siden fname = strchr(nvpair_name(elem), '@') + 1; 60312acef22dSMatthew Ahrens VERIFY0(zfeature_lookup_name(fname, &fid)); 6032ad135b5dSChristopher Siden 60332acef22dSMatthew Ahrens spa_feature_enable(spa, fid, tx); 60344445fffbSMatthew Ahrens spa_history_log_internal(spa, "set", tx, 60354445fffbSMatthew Ahrens "%s=enabled", nvpair_name(elem)); 6036ad135b5dSChristopher Siden break; 6037ad135b5dSChristopher Siden 6038990b4856Slling case ZPOOL_PROP_VERSION: 60390713e232SGeorge Wilson intval = fnvpair_value_uint64(elem); 6040990b4856Slling /* 6041ad135b5dSChristopher Siden * The version is synced seperatly before other 6042ad135b5dSChristopher Siden * properties and should be correct by now. 6043990b4856Slling */ 6044ad135b5dSChristopher Siden ASSERT3U(spa_version(spa), >=, intval); 6045ecd6cf80Smarks break; 6046990b4856Slling 6047990b4856Slling case ZPOOL_PROP_ALTROOT: 6048990b4856Slling /* 6049990b4856Slling * 'altroot' is a non-persistent property. It should 6050990b4856Slling * have been set temporarily at creation or import time. 6051990b4856Slling */ 6052990b4856Slling ASSERT(spa->spa_root != NULL); 6053b1b8ab34Slling break; 60543d7072f8Seschrock 6055f9af39baSGeorge Wilson case ZPOOL_PROP_READONLY: 60562f8aaab3Seschrock case ZPOOL_PROP_CACHEFILE: 6057990b4856Slling /* 6058f9af39baSGeorge Wilson * 'readonly' and 'cachefile' are also non-persisitent 6059f9af39baSGeorge Wilson * properties. 6060990b4856Slling */ 60613d7072f8Seschrock break; 60628704186eSDan McDonald case ZPOOL_PROP_COMMENT: 60630713e232SGeorge Wilson strval = fnvpair_value_string(elem); 60648704186eSDan McDonald if (spa->spa_comment != NULL) 60658704186eSDan McDonald spa_strfree(spa->spa_comment); 60668704186eSDan McDonald spa->spa_comment = spa_strdup(strval); 60678704186eSDan McDonald /* 60688704186eSDan McDonald * We need to dirty the configuration on all the vdevs 60698704186eSDan McDonald * so that their labels get updated. It's unnecessary 60708704186eSDan McDonald * to do this for pool creation since the vdev's 60718704186eSDan McDonald * configuratoin has already been dirtied. 60728704186eSDan McDonald */ 60738704186eSDan McDonald if (tx->tx_txg != TXG_INITIAL) 60748704186eSDan McDonald vdev_config_dirty(spa->spa_root_vdev); 60754445fffbSMatthew Ahrens spa_history_log_internal(spa, "set", tx, 60764445fffbSMatthew Ahrens "%s=%s", nvpair_name(elem), strval); 60778704186eSDan McDonald break; 6078990b4856Slling default: 6079990b4856Slling /* 6080990b4856Slling * Set pool property values in the poolprops mos object. 6081990b4856Slling */ 6082990b4856Slling if (spa->spa_pool_props_object == 0) { 6083ad135b5dSChristopher Siden spa->spa_pool_props_object = 6084ad135b5dSChristopher Siden zap_create_link(mos, DMU_OT_POOL_PROPS, 6085990b4856Slling DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS, 6086ad135b5dSChristopher Siden tx); 6087990b4856Slling } 6088990b4856Slling 6089990b4856Slling /* normalize the property name */ 6090990b4856Slling propname = zpool_prop_to_name(prop); 6091990b4856Slling proptype = zpool_prop_get_type(prop); 6092990b4856Slling 6093990b4856Slling if (nvpair_type(elem) == DATA_TYPE_STRING) { 6094990b4856Slling ASSERT(proptype == PROP_TYPE_STRING); 60950713e232SGeorge Wilson strval = fnvpair_value_string(elem); 60960713e232SGeorge Wilson VERIFY0(zap_update(mos, 6097990b4856Slling spa->spa_pool_props_object, propname, 60980713e232SGeorge Wilson 1, strlen(strval) + 1, strval, tx)); 60994445fffbSMatthew Ahrens spa_history_log_internal(spa, "set", tx, 61004445fffbSMatthew Ahrens "%s=%s", nvpair_name(elem), strval); 6101990b4856Slling } else if (nvpair_type(elem) == DATA_TYPE_UINT64) { 61020713e232SGeorge Wilson intval = fnvpair_value_uint64(elem); 6103990b4856Slling 6104990b4856Slling if (proptype == PROP_TYPE_INDEX) { 6105990b4856Slling const char *unused; 61060713e232SGeorge Wilson VERIFY0(zpool_prop_index_to_string( 61070713e232SGeorge Wilson prop, intval, &unused)); 6108990b4856Slling } 61090713e232SGeorge Wilson VERIFY0(zap_update(mos, 6110990b4856Slling spa->spa_pool_props_object, propname, 61110713e232SGeorge Wilson 8, 1, &intval, tx)); 61124445fffbSMatthew Ahrens spa_history_log_internal(spa, "set", tx, 61134445fffbSMatthew Ahrens "%s=%lld", nvpair_name(elem), intval); 6114990b4856Slling } else { 6115990b4856Slling ASSERT(0); /* not allowed */ 6116990b4856Slling } 6117990b4856Slling 61180a4e9518Sgw switch (prop) { 61190a4e9518Sgw case ZPOOL_PROP_DELEGATION: 6120990b4856Slling spa->spa_delegation = intval; 61210a4e9518Sgw break; 61220a4e9518Sgw case ZPOOL_PROP_BOOTFS: 6123990b4856Slling spa->spa_bootfs = intval; 61240a4e9518Sgw break; 61250a4e9518Sgw case ZPOOL_PROP_FAILUREMODE: 61260a4e9518Sgw spa->spa_failmode = intval; 61270a4e9518Sgw break; 6128573ca77eSGeorge Wilson case ZPOOL_PROP_AUTOEXPAND: 6129573ca77eSGeorge Wilson spa->spa_autoexpand = intval; 6130b98131cfSEric Taylor if (tx->tx_txg != TXG_INITIAL) 6131b98131cfSEric Taylor spa_async_request(spa, 6132b98131cfSEric Taylor SPA_ASYNC_AUTOEXPAND); 6133573ca77eSGeorge Wilson break; 6134b24ab676SJeff Bonwick case ZPOOL_PROP_DEDUPDITTO: 6135b24ab676SJeff Bonwick spa->spa_dedup_ditto = intval; 6136b24ab676SJeff Bonwick break; 61370a4e9518Sgw default: 61380a4e9518Sgw break; 61390a4e9518Sgw } 6140990b4856Slling } 6141990b4856Slling 6142b1b8ab34Slling } 6143e14bb325SJeff Bonwick 6144e14bb325SJeff Bonwick mutex_exit(&spa->spa_props_lock); 6145b1b8ab34Slling } 6146b1b8ab34Slling 6147cde58dbcSMatthew Ahrens /* 6148cde58dbcSMatthew Ahrens * Perform one-time upgrade on-disk changes. spa_version() does not 6149cde58dbcSMatthew Ahrens * reflect the new version this txg, so there must be no changes this 6150cde58dbcSMatthew Ahrens * txg to anything that the upgrade code depends on after it executes. 6151cde58dbcSMatthew Ahrens * Therefore this must be called after dsl_pool_sync() does the sync 6152cde58dbcSMatthew Ahrens * tasks. 6153cde58dbcSMatthew Ahrens */ 6154cde58dbcSMatthew Ahrens static void 6155cde58dbcSMatthew Ahrens spa_sync_upgrades(spa_t *spa, dmu_tx_t *tx) 6156cde58dbcSMatthew Ahrens { 6157cde58dbcSMatthew Ahrens dsl_pool_t *dp = spa->spa_dsl_pool; 6158cde58dbcSMatthew Ahrens 6159cde58dbcSMatthew Ahrens ASSERT(spa->spa_sync_pass == 1); 6160cde58dbcSMatthew Ahrens 61613b2aab18SMatthew Ahrens rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG); 61623b2aab18SMatthew Ahrens 6163cde58dbcSMatthew Ahrens if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN && 6164cde58dbcSMatthew Ahrens spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) { 6165cde58dbcSMatthew Ahrens dsl_pool_create_origin(dp, tx); 6166cde58dbcSMatthew Ahrens 6167cde58dbcSMatthew Ahrens /* Keeping the origin open increases spa_minref */ 6168cde58dbcSMatthew Ahrens spa->spa_minref += 3; 6169cde58dbcSMatthew Ahrens } 6170cde58dbcSMatthew Ahrens 6171cde58dbcSMatthew Ahrens if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES && 6172cde58dbcSMatthew Ahrens spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) { 6173cde58dbcSMatthew Ahrens dsl_pool_upgrade_clones(dp, tx); 6174cde58dbcSMatthew Ahrens } 6175cde58dbcSMatthew Ahrens 6176cde58dbcSMatthew Ahrens if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES && 6177cde58dbcSMatthew Ahrens spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) { 6178cde58dbcSMatthew Ahrens dsl_pool_upgrade_dir_clones(dp, tx); 6179cde58dbcSMatthew Ahrens 6180cde58dbcSMatthew Ahrens /* Keeping the freedir open increases spa_minref */ 6181cde58dbcSMatthew Ahrens spa->spa_minref += 3; 6182cde58dbcSMatthew Ahrens } 6183ad135b5dSChristopher Siden 6184ad135b5dSChristopher Siden if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES && 6185ad135b5dSChristopher Siden spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) { 6186ad135b5dSChristopher Siden spa_feature_create_zap_objects(spa, tx); 6187ad135b5dSChristopher Siden } 6188b8289d24SDaniil Lunev 6189b8289d24SDaniil Lunev /* 6190b8289d24SDaniil Lunev * LZ4_COMPRESS feature's behaviour was changed to activate_on_enable 6191b8289d24SDaniil Lunev * when possibility to use lz4 compression for metadata was added 6192b8289d24SDaniil Lunev * Old pools that have this feature enabled must be upgraded to have 6193b8289d24SDaniil Lunev * this feature active 6194b8289d24SDaniil Lunev */ 6195b8289d24SDaniil Lunev if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) { 6196b8289d24SDaniil Lunev boolean_t lz4_en = spa_feature_is_enabled(spa, 6197b8289d24SDaniil Lunev SPA_FEATURE_LZ4_COMPRESS); 6198b8289d24SDaniil Lunev boolean_t lz4_ac = spa_feature_is_active(spa, 6199b8289d24SDaniil Lunev SPA_FEATURE_LZ4_COMPRESS); 6200b8289d24SDaniil Lunev 6201b8289d24SDaniil Lunev if (lz4_en && !lz4_ac) 6202b8289d24SDaniil Lunev spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx); 6203b8289d24SDaniil Lunev } 62043b2aab18SMatthew Ahrens rrw_exit(&dp->dp_config_rwlock, FTAG); 6205cde58dbcSMatthew Ahrens } 6206cde58dbcSMatthew Ahrens 6207fa9e4066Sahrens /* 6208fa9e4066Sahrens * Sync the specified transaction group. New blocks may be dirtied as 6209fa9e4066Sahrens * part of the process, so we iterate until it converges. 6210fa9e4066Sahrens */ 6211fa9e4066Sahrens void 6212fa9e4066Sahrens spa_sync(spa_t *spa, uint64_t txg) 6213fa9e4066Sahrens { 6214fa9e4066Sahrens dsl_pool_t *dp = spa->spa_dsl_pool; 6215fa9e4066Sahrens objset_t *mos = spa->spa_meta_objset; 6216b24ab676SJeff Bonwick bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK]; 62170373e76bSbonwick vdev_t *rvd = spa->spa_root_vdev; 6218fa9e4066Sahrens vdev_t *vd; 6219fa9e4066Sahrens dmu_tx_t *tx; 6220e14bb325SJeff Bonwick int error; 6221fa9e4066Sahrens 6222f9af39baSGeorge Wilson VERIFY(spa_writeable(spa)); 6223f9af39baSGeorge Wilson 6224fa9e4066Sahrens /* 6225fa9e4066Sahrens * Lock out configuration changes. 6226fa9e4066Sahrens */ 6227e14bb325SJeff Bonwick spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 6228fa9e4066Sahrens 6229fa9e4066Sahrens spa->spa_syncing_txg = txg; 6230fa9e4066Sahrens spa->spa_sync_pass = 0; 6231fa9e4066Sahrens 6232e14bb325SJeff Bonwick /* 6233e14bb325SJeff Bonwick * If there are any pending vdev state changes, convert them 6234e14bb325SJeff Bonwick * into config changes that go out with this transaction group. 6235e14bb325SJeff Bonwick */ 6236e14bb325SJeff Bonwick spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 62378ad4d6ddSJeff Bonwick while (list_head(&spa->spa_state_dirty_list) != NULL) { 62388ad4d6ddSJeff Bonwick /* 62398ad4d6ddSJeff Bonwick * We need the write lock here because, for aux vdevs, 62408ad4d6ddSJeff Bonwick * calling vdev_config_dirty() modifies sav_config. 62418ad4d6ddSJeff Bonwick * This is ugly and will become unnecessary when we 62428ad4d6ddSJeff Bonwick * eliminate the aux vdev wart by integrating all vdevs 62438ad4d6ddSJeff Bonwick * into the root vdev tree. 62448ad4d6ddSJeff Bonwick */ 62458ad4d6ddSJeff Bonwick spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 62468ad4d6ddSJeff Bonwick spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER); 62478ad4d6ddSJeff Bonwick while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) { 62488ad4d6ddSJeff Bonwick vdev_state_clean(vd); 62498ad4d6ddSJeff Bonwick vdev_config_dirty(vd); 62508ad4d6ddSJeff Bonwick } 62518ad4d6ddSJeff Bonwick spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 62528ad4d6ddSJeff Bonwick spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 6253e14bb325SJeff Bonwick } 6254e14bb325SJeff Bonwick spa_config_exit(spa, SCL_STATE, FTAG); 6255e14bb325SJeff Bonwick 625699653d4eSeschrock tx = dmu_tx_create_assigned(dp, txg); 625799653d4eSeschrock 6258283b8460SGeorge.Wilson spa->spa_sync_starttime = gethrtime(); 6259283b8460SGeorge.Wilson VERIFY(cyclic_reprogram(spa->spa_deadman_cycid, 6260283b8460SGeorge.Wilson spa->spa_sync_starttime + spa->spa_deadman_synctime)); 6261283b8460SGeorge.Wilson 626299653d4eSeschrock /* 6263e7437265Sahrens * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg, 626499653d4eSeschrock * set spa_deflate if we have no raid-z vdevs. 626599653d4eSeschrock */ 6266e7437265Sahrens if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE && 6267e7437265Sahrens spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) { 626899653d4eSeschrock int i; 626999653d4eSeschrock 627099653d4eSeschrock for (i = 0; i < rvd->vdev_children; i++) { 627199653d4eSeschrock vd = rvd->vdev_child[i]; 627299653d4eSeschrock if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE) 627399653d4eSeschrock break; 627499653d4eSeschrock } 627599653d4eSeschrock if (i == rvd->vdev_children) { 627699653d4eSeschrock spa->spa_deflate = TRUE; 627799653d4eSeschrock VERIFY(0 == zap_add(spa->spa_meta_objset, 627899653d4eSeschrock DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 627999653d4eSeschrock sizeof (uint64_t), 1, &spa->spa_deflate, tx)); 628099653d4eSeschrock } 628199653d4eSeschrock } 628299653d4eSeschrock 6283fa9e4066Sahrens /* 6284fa9e4066Sahrens * Iterate to convergence. 6285fa9e4066Sahrens */ 6286fa9e4066Sahrens do { 6287b24ab676SJeff Bonwick int pass = ++spa->spa_sync_pass; 6288fa9e4066Sahrens 6289fa9e4066Sahrens spa_sync_config_object(spa, tx); 6290fa94a07fSbrendan spa_sync_aux_dev(spa, &spa->spa_spares, tx, 6291fa94a07fSbrendan ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES); 6292fa94a07fSbrendan spa_sync_aux_dev(spa, &spa->spa_l2cache, tx, 6293fa94a07fSbrendan ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE); 6294ea8dc4b6Seschrock spa_errlog_sync(spa, txg); 6295fa9e4066Sahrens dsl_pool_sync(dp, txg); 6296fa9e4066Sahrens 629701f55e48SGeorge Wilson if (pass < zfs_sync_pass_deferred_free) { 629869962b56SMatthew Ahrens spa_sync_frees(spa, free_bpl, tx); 6299b24ab676SJeff Bonwick } else { 6300231aab85SMatthew Ahrens /* 6301231aab85SMatthew Ahrens * We can not defer frees in pass 1, because 6302231aab85SMatthew Ahrens * we sync the deferred frees later in pass 1. 6303231aab85SMatthew Ahrens */ 6304231aab85SMatthew Ahrens ASSERT3U(pass, >, 1); 6305cde58dbcSMatthew Ahrens bplist_iterate(free_bpl, bpobj_enqueue_cb, 630669962b56SMatthew Ahrens &spa->spa_deferred_bpobj, tx); 6307fa9e4066Sahrens } 6308fa9e4066Sahrens 6309b24ab676SJeff Bonwick ddt_sync(spa, txg); 63103f9d6ad7SLin Ling dsl_scan_sync(dp, tx); 6311afee20e4SGeorge Wilson 6312b24ab676SJeff Bonwick while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) 6313b24ab676SJeff Bonwick vdev_sync(vd, txg); 6314b24ab676SJeff Bonwick 6315231aab85SMatthew Ahrens if (pass == 1) { 6316cde58dbcSMatthew Ahrens spa_sync_upgrades(spa, tx); 6317231aab85SMatthew Ahrens ASSERT3U(txg, >=, 6318231aab85SMatthew Ahrens spa->spa_uberblock.ub_rootbp.blk_birth); 6319231aab85SMatthew Ahrens /* 6320231aab85SMatthew Ahrens * Note: We need to check if the MOS is dirty 6321231aab85SMatthew Ahrens * because we could have marked the MOS dirty 6322231aab85SMatthew Ahrens * without updating the uberblock (e.g. if we 6323231aab85SMatthew Ahrens * have sync tasks but no dirty user data). We 6324231aab85SMatthew Ahrens * need to check the uberblock's rootbp because 6325231aab85SMatthew Ahrens * it is updated if we have synced out dirty 6326231aab85SMatthew Ahrens * data (though in this case the MOS will most 6327231aab85SMatthew Ahrens * likely also be dirty due to second order 6328231aab85SMatthew Ahrens * effects, we don't want to rely on that here). 6329231aab85SMatthew Ahrens */ 6330231aab85SMatthew Ahrens if (spa->spa_uberblock.ub_rootbp.blk_birth < txg && 6331231aab85SMatthew Ahrens !dmu_objset_is_dirty(mos, txg)) { 6332231aab85SMatthew Ahrens /* 6333231aab85SMatthew Ahrens * Nothing changed on the first pass, 6334231aab85SMatthew Ahrens * therefore this TXG is a no-op. Avoid 6335231aab85SMatthew Ahrens * syncing deferred frees, so that we 6336231aab85SMatthew Ahrens * can keep this TXG as a no-op. 6337231aab85SMatthew Ahrens */ 6338231aab85SMatthew Ahrens ASSERT(txg_list_empty(&dp->dp_dirty_datasets, 6339231aab85SMatthew Ahrens txg)); 6340231aab85SMatthew Ahrens ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 6341231aab85SMatthew Ahrens ASSERT(txg_list_empty(&dp->dp_sync_tasks, txg)); 6342231aab85SMatthew Ahrens break; 6343231aab85SMatthew Ahrens } 6344231aab85SMatthew Ahrens spa_sync_deferred_frees(spa, tx); 6345231aab85SMatthew Ahrens } 6346fa9e4066Sahrens 6347cde58dbcSMatthew Ahrens } while (dmu_objset_is_dirty(mos, txg)); 6348fa9e4066Sahrens 6349fa9e4066Sahrens /* 6350fa9e4066Sahrens * Rewrite the vdev configuration (which includes the uberblock) 6351fa9e4066Sahrens * to commit the transaction group. 63520373e76bSbonwick * 635317f17c2dSbonwick * If there are no dirty vdevs, we sync the uberblock to a few 635417f17c2dSbonwick * random top-level vdevs that are known to be visible in the 6355e14bb325SJeff Bonwick * config cache (see spa_vdev_add() for a complete description). 6356e14bb325SJeff Bonwick * If there *are* dirty vdevs, sync the uberblock to all vdevs. 63570373e76bSbonwick */ 6358e14bb325SJeff Bonwick for (;;) { 6359e14bb325SJeff Bonwick /* 6360e14bb325SJeff Bonwick * We hold SCL_STATE to prevent vdev open/close/etc. 6361e14bb325SJeff Bonwick * while we're attempting to write the vdev labels. 6362e14bb325SJeff Bonwick */ 6363e14bb325SJeff Bonwick spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 6364e14bb325SJeff Bonwick 6365e14bb325SJeff Bonwick if (list_is_empty(&spa->spa_config_dirty_list)) { 6366e14bb325SJeff Bonwick vdev_t *svd[SPA_DVAS_PER_BP]; 6367e14bb325SJeff Bonwick int svdcount = 0; 6368e14bb325SJeff Bonwick int children = rvd->vdev_children; 6369e14bb325SJeff Bonwick int c0 = spa_get_random(children); 6370e14bb325SJeff Bonwick 6371573ca77eSGeorge Wilson for (int c = 0; c < children; c++) { 6372e14bb325SJeff Bonwick vd = rvd->vdev_child[(c0 + c) % children]; 6373e14bb325SJeff Bonwick if (vd->vdev_ms_array == 0 || vd->vdev_islog) 6374e14bb325SJeff Bonwick continue; 6375e14bb325SJeff Bonwick svd[svdcount++] = vd; 6376e14bb325SJeff Bonwick if (svdcount == SPA_DVAS_PER_BP) 6377e14bb325SJeff Bonwick break; 6378e14bb325SJeff Bonwick } 63798956713aSEric Schrock error = vdev_config_sync(svd, svdcount, txg, B_FALSE); 63808956713aSEric Schrock if (error != 0) 63818956713aSEric Schrock error = vdev_config_sync(svd, svdcount, txg, 63828956713aSEric Schrock B_TRUE); 6383e14bb325SJeff Bonwick } else { 6384e14bb325SJeff Bonwick error = vdev_config_sync(rvd->vdev_child, 63858956713aSEric Schrock rvd->vdev_children, txg, B_FALSE); 63868956713aSEric Schrock if (error != 0) 63878956713aSEric Schrock error = vdev_config_sync(rvd->vdev_child, 63888956713aSEric Schrock rvd->vdev_children, txg, B_TRUE); 63890373e76bSbonwick } 6390e14bb325SJeff Bonwick 6391dfbb9432SGeorge Wilson if (error == 0) 6392dfbb9432SGeorge Wilson spa->spa_last_synced_guid = rvd->vdev_guid; 6393dfbb9432SGeorge Wilson 6394e14bb325SJeff Bonwick spa_config_exit(spa, SCL_STATE, FTAG); 6395e14bb325SJeff Bonwick 6396e14bb325SJeff Bonwick if (error == 0) 6397e14bb325SJeff Bonwick break; 6398e14bb325SJeff Bonwick zio_suspend(spa, NULL); 6399e14bb325SJeff Bonwick zio_resume_wait(spa); 64000373e76bSbonwick } 640199653d4eSeschrock dmu_tx_commit(tx); 640299653d4eSeschrock 6403283b8460SGeorge.Wilson VERIFY(cyclic_reprogram(spa->spa_deadman_cycid, CY_INFINITY)); 6404283b8460SGeorge.Wilson 64050373e76bSbonwick /* 64060373e76bSbonwick * Clear the dirty config list. 6407fa9e4066Sahrens */ 6408e14bb325SJeff Bonwick while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL) 64090373e76bSbonwick vdev_config_clean(vd); 64100373e76bSbonwick 64110373e76bSbonwick /* 64120373e76bSbonwick * Now that the new config has synced transactionally, 64130373e76bSbonwick * let it become visible to the config cache. 64140373e76bSbonwick */ 64150373e76bSbonwick if (spa->spa_config_syncing != NULL) { 64160373e76bSbonwick spa_config_set(spa, spa->spa_config_syncing); 64170373e76bSbonwick spa->spa_config_txg = txg; 64180373e76bSbonwick spa->spa_config_syncing = NULL; 64190373e76bSbonwick } 6420fa9e4066Sahrens 6421fa9e4066Sahrens spa->spa_ubsync = spa->spa_uberblock; 6422fa9e4066Sahrens 6423b24ab676SJeff Bonwick dsl_pool_sync_done(dp, txg); 6424fa9e4066Sahrens 6425fa9e4066Sahrens /* 6426fa9e4066Sahrens * Update usable space statistics. 6427fa9e4066Sahrens */ 6428fa9e4066Sahrens while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg))) 6429fa9e4066Sahrens vdev_sync_done(vd, txg); 6430fa9e4066Sahrens 6431485bbbf5SGeorge Wilson spa_update_dspace(spa); 6432485bbbf5SGeorge Wilson 6433fa9e4066Sahrens /* 6434fa9e4066Sahrens * It had better be the case that we didn't dirty anything 643599653d4eSeschrock * since vdev_config_sync(). 6436fa9e4066Sahrens */ 6437fa9e4066Sahrens ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); 6438fa9e4066Sahrens ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 6439fa9e4066Sahrens ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg)); 6440b24ab676SJeff Bonwick 6441b24ab676SJeff Bonwick spa->spa_sync_pass = 0; 6442fa9e4066Sahrens 6443e14bb325SJeff Bonwick spa_config_exit(spa, SCL_CONFIG, FTAG); 6444ea8dc4b6Seschrock 6445468c413aSTim Haley spa_handle_ignored_writes(spa); 6446468c413aSTim Haley 6447ea8dc4b6Seschrock /* 6448ea8dc4b6Seschrock * If any async tasks have been requested, kick them off. 6449ea8dc4b6Seschrock */ 6450ea8dc4b6Seschrock spa_async_dispatch(spa); 6451fa9e4066Sahrens } 6452fa9e4066Sahrens 6453fa9e4066Sahrens /* 6454fa9e4066Sahrens * Sync all pools. We don't want to hold the namespace lock across these 6455fa9e4066Sahrens * operations, so we take a reference on the spa_t and drop the lock during the 6456fa9e4066Sahrens * sync. 6457fa9e4066Sahrens */ 6458fa9e4066Sahrens void 6459fa9e4066Sahrens spa_sync_allpools(void) 6460fa9e4066Sahrens { 6461fa9e4066Sahrens spa_t *spa = NULL; 6462fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 6463fa9e4066Sahrens while ((spa = spa_next(spa)) != NULL) { 6464f9af39baSGeorge Wilson if (spa_state(spa) != POOL_STATE_ACTIVE || 6465f9af39baSGeorge Wilson !spa_writeable(spa) || spa_suspended(spa)) 6466fa9e4066Sahrens continue; 6467fa9e4066Sahrens spa_open_ref(spa, FTAG); 6468fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 6469fa9e4066Sahrens txg_wait_synced(spa_get_dsl(spa), 0); 6470fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 6471fa9e4066Sahrens spa_close(spa, FTAG); 6472fa9e4066Sahrens } 6473fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 6474fa9e4066Sahrens } 6475fa9e4066Sahrens 6476fa9e4066Sahrens /* 6477fa9e4066Sahrens * ========================================================================== 6478fa9e4066Sahrens * Miscellaneous routines 6479fa9e4066Sahrens * ========================================================================== 6480fa9e4066Sahrens */ 6481fa9e4066Sahrens 6482fa9e4066Sahrens /* 6483fa9e4066Sahrens * Remove all pools in the system. 6484fa9e4066Sahrens */ 6485fa9e4066Sahrens void 6486fa9e4066Sahrens spa_evict_all(void) 6487fa9e4066Sahrens { 6488fa9e4066Sahrens spa_t *spa; 6489fa9e4066Sahrens 6490fa9e4066Sahrens /* 6491fa9e4066Sahrens * Remove all cached state. All pools should be closed now, 6492fa9e4066Sahrens * so every spa in the AVL tree should be unreferenced. 6493fa9e4066Sahrens */ 6494fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 6495fa9e4066Sahrens while ((spa = spa_next(NULL)) != NULL) { 6496fa9e4066Sahrens /* 6497ea8dc4b6Seschrock * Stop async tasks. The async thread may need to detach 6498ea8dc4b6Seschrock * a device that's been replaced, which requires grabbing 6499ea8dc4b6Seschrock * spa_namespace_lock, so we must drop it here. 6500fa9e4066Sahrens */ 6501fa9e4066Sahrens spa_open_ref(spa, FTAG); 6502fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 6503ea8dc4b6Seschrock spa_async_suspend(spa); 6504fa9e4066Sahrens mutex_enter(&spa_namespace_lock); 6505fa9e4066Sahrens spa_close(spa, FTAG); 6506fa9e4066Sahrens 6507fa9e4066Sahrens if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 6508fa9e4066Sahrens spa_unload(spa); 6509fa9e4066Sahrens spa_deactivate(spa); 6510fa9e4066Sahrens } 6511fa9e4066Sahrens spa_remove(spa); 6512fa9e4066Sahrens } 6513fa9e4066Sahrens mutex_exit(&spa_namespace_lock); 6514fa9e4066Sahrens } 6515ea8dc4b6Seschrock 6516ea8dc4b6Seschrock vdev_t * 65176809eb4eSEric Schrock spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux) 6518ea8dc4b6Seschrock { 6519c5904d13Seschrock vdev_t *vd; 6520c5904d13Seschrock int i; 6521c5904d13Seschrock 6522c5904d13Seschrock if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL) 6523c5904d13Seschrock return (vd); 6524c5904d13Seschrock 65256809eb4eSEric Schrock if (aux) { 6526c5904d13Seschrock for (i = 0; i < spa->spa_l2cache.sav_count; i++) { 6527c5904d13Seschrock vd = spa->spa_l2cache.sav_vdevs[i]; 65286809eb4eSEric Schrock if (vd->vdev_guid == guid) 65296809eb4eSEric Schrock return (vd); 65306809eb4eSEric Schrock } 65316809eb4eSEric Schrock 65326809eb4eSEric Schrock for (i = 0; i < spa->spa_spares.sav_count; i++) { 65336809eb4eSEric Schrock vd = spa->spa_spares.sav_vdevs[i]; 6534c5904d13Seschrock if (vd->vdev_guid == guid) 6535c5904d13Seschrock return (vd); 6536c5904d13Seschrock } 6537c5904d13Seschrock } 6538c5904d13Seschrock 6539c5904d13Seschrock return (NULL); 6540ea8dc4b6Seschrock } 6541eaca9bbdSeschrock 6542eaca9bbdSeschrock void 6543990b4856Slling spa_upgrade(spa_t *spa, uint64_t version) 6544eaca9bbdSeschrock { 6545f9af39baSGeorge Wilson ASSERT(spa_writeable(spa)); 6546f9af39baSGeorge Wilson 6547e14bb325SJeff Bonwick spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6548eaca9bbdSeschrock 6549eaca9bbdSeschrock /* 6550eaca9bbdSeschrock * This should only be called for a non-faulted pool, and since a 6551eaca9bbdSeschrock * future version would result in an unopenable pool, this shouldn't be 6552eaca9bbdSeschrock * possible. 6553eaca9bbdSeschrock */ 655462eae887SRichard Yao ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version)); 65555d7b4d43SMatthew Ahrens ASSERT3U(version, >=, spa->spa_uberblock.ub_version); 6556eaca9bbdSeschrock 6557990b4856Slling spa->spa_uberblock.ub_version = version; 6558eaca9bbdSeschrock vdev_config_dirty(spa->spa_root_vdev); 6559eaca9bbdSeschrock 6560e14bb325SJeff Bonwick spa_config_exit(spa, SCL_ALL, FTAG); 656199653d4eSeschrock 656299653d4eSeschrock txg_wait_synced(spa_get_dsl(spa), 0); 656399653d4eSeschrock } 656499653d4eSeschrock 656599653d4eSeschrock boolean_t 656699653d4eSeschrock spa_has_spare(spa_t *spa, uint64_t guid) 656799653d4eSeschrock { 656899653d4eSeschrock int i; 656939c23413Seschrock uint64_t spareguid; 6570fa94a07fSbrendan spa_aux_vdev_t *sav = &spa->spa_spares; 657199653d4eSeschrock 6572fa94a07fSbrendan for (i = 0; i < sav->sav_count; i++) 6573fa94a07fSbrendan if (sav->sav_vdevs[i]->vdev_guid == guid) 657499653d4eSeschrock return (B_TRUE); 657599653d4eSeschrock 6576fa94a07fSbrendan for (i = 0; i < sav->sav_npending; i++) { 6577fa94a07fSbrendan if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID, 6578fa94a07fSbrendan &spareguid) == 0 && spareguid == guid) 657939c23413Seschrock return (B_TRUE); 658039c23413Seschrock } 658139c23413Seschrock 658299653d4eSeschrock return (B_FALSE); 6583eaca9bbdSeschrock } 6584b1b8ab34Slling 658589a89ebfSlling /* 658689a89ebfSlling * Check if a pool has an active shared spare device. 658789a89ebfSlling * Note: reference count of an active spare is 2, as a spare and as a replace 658889a89ebfSlling */ 658989a89ebfSlling static boolean_t 659089a89ebfSlling spa_has_active_shared_spare(spa_t *spa) 659189a89ebfSlling { 659289a89ebfSlling int i, refcnt; 659389a89ebfSlling uint64_t pool; 659489a89ebfSlling spa_aux_vdev_t *sav = &spa->spa_spares; 659589a89ebfSlling 659689a89ebfSlling for (i = 0; i < sav->sav_count; i++) { 659789a89ebfSlling if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool, 659889a89ebfSlling &refcnt) && pool != 0ULL && pool == spa_guid(spa) && 659989a89ebfSlling refcnt > 2) 660089a89ebfSlling return (B_TRUE); 660189a89ebfSlling } 660289a89ebfSlling 660389a89ebfSlling return (B_FALSE); 660489a89ebfSlling } 660589a89ebfSlling 66063d7072f8Seschrock /* 66073d7072f8Seschrock * Post a sysevent corresponding to the given event. The 'name' must be one of 66083d7072f8Seschrock * the event definitions in sys/sysevent/eventdefs.h. The payload will be 66093d7072f8Seschrock * filled in from the spa and (optionally) the vdev. This doesn't do anything 66103d7072f8Seschrock * in the userland libzpool, as we don't want consumers to misinterpret ztest 66113d7072f8Seschrock * or zdb as real changes. 66123d7072f8Seschrock */ 66133d7072f8Seschrock void 66143d7072f8Seschrock spa_event_notify(spa_t *spa, vdev_t *vd, const char *name) 66153d7072f8Seschrock { 66163d7072f8Seschrock #ifdef _KERNEL 66173d7072f8Seschrock sysevent_t *ev; 66183d7072f8Seschrock sysevent_attr_list_t *attr = NULL; 66193d7072f8Seschrock sysevent_value_t value; 66203d7072f8Seschrock sysevent_id_t eid; 66213d7072f8Seschrock 66223d7072f8Seschrock ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs", 66233d7072f8Seschrock SE_SLEEP); 66243d7072f8Seschrock 66253d7072f8Seschrock value.value_type = SE_DATA_TYPE_STRING; 66263d7072f8Seschrock value.value.sv_string = spa_name(spa); 66273d7072f8Seschrock if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0) 66283d7072f8Seschrock goto done; 66293d7072f8Seschrock 66303d7072f8Seschrock value.value_type = SE_DATA_TYPE_UINT64; 66313d7072f8Seschrock value.value.sv_uint64 = spa_guid(spa); 66323d7072f8Seschrock if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0) 66333d7072f8Seschrock goto done; 66343d7072f8Seschrock 66353d7072f8Seschrock if (vd) { 66363d7072f8Seschrock value.value_type = SE_DATA_TYPE_UINT64; 66373d7072f8Seschrock value.value.sv_uint64 = vd->vdev_guid; 66383d7072f8Seschrock if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value, 66393d7072f8Seschrock SE_SLEEP) != 0) 66403d7072f8Seschrock goto done; 66413d7072f8Seschrock 66423d7072f8Seschrock if (vd->vdev_path) { 66433d7072f8Seschrock value.value_type = SE_DATA_TYPE_STRING; 66443d7072f8Seschrock value.value.sv_string = vd->vdev_path; 66453d7072f8Seschrock if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH, 66463d7072f8Seschrock &value, SE_SLEEP) != 0) 66473d7072f8Seschrock goto done; 66483d7072f8Seschrock } 66493d7072f8Seschrock } 66503d7072f8Seschrock 6651b01c3b58Seschrock if (sysevent_attach_attributes(ev, attr) != 0) 6652b01c3b58Seschrock goto done; 6653b01c3b58Seschrock attr = NULL; 6654b01c3b58Seschrock 66553d7072f8Seschrock (void) log_sysevent(ev, SE_SLEEP, &eid); 66563d7072f8Seschrock 66573d7072f8Seschrock done: 66583d7072f8Seschrock if (attr) 66593d7072f8Seschrock sysevent_free_attr(attr); 66603d7072f8Seschrock sysevent_free(ev); 66613d7072f8Seschrock #endif 66623d7072f8Seschrock } 6663