1eda14cbcSMatt Macy /* 2eda14cbcSMatt Macy * CDDL HEADER START 3eda14cbcSMatt Macy * 4eda14cbcSMatt Macy * The contents of this file are subject to the terms of the 5eda14cbcSMatt Macy * Common Development and Distribution License (the "License"). 6eda14cbcSMatt Macy * You may not use this file except in compliance with the License. 7eda14cbcSMatt Macy * 8eda14cbcSMatt Macy * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9271171e0SMartin Matuska * or https://opensource.org/licenses/CDDL-1.0. 10eda14cbcSMatt Macy * See the License for the specific language governing permissions 11eda14cbcSMatt Macy * and limitations under the License. 12eda14cbcSMatt Macy * 13eda14cbcSMatt Macy * When distributing Covered Code, include this CDDL HEADER in each 14eda14cbcSMatt Macy * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15eda14cbcSMatt Macy * If applicable, add the following below this CDDL HEADER, with the 16eda14cbcSMatt Macy * fields enclosed by brackets "[]" replaced with your own identifying 17eda14cbcSMatt Macy * information: Portions Copyright [yyyy] [name of copyright owner] 18eda14cbcSMatt Macy * 19eda14cbcSMatt Macy * CDDL HEADER END 20eda14cbcSMatt Macy */ 21eda14cbcSMatt Macy 22eda14cbcSMatt Macy /* 23eda14cbcSMatt Macy * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 242c48331dSMatt Macy * Copyright (c) 2011, 2020 by Delphix. All rights reserved. 25eda14cbcSMatt Macy * Copyright (c) 2018, Nexenta Systems, Inc. All rights reserved. 26eda14cbcSMatt Macy * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved. 27eda14cbcSMatt Macy * Copyright 2013 Saso Kiselkov. All rights reserved. 28eda14cbcSMatt Macy * Copyright (c) 2014 Integros [integros.com] 29eda14cbcSMatt Macy * Copyright 2016 Toomas Soome <tsoome@me.com> 30eda14cbcSMatt Macy * Copyright (c) 2016 Actifio, Inc. All rights reserved. 31eda14cbcSMatt Macy * Copyright 2018 Joyent, Inc. 32eda14cbcSMatt Macy * Copyright (c) 2017, 2019, Datto Inc. All rights reserved. 33eda14cbcSMatt Macy * Copyright 2017 Joyent, Inc. 34eda14cbcSMatt Macy * Copyright (c) 2017, Intel Corporation. 35ee36e25aSMartin Matuska * Copyright (c) 2021, Colm Buckley <colm@tuatha.org> 364e8d558cSMartin Matuska * Copyright (c) 2023 Hewlett Packard Enterprise Development LP. 37eda14cbcSMatt Macy */ 38eda14cbcSMatt Macy 39eda14cbcSMatt Macy /* 40eda14cbcSMatt Macy * SPA: Storage Pool Allocator 41eda14cbcSMatt Macy * 42eda14cbcSMatt Macy * This file contains all the routines used when modifying on-disk SPA state. 43eda14cbcSMatt Macy * This includes opening, importing, destroying, exporting a pool, and syncing a 44eda14cbcSMatt Macy * pool. 45eda14cbcSMatt Macy */ 46eda14cbcSMatt Macy 47eda14cbcSMatt Macy #include <sys/zfs_context.h> 48eda14cbcSMatt Macy #include <sys/fm/fs/zfs.h> 49eda14cbcSMatt Macy #include <sys/spa_impl.h> 50eda14cbcSMatt Macy #include <sys/zio.h> 51eda14cbcSMatt Macy #include <sys/zio_checksum.h> 52eda14cbcSMatt Macy #include <sys/dmu.h> 53eda14cbcSMatt Macy #include <sys/dmu_tx.h> 54eda14cbcSMatt Macy #include <sys/zap.h> 55eda14cbcSMatt Macy #include <sys/zil.h> 562a58b312SMartin Matuska #include <sys/brt.h> 57eda14cbcSMatt Macy #include <sys/ddt.h> 58eda14cbcSMatt Macy #include <sys/vdev_impl.h> 59eda14cbcSMatt Macy #include <sys/vdev_removal.h> 60eda14cbcSMatt Macy #include <sys/vdev_indirect_mapping.h> 61eda14cbcSMatt Macy #include <sys/vdev_indirect_births.h> 62eda14cbcSMatt Macy #include <sys/vdev_initialize.h> 63eda14cbcSMatt Macy #include <sys/vdev_rebuild.h> 64eda14cbcSMatt Macy #include <sys/vdev_trim.h> 65eda14cbcSMatt Macy #include <sys/vdev_disk.h> 667877fdebSMatt Macy #include <sys/vdev_draid.h> 67eda14cbcSMatt Macy #include <sys/metaslab.h> 68eda14cbcSMatt Macy #include <sys/metaslab_impl.h> 69eda14cbcSMatt Macy #include <sys/mmp.h> 70eda14cbcSMatt Macy #include <sys/uberblock_impl.h> 71eda14cbcSMatt Macy #include <sys/txg.h> 72eda14cbcSMatt Macy #include <sys/avl.h> 73eda14cbcSMatt Macy #include <sys/bpobj.h> 74eda14cbcSMatt Macy #include <sys/dmu_traverse.h> 75eda14cbcSMatt Macy #include <sys/dmu_objset.h> 76eda14cbcSMatt Macy #include <sys/unique.h> 77eda14cbcSMatt Macy #include <sys/dsl_pool.h> 78eda14cbcSMatt Macy #include <sys/dsl_dataset.h> 79eda14cbcSMatt Macy #include <sys/dsl_dir.h> 80eda14cbcSMatt Macy #include <sys/dsl_prop.h> 81eda14cbcSMatt Macy #include <sys/dsl_synctask.h> 82eda14cbcSMatt Macy #include <sys/fs/zfs.h> 83eda14cbcSMatt Macy #include <sys/arc.h> 84eda14cbcSMatt Macy #include <sys/callb.h> 85eda14cbcSMatt Macy #include <sys/systeminfo.h> 86eda14cbcSMatt Macy #include <sys/zfs_ioctl.h> 87eda14cbcSMatt Macy #include <sys/dsl_scan.h> 88eda14cbcSMatt Macy #include <sys/zfeature.h> 89eda14cbcSMatt Macy #include <sys/dsl_destroy.h> 90eda14cbcSMatt Macy #include <sys/zvol.h> 91eda14cbcSMatt Macy 92eda14cbcSMatt Macy #ifdef _KERNEL 93eda14cbcSMatt Macy #include <sys/fm/protocol.h> 94eda14cbcSMatt Macy #include <sys/fm/util.h> 95eda14cbcSMatt Macy #include <sys/callb.h> 96eda14cbcSMatt Macy #include <sys/zone.h> 97eda14cbcSMatt Macy #include <sys/vmsystm.h> 98eda14cbcSMatt Macy #endif /* _KERNEL */ 99eda14cbcSMatt Macy 100eda14cbcSMatt Macy #include "zfs_prop.h" 101eda14cbcSMatt Macy #include "zfs_comutil.h" 102eda14cbcSMatt Macy 103eda14cbcSMatt Macy /* 104eda14cbcSMatt Macy * The interval, in seconds, at which failed configuration cache file writes 105eda14cbcSMatt Macy * should be retried. 106eda14cbcSMatt Macy */ 107eda14cbcSMatt Macy int zfs_ccw_retry_interval = 300; 108eda14cbcSMatt Macy 109eda14cbcSMatt Macy typedef enum zti_modes { 110eda14cbcSMatt Macy ZTI_MODE_FIXED, /* value is # of threads (min 1) */ 111eda14cbcSMatt Macy ZTI_MODE_BATCH, /* cpu-intensive; value is ignored */ 11216038816SMartin Matuska ZTI_MODE_SCALE, /* Taskqs scale with CPUs. */ 113eda14cbcSMatt Macy ZTI_MODE_NULL, /* don't create a taskq */ 114eda14cbcSMatt Macy ZTI_NMODES 115eda14cbcSMatt Macy } zti_modes_t; 116eda14cbcSMatt Macy 117eda14cbcSMatt Macy #define ZTI_P(n, q) { ZTI_MODE_FIXED, (n), (q) } 118eda14cbcSMatt Macy #define ZTI_PCT(n) { ZTI_MODE_ONLINE_PERCENT, (n), 1 } 119eda14cbcSMatt Macy #define ZTI_BATCH { ZTI_MODE_BATCH, 0, 1 } 12016038816SMartin Matuska #define ZTI_SCALE { ZTI_MODE_SCALE, 0, 1 } 121eda14cbcSMatt Macy #define ZTI_NULL { ZTI_MODE_NULL, 0, 0 } 122eda14cbcSMatt Macy 123eda14cbcSMatt Macy #define ZTI_N(n) ZTI_P(n, 1) 124eda14cbcSMatt Macy #define ZTI_ONE ZTI_N(1) 125eda14cbcSMatt Macy 126eda14cbcSMatt Macy typedef struct zio_taskq_info { 127eda14cbcSMatt Macy zti_modes_t zti_mode; 128eda14cbcSMatt Macy uint_t zti_value; 129eda14cbcSMatt Macy uint_t zti_count; 130eda14cbcSMatt Macy } zio_taskq_info_t; 131eda14cbcSMatt Macy 132eda14cbcSMatt Macy static const char *const zio_taskq_types[ZIO_TASKQ_TYPES] = { 133eda14cbcSMatt Macy "iss", "iss_h", "int", "int_h" 134eda14cbcSMatt Macy }; 135eda14cbcSMatt Macy 136eda14cbcSMatt Macy /* 137eda14cbcSMatt Macy * This table defines the taskq settings for each ZFS I/O type. When 138eda14cbcSMatt Macy * initializing a pool, we use this table to create an appropriately sized 139eda14cbcSMatt Macy * taskq. Some operations are low volume and therefore have a small, static 140eda14cbcSMatt Macy * number of threads assigned to their taskqs using the ZTI_N(#) or ZTI_ONE 141eda14cbcSMatt Macy * macros. Other operations process a large amount of data; the ZTI_BATCH 142eda14cbcSMatt Macy * macro causes us to create a taskq oriented for throughput. Some operations 143eda14cbcSMatt Macy * are so high frequency and short-lived that the taskq itself can become a 144eda14cbcSMatt Macy * point of lock contention. The ZTI_P(#, #) macro indicates that we need an 145eda14cbcSMatt Macy * additional degree of parallelism specified by the number of threads per- 146eda14cbcSMatt Macy * taskq and the number of taskqs; when dispatching an event in this case, the 14716038816SMartin Matuska * particular taskq is chosen at random. ZTI_SCALE is similar to ZTI_BATCH, 14816038816SMartin Matuska * but with number of taskqs also scaling with number of CPUs. 149eda14cbcSMatt Macy * 150eda14cbcSMatt Macy * The different taskq priorities are to handle the different contexts (issue 151eda14cbcSMatt Macy * and interrupt) and then to reserve threads for ZIO_PRIORITY_NOW I/Os that 152eda14cbcSMatt Macy * need to be handled with minimum delay. 153eda14cbcSMatt Macy */ 154e92ffd9bSMartin Matuska static const zio_taskq_info_t zio_taskqs[ZIO_TYPES][ZIO_TASKQ_TYPES] = { 155eda14cbcSMatt Macy /* ISSUE ISSUE_HIGH INTR INTR_HIGH */ 156eda14cbcSMatt Macy { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* NULL */ 15716038816SMartin Matuska { ZTI_N(8), ZTI_NULL, ZTI_SCALE, ZTI_NULL }, /* READ */ 15816038816SMartin Matuska { ZTI_BATCH, ZTI_N(5), ZTI_SCALE, ZTI_N(5) }, /* WRITE */ 15916038816SMartin Matuska { ZTI_SCALE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* FREE */ 160eda14cbcSMatt Macy { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* CLAIM */ 161eda14cbcSMatt Macy { ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* IOCTL */ 162eda14cbcSMatt Macy { ZTI_N(4), ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* TRIM */ 163eda14cbcSMatt Macy }; 164eda14cbcSMatt Macy 165eda14cbcSMatt Macy static void spa_sync_version(void *arg, dmu_tx_t *tx); 166eda14cbcSMatt Macy static void spa_sync_props(void *arg, dmu_tx_t *tx); 167eda14cbcSMatt Macy static boolean_t spa_has_active_shared_spare(spa_t *spa); 168a0b956f5SMartin Matuska static int spa_load_impl(spa_t *spa, spa_import_type_t type, 169a0b956f5SMartin Matuska const char **ereport); 170eda14cbcSMatt Macy static void spa_vdev_resilver_done(spa_t *spa); 171eda14cbcSMatt Macy 172b2526e8bSMartin Matuska /* 173b2526e8bSMartin Matuska * Percentage of all CPUs that can be used by the metaslab preload taskq. 174b2526e8bSMartin Matuska */ 175b2526e8bSMartin Matuska static uint_t metaslab_preload_pct = 50; 176b2526e8bSMartin Matuska 177e92ffd9bSMartin Matuska static uint_t zio_taskq_batch_pct = 80; /* 1 thread per cpu in pset */ 178e92ffd9bSMartin Matuska static uint_t zio_taskq_batch_tpq; /* threads per taskq */ 179e92ffd9bSMartin Matuska static const boolean_t zio_taskq_sysdc = B_TRUE; /* use SDC scheduling class */ 180e92ffd9bSMartin Matuska static const uint_t zio_taskq_basedc = 80; /* base duty cycle */ 181eda14cbcSMatt Macy 182e92ffd9bSMartin Matuska static const boolean_t spa_create_process = B_TRUE; /* no process => no sysdc */ 183eda14cbcSMatt Macy 184eda14cbcSMatt Macy /* 185eda14cbcSMatt Macy * Report any spa_load_verify errors found, but do not fail spa_load. 186eda14cbcSMatt Macy * This is used by zdb to analyze non-idle pools. 187eda14cbcSMatt Macy */ 188eda14cbcSMatt Macy boolean_t spa_load_verify_dryrun = B_FALSE; 189eda14cbcSMatt Macy 190eda14cbcSMatt Macy /* 19181b22a98SMartin Matuska * Allow read spacemaps in case of readonly import (spa_mode == SPA_MODE_READ). 19281b22a98SMartin Matuska * This is used by zdb for spacemaps verification. 19381b22a98SMartin Matuska */ 19481b22a98SMartin Matuska boolean_t spa_mode_readable_spacemaps = B_FALSE; 19581b22a98SMartin Matuska 19681b22a98SMartin Matuska /* 197eda14cbcSMatt Macy * This (illegal) pool name is used when temporarily importing a spa_t in order 198eda14cbcSMatt Macy * to get the vdev stats associated with the imported devices. 199eda14cbcSMatt Macy */ 200eda14cbcSMatt Macy #define TRYIMPORT_NAME "$import" 201eda14cbcSMatt Macy 202eda14cbcSMatt Macy /* 203eda14cbcSMatt Macy * For debugging purposes: print out vdev tree during pool import. 204eda14cbcSMatt Macy */ 205e92ffd9bSMartin Matuska static int spa_load_print_vdev_tree = B_FALSE; 206eda14cbcSMatt Macy 207eda14cbcSMatt Macy /* 208eda14cbcSMatt Macy * A non-zero value for zfs_max_missing_tvds means that we allow importing 209eda14cbcSMatt Macy * pools with missing top-level vdevs. This is strictly intended for advanced 210eda14cbcSMatt Macy * pool recovery cases since missing data is almost inevitable. Pools with 211eda14cbcSMatt Macy * missing devices can only be imported read-only for safety reasons, and their 212eda14cbcSMatt Macy * fail-mode will be automatically set to "continue". 213eda14cbcSMatt Macy * 214eda14cbcSMatt Macy * With 1 missing vdev we should be able to import the pool and mount all 215eda14cbcSMatt Macy * datasets. User data that was not modified after the missing device has been 216eda14cbcSMatt Macy * added should be recoverable. This means that snapshots created prior to the 217eda14cbcSMatt Macy * addition of that device should be completely intact. 218eda14cbcSMatt Macy * 219eda14cbcSMatt Macy * With 2 missing vdevs, some datasets may fail to mount since there are 220eda14cbcSMatt Macy * dataset statistics that are stored as regular metadata. Some data might be 221eda14cbcSMatt Macy * recoverable if those vdevs were added recently. 222eda14cbcSMatt Macy * 223eda14cbcSMatt Macy * With 3 or more missing vdevs, the pool is severely damaged and MOS entries 224eda14cbcSMatt Macy * may be missing entirely. Chances of data recovery are very low. Note that 225eda14cbcSMatt Macy * there are also risks of performing an inadvertent rewind as we might be 226eda14cbcSMatt Macy * missing all the vdevs with the latest uberblocks. 227eda14cbcSMatt Macy */ 228dbd5678dSMartin Matuska uint64_t zfs_max_missing_tvds = 0; 229eda14cbcSMatt Macy 230eda14cbcSMatt Macy /* 231eda14cbcSMatt Macy * The parameters below are similar to zfs_max_missing_tvds but are only 232eda14cbcSMatt Macy * intended for a preliminary open of the pool with an untrusted config which 233eda14cbcSMatt Macy * might be incomplete or out-dated. 234eda14cbcSMatt Macy * 235eda14cbcSMatt Macy * We are more tolerant for pools opened from a cachefile since we could have 236eda14cbcSMatt Macy * an out-dated cachefile where a device removal was not registered. 237eda14cbcSMatt Macy * We could have set the limit arbitrarily high but in the case where devices 238eda14cbcSMatt Macy * are really missing we would want to return the proper error codes; we chose 239eda14cbcSMatt Macy * SPA_DVAS_PER_BP - 1 so that some copies of the MOS would still be available 240eda14cbcSMatt Macy * and we get a chance to retrieve the trusted config. 241eda14cbcSMatt Macy */ 242eda14cbcSMatt Macy uint64_t zfs_max_missing_tvds_cachefile = SPA_DVAS_PER_BP - 1; 243eda14cbcSMatt Macy 244eda14cbcSMatt Macy /* 245eda14cbcSMatt Macy * In the case where config was assembled by scanning device paths (/dev/dsks 246eda14cbcSMatt Macy * by default) we are less tolerant since all the existing devices should have 247eda14cbcSMatt Macy * been detected and we want spa_load to return the right error codes. 248eda14cbcSMatt Macy */ 249eda14cbcSMatt Macy uint64_t zfs_max_missing_tvds_scan = 0; 250eda14cbcSMatt Macy 251eda14cbcSMatt Macy /* 252eda14cbcSMatt Macy * Debugging aid that pauses spa_sync() towards the end. 253eda14cbcSMatt Macy */ 254e92ffd9bSMartin Matuska static const boolean_t zfs_pause_spa_sync = B_FALSE; 255eda14cbcSMatt Macy 256eda14cbcSMatt Macy /* 257eda14cbcSMatt Macy * Variables to indicate the livelist condense zthr func should wait at certain 258eda14cbcSMatt Macy * points for the livelist to be removed - used to test condense/destroy races 259eda14cbcSMatt Macy */ 260e92ffd9bSMartin Matuska static int zfs_livelist_condense_zthr_pause = 0; 261e92ffd9bSMartin Matuska static int zfs_livelist_condense_sync_pause = 0; 262eda14cbcSMatt Macy 263eda14cbcSMatt Macy /* 264eda14cbcSMatt Macy * Variables to track whether or not condense cancellation has been 265eda14cbcSMatt Macy * triggered in testing. 266eda14cbcSMatt Macy */ 267e92ffd9bSMartin Matuska static int zfs_livelist_condense_sync_cancel = 0; 268e92ffd9bSMartin Matuska static int zfs_livelist_condense_zthr_cancel = 0; 269eda14cbcSMatt Macy 270eda14cbcSMatt Macy /* 271eda14cbcSMatt Macy * Variable to track whether or not extra ALLOC blkptrs were added to a 272eda14cbcSMatt Macy * livelist entry while it was being condensed (caused by the way we track 273eda14cbcSMatt Macy * remapped blkptrs in dbuf_remap_impl) 274eda14cbcSMatt Macy */ 275e92ffd9bSMartin Matuska static int zfs_livelist_condense_new_alloc = 0; 276eda14cbcSMatt Macy 277eda14cbcSMatt Macy /* 278eda14cbcSMatt Macy * ========================================================================== 279eda14cbcSMatt Macy * SPA properties routines 280eda14cbcSMatt Macy * ========================================================================== 281eda14cbcSMatt Macy */ 282eda14cbcSMatt Macy 283eda14cbcSMatt Macy /* 284eda14cbcSMatt Macy * Add a (source=src, propname=propval) list to an nvlist. 285eda14cbcSMatt Macy */ 286eda14cbcSMatt Macy static void 287a0b956f5SMartin Matuska spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, const char *strval, 288eda14cbcSMatt Macy uint64_t intval, zprop_source_t src) 289eda14cbcSMatt Macy { 290eda14cbcSMatt Macy const char *propname = zpool_prop_to_name(prop); 291eda14cbcSMatt Macy nvlist_t *propval; 292eda14cbcSMatt Macy 29381b22a98SMartin Matuska propval = fnvlist_alloc(); 29481b22a98SMartin Matuska fnvlist_add_uint64(propval, ZPROP_SOURCE, src); 295eda14cbcSMatt Macy 296eda14cbcSMatt Macy if (strval != NULL) 29781b22a98SMartin Matuska fnvlist_add_string(propval, ZPROP_VALUE, strval); 298eda14cbcSMatt Macy else 29981b22a98SMartin Matuska fnvlist_add_uint64(propval, ZPROP_VALUE, intval); 300eda14cbcSMatt Macy 30181b22a98SMartin Matuska fnvlist_add_nvlist(nvl, propname, propval); 302eda14cbcSMatt Macy nvlist_free(propval); 303eda14cbcSMatt Macy } 304eda14cbcSMatt Macy 305eda14cbcSMatt Macy /* 306c98ecfceSAllan Jude * Add a user property (source=src, propname=propval) to an nvlist. 307c98ecfceSAllan Jude */ 308c98ecfceSAllan Jude static void 309c98ecfceSAllan Jude spa_prop_add_user(nvlist_t *nvl, const char *propname, char *strval, 310c98ecfceSAllan Jude zprop_source_t src) 311c98ecfceSAllan Jude { 312c98ecfceSAllan Jude nvlist_t *propval; 313c98ecfceSAllan Jude 314c98ecfceSAllan Jude VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0); 315c98ecfceSAllan Jude VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0); 316c98ecfceSAllan Jude VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0); 317c98ecfceSAllan Jude VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0); 318c98ecfceSAllan Jude nvlist_free(propval); 319c98ecfceSAllan Jude } 320c98ecfceSAllan Jude 321c98ecfceSAllan Jude /* 322eda14cbcSMatt Macy * Get property values from the spa configuration. 323eda14cbcSMatt Macy */ 324eda14cbcSMatt Macy static void 325eda14cbcSMatt Macy spa_prop_get_config(spa_t *spa, nvlist_t **nvp) 326eda14cbcSMatt Macy { 327eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 328eda14cbcSMatt Macy dsl_pool_t *pool = spa->spa_dsl_pool; 329eda14cbcSMatt Macy uint64_t size, alloc, cap, version; 330eda14cbcSMatt Macy const zprop_source_t src = ZPROP_SRC_NONE; 331eda14cbcSMatt Macy spa_config_dirent_t *dp; 332eda14cbcSMatt Macy metaslab_class_t *mc = spa_normal_class(spa); 333eda14cbcSMatt Macy 334eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa->spa_props_lock)); 335eda14cbcSMatt Macy 336eda14cbcSMatt Macy if (rvd != NULL) { 337eda14cbcSMatt Macy alloc = metaslab_class_get_alloc(mc); 338eda14cbcSMatt Macy alloc += metaslab_class_get_alloc(spa_special_class(spa)); 339eda14cbcSMatt Macy alloc += metaslab_class_get_alloc(spa_dedup_class(spa)); 340184c1b94SMartin Matuska alloc += metaslab_class_get_alloc(spa_embedded_log_class(spa)); 341eda14cbcSMatt Macy 342eda14cbcSMatt Macy size = metaslab_class_get_space(mc); 343eda14cbcSMatt Macy size += metaslab_class_get_space(spa_special_class(spa)); 344eda14cbcSMatt Macy size += metaslab_class_get_space(spa_dedup_class(spa)); 345184c1b94SMartin Matuska size += metaslab_class_get_space(spa_embedded_log_class(spa)); 346eda14cbcSMatt Macy 347eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src); 348eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src); 349eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_ALLOCATED, NULL, alloc, src); 350eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_FREE, NULL, 351eda14cbcSMatt Macy size - alloc, src); 352eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_CHECKPOINT, NULL, 353eda14cbcSMatt Macy spa->spa_checkpoint_info.sci_dspace, src); 354eda14cbcSMatt Macy 355eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_FRAGMENTATION, NULL, 356eda14cbcSMatt Macy metaslab_class_fragmentation(mc), src); 357eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_EXPANDSZ, NULL, 358eda14cbcSMatt Macy metaslab_class_expandable_space(mc), src); 359eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_READONLY, NULL, 360eda14cbcSMatt Macy (spa_mode(spa) == SPA_MODE_READ), src); 361eda14cbcSMatt Macy 362eda14cbcSMatt Macy cap = (size == 0) ? 0 : (alloc * 100 / size); 363eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src); 364eda14cbcSMatt Macy 365eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_DEDUPRATIO, NULL, 366eda14cbcSMatt Macy ddt_get_pool_dedup_ratio(spa), src); 3672a58b312SMartin Matuska spa_prop_add_list(*nvp, ZPOOL_PROP_BCLONEUSED, NULL, 3682a58b312SMartin Matuska brt_get_used(spa), src); 3692a58b312SMartin Matuska spa_prop_add_list(*nvp, ZPOOL_PROP_BCLONESAVED, NULL, 3702a58b312SMartin Matuska brt_get_saved(spa), src); 3712a58b312SMartin Matuska spa_prop_add_list(*nvp, ZPOOL_PROP_BCLONERATIO, NULL, 3722a58b312SMartin Matuska brt_get_ratio(spa), src); 373eda14cbcSMatt Macy 374eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL, 375eda14cbcSMatt Macy rvd->vdev_state, src); 376eda14cbcSMatt Macy 377eda14cbcSMatt Macy version = spa_version(spa); 378eda14cbcSMatt Macy if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION)) { 379eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, 380eda14cbcSMatt Macy version, ZPROP_SRC_DEFAULT); 381eda14cbcSMatt Macy } else { 382eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, 383eda14cbcSMatt Macy version, ZPROP_SRC_LOCAL); 384eda14cbcSMatt Macy } 385eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_LOAD_GUID, 386eda14cbcSMatt Macy NULL, spa_load_guid(spa), src); 387eda14cbcSMatt Macy } 388eda14cbcSMatt Macy 389eda14cbcSMatt Macy if (pool != NULL) { 390eda14cbcSMatt Macy /* 391eda14cbcSMatt Macy * The $FREE directory was introduced in SPA_VERSION_DEADLISTS, 392eda14cbcSMatt Macy * when opening pools before this version freedir will be NULL. 393eda14cbcSMatt Macy */ 394eda14cbcSMatt Macy if (pool->dp_free_dir != NULL) { 395eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING, NULL, 396eda14cbcSMatt Macy dsl_dir_phys(pool->dp_free_dir)->dd_used_bytes, 397eda14cbcSMatt Macy src); 398eda14cbcSMatt Macy } else { 399eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING, 400eda14cbcSMatt Macy NULL, 0, src); 401eda14cbcSMatt Macy } 402eda14cbcSMatt Macy 403eda14cbcSMatt Macy if (pool->dp_leak_dir != NULL) { 404eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED, NULL, 405eda14cbcSMatt Macy dsl_dir_phys(pool->dp_leak_dir)->dd_used_bytes, 406eda14cbcSMatt Macy src); 407eda14cbcSMatt Macy } else { 408eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED, 409eda14cbcSMatt Macy NULL, 0, src); 410eda14cbcSMatt Macy } 411eda14cbcSMatt Macy } 412eda14cbcSMatt Macy 413eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src); 414eda14cbcSMatt Macy 415eda14cbcSMatt Macy if (spa->spa_comment != NULL) { 416eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_COMMENT, spa->spa_comment, 417eda14cbcSMatt Macy 0, ZPROP_SRC_LOCAL); 418eda14cbcSMatt Macy } 419eda14cbcSMatt Macy 420ee36e25aSMartin Matuska if (spa->spa_compatibility != NULL) { 421ee36e25aSMartin Matuska spa_prop_add_list(*nvp, ZPOOL_PROP_COMPATIBILITY, 422ee36e25aSMartin Matuska spa->spa_compatibility, 0, ZPROP_SRC_LOCAL); 423ee36e25aSMartin Matuska } 424ee36e25aSMartin Matuska 425eda14cbcSMatt Macy if (spa->spa_root != NULL) 426eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root, 427eda14cbcSMatt Macy 0, ZPROP_SRC_LOCAL); 428eda14cbcSMatt Macy 429eda14cbcSMatt Macy if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) { 430eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL, 431eda14cbcSMatt Macy MIN(zfs_max_recordsize, SPA_MAXBLOCKSIZE), ZPROP_SRC_NONE); 432eda14cbcSMatt Macy } else { 433eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL, 434eda14cbcSMatt Macy SPA_OLD_MAXBLOCKSIZE, ZPROP_SRC_NONE); 435eda14cbcSMatt Macy } 436eda14cbcSMatt Macy 437eda14cbcSMatt Macy if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_DNODE)) { 438eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_MAXDNODESIZE, NULL, 439eda14cbcSMatt Macy DNODE_MAX_SIZE, ZPROP_SRC_NONE); 440eda14cbcSMatt Macy } else { 441eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_MAXDNODESIZE, NULL, 442eda14cbcSMatt Macy DNODE_MIN_SIZE, ZPROP_SRC_NONE); 443eda14cbcSMatt Macy } 444eda14cbcSMatt Macy 445eda14cbcSMatt Macy if ((dp = list_head(&spa->spa_config_list)) != NULL) { 446eda14cbcSMatt Macy if (dp->scd_path == NULL) { 447eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, 448eda14cbcSMatt Macy "none", 0, ZPROP_SRC_LOCAL); 449eda14cbcSMatt Macy } else if (strcmp(dp->scd_path, spa_config_path) != 0) { 450eda14cbcSMatt Macy spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, 451eda14cbcSMatt Macy dp->scd_path, 0, ZPROP_SRC_LOCAL); 452eda14cbcSMatt Macy } 453eda14cbcSMatt Macy } 454eda14cbcSMatt Macy } 455eda14cbcSMatt Macy 456eda14cbcSMatt Macy /* 457eda14cbcSMatt Macy * Get zpool property values. 458eda14cbcSMatt Macy */ 459eda14cbcSMatt Macy int 460eda14cbcSMatt Macy spa_prop_get(spa_t *spa, nvlist_t **nvp) 461eda14cbcSMatt Macy { 462eda14cbcSMatt Macy objset_t *mos = spa->spa_meta_objset; 463eda14cbcSMatt Macy zap_cursor_t zc; 464eda14cbcSMatt Macy zap_attribute_t za; 465eda14cbcSMatt Macy dsl_pool_t *dp; 466eda14cbcSMatt Macy int err; 467eda14cbcSMatt Macy 468eda14cbcSMatt Macy err = nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP); 469eda14cbcSMatt Macy if (err) 470eda14cbcSMatt Macy return (err); 471eda14cbcSMatt Macy 472eda14cbcSMatt Macy dp = spa_get_dsl(spa); 473eda14cbcSMatt Macy dsl_pool_config_enter(dp, FTAG); 474eda14cbcSMatt Macy mutex_enter(&spa->spa_props_lock); 475eda14cbcSMatt Macy 476eda14cbcSMatt Macy /* 477eda14cbcSMatt Macy * Get properties from the spa config. 478eda14cbcSMatt Macy */ 479eda14cbcSMatt Macy spa_prop_get_config(spa, nvp); 480eda14cbcSMatt Macy 481eda14cbcSMatt Macy /* If no pool property object, no more prop to get. */ 482eda14cbcSMatt Macy if (mos == NULL || spa->spa_pool_props_object == 0) 483eda14cbcSMatt Macy goto out; 484eda14cbcSMatt Macy 485eda14cbcSMatt Macy /* 486eda14cbcSMatt Macy * Get properties from the MOS pool property object. 487eda14cbcSMatt Macy */ 488eda14cbcSMatt Macy for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object); 489eda14cbcSMatt Macy (err = zap_cursor_retrieve(&zc, &za)) == 0; 490eda14cbcSMatt Macy zap_cursor_advance(&zc)) { 491eda14cbcSMatt Macy uint64_t intval = 0; 492eda14cbcSMatt Macy char *strval = NULL; 493eda14cbcSMatt Macy zprop_source_t src = ZPROP_SRC_DEFAULT; 494eda14cbcSMatt Macy zpool_prop_t prop; 495eda14cbcSMatt Macy 496c98ecfceSAllan Jude if ((prop = zpool_name_to_prop(za.za_name)) == 497c98ecfceSAllan Jude ZPOOL_PROP_INVAL && !zfs_prop_user(za.za_name)) 498eda14cbcSMatt Macy continue; 499eda14cbcSMatt Macy 500eda14cbcSMatt Macy switch (za.za_integer_length) { 501eda14cbcSMatt Macy case 8: 502eda14cbcSMatt Macy /* integer property */ 503eda14cbcSMatt Macy if (za.za_first_integer != 504eda14cbcSMatt Macy zpool_prop_default_numeric(prop)) 505eda14cbcSMatt Macy src = ZPROP_SRC_LOCAL; 506eda14cbcSMatt Macy 507eda14cbcSMatt Macy if (prop == ZPOOL_PROP_BOOTFS) { 508eda14cbcSMatt Macy dsl_dataset_t *ds = NULL; 509eda14cbcSMatt Macy 510eda14cbcSMatt Macy err = dsl_dataset_hold_obj(dp, 511eda14cbcSMatt Macy za.za_first_integer, FTAG, &ds); 512eda14cbcSMatt Macy if (err != 0) 513eda14cbcSMatt Macy break; 514eda14cbcSMatt Macy 515eda14cbcSMatt Macy strval = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, 516eda14cbcSMatt Macy KM_SLEEP); 517eda14cbcSMatt Macy dsl_dataset_name(ds, strval); 518eda14cbcSMatt Macy dsl_dataset_rele(ds, FTAG); 519eda14cbcSMatt Macy } else { 520eda14cbcSMatt Macy strval = NULL; 521eda14cbcSMatt Macy intval = za.za_first_integer; 522eda14cbcSMatt Macy } 523eda14cbcSMatt Macy 524eda14cbcSMatt Macy spa_prop_add_list(*nvp, prop, strval, intval, src); 525eda14cbcSMatt Macy 526eda14cbcSMatt Macy if (strval != NULL) 527eda14cbcSMatt Macy kmem_free(strval, ZFS_MAX_DATASET_NAME_LEN); 528eda14cbcSMatt Macy 529eda14cbcSMatt Macy break; 530eda14cbcSMatt Macy 531eda14cbcSMatt Macy case 1: 532eda14cbcSMatt Macy /* string property */ 533eda14cbcSMatt Macy strval = kmem_alloc(za.za_num_integers, KM_SLEEP); 534eda14cbcSMatt Macy err = zap_lookup(mos, spa->spa_pool_props_object, 535eda14cbcSMatt Macy za.za_name, 1, za.za_num_integers, strval); 536eda14cbcSMatt Macy if (err) { 537eda14cbcSMatt Macy kmem_free(strval, za.za_num_integers); 538eda14cbcSMatt Macy break; 539eda14cbcSMatt Macy } 540c98ecfceSAllan Jude if (prop != ZPOOL_PROP_INVAL) { 541eda14cbcSMatt Macy spa_prop_add_list(*nvp, prop, strval, 0, src); 542c98ecfceSAllan Jude } else { 543c98ecfceSAllan Jude src = ZPROP_SRC_LOCAL; 544c98ecfceSAllan Jude spa_prop_add_user(*nvp, za.za_name, strval, 545c98ecfceSAllan Jude src); 546c98ecfceSAllan Jude } 547eda14cbcSMatt Macy kmem_free(strval, za.za_num_integers); 548eda14cbcSMatt Macy break; 549eda14cbcSMatt Macy 550eda14cbcSMatt Macy default: 551eda14cbcSMatt Macy break; 552eda14cbcSMatt Macy } 553eda14cbcSMatt Macy } 554eda14cbcSMatt Macy zap_cursor_fini(&zc); 555eda14cbcSMatt Macy out: 556eda14cbcSMatt Macy mutex_exit(&spa->spa_props_lock); 557eda14cbcSMatt Macy dsl_pool_config_exit(dp, FTAG); 558eda14cbcSMatt Macy if (err && err != ENOENT) { 559eda14cbcSMatt Macy nvlist_free(*nvp); 560eda14cbcSMatt Macy *nvp = NULL; 561eda14cbcSMatt Macy return (err); 562eda14cbcSMatt Macy } 563eda14cbcSMatt Macy 564eda14cbcSMatt Macy return (0); 565eda14cbcSMatt Macy } 566eda14cbcSMatt Macy 567eda14cbcSMatt Macy /* 568eda14cbcSMatt Macy * Validate the given pool properties nvlist and modify the list 569eda14cbcSMatt Macy * for the property values to be set. 570eda14cbcSMatt Macy */ 571eda14cbcSMatt Macy static int 572eda14cbcSMatt Macy spa_prop_validate(spa_t *spa, nvlist_t *props) 573eda14cbcSMatt Macy { 574eda14cbcSMatt Macy nvpair_t *elem; 575eda14cbcSMatt Macy int error = 0, reset_bootfs = 0; 576eda14cbcSMatt Macy uint64_t objnum = 0; 577eda14cbcSMatt Macy boolean_t has_feature = B_FALSE; 578eda14cbcSMatt Macy 579eda14cbcSMatt Macy elem = NULL; 580eda14cbcSMatt Macy while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { 581eda14cbcSMatt Macy uint64_t intval; 5822a58b312SMartin Matuska const char *strval, *slash, *check, *fname; 583eda14cbcSMatt Macy const char *propname = nvpair_name(elem); 584eda14cbcSMatt Macy zpool_prop_t prop = zpool_name_to_prop(propname); 585eda14cbcSMatt Macy 586eda14cbcSMatt Macy switch (prop) { 587eda14cbcSMatt Macy case ZPOOL_PROP_INVAL: 588eda14cbcSMatt Macy /* 589eda14cbcSMatt Macy * Sanitize the input. 590eda14cbcSMatt Macy */ 591c98ecfceSAllan Jude if (zfs_prop_user(propname)) { 592c98ecfceSAllan Jude if (strlen(propname) >= ZAP_MAXNAMELEN) { 593c98ecfceSAllan Jude error = SET_ERROR(ENAMETOOLONG); 594c98ecfceSAllan Jude break; 595c98ecfceSAllan Jude } 596c98ecfceSAllan Jude 597c98ecfceSAllan Jude if (strlen(fnvpair_value_string(elem)) >= 598c98ecfceSAllan Jude ZAP_MAXVALUELEN) { 599c98ecfceSAllan Jude error = SET_ERROR(E2BIG); 600c98ecfceSAllan Jude break; 601c98ecfceSAllan Jude } 602c98ecfceSAllan Jude } else if (zpool_prop_feature(propname)) { 603eda14cbcSMatt Macy if (nvpair_type(elem) != DATA_TYPE_UINT64) { 604eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 605eda14cbcSMatt Macy break; 606eda14cbcSMatt Macy } 607eda14cbcSMatt Macy 608eda14cbcSMatt Macy if (nvpair_value_uint64(elem, &intval) != 0) { 609eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 610eda14cbcSMatt Macy break; 611eda14cbcSMatt Macy } 612eda14cbcSMatt Macy 613eda14cbcSMatt Macy if (intval != 0) { 614eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 615eda14cbcSMatt Macy break; 616eda14cbcSMatt Macy } 617eda14cbcSMatt Macy 618eda14cbcSMatt Macy fname = strchr(propname, '@') + 1; 619eda14cbcSMatt Macy if (zfeature_lookup_name(fname, NULL) != 0) { 620eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 621eda14cbcSMatt Macy break; 622eda14cbcSMatt Macy } 623eda14cbcSMatt Macy 624eda14cbcSMatt Macy has_feature = B_TRUE; 625c98ecfceSAllan Jude } else { 626c98ecfceSAllan Jude error = SET_ERROR(EINVAL); 627c98ecfceSAllan Jude break; 628c98ecfceSAllan Jude } 629eda14cbcSMatt Macy break; 630eda14cbcSMatt Macy 631eda14cbcSMatt Macy case ZPOOL_PROP_VERSION: 632eda14cbcSMatt Macy error = nvpair_value_uint64(elem, &intval); 633eda14cbcSMatt Macy if (!error && 634eda14cbcSMatt Macy (intval < spa_version(spa) || 635eda14cbcSMatt Macy intval > SPA_VERSION_BEFORE_FEATURES || 636eda14cbcSMatt Macy has_feature)) 637eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 638eda14cbcSMatt Macy break; 639eda14cbcSMatt Macy 640eda14cbcSMatt Macy case ZPOOL_PROP_DELEGATION: 641eda14cbcSMatt Macy case ZPOOL_PROP_AUTOREPLACE: 642eda14cbcSMatt Macy case ZPOOL_PROP_LISTSNAPS: 643eda14cbcSMatt Macy case ZPOOL_PROP_AUTOEXPAND: 644eda14cbcSMatt Macy case ZPOOL_PROP_AUTOTRIM: 645eda14cbcSMatt Macy error = nvpair_value_uint64(elem, &intval); 646eda14cbcSMatt Macy if (!error && intval > 1) 647eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 648eda14cbcSMatt Macy break; 649eda14cbcSMatt Macy 650eda14cbcSMatt Macy case ZPOOL_PROP_MULTIHOST: 651eda14cbcSMatt Macy error = nvpair_value_uint64(elem, &intval); 652eda14cbcSMatt Macy if (!error && intval > 1) 653eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 654eda14cbcSMatt Macy 655eda14cbcSMatt Macy if (!error) { 656eda14cbcSMatt Macy uint32_t hostid = zone_get_hostid(NULL); 657eda14cbcSMatt Macy if (hostid) 658eda14cbcSMatt Macy spa->spa_hostid = hostid; 659eda14cbcSMatt Macy else 660eda14cbcSMatt Macy error = SET_ERROR(ENOTSUP); 661eda14cbcSMatt Macy } 662eda14cbcSMatt Macy 663eda14cbcSMatt Macy break; 664eda14cbcSMatt Macy 665eda14cbcSMatt Macy case ZPOOL_PROP_BOOTFS: 666eda14cbcSMatt Macy /* 667eda14cbcSMatt Macy * If the pool version is less than SPA_VERSION_BOOTFS, 668eda14cbcSMatt Macy * or the pool is still being created (version == 0), 669eda14cbcSMatt Macy * the bootfs property cannot be set. 670eda14cbcSMatt Macy */ 671eda14cbcSMatt Macy if (spa_version(spa) < SPA_VERSION_BOOTFS) { 672eda14cbcSMatt Macy error = SET_ERROR(ENOTSUP); 673eda14cbcSMatt Macy break; 674eda14cbcSMatt Macy } 675eda14cbcSMatt Macy 676eda14cbcSMatt Macy /* 677eda14cbcSMatt Macy * Make sure the vdev config is bootable 678eda14cbcSMatt Macy */ 679eda14cbcSMatt Macy if (!vdev_is_bootable(spa->spa_root_vdev)) { 680eda14cbcSMatt Macy error = SET_ERROR(ENOTSUP); 681eda14cbcSMatt Macy break; 682eda14cbcSMatt Macy } 683eda14cbcSMatt Macy 684eda14cbcSMatt Macy reset_bootfs = 1; 685eda14cbcSMatt Macy 686eda14cbcSMatt Macy error = nvpair_value_string(elem, &strval); 687eda14cbcSMatt Macy 688eda14cbcSMatt Macy if (!error) { 689eda14cbcSMatt Macy objset_t *os; 690eda14cbcSMatt Macy 691eda14cbcSMatt Macy if (strval == NULL || strval[0] == '\0') { 692eda14cbcSMatt Macy objnum = zpool_prop_default_numeric( 693eda14cbcSMatt Macy ZPOOL_PROP_BOOTFS); 694eda14cbcSMatt Macy break; 695eda14cbcSMatt Macy } 696eda14cbcSMatt Macy 697eda14cbcSMatt Macy error = dmu_objset_hold(strval, FTAG, &os); 698eda14cbcSMatt Macy if (error != 0) 699eda14cbcSMatt Macy break; 700eda14cbcSMatt Macy 701eda14cbcSMatt Macy /* Must be ZPL. */ 702eda14cbcSMatt Macy if (dmu_objset_type(os) != DMU_OST_ZFS) { 703eda14cbcSMatt Macy error = SET_ERROR(ENOTSUP); 704eda14cbcSMatt Macy } else { 705eda14cbcSMatt Macy objnum = dmu_objset_id(os); 706eda14cbcSMatt Macy } 707eda14cbcSMatt Macy dmu_objset_rele(os, FTAG); 708eda14cbcSMatt Macy } 709eda14cbcSMatt Macy break; 710eda14cbcSMatt Macy 711eda14cbcSMatt Macy case ZPOOL_PROP_FAILUREMODE: 712eda14cbcSMatt Macy error = nvpair_value_uint64(elem, &intval); 713eda14cbcSMatt Macy if (!error && intval > ZIO_FAILURE_MODE_PANIC) 714eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 715eda14cbcSMatt Macy 716eda14cbcSMatt Macy /* 717eda14cbcSMatt Macy * This is a special case which only occurs when 718eda14cbcSMatt Macy * the pool has completely failed. This allows 719eda14cbcSMatt Macy * the user to change the in-core failmode property 720eda14cbcSMatt Macy * without syncing it out to disk (I/Os might 721eda14cbcSMatt Macy * currently be blocked). We do this by returning 722eda14cbcSMatt Macy * EIO to the caller (spa_prop_set) to trick it 723eda14cbcSMatt Macy * into thinking we encountered a property validation 724eda14cbcSMatt Macy * error. 725eda14cbcSMatt Macy */ 726eda14cbcSMatt Macy if (!error && spa_suspended(spa)) { 727eda14cbcSMatt Macy spa->spa_failmode = intval; 728eda14cbcSMatt Macy error = SET_ERROR(EIO); 729eda14cbcSMatt Macy } 730eda14cbcSMatt Macy break; 731eda14cbcSMatt Macy 732eda14cbcSMatt Macy case ZPOOL_PROP_CACHEFILE: 733eda14cbcSMatt Macy if ((error = nvpair_value_string(elem, &strval)) != 0) 734eda14cbcSMatt Macy break; 735eda14cbcSMatt Macy 736eda14cbcSMatt Macy if (strval[0] == '\0') 737eda14cbcSMatt Macy break; 738eda14cbcSMatt Macy 739eda14cbcSMatt Macy if (strcmp(strval, "none") == 0) 740eda14cbcSMatt Macy break; 741eda14cbcSMatt Macy 742eda14cbcSMatt Macy if (strval[0] != '/') { 743eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 744eda14cbcSMatt Macy break; 745eda14cbcSMatt Macy } 746eda14cbcSMatt Macy 747eda14cbcSMatt Macy slash = strrchr(strval, '/'); 748eda14cbcSMatt Macy ASSERT(slash != NULL); 749eda14cbcSMatt Macy 750eda14cbcSMatt Macy if (slash[1] == '\0' || strcmp(slash, "/.") == 0 || 751eda14cbcSMatt Macy strcmp(slash, "/..") == 0) 752eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 753eda14cbcSMatt Macy break; 754eda14cbcSMatt Macy 755eda14cbcSMatt Macy case ZPOOL_PROP_COMMENT: 756eda14cbcSMatt Macy if ((error = nvpair_value_string(elem, &strval)) != 0) 757eda14cbcSMatt Macy break; 758eda14cbcSMatt Macy for (check = strval; *check != '\0'; check++) { 759eda14cbcSMatt Macy if (!isprint(*check)) { 760eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 761eda14cbcSMatt Macy break; 762eda14cbcSMatt Macy } 763eda14cbcSMatt Macy } 764eda14cbcSMatt Macy if (strlen(strval) > ZPROP_MAX_COMMENT) 765eda14cbcSMatt Macy error = SET_ERROR(E2BIG); 766eda14cbcSMatt Macy break; 767eda14cbcSMatt Macy 768eda14cbcSMatt Macy default: 769eda14cbcSMatt Macy break; 770eda14cbcSMatt Macy } 771eda14cbcSMatt Macy 772eda14cbcSMatt Macy if (error) 773eda14cbcSMatt Macy break; 774eda14cbcSMatt Macy } 775eda14cbcSMatt Macy 776eda14cbcSMatt Macy (void) nvlist_remove_all(props, 777eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_DEDUPDITTO)); 778eda14cbcSMatt Macy 779eda14cbcSMatt Macy if (!error && reset_bootfs) { 780eda14cbcSMatt Macy error = nvlist_remove(props, 781eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING); 782eda14cbcSMatt Macy 783eda14cbcSMatt Macy if (!error) { 784eda14cbcSMatt Macy error = nvlist_add_uint64(props, 785eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum); 786eda14cbcSMatt Macy } 787eda14cbcSMatt Macy } 788eda14cbcSMatt Macy 789eda14cbcSMatt Macy return (error); 790eda14cbcSMatt Macy } 791eda14cbcSMatt Macy 792eda14cbcSMatt Macy void 793eda14cbcSMatt Macy spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync) 794eda14cbcSMatt Macy { 7952a58b312SMartin Matuska const char *cachefile; 796eda14cbcSMatt Macy spa_config_dirent_t *dp; 797eda14cbcSMatt Macy 798eda14cbcSMatt Macy if (nvlist_lookup_string(nvp, zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 799eda14cbcSMatt Macy &cachefile) != 0) 800eda14cbcSMatt Macy return; 801eda14cbcSMatt Macy 802eda14cbcSMatt Macy dp = kmem_alloc(sizeof (spa_config_dirent_t), 803eda14cbcSMatt Macy KM_SLEEP); 804eda14cbcSMatt Macy 805eda14cbcSMatt Macy if (cachefile[0] == '\0') 806eda14cbcSMatt Macy dp->scd_path = spa_strdup(spa_config_path); 807eda14cbcSMatt Macy else if (strcmp(cachefile, "none") == 0) 808eda14cbcSMatt Macy dp->scd_path = NULL; 809eda14cbcSMatt Macy else 810eda14cbcSMatt Macy dp->scd_path = spa_strdup(cachefile); 811eda14cbcSMatt Macy 812eda14cbcSMatt Macy list_insert_head(&spa->spa_config_list, dp); 813eda14cbcSMatt Macy if (need_sync) 814eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 815eda14cbcSMatt Macy } 816eda14cbcSMatt Macy 817eda14cbcSMatt Macy int 818eda14cbcSMatt Macy spa_prop_set(spa_t *spa, nvlist_t *nvp) 819eda14cbcSMatt Macy { 820eda14cbcSMatt Macy int error; 821eda14cbcSMatt Macy nvpair_t *elem = NULL; 822eda14cbcSMatt Macy boolean_t need_sync = B_FALSE; 823eda14cbcSMatt Macy 824eda14cbcSMatt Macy if ((error = spa_prop_validate(spa, nvp)) != 0) 825eda14cbcSMatt Macy return (error); 826eda14cbcSMatt Macy 827eda14cbcSMatt Macy while ((elem = nvlist_next_nvpair(nvp, elem)) != NULL) { 828eda14cbcSMatt Macy zpool_prop_t prop = zpool_name_to_prop(nvpair_name(elem)); 829eda14cbcSMatt Macy 830eda14cbcSMatt Macy if (prop == ZPOOL_PROP_CACHEFILE || 831eda14cbcSMatt Macy prop == ZPOOL_PROP_ALTROOT || 832eda14cbcSMatt Macy prop == ZPOOL_PROP_READONLY) 833eda14cbcSMatt Macy continue; 834eda14cbcSMatt Macy 835c98ecfceSAllan Jude if (prop == ZPOOL_PROP_INVAL && 836c98ecfceSAllan Jude zfs_prop_user(nvpair_name(elem))) { 837c98ecfceSAllan Jude need_sync = B_TRUE; 838c98ecfceSAllan Jude break; 839c98ecfceSAllan Jude } 840c98ecfceSAllan Jude 841eda14cbcSMatt Macy if (prop == ZPOOL_PROP_VERSION || prop == ZPOOL_PROP_INVAL) { 842681ce946SMartin Matuska uint64_t ver = 0; 843eda14cbcSMatt Macy 844eda14cbcSMatt Macy if (prop == ZPOOL_PROP_VERSION) { 845eda14cbcSMatt Macy VERIFY(nvpair_value_uint64(elem, &ver) == 0); 846eda14cbcSMatt Macy } else { 847eda14cbcSMatt Macy ASSERT(zpool_prop_feature(nvpair_name(elem))); 848eda14cbcSMatt Macy ver = SPA_VERSION_FEATURES; 849eda14cbcSMatt Macy need_sync = B_TRUE; 850eda14cbcSMatt Macy } 851eda14cbcSMatt Macy 852eda14cbcSMatt Macy /* Save time if the version is already set. */ 853eda14cbcSMatt Macy if (ver == spa_version(spa)) 854eda14cbcSMatt Macy continue; 855eda14cbcSMatt Macy 856eda14cbcSMatt Macy /* 857eda14cbcSMatt Macy * In addition to the pool directory object, we might 858eda14cbcSMatt Macy * create the pool properties object, the features for 859eda14cbcSMatt Macy * read object, the features for write object, or the 860eda14cbcSMatt Macy * feature descriptions object. 861eda14cbcSMatt Macy */ 862eda14cbcSMatt Macy error = dsl_sync_task(spa->spa_name, NULL, 863eda14cbcSMatt Macy spa_sync_version, &ver, 864eda14cbcSMatt Macy 6, ZFS_SPACE_CHECK_RESERVED); 865eda14cbcSMatt Macy if (error) 866eda14cbcSMatt Macy return (error); 867eda14cbcSMatt Macy continue; 868eda14cbcSMatt Macy } 869eda14cbcSMatt Macy 870eda14cbcSMatt Macy need_sync = B_TRUE; 871eda14cbcSMatt Macy break; 872eda14cbcSMatt Macy } 873eda14cbcSMatt Macy 874eda14cbcSMatt Macy if (need_sync) { 875eda14cbcSMatt Macy return (dsl_sync_task(spa->spa_name, NULL, spa_sync_props, 876eda14cbcSMatt Macy nvp, 6, ZFS_SPACE_CHECK_RESERVED)); 877eda14cbcSMatt Macy } 878eda14cbcSMatt Macy 879eda14cbcSMatt Macy return (0); 880eda14cbcSMatt Macy } 881eda14cbcSMatt Macy 882eda14cbcSMatt Macy /* 883eda14cbcSMatt Macy * If the bootfs property value is dsobj, clear it. 884eda14cbcSMatt Macy */ 885eda14cbcSMatt Macy void 886eda14cbcSMatt Macy spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx) 887eda14cbcSMatt Macy { 888eda14cbcSMatt Macy if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) { 889eda14cbcSMatt Macy VERIFY(zap_remove(spa->spa_meta_objset, 890eda14cbcSMatt Macy spa->spa_pool_props_object, 891eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0); 892eda14cbcSMatt Macy spa->spa_bootfs = 0; 893eda14cbcSMatt Macy } 894eda14cbcSMatt Macy } 895eda14cbcSMatt Macy 896eda14cbcSMatt Macy static int 897eda14cbcSMatt Macy spa_change_guid_check(void *arg, dmu_tx_t *tx) 898eda14cbcSMatt Macy { 899eda14cbcSMatt Macy uint64_t *newguid __maybe_unused = arg; 900eda14cbcSMatt Macy spa_t *spa = dmu_tx_pool(tx)->dp_spa; 901eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 902eda14cbcSMatt Macy uint64_t vdev_state; 903eda14cbcSMatt Macy 904eda14cbcSMatt Macy if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) { 905eda14cbcSMatt Macy int error = (spa_has_checkpoint(spa)) ? 906eda14cbcSMatt Macy ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT; 907eda14cbcSMatt Macy return (SET_ERROR(error)); 908eda14cbcSMatt Macy } 909eda14cbcSMatt Macy 910eda14cbcSMatt Macy spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 911eda14cbcSMatt Macy vdev_state = rvd->vdev_state; 912eda14cbcSMatt Macy spa_config_exit(spa, SCL_STATE, FTAG); 913eda14cbcSMatt Macy 914eda14cbcSMatt Macy if (vdev_state != VDEV_STATE_HEALTHY) 915eda14cbcSMatt Macy return (SET_ERROR(ENXIO)); 916eda14cbcSMatt Macy 917eda14cbcSMatt Macy ASSERT3U(spa_guid(spa), !=, *newguid); 918eda14cbcSMatt Macy 919eda14cbcSMatt Macy return (0); 920eda14cbcSMatt Macy } 921eda14cbcSMatt Macy 922eda14cbcSMatt Macy static void 923eda14cbcSMatt Macy spa_change_guid_sync(void *arg, dmu_tx_t *tx) 924eda14cbcSMatt Macy { 925eda14cbcSMatt Macy uint64_t *newguid = arg; 926eda14cbcSMatt Macy spa_t *spa = dmu_tx_pool(tx)->dp_spa; 927eda14cbcSMatt Macy uint64_t oldguid; 928eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 929eda14cbcSMatt Macy 930eda14cbcSMatt Macy oldguid = spa_guid(spa); 931eda14cbcSMatt Macy 932eda14cbcSMatt Macy spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 933eda14cbcSMatt Macy rvd->vdev_guid = *newguid; 934eda14cbcSMatt Macy rvd->vdev_guid_sum += (*newguid - oldguid); 935eda14cbcSMatt Macy vdev_config_dirty(rvd); 936eda14cbcSMatt Macy spa_config_exit(spa, SCL_STATE, FTAG); 937eda14cbcSMatt Macy 938eda14cbcSMatt Macy spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu", 939eda14cbcSMatt Macy (u_longlong_t)oldguid, (u_longlong_t)*newguid); 940eda14cbcSMatt Macy } 941eda14cbcSMatt Macy 942eda14cbcSMatt Macy /* 943eda14cbcSMatt Macy * Change the GUID for the pool. This is done so that we can later 944eda14cbcSMatt Macy * re-import a pool built from a clone of our own vdevs. We will modify 945eda14cbcSMatt Macy * the root vdev's guid, our own pool guid, and then mark all of our 946eda14cbcSMatt Macy * vdevs dirty. Note that we must make sure that all our vdevs are 947eda14cbcSMatt Macy * online when we do this, or else any vdevs that weren't present 948eda14cbcSMatt Macy * would be orphaned from our pool. We are also going to issue a 949eda14cbcSMatt Macy * sysevent to update any watchers. 950eda14cbcSMatt Macy */ 951eda14cbcSMatt Macy int 952eda14cbcSMatt Macy spa_change_guid(spa_t *spa) 953eda14cbcSMatt Macy { 954eda14cbcSMatt Macy int error; 955eda14cbcSMatt Macy uint64_t guid; 956eda14cbcSMatt Macy 957eda14cbcSMatt Macy mutex_enter(&spa->spa_vdev_top_lock); 958eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 959eda14cbcSMatt Macy guid = spa_generate_guid(NULL); 960eda14cbcSMatt Macy 961eda14cbcSMatt Macy error = dsl_sync_task(spa->spa_name, spa_change_guid_check, 962eda14cbcSMatt Macy spa_change_guid_sync, &guid, 5, ZFS_SPACE_CHECK_RESERVED); 963eda14cbcSMatt Macy 964eda14cbcSMatt Macy if (error == 0) { 965be181ee2SMartin Matuska /* 966be181ee2SMartin Matuska * Clear the kobj flag from all the vdevs to allow 967be181ee2SMartin Matuska * vdev_cache_process_kobj_evt() to post events to all the 968be181ee2SMartin Matuska * vdevs since GUID is updated. 969be181ee2SMartin Matuska */ 970be181ee2SMartin Matuska vdev_clear_kobj_evt(spa->spa_root_vdev); 971be181ee2SMartin Matuska for (int i = 0; i < spa->spa_l2cache.sav_count; i++) 972be181ee2SMartin Matuska vdev_clear_kobj_evt(spa->spa_l2cache.sav_vdevs[i]); 973be181ee2SMartin Matuska 974be181ee2SMartin Matuska spa_write_cachefile(spa, B_FALSE, B_TRUE, B_TRUE); 975eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_REGUID); 976eda14cbcSMatt Macy } 977eda14cbcSMatt Macy 978eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 979eda14cbcSMatt Macy mutex_exit(&spa->spa_vdev_top_lock); 980eda14cbcSMatt Macy 981eda14cbcSMatt Macy return (error); 982eda14cbcSMatt Macy } 983eda14cbcSMatt Macy 984eda14cbcSMatt Macy /* 985eda14cbcSMatt Macy * ========================================================================== 986eda14cbcSMatt Macy * SPA state manipulation (open/create/destroy/import/export) 987eda14cbcSMatt Macy * ========================================================================== 988eda14cbcSMatt Macy */ 989eda14cbcSMatt Macy 990eda14cbcSMatt Macy static int 991eda14cbcSMatt Macy spa_error_entry_compare(const void *a, const void *b) 992eda14cbcSMatt Macy { 993eda14cbcSMatt Macy const spa_error_entry_t *sa = (const spa_error_entry_t *)a; 994eda14cbcSMatt Macy const spa_error_entry_t *sb = (const spa_error_entry_t *)b; 995eda14cbcSMatt Macy int ret; 996eda14cbcSMatt Macy 997eda14cbcSMatt Macy ret = memcmp(&sa->se_bookmark, &sb->se_bookmark, 998eda14cbcSMatt Macy sizeof (zbookmark_phys_t)); 999eda14cbcSMatt Macy 1000eda14cbcSMatt Macy return (TREE_ISIGN(ret)); 1001eda14cbcSMatt Macy } 1002eda14cbcSMatt Macy 1003eda14cbcSMatt Macy /* 1004eda14cbcSMatt Macy * Utility function which retrieves copies of the current logs and 1005eda14cbcSMatt Macy * re-initializes them in the process. 1006eda14cbcSMatt Macy */ 1007eda14cbcSMatt Macy void 1008eda14cbcSMatt Macy spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub) 1009eda14cbcSMatt Macy { 1010eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa->spa_errlist_lock)); 1011eda14cbcSMatt Macy 1012da5137abSMartin Matuska memcpy(last, &spa->spa_errlist_last, sizeof (avl_tree_t)); 1013da5137abSMartin Matuska memcpy(scrub, &spa->spa_errlist_scrub, sizeof (avl_tree_t)); 1014eda14cbcSMatt Macy 1015eda14cbcSMatt Macy avl_create(&spa->spa_errlist_scrub, 1016eda14cbcSMatt Macy spa_error_entry_compare, sizeof (spa_error_entry_t), 1017eda14cbcSMatt Macy offsetof(spa_error_entry_t, se_avl)); 1018eda14cbcSMatt Macy avl_create(&spa->spa_errlist_last, 1019eda14cbcSMatt Macy spa_error_entry_compare, sizeof (spa_error_entry_t), 1020eda14cbcSMatt Macy offsetof(spa_error_entry_t, se_avl)); 1021eda14cbcSMatt Macy } 1022eda14cbcSMatt Macy 1023eda14cbcSMatt Macy static void 1024eda14cbcSMatt Macy spa_taskqs_init(spa_t *spa, zio_type_t t, zio_taskq_type_t q) 1025eda14cbcSMatt Macy { 1026eda14cbcSMatt Macy const zio_taskq_info_t *ztip = &zio_taskqs[t][q]; 1027eda14cbcSMatt Macy enum zti_modes mode = ztip->zti_mode; 1028eda14cbcSMatt Macy uint_t value = ztip->zti_value; 1029eda14cbcSMatt Macy uint_t count = ztip->zti_count; 1030eda14cbcSMatt Macy spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 103116038816SMartin Matuska uint_t cpus, flags = TASKQ_DYNAMIC; 1032eda14cbcSMatt Macy boolean_t batch = B_FALSE; 1033eda14cbcSMatt Macy 1034eda14cbcSMatt Macy switch (mode) { 1035eda14cbcSMatt Macy case ZTI_MODE_FIXED: 103616038816SMartin Matuska ASSERT3U(value, >, 0); 1037eda14cbcSMatt Macy break; 1038eda14cbcSMatt Macy 1039eda14cbcSMatt Macy case ZTI_MODE_BATCH: 1040eda14cbcSMatt Macy batch = B_TRUE; 1041eda14cbcSMatt Macy flags |= TASKQ_THREADS_CPU_PCT; 1042eda14cbcSMatt Macy value = MIN(zio_taskq_batch_pct, 100); 1043eda14cbcSMatt Macy break; 1044eda14cbcSMatt Macy 104516038816SMartin Matuska case ZTI_MODE_SCALE: 104616038816SMartin Matuska flags |= TASKQ_THREADS_CPU_PCT; 104716038816SMartin Matuska /* 104816038816SMartin Matuska * We want more taskqs to reduce lock contention, but we want 104916038816SMartin Matuska * less for better request ordering and CPU utilization. 105016038816SMartin Matuska */ 105116038816SMartin Matuska cpus = MAX(1, boot_ncpus * zio_taskq_batch_pct / 100); 105216038816SMartin Matuska if (zio_taskq_batch_tpq > 0) { 105316038816SMartin Matuska count = MAX(1, (cpus + zio_taskq_batch_tpq / 2) / 105416038816SMartin Matuska zio_taskq_batch_tpq); 105516038816SMartin Matuska } else { 105616038816SMartin Matuska /* 105716038816SMartin Matuska * Prefer 6 threads per taskq, but no more taskqs 105816038816SMartin Matuska * than threads in them on large systems. For 80%: 105916038816SMartin Matuska * 106016038816SMartin Matuska * taskq taskq total 106116038816SMartin Matuska * cpus taskqs percent threads threads 106216038816SMartin Matuska * ------- ------- ------- ------- ------- 106316038816SMartin Matuska * 1 1 80% 1 1 106416038816SMartin Matuska * 2 1 80% 1 1 106516038816SMartin Matuska * 4 1 80% 3 3 106616038816SMartin Matuska * 8 2 40% 3 6 106716038816SMartin Matuska * 16 3 27% 4 12 106816038816SMartin Matuska * 32 5 16% 5 25 106916038816SMartin Matuska * 64 7 11% 7 49 107016038816SMartin Matuska * 128 10 8% 10 100 107116038816SMartin Matuska * 256 14 6% 15 210 107216038816SMartin Matuska */ 107316038816SMartin Matuska count = 1 + cpus / 6; 107416038816SMartin Matuska while (count * count > cpus) 107516038816SMartin Matuska count--; 107616038816SMartin Matuska } 107716038816SMartin Matuska /* Limit each taskq within 100% to not trigger assertion. */ 107816038816SMartin Matuska count = MAX(count, (zio_taskq_batch_pct + 99) / 100); 107916038816SMartin Matuska value = (zio_taskq_batch_pct + count / 2) / count; 108016038816SMartin Matuska break; 108116038816SMartin Matuska 108216038816SMartin Matuska case ZTI_MODE_NULL: 108316038816SMartin Matuska tqs->stqs_count = 0; 108416038816SMartin Matuska tqs->stqs_taskq = NULL; 108516038816SMartin Matuska return; 108616038816SMartin Matuska 1087eda14cbcSMatt Macy default: 1088eda14cbcSMatt Macy panic("unrecognized mode for %s_%s taskq (%u:%u) in " 1089eda14cbcSMatt Macy "spa_activate()", 1090eda14cbcSMatt Macy zio_type_name[t], zio_taskq_types[q], mode, value); 1091eda14cbcSMatt Macy break; 1092eda14cbcSMatt Macy } 1093eda14cbcSMatt Macy 109416038816SMartin Matuska ASSERT3U(count, >, 0); 109516038816SMartin Matuska tqs->stqs_count = count; 109616038816SMartin Matuska tqs->stqs_taskq = kmem_alloc(count * sizeof (taskq_t *), KM_SLEEP); 109716038816SMartin Matuska 1098eda14cbcSMatt Macy for (uint_t i = 0; i < count; i++) { 1099eda14cbcSMatt Macy taskq_t *tq; 1100eda14cbcSMatt Macy char name[32]; 1101eda14cbcSMatt Macy 110216038816SMartin Matuska if (count > 1) 110316038816SMartin Matuska (void) snprintf(name, sizeof (name), "%s_%s_%u", 110416038816SMartin Matuska zio_type_name[t], zio_taskq_types[q], i); 110516038816SMartin Matuska else 1106eda14cbcSMatt Macy (void) snprintf(name, sizeof (name), "%s_%s", 1107eda14cbcSMatt Macy zio_type_name[t], zio_taskq_types[q]); 1108eda14cbcSMatt Macy 1109eda14cbcSMatt Macy if (zio_taskq_sysdc && spa->spa_proc != &p0) { 1110eda14cbcSMatt Macy if (batch) 1111eda14cbcSMatt Macy flags |= TASKQ_DC_BATCH; 1112eda14cbcSMatt Macy 1113e92ffd9bSMartin Matuska (void) zio_taskq_basedc; 1114eda14cbcSMatt Macy tq = taskq_create_sysdc(name, value, 50, INT_MAX, 1115eda14cbcSMatt Macy spa->spa_proc, zio_taskq_basedc, flags); 1116eda14cbcSMatt Macy } else { 1117eda14cbcSMatt Macy pri_t pri = maxclsyspri; 1118eda14cbcSMatt Macy /* 1119eda14cbcSMatt Macy * The write issue taskq can be extremely CPU 1120eda14cbcSMatt Macy * intensive. Run it at slightly less important 11212c48331dSMatt Macy * priority than the other taskqs. 11222c48331dSMatt Macy * 11232c48331dSMatt Macy * Under Linux and FreeBSD this means incrementing 11242c48331dSMatt Macy * the priority value as opposed to platforms like 11252c48331dSMatt Macy * illumos where it should be decremented. 11262c48331dSMatt Macy * 11272c48331dSMatt Macy * On FreeBSD, if priorities divided by four (RQ_PPQ) 11282c48331dSMatt Macy * are equal then a difference between them is 11292c48331dSMatt Macy * insignificant. 1130eda14cbcSMatt Macy */ 11312c48331dSMatt Macy if (t == ZIO_TYPE_WRITE && q == ZIO_TASKQ_ISSUE) { 11322c48331dSMatt Macy #if defined(__linux__) 1133eda14cbcSMatt Macy pri++; 11342c48331dSMatt Macy #elif defined(__FreeBSD__) 11352c48331dSMatt Macy pri += 4; 11362c48331dSMatt Macy #else 11372c48331dSMatt Macy #error "unknown OS" 11382c48331dSMatt Macy #endif 11392c48331dSMatt Macy } 1140eda14cbcSMatt Macy tq = taskq_create_proc(name, value, pri, 50, 1141eda14cbcSMatt Macy INT_MAX, spa->spa_proc, flags); 1142eda14cbcSMatt Macy } 1143eda14cbcSMatt Macy 1144eda14cbcSMatt Macy tqs->stqs_taskq[i] = tq; 1145eda14cbcSMatt Macy } 1146eda14cbcSMatt Macy } 1147eda14cbcSMatt Macy 1148eda14cbcSMatt Macy static void 1149eda14cbcSMatt Macy spa_taskqs_fini(spa_t *spa, zio_type_t t, zio_taskq_type_t q) 1150eda14cbcSMatt Macy { 1151eda14cbcSMatt Macy spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 1152eda14cbcSMatt Macy 1153eda14cbcSMatt Macy if (tqs->stqs_taskq == NULL) { 1154eda14cbcSMatt Macy ASSERT3U(tqs->stqs_count, ==, 0); 1155eda14cbcSMatt Macy return; 1156eda14cbcSMatt Macy } 1157eda14cbcSMatt Macy 1158eda14cbcSMatt Macy for (uint_t i = 0; i < tqs->stqs_count; i++) { 1159eda14cbcSMatt Macy ASSERT3P(tqs->stqs_taskq[i], !=, NULL); 1160eda14cbcSMatt Macy taskq_destroy(tqs->stqs_taskq[i]); 1161eda14cbcSMatt Macy } 1162eda14cbcSMatt Macy 1163eda14cbcSMatt Macy kmem_free(tqs->stqs_taskq, tqs->stqs_count * sizeof (taskq_t *)); 1164eda14cbcSMatt Macy tqs->stqs_taskq = NULL; 1165eda14cbcSMatt Macy } 1166eda14cbcSMatt Macy 1167eda14cbcSMatt Macy /* 1168eda14cbcSMatt Macy * Dispatch a task to the appropriate taskq for the ZFS I/O type and priority. 1169eda14cbcSMatt Macy * Note that a type may have multiple discrete taskqs to avoid lock contention 1170eda14cbcSMatt Macy * on the taskq itself. In that case we choose which taskq at random by using 1171eda14cbcSMatt Macy * the low bits of gethrtime(). 1172eda14cbcSMatt Macy */ 1173eda14cbcSMatt Macy void 1174eda14cbcSMatt Macy spa_taskq_dispatch_ent(spa_t *spa, zio_type_t t, zio_taskq_type_t q, 1175eda14cbcSMatt Macy task_func_t *func, void *arg, uint_t flags, taskq_ent_t *ent) 1176eda14cbcSMatt Macy { 1177eda14cbcSMatt Macy spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 1178eda14cbcSMatt Macy taskq_t *tq; 1179eda14cbcSMatt Macy 1180eda14cbcSMatt Macy ASSERT3P(tqs->stqs_taskq, !=, NULL); 1181eda14cbcSMatt Macy ASSERT3U(tqs->stqs_count, !=, 0); 1182eda14cbcSMatt Macy 1183eda14cbcSMatt Macy if (tqs->stqs_count == 1) { 1184eda14cbcSMatt Macy tq = tqs->stqs_taskq[0]; 1185eda14cbcSMatt Macy } else { 1186eda14cbcSMatt Macy tq = tqs->stqs_taskq[((uint64_t)gethrtime()) % tqs->stqs_count]; 1187eda14cbcSMatt Macy } 1188eda14cbcSMatt Macy 1189eda14cbcSMatt Macy taskq_dispatch_ent(tq, func, arg, flags, ent); 1190eda14cbcSMatt Macy } 1191eda14cbcSMatt Macy 1192eda14cbcSMatt Macy /* 1193eda14cbcSMatt Macy * Same as spa_taskq_dispatch_ent() but block on the task until completion. 1194eda14cbcSMatt Macy */ 1195eda14cbcSMatt Macy void 1196eda14cbcSMatt Macy spa_taskq_dispatch_sync(spa_t *spa, zio_type_t t, zio_taskq_type_t q, 1197eda14cbcSMatt Macy task_func_t *func, void *arg, uint_t flags) 1198eda14cbcSMatt Macy { 1199eda14cbcSMatt Macy spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q]; 1200eda14cbcSMatt Macy taskq_t *tq; 1201eda14cbcSMatt Macy taskqid_t id; 1202eda14cbcSMatt Macy 1203eda14cbcSMatt Macy ASSERT3P(tqs->stqs_taskq, !=, NULL); 1204eda14cbcSMatt Macy ASSERT3U(tqs->stqs_count, !=, 0); 1205eda14cbcSMatt Macy 1206eda14cbcSMatt Macy if (tqs->stqs_count == 1) { 1207eda14cbcSMatt Macy tq = tqs->stqs_taskq[0]; 1208eda14cbcSMatt Macy } else { 1209eda14cbcSMatt Macy tq = tqs->stqs_taskq[((uint64_t)gethrtime()) % tqs->stqs_count]; 1210eda14cbcSMatt Macy } 1211eda14cbcSMatt Macy 1212eda14cbcSMatt Macy id = taskq_dispatch(tq, func, arg, flags); 1213eda14cbcSMatt Macy if (id) 1214eda14cbcSMatt Macy taskq_wait_id(tq, id); 1215eda14cbcSMatt Macy } 1216eda14cbcSMatt Macy 1217eda14cbcSMatt Macy static void 1218eda14cbcSMatt Macy spa_create_zio_taskqs(spa_t *spa) 1219eda14cbcSMatt Macy { 1220eda14cbcSMatt Macy for (int t = 0; t < ZIO_TYPES; t++) { 1221eda14cbcSMatt Macy for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { 1222eda14cbcSMatt Macy spa_taskqs_init(spa, t, q); 1223eda14cbcSMatt Macy } 1224eda14cbcSMatt Macy } 1225eda14cbcSMatt Macy } 1226eda14cbcSMatt Macy 1227eda14cbcSMatt Macy /* 1228eda14cbcSMatt Macy * Disabled until spa_thread() can be adapted for Linux. 1229eda14cbcSMatt Macy */ 1230eda14cbcSMatt Macy #undef HAVE_SPA_THREAD 1231eda14cbcSMatt Macy 1232eda14cbcSMatt Macy #if defined(_KERNEL) && defined(HAVE_SPA_THREAD) 1233eda14cbcSMatt Macy static void 1234eda14cbcSMatt Macy spa_thread(void *arg) 1235eda14cbcSMatt Macy { 1236eda14cbcSMatt Macy psetid_t zio_taskq_psrset_bind = PS_NONE; 1237eda14cbcSMatt Macy callb_cpr_t cprinfo; 1238eda14cbcSMatt Macy 1239eda14cbcSMatt Macy spa_t *spa = arg; 1240eda14cbcSMatt Macy user_t *pu = PTOU(curproc); 1241eda14cbcSMatt Macy 1242eda14cbcSMatt Macy CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr, 1243eda14cbcSMatt Macy spa->spa_name); 1244eda14cbcSMatt Macy 1245eda14cbcSMatt Macy ASSERT(curproc != &p0); 1246eda14cbcSMatt Macy (void) snprintf(pu->u_psargs, sizeof (pu->u_psargs), 1247eda14cbcSMatt Macy "zpool-%s", spa->spa_name); 1248eda14cbcSMatt Macy (void) strlcpy(pu->u_comm, pu->u_psargs, sizeof (pu->u_comm)); 1249eda14cbcSMatt Macy 1250eda14cbcSMatt Macy /* bind this thread to the requested psrset */ 1251eda14cbcSMatt Macy if (zio_taskq_psrset_bind != PS_NONE) { 1252eda14cbcSMatt Macy pool_lock(); 1253eda14cbcSMatt Macy mutex_enter(&cpu_lock); 1254eda14cbcSMatt Macy mutex_enter(&pidlock); 1255eda14cbcSMatt Macy mutex_enter(&curproc->p_lock); 1256eda14cbcSMatt Macy 1257eda14cbcSMatt Macy if (cpupart_bind_thread(curthread, zio_taskq_psrset_bind, 1258eda14cbcSMatt Macy 0, NULL, NULL) == 0) { 1259eda14cbcSMatt Macy curthread->t_bind_pset = zio_taskq_psrset_bind; 1260eda14cbcSMatt Macy } else { 1261eda14cbcSMatt Macy cmn_err(CE_WARN, 1262eda14cbcSMatt Macy "Couldn't bind process for zfs pool \"%s\" to " 1263eda14cbcSMatt Macy "pset %d\n", spa->spa_name, zio_taskq_psrset_bind); 1264eda14cbcSMatt Macy } 1265eda14cbcSMatt Macy 1266eda14cbcSMatt Macy mutex_exit(&curproc->p_lock); 1267eda14cbcSMatt Macy mutex_exit(&pidlock); 1268eda14cbcSMatt Macy mutex_exit(&cpu_lock); 1269eda14cbcSMatt Macy pool_unlock(); 1270eda14cbcSMatt Macy } 1271eda14cbcSMatt Macy 1272eda14cbcSMatt Macy if (zio_taskq_sysdc) { 1273eda14cbcSMatt Macy sysdc_thread_enter(curthread, 100, 0); 1274eda14cbcSMatt Macy } 1275eda14cbcSMatt Macy 1276eda14cbcSMatt Macy spa->spa_proc = curproc; 1277eda14cbcSMatt Macy spa->spa_did = curthread->t_did; 1278eda14cbcSMatt Macy 1279eda14cbcSMatt Macy spa_create_zio_taskqs(spa); 1280eda14cbcSMatt Macy 1281eda14cbcSMatt Macy mutex_enter(&spa->spa_proc_lock); 1282eda14cbcSMatt Macy ASSERT(spa->spa_proc_state == SPA_PROC_CREATED); 1283eda14cbcSMatt Macy 1284eda14cbcSMatt Macy spa->spa_proc_state = SPA_PROC_ACTIVE; 1285eda14cbcSMatt Macy cv_broadcast(&spa->spa_proc_cv); 1286eda14cbcSMatt Macy 1287eda14cbcSMatt Macy CALLB_CPR_SAFE_BEGIN(&cprinfo); 1288eda14cbcSMatt Macy while (spa->spa_proc_state == SPA_PROC_ACTIVE) 1289eda14cbcSMatt Macy cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock); 1290eda14cbcSMatt Macy CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock); 1291eda14cbcSMatt Macy 1292eda14cbcSMatt Macy ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE); 1293eda14cbcSMatt Macy spa->spa_proc_state = SPA_PROC_GONE; 1294eda14cbcSMatt Macy spa->spa_proc = &p0; 1295eda14cbcSMatt Macy cv_broadcast(&spa->spa_proc_cv); 1296eda14cbcSMatt Macy CALLB_CPR_EXIT(&cprinfo); /* drops spa_proc_lock */ 1297eda14cbcSMatt Macy 1298eda14cbcSMatt Macy mutex_enter(&curproc->p_lock); 1299eda14cbcSMatt Macy lwp_exit(); 1300eda14cbcSMatt Macy } 1301eda14cbcSMatt Macy #endif 1302eda14cbcSMatt Macy 13032ad756a6SMartin Matuska extern metaslab_ops_t *metaslab_allocator(spa_t *spa); 13042ad756a6SMartin Matuska 1305eda14cbcSMatt Macy /* 1306eda14cbcSMatt Macy * Activate an uninitialized pool. 1307eda14cbcSMatt Macy */ 1308eda14cbcSMatt Macy static void 1309eda14cbcSMatt Macy spa_activate(spa_t *spa, spa_mode_t mode) 1310eda14cbcSMatt Macy { 13112ad756a6SMartin Matuska metaslab_ops_t *msp = metaslab_allocator(spa); 1312eda14cbcSMatt Macy ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); 1313eda14cbcSMatt Macy 1314eda14cbcSMatt Macy spa->spa_state = POOL_STATE_ACTIVE; 1315eda14cbcSMatt Macy spa->spa_mode = mode; 131681b22a98SMartin Matuska spa->spa_read_spacemaps = spa_mode_readable_spacemaps; 1317eda14cbcSMatt Macy 13182ad756a6SMartin Matuska spa->spa_normal_class = metaslab_class_create(spa, msp); 13192ad756a6SMartin Matuska spa->spa_log_class = metaslab_class_create(spa, msp); 13202ad756a6SMartin Matuska spa->spa_embedded_log_class = metaslab_class_create(spa, msp); 13212ad756a6SMartin Matuska spa->spa_special_class = metaslab_class_create(spa, msp); 13222ad756a6SMartin Matuska spa->spa_dedup_class = metaslab_class_create(spa, msp); 1323eda14cbcSMatt Macy 1324eda14cbcSMatt Macy /* Try to create a covering process */ 1325eda14cbcSMatt Macy mutex_enter(&spa->spa_proc_lock); 1326eda14cbcSMatt Macy ASSERT(spa->spa_proc_state == SPA_PROC_NONE); 1327eda14cbcSMatt Macy ASSERT(spa->spa_proc == &p0); 1328eda14cbcSMatt Macy spa->spa_did = 0; 1329eda14cbcSMatt Macy 1330e92ffd9bSMartin Matuska (void) spa_create_process; 1331eda14cbcSMatt Macy #ifdef HAVE_SPA_THREAD 1332eda14cbcSMatt Macy /* Only create a process if we're going to be around a while. */ 1333eda14cbcSMatt Macy if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) { 1334eda14cbcSMatt Macy if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri, 1335eda14cbcSMatt Macy NULL, 0) == 0) { 1336eda14cbcSMatt Macy spa->spa_proc_state = SPA_PROC_CREATED; 1337eda14cbcSMatt Macy while (spa->spa_proc_state == SPA_PROC_CREATED) { 1338eda14cbcSMatt Macy cv_wait(&spa->spa_proc_cv, 1339eda14cbcSMatt Macy &spa->spa_proc_lock); 1340eda14cbcSMatt Macy } 1341eda14cbcSMatt Macy ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE); 1342eda14cbcSMatt Macy ASSERT(spa->spa_proc != &p0); 1343eda14cbcSMatt Macy ASSERT(spa->spa_did != 0); 1344eda14cbcSMatt Macy } else { 1345eda14cbcSMatt Macy #ifdef _KERNEL 1346eda14cbcSMatt Macy cmn_err(CE_WARN, 1347eda14cbcSMatt Macy "Couldn't create process for zfs pool \"%s\"\n", 1348eda14cbcSMatt Macy spa->spa_name); 1349eda14cbcSMatt Macy #endif 1350eda14cbcSMatt Macy } 1351eda14cbcSMatt Macy } 1352eda14cbcSMatt Macy #endif /* HAVE_SPA_THREAD */ 1353eda14cbcSMatt Macy mutex_exit(&spa->spa_proc_lock); 1354eda14cbcSMatt Macy 1355eda14cbcSMatt Macy /* If we didn't create a process, we need to create our taskqs. */ 1356eda14cbcSMatt Macy if (spa->spa_proc == &p0) { 1357eda14cbcSMatt Macy spa_create_zio_taskqs(spa); 1358eda14cbcSMatt Macy } 1359eda14cbcSMatt Macy 1360eda14cbcSMatt Macy for (size_t i = 0; i < TXG_SIZE; i++) { 1361eda14cbcSMatt Macy spa->spa_txg_zio[i] = zio_root(spa, NULL, NULL, 1362eda14cbcSMatt Macy ZIO_FLAG_CANFAIL); 1363eda14cbcSMatt Macy } 1364eda14cbcSMatt Macy 1365eda14cbcSMatt Macy list_create(&spa->spa_config_dirty_list, sizeof (vdev_t), 1366eda14cbcSMatt Macy offsetof(vdev_t, vdev_config_dirty_node)); 1367eda14cbcSMatt Macy list_create(&spa->spa_evicting_os_list, sizeof (objset_t), 1368eda14cbcSMatt Macy offsetof(objset_t, os_evicting_node)); 1369eda14cbcSMatt Macy list_create(&spa->spa_state_dirty_list, sizeof (vdev_t), 1370eda14cbcSMatt Macy offsetof(vdev_t, vdev_state_dirty_node)); 1371eda14cbcSMatt Macy 1372eda14cbcSMatt Macy txg_list_create(&spa->spa_vdev_txg_list, spa, 1373eda14cbcSMatt Macy offsetof(struct vdev, vdev_txg_node)); 1374eda14cbcSMatt Macy 1375eda14cbcSMatt Macy avl_create(&spa->spa_errlist_scrub, 1376eda14cbcSMatt Macy spa_error_entry_compare, sizeof (spa_error_entry_t), 1377eda14cbcSMatt Macy offsetof(spa_error_entry_t, se_avl)); 1378eda14cbcSMatt Macy avl_create(&spa->spa_errlist_last, 1379eda14cbcSMatt Macy spa_error_entry_compare, sizeof (spa_error_entry_t), 1380eda14cbcSMatt Macy offsetof(spa_error_entry_t, se_avl)); 1381271171e0SMartin Matuska avl_create(&spa->spa_errlist_healed, 1382271171e0SMartin Matuska spa_error_entry_compare, sizeof (spa_error_entry_t), 1383271171e0SMartin Matuska offsetof(spa_error_entry_t, se_avl)); 1384eda14cbcSMatt Macy 1385c03c5b1cSMartin Matuska spa_activate_os(spa); 1386c03c5b1cSMartin Matuska 1387eda14cbcSMatt Macy spa_keystore_init(&spa->spa_keystore); 1388eda14cbcSMatt Macy 1389eda14cbcSMatt Macy /* 1390eda14cbcSMatt Macy * This taskq is used to perform zvol-minor-related tasks 1391eda14cbcSMatt Macy * asynchronously. This has several advantages, including easy 1392180f8225SMatt Macy * resolution of various deadlocks. 1393eda14cbcSMatt Macy * 1394eda14cbcSMatt Macy * The taskq must be single threaded to ensure tasks are always 1395eda14cbcSMatt Macy * processed in the order in which they were dispatched. 1396eda14cbcSMatt Macy * 1397eda14cbcSMatt Macy * A taskq per pool allows one to keep the pools independent. 1398eda14cbcSMatt Macy * This way if one pool is suspended, it will not impact another. 1399eda14cbcSMatt Macy * 1400eda14cbcSMatt Macy * The preferred location to dispatch a zvol minor task is a sync 1401eda14cbcSMatt Macy * task. In this context, there is easy access to the spa_t and minimal 1402eda14cbcSMatt Macy * error handling is required because the sync task must succeed. 1403eda14cbcSMatt Macy */ 1404eda14cbcSMatt Macy spa->spa_zvol_taskq = taskq_create("z_zvol", 1, defclsyspri, 1405eda14cbcSMatt Macy 1, INT_MAX, 0); 1406eda14cbcSMatt Macy 1407eda14cbcSMatt Macy /* 1408b2526e8bSMartin Matuska * The taskq to preload metaslabs. 1409b2526e8bSMartin Matuska */ 1410b2526e8bSMartin Matuska spa->spa_metaslab_taskq = taskq_create("z_metaslab", 1411b2526e8bSMartin Matuska metaslab_preload_pct, maxclsyspri, 1, INT_MAX, 1412b2526e8bSMartin Matuska TASKQ_DYNAMIC | TASKQ_THREADS_CPU_PCT); 1413b2526e8bSMartin Matuska 1414b2526e8bSMartin Matuska /* 1415eda14cbcSMatt Macy * Taskq dedicated to prefetcher threads: this is used to prevent the 1416eda14cbcSMatt Macy * pool traverse code from monopolizing the global (and limited) 1417eda14cbcSMatt Macy * system_taskq by inappropriately scheduling long running tasks on it. 1418eda14cbcSMatt Macy */ 14197877fdebSMatt Macy spa->spa_prefetch_taskq = taskq_create("z_prefetch", 100, 14207877fdebSMatt Macy defclsyspri, 1, INT_MAX, TASKQ_DYNAMIC | TASKQ_THREADS_CPU_PCT); 1421eda14cbcSMatt Macy 1422eda14cbcSMatt Macy /* 1423eda14cbcSMatt Macy * The taskq to upgrade datasets in this pool. Currently used by 1424eda14cbcSMatt Macy * feature SPA_FEATURE_USEROBJ_ACCOUNTING/SPA_FEATURE_PROJECT_QUOTA. 1425eda14cbcSMatt Macy */ 14267877fdebSMatt Macy spa->spa_upgrade_taskq = taskq_create("z_upgrade", 100, 14277877fdebSMatt Macy defclsyspri, 1, INT_MAX, TASKQ_DYNAMIC | TASKQ_THREADS_CPU_PCT); 1428eda14cbcSMatt Macy } 1429eda14cbcSMatt Macy 1430eda14cbcSMatt Macy /* 1431eda14cbcSMatt Macy * Opposite of spa_activate(). 1432eda14cbcSMatt Macy */ 1433eda14cbcSMatt Macy static void 1434eda14cbcSMatt Macy spa_deactivate(spa_t *spa) 1435eda14cbcSMatt Macy { 1436eda14cbcSMatt Macy ASSERT(spa->spa_sync_on == B_FALSE); 1437eda14cbcSMatt Macy ASSERT(spa->spa_dsl_pool == NULL); 1438eda14cbcSMatt Macy ASSERT(spa->spa_root_vdev == NULL); 1439eda14cbcSMatt Macy ASSERT(spa->spa_async_zio_root == NULL); 1440eda14cbcSMatt Macy ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED); 1441eda14cbcSMatt Macy 1442eda14cbcSMatt Macy spa_evicting_os_wait(spa); 1443eda14cbcSMatt Macy 1444eda14cbcSMatt Macy if (spa->spa_zvol_taskq) { 1445eda14cbcSMatt Macy taskq_destroy(spa->spa_zvol_taskq); 1446eda14cbcSMatt Macy spa->spa_zvol_taskq = NULL; 1447eda14cbcSMatt Macy } 1448eda14cbcSMatt Macy 1449b2526e8bSMartin Matuska if (spa->spa_metaslab_taskq) { 1450b2526e8bSMartin Matuska taskq_destroy(spa->spa_metaslab_taskq); 1451b2526e8bSMartin Matuska spa->spa_metaslab_taskq = NULL; 1452b2526e8bSMartin Matuska } 1453b2526e8bSMartin Matuska 1454eda14cbcSMatt Macy if (spa->spa_prefetch_taskq) { 1455eda14cbcSMatt Macy taskq_destroy(spa->spa_prefetch_taskq); 1456eda14cbcSMatt Macy spa->spa_prefetch_taskq = NULL; 1457eda14cbcSMatt Macy } 1458eda14cbcSMatt Macy 1459eda14cbcSMatt Macy if (spa->spa_upgrade_taskq) { 1460eda14cbcSMatt Macy taskq_destroy(spa->spa_upgrade_taskq); 1461eda14cbcSMatt Macy spa->spa_upgrade_taskq = NULL; 1462eda14cbcSMatt Macy } 1463eda14cbcSMatt Macy 1464eda14cbcSMatt Macy txg_list_destroy(&spa->spa_vdev_txg_list); 1465eda14cbcSMatt Macy 1466eda14cbcSMatt Macy list_destroy(&spa->spa_config_dirty_list); 1467eda14cbcSMatt Macy list_destroy(&spa->spa_evicting_os_list); 1468eda14cbcSMatt Macy list_destroy(&spa->spa_state_dirty_list); 1469eda14cbcSMatt Macy 1470eda14cbcSMatt Macy taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid); 1471eda14cbcSMatt Macy 1472eda14cbcSMatt Macy for (int t = 0; t < ZIO_TYPES; t++) { 1473eda14cbcSMatt Macy for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { 1474eda14cbcSMatt Macy spa_taskqs_fini(spa, t, q); 1475eda14cbcSMatt Macy } 1476eda14cbcSMatt Macy } 1477eda14cbcSMatt Macy 1478eda14cbcSMatt Macy for (size_t i = 0; i < TXG_SIZE; i++) { 1479eda14cbcSMatt Macy ASSERT3P(spa->spa_txg_zio[i], !=, NULL); 1480eda14cbcSMatt Macy VERIFY0(zio_wait(spa->spa_txg_zio[i])); 1481eda14cbcSMatt Macy spa->spa_txg_zio[i] = NULL; 1482eda14cbcSMatt Macy } 1483eda14cbcSMatt Macy 1484eda14cbcSMatt Macy metaslab_class_destroy(spa->spa_normal_class); 1485eda14cbcSMatt Macy spa->spa_normal_class = NULL; 1486eda14cbcSMatt Macy 1487eda14cbcSMatt Macy metaslab_class_destroy(spa->spa_log_class); 1488eda14cbcSMatt Macy spa->spa_log_class = NULL; 1489eda14cbcSMatt Macy 1490184c1b94SMartin Matuska metaslab_class_destroy(spa->spa_embedded_log_class); 1491184c1b94SMartin Matuska spa->spa_embedded_log_class = NULL; 1492184c1b94SMartin Matuska 1493eda14cbcSMatt Macy metaslab_class_destroy(spa->spa_special_class); 1494eda14cbcSMatt Macy spa->spa_special_class = NULL; 1495eda14cbcSMatt Macy 1496eda14cbcSMatt Macy metaslab_class_destroy(spa->spa_dedup_class); 1497eda14cbcSMatt Macy spa->spa_dedup_class = NULL; 1498eda14cbcSMatt Macy 1499eda14cbcSMatt Macy /* 1500eda14cbcSMatt Macy * If this was part of an import or the open otherwise failed, we may 1501eda14cbcSMatt Macy * still have errors left in the queues. Empty them just in case. 1502eda14cbcSMatt Macy */ 1503eda14cbcSMatt Macy spa_errlog_drain(spa); 1504eda14cbcSMatt Macy avl_destroy(&spa->spa_errlist_scrub); 1505eda14cbcSMatt Macy avl_destroy(&spa->spa_errlist_last); 1506271171e0SMartin Matuska avl_destroy(&spa->spa_errlist_healed); 1507eda14cbcSMatt Macy 1508eda14cbcSMatt Macy spa_keystore_fini(&spa->spa_keystore); 1509eda14cbcSMatt Macy 1510eda14cbcSMatt Macy spa->spa_state = POOL_STATE_UNINITIALIZED; 1511eda14cbcSMatt Macy 1512eda14cbcSMatt Macy mutex_enter(&spa->spa_proc_lock); 1513eda14cbcSMatt Macy if (spa->spa_proc_state != SPA_PROC_NONE) { 1514eda14cbcSMatt Macy ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE); 1515eda14cbcSMatt Macy spa->spa_proc_state = SPA_PROC_DEACTIVATE; 1516eda14cbcSMatt Macy cv_broadcast(&spa->spa_proc_cv); 1517eda14cbcSMatt Macy while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) { 1518eda14cbcSMatt Macy ASSERT(spa->spa_proc != &p0); 1519eda14cbcSMatt Macy cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock); 1520eda14cbcSMatt Macy } 1521eda14cbcSMatt Macy ASSERT(spa->spa_proc_state == SPA_PROC_GONE); 1522eda14cbcSMatt Macy spa->spa_proc_state = SPA_PROC_NONE; 1523eda14cbcSMatt Macy } 1524eda14cbcSMatt Macy ASSERT(spa->spa_proc == &p0); 1525eda14cbcSMatt Macy mutex_exit(&spa->spa_proc_lock); 1526eda14cbcSMatt Macy 1527eda14cbcSMatt Macy /* 1528eda14cbcSMatt Macy * We want to make sure spa_thread() has actually exited the ZFS 1529eda14cbcSMatt Macy * module, so that the module can't be unloaded out from underneath 1530eda14cbcSMatt Macy * it. 1531eda14cbcSMatt Macy */ 1532eda14cbcSMatt Macy if (spa->spa_did != 0) { 1533eda14cbcSMatt Macy thread_join(spa->spa_did); 1534eda14cbcSMatt Macy spa->spa_did = 0; 1535eda14cbcSMatt Macy } 1536c03c5b1cSMartin Matuska 1537c03c5b1cSMartin Matuska spa_deactivate_os(spa); 1538c03c5b1cSMartin Matuska 1539eda14cbcSMatt Macy } 1540eda14cbcSMatt Macy 1541eda14cbcSMatt Macy /* 1542eda14cbcSMatt Macy * Verify a pool configuration, and construct the vdev tree appropriately. This 1543eda14cbcSMatt Macy * will create all the necessary vdevs in the appropriate layout, with each vdev 1544eda14cbcSMatt Macy * in the CLOSED state. This will prep the pool before open/creation/import. 1545eda14cbcSMatt Macy * All vdev validation is done by the vdev_alloc() routine. 1546eda14cbcSMatt Macy */ 1547eda14cbcSMatt Macy int 1548eda14cbcSMatt Macy spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, 1549eda14cbcSMatt Macy uint_t id, int atype) 1550eda14cbcSMatt Macy { 1551eda14cbcSMatt Macy nvlist_t **child; 1552eda14cbcSMatt Macy uint_t children; 1553eda14cbcSMatt Macy int error; 1554eda14cbcSMatt Macy 1555eda14cbcSMatt Macy if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0) 1556eda14cbcSMatt Macy return (error); 1557eda14cbcSMatt Macy 1558eda14cbcSMatt Macy if ((*vdp)->vdev_ops->vdev_op_leaf) 1559eda14cbcSMatt Macy return (0); 1560eda14cbcSMatt Macy 1561eda14cbcSMatt Macy error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1562eda14cbcSMatt Macy &child, &children); 1563eda14cbcSMatt Macy 1564eda14cbcSMatt Macy if (error == ENOENT) 1565eda14cbcSMatt Macy return (0); 1566eda14cbcSMatt Macy 1567eda14cbcSMatt Macy if (error) { 1568eda14cbcSMatt Macy vdev_free(*vdp); 1569eda14cbcSMatt Macy *vdp = NULL; 1570eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 1571eda14cbcSMatt Macy } 1572eda14cbcSMatt Macy 1573eda14cbcSMatt Macy for (int c = 0; c < children; c++) { 1574eda14cbcSMatt Macy vdev_t *vd; 1575eda14cbcSMatt Macy if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c, 1576eda14cbcSMatt Macy atype)) != 0) { 1577eda14cbcSMatt Macy vdev_free(*vdp); 1578eda14cbcSMatt Macy *vdp = NULL; 1579eda14cbcSMatt Macy return (error); 1580eda14cbcSMatt Macy } 1581eda14cbcSMatt Macy } 1582eda14cbcSMatt Macy 1583eda14cbcSMatt Macy ASSERT(*vdp != NULL); 1584eda14cbcSMatt Macy 1585eda14cbcSMatt Macy return (0); 1586eda14cbcSMatt Macy } 1587eda14cbcSMatt Macy 1588eda14cbcSMatt Macy static boolean_t 1589eda14cbcSMatt Macy spa_should_flush_logs_on_unload(spa_t *spa) 1590eda14cbcSMatt Macy { 1591eda14cbcSMatt Macy if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) 1592eda14cbcSMatt Macy return (B_FALSE); 1593eda14cbcSMatt Macy 1594eda14cbcSMatt Macy if (!spa_writeable(spa)) 1595eda14cbcSMatt Macy return (B_FALSE); 1596eda14cbcSMatt Macy 1597eda14cbcSMatt Macy if (!spa->spa_sync_on) 1598eda14cbcSMatt Macy return (B_FALSE); 1599eda14cbcSMatt Macy 1600eda14cbcSMatt Macy if (spa_state(spa) != POOL_STATE_EXPORTED) 1601eda14cbcSMatt Macy return (B_FALSE); 1602eda14cbcSMatt Macy 1603eda14cbcSMatt Macy if (zfs_keep_log_spacemaps_at_export) 1604eda14cbcSMatt Macy return (B_FALSE); 1605eda14cbcSMatt Macy 1606eda14cbcSMatt Macy return (B_TRUE); 1607eda14cbcSMatt Macy } 1608eda14cbcSMatt Macy 1609eda14cbcSMatt Macy /* 1610eda14cbcSMatt Macy * Opens a transaction that will set the flag that will instruct 1611eda14cbcSMatt Macy * spa_sync to attempt to flush all the metaslabs for that txg. 1612eda14cbcSMatt Macy */ 1613eda14cbcSMatt Macy static void 1614eda14cbcSMatt Macy spa_unload_log_sm_flush_all(spa_t *spa) 1615eda14cbcSMatt Macy { 1616eda14cbcSMatt Macy dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); 1617eda14cbcSMatt Macy VERIFY0(dmu_tx_assign(tx, TXG_WAIT)); 1618eda14cbcSMatt Macy 1619eda14cbcSMatt Macy ASSERT3U(spa->spa_log_flushall_txg, ==, 0); 1620eda14cbcSMatt Macy spa->spa_log_flushall_txg = dmu_tx_get_txg(tx); 1621eda14cbcSMatt Macy 1622eda14cbcSMatt Macy dmu_tx_commit(tx); 1623eda14cbcSMatt Macy txg_wait_synced(spa_get_dsl(spa), spa->spa_log_flushall_txg); 1624eda14cbcSMatt Macy } 1625eda14cbcSMatt Macy 1626eda14cbcSMatt Macy static void 1627eda14cbcSMatt Macy spa_unload_log_sm_metadata(spa_t *spa) 1628eda14cbcSMatt Macy { 1629eda14cbcSMatt Macy void *cookie = NULL; 1630eda14cbcSMatt Macy spa_log_sm_t *sls; 16314e8d558cSMartin Matuska log_summary_entry_t *e; 16324e8d558cSMartin Matuska 1633eda14cbcSMatt Macy while ((sls = avl_destroy_nodes(&spa->spa_sm_logs_by_txg, 1634eda14cbcSMatt Macy &cookie)) != NULL) { 1635eda14cbcSMatt Macy VERIFY0(sls->sls_mscount); 1636eda14cbcSMatt Macy kmem_free(sls, sizeof (spa_log_sm_t)); 1637eda14cbcSMatt Macy } 1638eda14cbcSMatt Macy 16394e8d558cSMartin Matuska while ((e = list_remove_head(&spa->spa_log_summary)) != NULL) { 1640eda14cbcSMatt Macy VERIFY0(e->lse_mscount); 1641eda14cbcSMatt Macy kmem_free(e, sizeof (log_summary_entry_t)); 1642eda14cbcSMatt Macy } 1643eda14cbcSMatt Macy 1644eda14cbcSMatt Macy spa->spa_unflushed_stats.sus_nblocks = 0; 1645eda14cbcSMatt Macy spa->spa_unflushed_stats.sus_memused = 0; 1646eda14cbcSMatt Macy spa->spa_unflushed_stats.sus_blocklimit = 0; 1647eda14cbcSMatt Macy } 1648eda14cbcSMatt Macy 1649eda14cbcSMatt Macy static void 1650eda14cbcSMatt Macy spa_destroy_aux_threads(spa_t *spa) 1651eda14cbcSMatt Macy { 1652eda14cbcSMatt Macy if (spa->spa_condense_zthr != NULL) { 1653eda14cbcSMatt Macy zthr_destroy(spa->spa_condense_zthr); 1654eda14cbcSMatt Macy spa->spa_condense_zthr = NULL; 1655eda14cbcSMatt Macy } 1656eda14cbcSMatt Macy if (spa->spa_checkpoint_discard_zthr != NULL) { 1657eda14cbcSMatt Macy zthr_destroy(spa->spa_checkpoint_discard_zthr); 1658eda14cbcSMatt Macy spa->spa_checkpoint_discard_zthr = NULL; 1659eda14cbcSMatt Macy } 1660eda14cbcSMatt Macy if (spa->spa_livelist_delete_zthr != NULL) { 1661eda14cbcSMatt Macy zthr_destroy(spa->spa_livelist_delete_zthr); 1662eda14cbcSMatt Macy spa->spa_livelist_delete_zthr = NULL; 1663eda14cbcSMatt Macy } 1664eda14cbcSMatt Macy if (spa->spa_livelist_condense_zthr != NULL) { 1665eda14cbcSMatt Macy zthr_destroy(spa->spa_livelist_condense_zthr); 1666eda14cbcSMatt Macy spa->spa_livelist_condense_zthr = NULL; 1667eda14cbcSMatt Macy } 1668eda14cbcSMatt Macy } 1669eda14cbcSMatt Macy 1670eda14cbcSMatt Macy /* 1671eda14cbcSMatt Macy * Opposite of spa_load(). 1672eda14cbcSMatt Macy */ 1673eda14cbcSMatt Macy static void 1674eda14cbcSMatt Macy spa_unload(spa_t *spa) 1675eda14cbcSMatt Macy { 1676eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 1677eda14cbcSMatt Macy ASSERT(spa_state(spa) != POOL_STATE_UNINITIALIZED); 1678eda14cbcSMatt Macy 1679eda14cbcSMatt Macy spa_import_progress_remove(spa_guid(spa)); 1680eda14cbcSMatt Macy spa_load_note(spa, "UNLOADING"); 1681eda14cbcSMatt Macy 1682eda14cbcSMatt Macy spa_wake_waiters(spa); 1683eda14cbcSMatt Macy 1684eda14cbcSMatt Macy /* 1685c03c5b1cSMartin Matuska * If we have set the spa_final_txg, we have already performed the 1686c03c5b1cSMartin Matuska * tasks below in spa_export_common(). We should not redo it here since 1687c03c5b1cSMartin Matuska * we delay the final TXGs beyond what spa_final_txg is set at. 1688c03c5b1cSMartin Matuska */ 1689c03c5b1cSMartin Matuska if (spa->spa_final_txg == UINT64_MAX) { 1690c03c5b1cSMartin Matuska /* 1691c03c5b1cSMartin Matuska * If the log space map feature is enabled and the pool is 1692c03c5b1cSMartin Matuska * getting exported (but not destroyed), we want to spend some 1693c03c5b1cSMartin Matuska * time flushing as many metaslabs as we can in an attempt to 1694c03c5b1cSMartin Matuska * destroy log space maps and save import time. 1695eda14cbcSMatt Macy */ 1696eda14cbcSMatt Macy if (spa_should_flush_logs_on_unload(spa)) 1697eda14cbcSMatt Macy spa_unload_log_sm_flush_all(spa); 1698eda14cbcSMatt Macy 1699eda14cbcSMatt Macy /* 1700eda14cbcSMatt Macy * Stop async tasks. 1701eda14cbcSMatt Macy */ 1702eda14cbcSMatt Macy spa_async_suspend(spa); 1703eda14cbcSMatt Macy 1704eda14cbcSMatt Macy if (spa->spa_root_vdev) { 1705eda14cbcSMatt Macy vdev_t *root_vdev = spa->spa_root_vdev; 1706c03c5b1cSMartin Matuska vdev_initialize_stop_all(root_vdev, 1707c03c5b1cSMartin Matuska VDEV_INITIALIZE_ACTIVE); 1708eda14cbcSMatt Macy vdev_trim_stop_all(root_vdev, VDEV_TRIM_ACTIVE); 1709eda14cbcSMatt Macy vdev_autotrim_stop_all(spa); 1710eda14cbcSMatt Macy vdev_rebuild_stop_all(spa); 1711eda14cbcSMatt Macy } 1712c03c5b1cSMartin Matuska } 1713eda14cbcSMatt Macy 1714eda14cbcSMatt Macy /* 1715eda14cbcSMatt Macy * Stop syncing. 1716eda14cbcSMatt Macy */ 1717eda14cbcSMatt Macy if (spa->spa_sync_on) { 1718eda14cbcSMatt Macy txg_sync_stop(spa->spa_dsl_pool); 1719eda14cbcSMatt Macy spa->spa_sync_on = B_FALSE; 1720eda14cbcSMatt Macy } 1721eda14cbcSMatt Macy 1722eda14cbcSMatt Macy /* 1723eda14cbcSMatt Macy * This ensures that there is no async metaslab prefetching 1724eda14cbcSMatt Macy * while we attempt to unload the spa. 1725eda14cbcSMatt Macy */ 1726b2526e8bSMartin Matuska taskq_wait(spa->spa_metaslab_taskq); 1727eda14cbcSMatt Macy 1728eda14cbcSMatt Macy if (spa->spa_mmp.mmp_thread) 1729eda14cbcSMatt Macy mmp_thread_stop(spa); 1730eda14cbcSMatt Macy 1731eda14cbcSMatt Macy /* 1732eda14cbcSMatt Macy * Wait for any outstanding async I/O to complete. 1733eda14cbcSMatt Macy */ 1734eda14cbcSMatt Macy if (spa->spa_async_zio_root != NULL) { 1735eda14cbcSMatt Macy for (int i = 0; i < max_ncpus; i++) 1736eda14cbcSMatt Macy (void) zio_wait(spa->spa_async_zio_root[i]); 1737eda14cbcSMatt Macy kmem_free(spa->spa_async_zio_root, max_ncpus * sizeof (void *)); 1738eda14cbcSMatt Macy spa->spa_async_zio_root = NULL; 1739eda14cbcSMatt Macy } 1740eda14cbcSMatt Macy 1741eda14cbcSMatt Macy if (spa->spa_vdev_removal != NULL) { 1742eda14cbcSMatt Macy spa_vdev_removal_destroy(spa->spa_vdev_removal); 1743eda14cbcSMatt Macy spa->spa_vdev_removal = NULL; 1744eda14cbcSMatt Macy } 1745eda14cbcSMatt Macy 1746eda14cbcSMatt Macy spa_destroy_aux_threads(spa); 1747eda14cbcSMatt Macy 1748eda14cbcSMatt Macy spa_condense_fini(spa); 1749eda14cbcSMatt Macy 1750eda14cbcSMatt Macy bpobj_close(&spa->spa_deferred_bpobj); 1751eda14cbcSMatt Macy 1752eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, spa, RW_WRITER); 1753eda14cbcSMatt Macy 1754eda14cbcSMatt Macy /* 1755eda14cbcSMatt Macy * Close all vdevs. 1756eda14cbcSMatt Macy */ 1757eda14cbcSMatt Macy if (spa->spa_root_vdev) 1758eda14cbcSMatt Macy vdev_free(spa->spa_root_vdev); 1759eda14cbcSMatt Macy ASSERT(spa->spa_root_vdev == NULL); 1760eda14cbcSMatt Macy 1761eda14cbcSMatt Macy /* 1762eda14cbcSMatt Macy * Close the dsl pool. 1763eda14cbcSMatt Macy */ 1764eda14cbcSMatt Macy if (spa->spa_dsl_pool) { 1765eda14cbcSMatt Macy dsl_pool_close(spa->spa_dsl_pool); 1766eda14cbcSMatt Macy spa->spa_dsl_pool = NULL; 1767eda14cbcSMatt Macy spa->spa_meta_objset = NULL; 1768eda14cbcSMatt Macy } 1769eda14cbcSMatt Macy 1770eda14cbcSMatt Macy ddt_unload(spa); 17712a58b312SMartin Matuska brt_unload(spa); 1772eda14cbcSMatt Macy spa_unload_log_sm_metadata(spa); 1773eda14cbcSMatt Macy 1774eda14cbcSMatt Macy /* 1775eda14cbcSMatt Macy * Drop and purge level 2 cache 1776eda14cbcSMatt Macy */ 1777eda14cbcSMatt Macy spa_l2cache_drop(spa); 1778eda14cbcSMatt Macy 1779c9539b89SMartin Matuska if (spa->spa_spares.sav_vdevs) { 1780eda14cbcSMatt Macy for (int i = 0; i < spa->spa_spares.sav_count; i++) 1781eda14cbcSMatt Macy vdev_free(spa->spa_spares.sav_vdevs[i]); 1782eda14cbcSMatt Macy kmem_free(spa->spa_spares.sav_vdevs, 1783eda14cbcSMatt Macy spa->spa_spares.sav_count * sizeof (void *)); 1784eda14cbcSMatt Macy spa->spa_spares.sav_vdevs = NULL; 1785eda14cbcSMatt Macy } 1786eda14cbcSMatt Macy if (spa->spa_spares.sav_config) { 1787eda14cbcSMatt Macy nvlist_free(spa->spa_spares.sav_config); 1788eda14cbcSMatt Macy spa->spa_spares.sav_config = NULL; 1789eda14cbcSMatt Macy } 1790eda14cbcSMatt Macy spa->spa_spares.sav_count = 0; 1791eda14cbcSMatt Macy 1792c9539b89SMartin Matuska if (spa->spa_l2cache.sav_vdevs) { 1793eda14cbcSMatt Macy for (int i = 0; i < spa->spa_l2cache.sav_count; i++) { 1794eda14cbcSMatt Macy vdev_clear_stats(spa->spa_l2cache.sav_vdevs[i]); 1795eda14cbcSMatt Macy vdev_free(spa->spa_l2cache.sav_vdevs[i]); 1796eda14cbcSMatt Macy } 1797eda14cbcSMatt Macy kmem_free(spa->spa_l2cache.sav_vdevs, 1798eda14cbcSMatt Macy spa->spa_l2cache.sav_count * sizeof (void *)); 1799eda14cbcSMatt Macy spa->spa_l2cache.sav_vdevs = NULL; 1800eda14cbcSMatt Macy } 1801eda14cbcSMatt Macy if (spa->spa_l2cache.sav_config) { 1802eda14cbcSMatt Macy nvlist_free(spa->spa_l2cache.sav_config); 1803eda14cbcSMatt Macy spa->spa_l2cache.sav_config = NULL; 1804eda14cbcSMatt Macy } 1805eda14cbcSMatt Macy spa->spa_l2cache.sav_count = 0; 1806eda14cbcSMatt Macy 1807eda14cbcSMatt Macy spa->spa_async_suspended = 0; 1808eda14cbcSMatt Macy 1809eda14cbcSMatt Macy spa->spa_indirect_vdevs_loaded = B_FALSE; 1810eda14cbcSMatt Macy 1811eda14cbcSMatt Macy if (spa->spa_comment != NULL) { 1812eda14cbcSMatt Macy spa_strfree(spa->spa_comment); 1813eda14cbcSMatt Macy spa->spa_comment = NULL; 1814eda14cbcSMatt Macy } 1815ee36e25aSMartin Matuska if (spa->spa_compatibility != NULL) { 1816ee36e25aSMartin Matuska spa_strfree(spa->spa_compatibility); 1817ee36e25aSMartin Matuska spa->spa_compatibility = NULL; 1818ee36e25aSMartin Matuska } 1819eda14cbcSMatt Macy 1820eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, spa); 1821eda14cbcSMatt Macy } 1822eda14cbcSMatt Macy 1823eda14cbcSMatt Macy /* 1824eda14cbcSMatt Macy * Load (or re-load) the current list of vdevs describing the active spares for 1825eda14cbcSMatt Macy * this pool. When this is called, we have some form of basic information in 1826eda14cbcSMatt Macy * 'spa_spares.sav_config'. We parse this into vdevs, try to open them, and 1827eda14cbcSMatt Macy * then re-generate a more complete list including status information. 1828eda14cbcSMatt Macy */ 1829eda14cbcSMatt Macy void 1830eda14cbcSMatt Macy spa_load_spares(spa_t *spa) 1831eda14cbcSMatt Macy { 1832eda14cbcSMatt Macy nvlist_t **spares; 1833eda14cbcSMatt Macy uint_t nspares; 1834eda14cbcSMatt Macy int i; 1835eda14cbcSMatt Macy vdev_t *vd, *tvd; 1836eda14cbcSMatt Macy 1837eda14cbcSMatt Macy #ifndef _KERNEL 1838eda14cbcSMatt Macy /* 1839eda14cbcSMatt Macy * zdb opens both the current state of the pool and the 1840eda14cbcSMatt Macy * checkpointed state (if present), with a different spa_t. 1841eda14cbcSMatt Macy * 1842eda14cbcSMatt Macy * As spare vdevs are shared among open pools, we skip loading 1843eda14cbcSMatt Macy * them when we load the checkpointed state of the pool. 1844eda14cbcSMatt Macy */ 1845eda14cbcSMatt Macy if (!spa_writeable(spa)) 1846eda14cbcSMatt Macy return; 1847eda14cbcSMatt Macy #endif 1848eda14cbcSMatt Macy 1849eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 1850eda14cbcSMatt Macy 1851eda14cbcSMatt Macy /* 1852eda14cbcSMatt Macy * First, close and free any existing spare vdevs. 1853eda14cbcSMatt Macy */ 1854c9539b89SMartin Matuska if (spa->spa_spares.sav_vdevs) { 1855eda14cbcSMatt Macy for (i = 0; i < spa->spa_spares.sav_count; i++) { 1856eda14cbcSMatt Macy vd = spa->spa_spares.sav_vdevs[i]; 1857eda14cbcSMatt Macy 1858eda14cbcSMatt Macy /* Undo the call to spa_activate() below */ 1859eda14cbcSMatt Macy if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, 1860eda14cbcSMatt Macy B_FALSE)) != NULL && tvd->vdev_isspare) 1861eda14cbcSMatt Macy spa_spare_remove(tvd); 1862eda14cbcSMatt Macy vdev_close(vd); 1863eda14cbcSMatt Macy vdev_free(vd); 1864eda14cbcSMatt Macy } 1865eda14cbcSMatt Macy 1866eda14cbcSMatt Macy kmem_free(spa->spa_spares.sav_vdevs, 1867eda14cbcSMatt Macy spa->spa_spares.sav_count * sizeof (void *)); 1868c9539b89SMartin Matuska } 1869eda14cbcSMatt Macy 1870eda14cbcSMatt Macy if (spa->spa_spares.sav_config == NULL) 1871eda14cbcSMatt Macy nspares = 0; 1872eda14cbcSMatt Macy else 187381b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 187481b22a98SMartin Matuska ZPOOL_CONFIG_SPARES, &spares, &nspares)); 1875eda14cbcSMatt Macy 1876eda14cbcSMatt Macy spa->spa_spares.sav_count = (int)nspares; 1877eda14cbcSMatt Macy spa->spa_spares.sav_vdevs = NULL; 1878eda14cbcSMatt Macy 1879eda14cbcSMatt Macy if (nspares == 0) 1880eda14cbcSMatt Macy return; 1881eda14cbcSMatt Macy 1882eda14cbcSMatt Macy /* 1883eda14cbcSMatt Macy * Construct the array of vdevs, opening them to get status in the 1884eda14cbcSMatt Macy * process. For each spare, there is potentially two different vdev_t 1885eda14cbcSMatt Macy * structures associated with it: one in the list of spares (used only 1886eda14cbcSMatt Macy * for basic validation purposes) and one in the active vdev 1887eda14cbcSMatt Macy * configuration (if it's spared in). During this phase we open and 1888eda14cbcSMatt Macy * validate each vdev on the spare list. If the vdev also exists in the 1889eda14cbcSMatt Macy * active configuration, then we also mark this vdev as an active spare. 1890eda14cbcSMatt Macy */ 1891eda14cbcSMatt Macy spa->spa_spares.sav_vdevs = kmem_zalloc(nspares * sizeof (void *), 1892eda14cbcSMatt Macy KM_SLEEP); 1893eda14cbcSMatt Macy for (i = 0; i < spa->spa_spares.sav_count; i++) { 1894eda14cbcSMatt Macy VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0, 1895eda14cbcSMatt Macy VDEV_ALLOC_SPARE) == 0); 1896eda14cbcSMatt Macy ASSERT(vd != NULL); 1897eda14cbcSMatt Macy 1898eda14cbcSMatt Macy spa->spa_spares.sav_vdevs[i] = vd; 1899eda14cbcSMatt Macy 1900eda14cbcSMatt Macy if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, 1901eda14cbcSMatt Macy B_FALSE)) != NULL) { 1902eda14cbcSMatt Macy if (!tvd->vdev_isspare) 1903eda14cbcSMatt Macy spa_spare_add(tvd); 1904eda14cbcSMatt Macy 1905eda14cbcSMatt Macy /* 1906eda14cbcSMatt Macy * We only mark the spare active if we were successfully 1907eda14cbcSMatt Macy * able to load the vdev. Otherwise, importing a pool 1908eda14cbcSMatt Macy * with a bad active spare would result in strange 1909eda14cbcSMatt Macy * behavior, because multiple pool would think the spare 1910eda14cbcSMatt Macy * is actively in use. 1911eda14cbcSMatt Macy * 1912eda14cbcSMatt Macy * There is a vulnerability here to an equally bizarre 1913eda14cbcSMatt Macy * circumstance, where a dead active spare is later 1914eda14cbcSMatt Macy * brought back to life (onlined or otherwise). Given 1915eda14cbcSMatt Macy * the rarity of this scenario, and the extra complexity 1916eda14cbcSMatt Macy * it adds, we ignore the possibility. 1917eda14cbcSMatt Macy */ 1918eda14cbcSMatt Macy if (!vdev_is_dead(tvd)) 1919eda14cbcSMatt Macy spa_spare_activate(tvd); 1920eda14cbcSMatt Macy } 1921eda14cbcSMatt Macy 1922eda14cbcSMatt Macy vd->vdev_top = vd; 1923eda14cbcSMatt Macy vd->vdev_aux = &spa->spa_spares; 1924eda14cbcSMatt Macy 1925eda14cbcSMatt Macy if (vdev_open(vd) != 0) 1926eda14cbcSMatt Macy continue; 1927eda14cbcSMatt Macy 1928eda14cbcSMatt Macy if (vdev_validate_aux(vd) == 0) 1929eda14cbcSMatt Macy spa_spare_add(vd); 1930eda14cbcSMatt Macy } 1931eda14cbcSMatt Macy 1932eda14cbcSMatt Macy /* 1933eda14cbcSMatt Macy * Recompute the stashed list of spares, with status information 1934eda14cbcSMatt Macy * this time. 1935eda14cbcSMatt Macy */ 193681b22a98SMartin Matuska fnvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES); 1937eda14cbcSMatt Macy 1938eda14cbcSMatt Macy spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *), 1939eda14cbcSMatt Macy KM_SLEEP); 1940eda14cbcSMatt Macy for (i = 0; i < spa->spa_spares.sav_count; i++) 1941eda14cbcSMatt Macy spares[i] = vdev_config_generate(spa, 1942eda14cbcSMatt Macy spa->spa_spares.sav_vdevs[i], B_TRUE, VDEV_CONFIG_SPARE); 194381b22a98SMartin Matuska fnvlist_add_nvlist_array(spa->spa_spares.sav_config, 1944681ce946SMartin Matuska ZPOOL_CONFIG_SPARES, (const nvlist_t * const *)spares, 1945681ce946SMartin Matuska spa->spa_spares.sav_count); 1946eda14cbcSMatt Macy for (i = 0; i < spa->spa_spares.sav_count; i++) 1947eda14cbcSMatt Macy nvlist_free(spares[i]); 1948eda14cbcSMatt Macy kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *)); 1949eda14cbcSMatt Macy } 1950eda14cbcSMatt Macy 1951eda14cbcSMatt Macy /* 1952eda14cbcSMatt Macy * Load (or re-load) the current list of vdevs describing the active l2cache for 1953eda14cbcSMatt Macy * this pool. When this is called, we have some form of basic information in 1954eda14cbcSMatt Macy * 'spa_l2cache.sav_config'. We parse this into vdevs, try to open them, and 1955eda14cbcSMatt Macy * then re-generate a more complete list including status information. 1956eda14cbcSMatt Macy * Devices which are already active have their details maintained, and are 1957eda14cbcSMatt Macy * not re-opened. 1958eda14cbcSMatt Macy */ 1959eda14cbcSMatt Macy void 1960eda14cbcSMatt Macy spa_load_l2cache(spa_t *spa) 1961eda14cbcSMatt Macy { 1962eda14cbcSMatt Macy nvlist_t **l2cache = NULL; 1963eda14cbcSMatt Macy uint_t nl2cache; 1964eda14cbcSMatt Macy int i, j, oldnvdevs; 1965eda14cbcSMatt Macy uint64_t guid; 1966eda14cbcSMatt Macy vdev_t *vd, **oldvdevs, **newvdevs; 1967eda14cbcSMatt Macy spa_aux_vdev_t *sav = &spa->spa_l2cache; 1968eda14cbcSMatt Macy 1969eda14cbcSMatt Macy #ifndef _KERNEL 1970eda14cbcSMatt Macy /* 1971eda14cbcSMatt Macy * zdb opens both the current state of the pool and the 1972eda14cbcSMatt Macy * checkpointed state (if present), with a different spa_t. 1973eda14cbcSMatt Macy * 1974eda14cbcSMatt Macy * As L2 caches are part of the ARC which is shared among open 1975eda14cbcSMatt Macy * pools, we skip loading them when we load the checkpointed 1976eda14cbcSMatt Macy * state of the pool. 1977eda14cbcSMatt Macy */ 1978eda14cbcSMatt Macy if (!spa_writeable(spa)) 1979eda14cbcSMatt Macy return; 1980eda14cbcSMatt Macy #endif 1981eda14cbcSMatt Macy 1982eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 1983eda14cbcSMatt Macy 1984eda14cbcSMatt Macy oldvdevs = sav->sav_vdevs; 1985eda14cbcSMatt Macy oldnvdevs = sav->sav_count; 1986eda14cbcSMatt Macy sav->sav_vdevs = NULL; 1987eda14cbcSMatt Macy sav->sav_count = 0; 1988eda14cbcSMatt Macy 1989eda14cbcSMatt Macy if (sav->sav_config == NULL) { 1990eda14cbcSMatt Macy nl2cache = 0; 1991eda14cbcSMatt Macy newvdevs = NULL; 1992eda14cbcSMatt Macy goto out; 1993eda14cbcSMatt Macy } 1994eda14cbcSMatt Macy 199581b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(sav->sav_config, 199681b22a98SMartin Matuska ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache)); 1997eda14cbcSMatt Macy newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP); 1998eda14cbcSMatt Macy 1999eda14cbcSMatt Macy /* 2000eda14cbcSMatt Macy * Process new nvlist of vdevs. 2001eda14cbcSMatt Macy */ 2002eda14cbcSMatt Macy for (i = 0; i < nl2cache; i++) { 200381b22a98SMartin Matuska guid = fnvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID); 2004eda14cbcSMatt Macy 2005eda14cbcSMatt Macy newvdevs[i] = NULL; 2006eda14cbcSMatt Macy for (j = 0; j < oldnvdevs; j++) { 2007eda14cbcSMatt Macy vd = oldvdevs[j]; 2008eda14cbcSMatt Macy if (vd != NULL && guid == vd->vdev_guid) { 2009eda14cbcSMatt Macy /* 2010eda14cbcSMatt Macy * Retain previous vdev for add/remove ops. 2011eda14cbcSMatt Macy */ 2012eda14cbcSMatt Macy newvdevs[i] = vd; 2013eda14cbcSMatt Macy oldvdevs[j] = NULL; 2014eda14cbcSMatt Macy break; 2015eda14cbcSMatt Macy } 2016eda14cbcSMatt Macy } 2017eda14cbcSMatt Macy 2018eda14cbcSMatt Macy if (newvdevs[i] == NULL) { 2019eda14cbcSMatt Macy /* 2020eda14cbcSMatt Macy * Create new vdev 2021eda14cbcSMatt Macy */ 2022eda14cbcSMatt Macy VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0, 2023eda14cbcSMatt Macy VDEV_ALLOC_L2CACHE) == 0); 2024eda14cbcSMatt Macy ASSERT(vd != NULL); 2025eda14cbcSMatt Macy newvdevs[i] = vd; 2026eda14cbcSMatt Macy 2027eda14cbcSMatt Macy /* 2028eda14cbcSMatt Macy * Commit this vdev as an l2cache device, 2029eda14cbcSMatt Macy * even if it fails to open. 2030eda14cbcSMatt Macy */ 2031eda14cbcSMatt Macy spa_l2cache_add(vd); 2032eda14cbcSMatt Macy 2033eda14cbcSMatt Macy vd->vdev_top = vd; 2034eda14cbcSMatt Macy vd->vdev_aux = sav; 2035eda14cbcSMatt Macy 2036eda14cbcSMatt Macy spa_l2cache_activate(vd); 2037eda14cbcSMatt Macy 2038eda14cbcSMatt Macy if (vdev_open(vd) != 0) 2039eda14cbcSMatt Macy continue; 2040eda14cbcSMatt Macy 2041eda14cbcSMatt Macy (void) vdev_validate_aux(vd); 2042eda14cbcSMatt Macy 2043eda14cbcSMatt Macy if (!vdev_is_dead(vd)) 2044eda14cbcSMatt Macy l2arc_add_vdev(spa, vd); 2045eda14cbcSMatt Macy 2046eda14cbcSMatt Macy /* 2047eda14cbcSMatt Macy * Upon cache device addition to a pool or pool 2048eda14cbcSMatt Macy * creation with a cache device or if the header 2049eda14cbcSMatt Macy * of the device is invalid we issue an async 2050eda14cbcSMatt Macy * TRIM command for the whole device which will 2051eda14cbcSMatt Macy * execute if l2arc_trim_ahead > 0. 2052eda14cbcSMatt Macy */ 2053eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_L2CACHE_TRIM); 2054eda14cbcSMatt Macy } 2055eda14cbcSMatt Macy } 2056eda14cbcSMatt Macy 2057eda14cbcSMatt Macy sav->sav_vdevs = newvdevs; 2058eda14cbcSMatt Macy sav->sav_count = (int)nl2cache; 2059eda14cbcSMatt Macy 2060eda14cbcSMatt Macy /* 2061eda14cbcSMatt Macy * Recompute the stashed list of l2cache devices, with status 2062eda14cbcSMatt Macy * information this time. 2063eda14cbcSMatt Macy */ 206481b22a98SMartin Matuska fnvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE); 2065eda14cbcSMatt Macy 2066eda14cbcSMatt Macy if (sav->sav_count > 0) 2067eda14cbcSMatt Macy l2cache = kmem_alloc(sav->sav_count * sizeof (void *), 2068eda14cbcSMatt Macy KM_SLEEP); 2069eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) 2070eda14cbcSMatt Macy l2cache[i] = vdev_config_generate(spa, 2071eda14cbcSMatt Macy sav->sav_vdevs[i], B_TRUE, VDEV_CONFIG_L2CACHE); 2072681ce946SMartin Matuska fnvlist_add_nvlist_array(sav->sav_config, ZPOOL_CONFIG_L2CACHE, 2073681ce946SMartin Matuska (const nvlist_t * const *)l2cache, sav->sav_count); 2074eda14cbcSMatt Macy 2075eda14cbcSMatt Macy out: 2076eda14cbcSMatt Macy /* 2077eda14cbcSMatt Macy * Purge vdevs that were dropped 2078eda14cbcSMatt Macy */ 2079c9539b89SMartin Matuska if (oldvdevs) { 2080eda14cbcSMatt Macy for (i = 0; i < oldnvdevs; i++) { 2081eda14cbcSMatt Macy uint64_t pool; 2082eda14cbcSMatt Macy 2083eda14cbcSMatt Macy vd = oldvdevs[i]; 2084eda14cbcSMatt Macy if (vd != NULL) { 2085eda14cbcSMatt Macy ASSERT(vd->vdev_isl2cache); 2086eda14cbcSMatt Macy 2087eda14cbcSMatt Macy if (spa_l2cache_exists(vd->vdev_guid, &pool) && 2088eda14cbcSMatt Macy pool != 0ULL && l2arc_vdev_present(vd)) 2089eda14cbcSMatt Macy l2arc_remove_vdev(vd); 2090eda14cbcSMatt Macy vdev_clear_stats(vd); 2091eda14cbcSMatt Macy vdev_free(vd); 2092eda14cbcSMatt Macy } 2093eda14cbcSMatt Macy } 2094eda14cbcSMatt Macy 2095eda14cbcSMatt Macy kmem_free(oldvdevs, oldnvdevs * sizeof (void *)); 2096c9539b89SMartin Matuska } 2097eda14cbcSMatt Macy 2098eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) 2099eda14cbcSMatt Macy nvlist_free(l2cache[i]); 2100eda14cbcSMatt Macy if (sav->sav_count) 2101eda14cbcSMatt Macy kmem_free(l2cache, sav->sav_count * sizeof (void *)); 2102eda14cbcSMatt Macy } 2103eda14cbcSMatt Macy 2104eda14cbcSMatt Macy static int 2105eda14cbcSMatt Macy load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value) 2106eda14cbcSMatt Macy { 2107eda14cbcSMatt Macy dmu_buf_t *db; 2108eda14cbcSMatt Macy char *packed = NULL; 2109eda14cbcSMatt Macy size_t nvsize = 0; 2110eda14cbcSMatt Macy int error; 2111eda14cbcSMatt Macy *value = NULL; 2112eda14cbcSMatt Macy 2113eda14cbcSMatt Macy error = dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db); 2114eda14cbcSMatt Macy if (error) 2115eda14cbcSMatt Macy return (error); 2116eda14cbcSMatt Macy 2117eda14cbcSMatt Macy nvsize = *(uint64_t *)db->db_data; 2118eda14cbcSMatt Macy dmu_buf_rele(db, FTAG); 2119eda14cbcSMatt Macy 2120eda14cbcSMatt Macy packed = vmem_alloc(nvsize, KM_SLEEP); 2121eda14cbcSMatt Macy error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed, 2122eda14cbcSMatt Macy DMU_READ_PREFETCH); 2123eda14cbcSMatt Macy if (error == 0) 2124eda14cbcSMatt Macy error = nvlist_unpack(packed, nvsize, value, 0); 2125eda14cbcSMatt Macy vmem_free(packed, nvsize); 2126eda14cbcSMatt Macy 2127eda14cbcSMatt Macy return (error); 2128eda14cbcSMatt Macy } 2129eda14cbcSMatt Macy 2130eda14cbcSMatt Macy /* 2131eda14cbcSMatt Macy * Concrete top-level vdevs that are not missing and are not logs. At every 2132eda14cbcSMatt Macy * spa_sync we write new uberblocks to at least SPA_SYNC_MIN_VDEVS core tvds. 2133eda14cbcSMatt Macy */ 2134eda14cbcSMatt Macy static uint64_t 2135eda14cbcSMatt Macy spa_healthy_core_tvds(spa_t *spa) 2136eda14cbcSMatt Macy { 2137eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 2138eda14cbcSMatt Macy uint64_t tvds = 0; 2139eda14cbcSMatt Macy 2140eda14cbcSMatt Macy for (uint64_t i = 0; i < rvd->vdev_children; i++) { 2141eda14cbcSMatt Macy vdev_t *vd = rvd->vdev_child[i]; 2142eda14cbcSMatt Macy if (vd->vdev_islog) 2143eda14cbcSMatt Macy continue; 2144eda14cbcSMatt Macy if (vdev_is_concrete(vd) && !vdev_is_dead(vd)) 2145eda14cbcSMatt Macy tvds++; 2146eda14cbcSMatt Macy } 2147eda14cbcSMatt Macy 2148eda14cbcSMatt Macy return (tvds); 2149eda14cbcSMatt Macy } 2150eda14cbcSMatt Macy 2151eda14cbcSMatt Macy /* 2152eda14cbcSMatt Macy * Checks to see if the given vdev could not be opened, in which case we post a 2153eda14cbcSMatt Macy * sysevent to notify the autoreplace code that the device has been removed. 2154eda14cbcSMatt Macy */ 2155eda14cbcSMatt Macy static void 2156eda14cbcSMatt Macy spa_check_removed(vdev_t *vd) 2157eda14cbcSMatt Macy { 2158eda14cbcSMatt Macy for (uint64_t c = 0; c < vd->vdev_children; c++) 2159eda14cbcSMatt Macy spa_check_removed(vd->vdev_child[c]); 2160eda14cbcSMatt Macy 2161eda14cbcSMatt Macy if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd) && 2162eda14cbcSMatt Macy vdev_is_concrete(vd)) { 2163eda14cbcSMatt Macy zfs_post_autoreplace(vd->vdev_spa, vd); 2164eda14cbcSMatt Macy spa_event_notify(vd->vdev_spa, vd, NULL, ESC_ZFS_VDEV_CHECK); 2165eda14cbcSMatt Macy } 2166eda14cbcSMatt Macy } 2167eda14cbcSMatt Macy 2168eda14cbcSMatt Macy static int 2169eda14cbcSMatt Macy spa_check_for_missing_logs(spa_t *spa) 2170eda14cbcSMatt Macy { 2171eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 2172eda14cbcSMatt Macy 2173eda14cbcSMatt Macy /* 2174eda14cbcSMatt Macy * If we're doing a normal import, then build up any additional 2175eda14cbcSMatt Macy * diagnostic information about missing log devices. 2176eda14cbcSMatt Macy * We'll pass this up to the user for further processing. 2177eda14cbcSMatt Macy */ 2178eda14cbcSMatt Macy if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) { 2179eda14cbcSMatt Macy nvlist_t **child, *nv; 2180eda14cbcSMatt Macy uint64_t idx = 0; 2181eda14cbcSMatt Macy 2182eda14cbcSMatt Macy child = kmem_alloc(rvd->vdev_children * sizeof (nvlist_t *), 2183eda14cbcSMatt Macy KM_SLEEP); 218481b22a98SMartin Matuska nv = fnvlist_alloc(); 2185eda14cbcSMatt Macy 2186eda14cbcSMatt Macy for (uint64_t c = 0; c < rvd->vdev_children; c++) { 2187eda14cbcSMatt Macy vdev_t *tvd = rvd->vdev_child[c]; 2188eda14cbcSMatt Macy 2189eda14cbcSMatt Macy /* 2190eda14cbcSMatt Macy * We consider a device as missing only if it failed 2191eda14cbcSMatt Macy * to open (i.e. offline or faulted is not considered 2192eda14cbcSMatt Macy * as missing). 2193eda14cbcSMatt Macy */ 2194eda14cbcSMatt Macy if (tvd->vdev_islog && 2195eda14cbcSMatt Macy tvd->vdev_state == VDEV_STATE_CANT_OPEN) { 2196eda14cbcSMatt Macy child[idx++] = vdev_config_generate(spa, tvd, 2197eda14cbcSMatt Macy B_FALSE, VDEV_CONFIG_MISSING); 2198eda14cbcSMatt Macy } 2199eda14cbcSMatt Macy } 2200eda14cbcSMatt Macy 2201eda14cbcSMatt Macy if (idx > 0) { 2202681ce946SMartin Matuska fnvlist_add_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2203681ce946SMartin Matuska (const nvlist_t * const *)child, idx); 2204eda14cbcSMatt Macy fnvlist_add_nvlist(spa->spa_load_info, 2205eda14cbcSMatt Macy ZPOOL_CONFIG_MISSING_DEVICES, nv); 2206eda14cbcSMatt Macy 2207eda14cbcSMatt Macy for (uint64_t i = 0; i < idx; i++) 2208eda14cbcSMatt Macy nvlist_free(child[i]); 2209eda14cbcSMatt Macy } 2210eda14cbcSMatt Macy nvlist_free(nv); 2211eda14cbcSMatt Macy kmem_free(child, rvd->vdev_children * sizeof (char **)); 2212eda14cbcSMatt Macy 2213eda14cbcSMatt Macy if (idx > 0) { 2214eda14cbcSMatt Macy spa_load_failed(spa, "some log devices are missing"); 2215eda14cbcSMatt Macy vdev_dbgmsg_print_tree(rvd, 2); 2216eda14cbcSMatt Macy return (SET_ERROR(ENXIO)); 2217eda14cbcSMatt Macy } 2218eda14cbcSMatt Macy } else { 2219eda14cbcSMatt Macy for (uint64_t c = 0; c < rvd->vdev_children; c++) { 2220eda14cbcSMatt Macy vdev_t *tvd = rvd->vdev_child[c]; 2221eda14cbcSMatt Macy 2222eda14cbcSMatt Macy if (tvd->vdev_islog && 2223eda14cbcSMatt Macy tvd->vdev_state == VDEV_STATE_CANT_OPEN) { 2224eda14cbcSMatt Macy spa_set_log_state(spa, SPA_LOG_CLEAR); 2225eda14cbcSMatt Macy spa_load_note(spa, "some log devices are " 2226eda14cbcSMatt Macy "missing, ZIL is dropped."); 2227eda14cbcSMatt Macy vdev_dbgmsg_print_tree(rvd, 2); 2228eda14cbcSMatt Macy break; 2229eda14cbcSMatt Macy } 2230eda14cbcSMatt Macy } 2231eda14cbcSMatt Macy } 2232eda14cbcSMatt Macy 2233eda14cbcSMatt Macy return (0); 2234eda14cbcSMatt Macy } 2235eda14cbcSMatt Macy 2236eda14cbcSMatt Macy /* 2237eda14cbcSMatt Macy * Check for missing log devices 2238eda14cbcSMatt Macy */ 2239eda14cbcSMatt Macy static boolean_t 2240eda14cbcSMatt Macy spa_check_logs(spa_t *spa) 2241eda14cbcSMatt Macy { 2242eda14cbcSMatt Macy boolean_t rv = B_FALSE; 2243eda14cbcSMatt Macy dsl_pool_t *dp = spa_get_dsl(spa); 2244eda14cbcSMatt Macy 2245eda14cbcSMatt Macy switch (spa->spa_log_state) { 2246eda14cbcSMatt Macy default: 2247eda14cbcSMatt Macy break; 2248eda14cbcSMatt Macy case SPA_LOG_MISSING: 2249eda14cbcSMatt Macy /* need to recheck in case slog has been restored */ 2250eda14cbcSMatt Macy case SPA_LOG_UNKNOWN: 2251eda14cbcSMatt Macy rv = (dmu_objset_find_dp(dp, dp->dp_root_dir_obj, 2252eda14cbcSMatt Macy zil_check_log_chain, NULL, DS_FIND_CHILDREN) != 0); 2253eda14cbcSMatt Macy if (rv) 2254eda14cbcSMatt Macy spa_set_log_state(spa, SPA_LOG_MISSING); 2255eda14cbcSMatt Macy break; 2256eda14cbcSMatt Macy } 2257eda14cbcSMatt Macy return (rv); 2258eda14cbcSMatt Macy } 2259eda14cbcSMatt Macy 2260184c1b94SMartin Matuska /* 2261184c1b94SMartin Matuska * Passivate any log vdevs (note, does not apply to embedded log metaslabs). 2262184c1b94SMartin Matuska */ 2263eda14cbcSMatt Macy static boolean_t 2264eda14cbcSMatt Macy spa_passivate_log(spa_t *spa) 2265eda14cbcSMatt Macy { 2266eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 2267eda14cbcSMatt Macy boolean_t slog_found = B_FALSE; 2268eda14cbcSMatt Macy 2269eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER)); 2270eda14cbcSMatt Macy 2271eda14cbcSMatt Macy for (int c = 0; c < rvd->vdev_children; c++) { 2272eda14cbcSMatt Macy vdev_t *tvd = rvd->vdev_child[c]; 2273eda14cbcSMatt Macy 2274eda14cbcSMatt Macy if (tvd->vdev_islog) { 2275184c1b94SMartin Matuska ASSERT3P(tvd->vdev_log_mg, ==, NULL); 2276184c1b94SMartin Matuska metaslab_group_passivate(tvd->vdev_mg); 2277eda14cbcSMatt Macy slog_found = B_TRUE; 2278eda14cbcSMatt Macy } 2279eda14cbcSMatt Macy } 2280eda14cbcSMatt Macy 2281eda14cbcSMatt Macy return (slog_found); 2282eda14cbcSMatt Macy } 2283eda14cbcSMatt Macy 2284184c1b94SMartin Matuska /* 2285184c1b94SMartin Matuska * Activate any log vdevs (note, does not apply to embedded log metaslabs). 2286184c1b94SMartin Matuska */ 2287eda14cbcSMatt Macy static void 2288eda14cbcSMatt Macy spa_activate_log(spa_t *spa) 2289eda14cbcSMatt Macy { 2290eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 2291eda14cbcSMatt Macy 2292eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER)); 2293eda14cbcSMatt Macy 2294eda14cbcSMatt Macy for (int c = 0; c < rvd->vdev_children; c++) { 2295eda14cbcSMatt Macy vdev_t *tvd = rvd->vdev_child[c]; 2296eda14cbcSMatt Macy 2297184c1b94SMartin Matuska if (tvd->vdev_islog) { 2298184c1b94SMartin Matuska ASSERT3P(tvd->vdev_log_mg, ==, NULL); 2299184c1b94SMartin Matuska metaslab_group_activate(tvd->vdev_mg); 2300184c1b94SMartin Matuska } 2301eda14cbcSMatt Macy } 2302eda14cbcSMatt Macy } 2303eda14cbcSMatt Macy 2304eda14cbcSMatt Macy int 2305eda14cbcSMatt Macy spa_reset_logs(spa_t *spa) 2306eda14cbcSMatt Macy { 2307eda14cbcSMatt Macy int error; 2308eda14cbcSMatt Macy 2309eda14cbcSMatt Macy error = dmu_objset_find(spa_name(spa), zil_reset, 2310eda14cbcSMatt Macy NULL, DS_FIND_CHILDREN); 2311eda14cbcSMatt Macy if (error == 0) { 2312eda14cbcSMatt Macy /* 2313eda14cbcSMatt Macy * We successfully offlined the log device, sync out the 2314eda14cbcSMatt Macy * current txg so that the "stubby" block can be removed 2315eda14cbcSMatt Macy * by zil_sync(). 2316eda14cbcSMatt Macy */ 2317eda14cbcSMatt Macy txg_wait_synced(spa->spa_dsl_pool, 0); 2318eda14cbcSMatt Macy } 2319eda14cbcSMatt Macy return (error); 2320eda14cbcSMatt Macy } 2321eda14cbcSMatt Macy 2322eda14cbcSMatt Macy static void 2323eda14cbcSMatt Macy spa_aux_check_removed(spa_aux_vdev_t *sav) 2324eda14cbcSMatt Macy { 2325eda14cbcSMatt Macy for (int i = 0; i < sav->sav_count; i++) 2326eda14cbcSMatt Macy spa_check_removed(sav->sav_vdevs[i]); 2327eda14cbcSMatt Macy } 2328eda14cbcSMatt Macy 2329eda14cbcSMatt Macy void 2330eda14cbcSMatt Macy spa_claim_notify(zio_t *zio) 2331eda14cbcSMatt Macy { 2332eda14cbcSMatt Macy spa_t *spa = zio->io_spa; 2333eda14cbcSMatt Macy 2334eda14cbcSMatt Macy if (zio->io_error) 2335eda14cbcSMatt Macy return; 2336eda14cbcSMatt Macy 2337eda14cbcSMatt Macy mutex_enter(&spa->spa_props_lock); /* any mutex will do */ 2338eda14cbcSMatt Macy if (spa->spa_claim_max_txg < zio->io_bp->blk_birth) 2339eda14cbcSMatt Macy spa->spa_claim_max_txg = zio->io_bp->blk_birth; 2340eda14cbcSMatt Macy mutex_exit(&spa->spa_props_lock); 2341eda14cbcSMatt Macy } 2342eda14cbcSMatt Macy 2343eda14cbcSMatt Macy typedef struct spa_load_error { 2344c03c5b1cSMartin Matuska boolean_t sle_verify_data; 2345eda14cbcSMatt Macy uint64_t sle_meta_count; 2346eda14cbcSMatt Macy uint64_t sle_data_count; 2347eda14cbcSMatt Macy } spa_load_error_t; 2348eda14cbcSMatt Macy 2349eda14cbcSMatt Macy static void 2350eda14cbcSMatt Macy spa_load_verify_done(zio_t *zio) 2351eda14cbcSMatt Macy { 2352eda14cbcSMatt Macy blkptr_t *bp = zio->io_bp; 2353eda14cbcSMatt Macy spa_load_error_t *sle = zio->io_private; 2354eda14cbcSMatt Macy dmu_object_type_t type = BP_GET_TYPE(bp); 2355eda14cbcSMatt Macy int error = zio->io_error; 2356eda14cbcSMatt Macy spa_t *spa = zio->io_spa; 2357eda14cbcSMatt Macy 2358eda14cbcSMatt Macy abd_free(zio->io_abd); 2359eda14cbcSMatt Macy if (error) { 2360eda14cbcSMatt Macy if ((BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type)) && 2361eda14cbcSMatt Macy type != DMU_OT_INTENT_LOG) 2362eda14cbcSMatt Macy atomic_inc_64(&sle->sle_meta_count); 2363eda14cbcSMatt Macy else 2364eda14cbcSMatt Macy atomic_inc_64(&sle->sle_data_count); 2365eda14cbcSMatt Macy } 2366eda14cbcSMatt Macy 2367eda14cbcSMatt Macy mutex_enter(&spa->spa_scrub_lock); 2368eda14cbcSMatt Macy spa->spa_load_verify_bytes -= BP_GET_PSIZE(bp); 2369eda14cbcSMatt Macy cv_broadcast(&spa->spa_scrub_io_cv); 2370eda14cbcSMatt Macy mutex_exit(&spa->spa_scrub_lock); 2371eda14cbcSMatt Macy } 2372eda14cbcSMatt Macy 2373eda14cbcSMatt Macy /* 2374eda14cbcSMatt Macy * Maximum number of inflight bytes is the log2 fraction of the arc size. 2375eda14cbcSMatt Macy * By default, we set it to 1/16th of the arc. 2376eda14cbcSMatt Macy */ 2377be181ee2SMartin Matuska static uint_t spa_load_verify_shift = 4; 2378e92ffd9bSMartin Matuska static int spa_load_verify_metadata = B_TRUE; 2379e92ffd9bSMartin Matuska static int spa_load_verify_data = B_TRUE; 2380eda14cbcSMatt Macy 2381eda14cbcSMatt Macy static int 2382eda14cbcSMatt Macy spa_load_verify_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 2383eda14cbcSMatt Macy const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg) 2384eda14cbcSMatt Macy { 2385c03c5b1cSMartin Matuska zio_t *rio = arg; 2386c03c5b1cSMartin Matuska spa_load_error_t *sle = rio->io_private; 2387c03c5b1cSMartin Matuska 2388e92ffd9bSMartin Matuska (void) zilog, (void) dnp; 2389e92ffd9bSMartin Matuska 2390eda14cbcSMatt Macy /* 2391eda14cbcSMatt Macy * Note: normally this routine will not be called if 2392eda14cbcSMatt Macy * spa_load_verify_metadata is not set. However, it may be useful 2393eda14cbcSMatt Macy * to manually set the flag after the traversal has begun. 2394eda14cbcSMatt Macy */ 2395eda14cbcSMatt Macy if (!spa_load_verify_metadata) 2396eda14cbcSMatt Macy return (0); 2397e3aa18adSMartin Matuska 2398e3aa18adSMartin Matuska /* 2399e3aa18adSMartin Matuska * Sanity check the block pointer in order to detect obvious damage 2400e3aa18adSMartin Matuska * before using the contents in subsequent checks or in zio_read(). 2401e3aa18adSMartin Matuska * When damaged consider it to be a metadata error since we cannot 2402e3aa18adSMartin Matuska * trust the BP_GET_TYPE and BP_GET_LEVEL values. 2403e3aa18adSMartin Matuska */ 2404e639e0d2SMartin Matuska if (!zfs_blkptr_verify(spa, bp, BLK_CONFIG_NEEDED, BLK_VERIFY_LOG)) { 2405e3aa18adSMartin Matuska atomic_inc_64(&sle->sle_meta_count); 2406e3aa18adSMartin Matuska return (0); 2407e3aa18adSMartin Matuska } 2408e3aa18adSMartin Matuska 2409e3aa18adSMartin Matuska if (zb->zb_level == ZB_DNODE_LEVEL || BP_IS_HOLE(bp) || 2410e3aa18adSMartin Matuska BP_IS_EMBEDDED(bp) || BP_IS_REDACTED(bp)) 2411e3aa18adSMartin Matuska return (0); 2412e3aa18adSMartin Matuska 2413c03c5b1cSMartin Matuska if (!BP_IS_METADATA(bp) && 2414c03c5b1cSMartin Matuska (!spa_load_verify_data || !sle->sle_verify_data)) 2415eda14cbcSMatt Macy return (0); 2416eda14cbcSMatt Macy 2417eda14cbcSMatt Macy uint64_t maxinflight_bytes = 2418eda14cbcSMatt Macy arc_target_bytes() >> spa_load_verify_shift; 2419eda14cbcSMatt Macy size_t size = BP_GET_PSIZE(bp); 2420eda14cbcSMatt Macy 2421eda14cbcSMatt Macy mutex_enter(&spa->spa_scrub_lock); 2422eda14cbcSMatt Macy while (spa->spa_load_verify_bytes >= maxinflight_bytes) 2423eda14cbcSMatt Macy cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 2424eda14cbcSMatt Macy spa->spa_load_verify_bytes += size; 2425eda14cbcSMatt Macy mutex_exit(&spa->spa_scrub_lock); 2426eda14cbcSMatt Macy 2427eda14cbcSMatt Macy zio_nowait(zio_read(rio, spa, bp, abd_alloc_for_io(size, B_FALSE), size, 2428eda14cbcSMatt Macy spa_load_verify_done, rio->io_private, ZIO_PRIORITY_SCRUB, 2429eda14cbcSMatt Macy ZIO_FLAG_SPECULATIVE | ZIO_FLAG_CANFAIL | 2430eda14cbcSMatt Macy ZIO_FLAG_SCRUB | ZIO_FLAG_RAW, zb)); 2431eda14cbcSMatt Macy return (0); 2432eda14cbcSMatt Macy } 2433eda14cbcSMatt Macy 2434eda14cbcSMatt Macy static int 2435eda14cbcSMatt Macy verify_dataset_name_len(dsl_pool_t *dp, dsl_dataset_t *ds, void *arg) 2436eda14cbcSMatt Macy { 2437e92ffd9bSMartin Matuska (void) dp, (void) arg; 2438e92ffd9bSMartin Matuska 2439eda14cbcSMatt Macy if (dsl_dataset_namelen(ds) >= ZFS_MAX_DATASET_NAME_LEN) 2440eda14cbcSMatt Macy return (SET_ERROR(ENAMETOOLONG)); 2441eda14cbcSMatt Macy 2442eda14cbcSMatt Macy return (0); 2443eda14cbcSMatt Macy } 2444eda14cbcSMatt Macy 2445eda14cbcSMatt Macy static int 2446eda14cbcSMatt Macy spa_load_verify(spa_t *spa) 2447eda14cbcSMatt Macy { 2448eda14cbcSMatt Macy zio_t *rio; 2449eda14cbcSMatt Macy spa_load_error_t sle = { 0 }; 2450eda14cbcSMatt Macy zpool_load_policy_t policy; 2451eda14cbcSMatt Macy boolean_t verify_ok = B_FALSE; 2452eda14cbcSMatt Macy int error = 0; 2453eda14cbcSMatt Macy 2454eda14cbcSMatt Macy zpool_get_load_policy(spa->spa_config, &policy); 2455eda14cbcSMatt Macy 2456c03c5b1cSMartin Matuska if (policy.zlp_rewind & ZPOOL_NEVER_REWIND || 2457c03c5b1cSMartin Matuska policy.zlp_maxmeta == UINT64_MAX) 2458eda14cbcSMatt Macy return (0); 2459eda14cbcSMatt Macy 2460eda14cbcSMatt Macy dsl_pool_config_enter(spa->spa_dsl_pool, FTAG); 2461eda14cbcSMatt Macy error = dmu_objset_find_dp(spa->spa_dsl_pool, 2462eda14cbcSMatt Macy spa->spa_dsl_pool->dp_root_dir_obj, verify_dataset_name_len, NULL, 2463eda14cbcSMatt Macy DS_FIND_CHILDREN); 2464eda14cbcSMatt Macy dsl_pool_config_exit(spa->spa_dsl_pool, FTAG); 2465eda14cbcSMatt Macy if (error != 0) 2466eda14cbcSMatt Macy return (error); 2467eda14cbcSMatt Macy 2468c03c5b1cSMartin Matuska /* 2469c03c5b1cSMartin Matuska * Verify data only if we are rewinding or error limit was set. 2470c03c5b1cSMartin Matuska * Otherwise nothing except dbgmsg care about it to waste time. 2471c03c5b1cSMartin Matuska */ 2472c03c5b1cSMartin Matuska sle.sle_verify_data = (policy.zlp_rewind & ZPOOL_REWIND_MASK) || 2473c03c5b1cSMartin Matuska (policy.zlp_maxdata < UINT64_MAX); 2474c03c5b1cSMartin Matuska 2475eda14cbcSMatt Macy rio = zio_root(spa, NULL, &sle, 2476eda14cbcSMatt Macy ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE); 2477eda14cbcSMatt Macy 2478eda14cbcSMatt Macy if (spa_load_verify_metadata) { 2479eda14cbcSMatt Macy if (spa->spa_extreme_rewind) { 2480eda14cbcSMatt Macy spa_load_note(spa, "performing a complete scan of the " 2481eda14cbcSMatt Macy "pool since extreme rewind is on. This may take " 2482eda14cbcSMatt Macy "a very long time.\n (spa_load_verify_data=%u, " 2483eda14cbcSMatt Macy "spa_load_verify_metadata=%u)", 2484eda14cbcSMatt Macy spa_load_verify_data, spa_load_verify_metadata); 2485eda14cbcSMatt Macy } 2486eda14cbcSMatt Macy 2487eda14cbcSMatt Macy error = traverse_pool(spa, spa->spa_verify_min_txg, 2488eda14cbcSMatt Macy TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | 2489eda14cbcSMatt Macy TRAVERSE_NO_DECRYPT, spa_load_verify_cb, rio); 2490eda14cbcSMatt Macy } 2491eda14cbcSMatt Macy 2492eda14cbcSMatt Macy (void) zio_wait(rio); 2493eda14cbcSMatt Macy ASSERT0(spa->spa_load_verify_bytes); 2494eda14cbcSMatt Macy 2495eda14cbcSMatt Macy spa->spa_load_meta_errors = sle.sle_meta_count; 2496eda14cbcSMatt Macy spa->spa_load_data_errors = sle.sle_data_count; 2497eda14cbcSMatt Macy 2498eda14cbcSMatt Macy if (sle.sle_meta_count != 0 || sle.sle_data_count != 0) { 2499eda14cbcSMatt Macy spa_load_note(spa, "spa_load_verify found %llu metadata errors " 2500eda14cbcSMatt Macy "and %llu data errors", (u_longlong_t)sle.sle_meta_count, 2501eda14cbcSMatt Macy (u_longlong_t)sle.sle_data_count); 2502eda14cbcSMatt Macy } 2503eda14cbcSMatt Macy 2504eda14cbcSMatt Macy if (spa_load_verify_dryrun || 2505eda14cbcSMatt Macy (!error && sle.sle_meta_count <= policy.zlp_maxmeta && 2506eda14cbcSMatt Macy sle.sle_data_count <= policy.zlp_maxdata)) { 2507eda14cbcSMatt Macy int64_t loss = 0; 2508eda14cbcSMatt Macy 2509eda14cbcSMatt Macy verify_ok = B_TRUE; 2510eda14cbcSMatt Macy spa->spa_load_txg = spa->spa_uberblock.ub_txg; 2511eda14cbcSMatt Macy spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp; 2512eda14cbcSMatt Macy 2513eda14cbcSMatt Macy loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts; 251481b22a98SMartin Matuska fnvlist_add_uint64(spa->spa_load_info, ZPOOL_CONFIG_LOAD_TIME, 251581b22a98SMartin Matuska spa->spa_load_txg_ts); 251681b22a98SMartin Matuska fnvlist_add_int64(spa->spa_load_info, ZPOOL_CONFIG_REWIND_TIME, 251781b22a98SMartin Matuska loss); 251881b22a98SMartin Matuska fnvlist_add_uint64(spa->spa_load_info, 2519c03c5b1cSMartin Matuska ZPOOL_CONFIG_LOAD_META_ERRORS, sle.sle_meta_count); 2520c03c5b1cSMartin Matuska fnvlist_add_uint64(spa->spa_load_info, 252181b22a98SMartin Matuska ZPOOL_CONFIG_LOAD_DATA_ERRORS, sle.sle_data_count); 2522eda14cbcSMatt Macy } else { 2523eda14cbcSMatt Macy spa->spa_load_max_txg = spa->spa_uberblock.ub_txg; 2524eda14cbcSMatt Macy } 2525eda14cbcSMatt Macy 2526eda14cbcSMatt Macy if (spa_load_verify_dryrun) 2527eda14cbcSMatt Macy return (0); 2528eda14cbcSMatt Macy 2529eda14cbcSMatt Macy if (error) { 2530eda14cbcSMatt Macy if (error != ENXIO && error != EIO) 2531eda14cbcSMatt Macy error = SET_ERROR(EIO); 2532eda14cbcSMatt Macy return (error); 2533eda14cbcSMatt Macy } 2534eda14cbcSMatt Macy 2535eda14cbcSMatt Macy return (verify_ok ? 0 : EIO); 2536eda14cbcSMatt Macy } 2537eda14cbcSMatt Macy 2538eda14cbcSMatt Macy /* 2539eda14cbcSMatt Macy * Find a value in the pool props object. 2540eda14cbcSMatt Macy */ 2541eda14cbcSMatt Macy static void 2542eda14cbcSMatt Macy spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val) 2543eda14cbcSMatt Macy { 2544eda14cbcSMatt Macy (void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object, 2545eda14cbcSMatt Macy zpool_prop_to_name(prop), sizeof (uint64_t), 1, val); 2546eda14cbcSMatt Macy } 2547eda14cbcSMatt Macy 2548eda14cbcSMatt Macy /* 2549eda14cbcSMatt Macy * Find a value in the pool directory object. 2550eda14cbcSMatt Macy */ 2551eda14cbcSMatt Macy static int 2552eda14cbcSMatt Macy spa_dir_prop(spa_t *spa, const char *name, uint64_t *val, boolean_t log_enoent) 2553eda14cbcSMatt Macy { 2554eda14cbcSMatt Macy int error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 2555eda14cbcSMatt Macy name, sizeof (uint64_t), 1, val); 2556eda14cbcSMatt Macy 2557eda14cbcSMatt Macy if (error != 0 && (error != ENOENT || log_enoent)) { 2558eda14cbcSMatt Macy spa_load_failed(spa, "couldn't get '%s' value in MOS directory " 2559eda14cbcSMatt Macy "[error=%d]", name, error); 2560eda14cbcSMatt Macy } 2561eda14cbcSMatt Macy 2562eda14cbcSMatt Macy return (error); 2563eda14cbcSMatt Macy } 2564eda14cbcSMatt Macy 2565eda14cbcSMatt Macy static int 2566eda14cbcSMatt Macy spa_vdev_err(vdev_t *vdev, vdev_aux_t aux, int err) 2567eda14cbcSMatt Macy { 2568eda14cbcSMatt Macy vdev_set_state(vdev, B_TRUE, VDEV_STATE_CANT_OPEN, aux); 2569eda14cbcSMatt Macy return (SET_ERROR(err)); 2570eda14cbcSMatt Macy } 2571eda14cbcSMatt Macy 2572eda14cbcSMatt Macy boolean_t 2573eda14cbcSMatt Macy spa_livelist_delete_check(spa_t *spa) 2574eda14cbcSMatt Macy { 2575eda14cbcSMatt Macy return (spa->spa_livelists_to_delete != 0); 2576eda14cbcSMatt Macy } 2577eda14cbcSMatt Macy 2578eda14cbcSMatt Macy static boolean_t 2579eda14cbcSMatt Macy spa_livelist_delete_cb_check(void *arg, zthr_t *z) 2580eda14cbcSMatt Macy { 2581e92ffd9bSMartin Matuska (void) z; 2582eda14cbcSMatt Macy spa_t *spa = arg; 2583eda14cbcSMatt Macy return (spa_livelist_delete_check(spa)); 2584eda14cbcSMatt Macy } 2585eda14cbcSMatt Macy 2586eda14cbcSMatt Macy static int 2587eda14cbcSMatt Macy delete_blkptr_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 2588eda14cbcSMatt Macy { 2589eda14cbcSMatt Macy spa_t *spa = arg; 2590eda14cbcSMatt Macy zio_free(spa, tx->tx_txg, bp); 2591eda14cbcSMatt Macy dsl_dir_diduse_space(tx->tx_pool->dp_free_dir, DD_USED_HEAD, 2592eda14cbcSMatt Macy -bp_get_dsize_sync(spa, bp), 2593eda14cbcSMatt Macy -BP_GET_PSIZE(bp), -BP_GET_UCSIZE(bp), tx); 2594eda14cbcSMatt Macy return (0); 2595eda14cbcSMatt Macy } 2596eda14cbcSMatt Macy 2597eda14cbcSMatt Macy static int 2598eda14cbcSMatt Macy dsl_get_next_livelist_obj(objset_t *os, uint64_t zap_obj, uint64_t *llp) 2599eda14cbcSMatt Macy { 2600eda14cbcSMatt Macy int err; 2601eda14cbcSMatt Macy zap_cursor_t zc; 2602eda14cbcSMatt Macy zap_attribute_t za; 2603eda14cbcSMatt Macy zap_cursor_init(&zc, os, zap_obj); 2604eda14cbcSMatt Macy err = zap_cursor_retrieve(&zc, &za); 2605eda14cbcSMatt Macy zap_cursor_fini(&zc); 2606eda14cbcSMatt Macy if (err == 0) 2607eda14cbcSMatt Macy *llp = za.za_first_integer; 2608eda14cbcSMatt Macy return (err); 2609eda14cbcSMatt Macy } 2610eda14cbcSMatt Macy 2611eda14cbcSMatt Macy /* 2612eda14cbcSMatt Macy * Components of livelist deletion that must be performed in syncing 2613eda14cbcSMatt Macy * context: freeing block pointers and updating the pool-wide data 2614eda14cbcSMatt Macy * structures to indicate how much work is left to do 2615eda14cbcSMatt Macy */ 2616eda14cbcSMatt Macy typedef struct sublist_delete_arg { 2617eda14cbcSMatt Macy spa_t *spa; 2618eda14cbcSMatt Macy dsl_deadlist_t *ll; 2619eda14cbcSMatt Macy uint64_t key; 2620eda14cbcSMatt Macy bplist_t *to_free; 2621eda14cbcSMatt Macy } sublist_delete_arg_t; 2622eda14cbcSMatt Macy 2623eda14cbcSMatt Macy static void 2624eda14cbcSMatt Macy sublist_delete_sync(void *arg, dmu_tx_t *tx) 2625eda14cbcSMatt Macy { 2626eda14cbcSMatt Macy sublist_delete_arg_t *sda = arg; 2627eda14cbcSMatt Macy spa_t *spa = sda->spa; 2628eda14cbcSMatt Macy dsl_deadlist_t *ll = sda->ll; 2629eda14cbcSMatt Macy uint64_t key = sda->key; 2630eda14cbcSMatt Macy bplist_t *to_free = sda->to_free; 2631eda14cbcSMatt Macy 2632eda14cbcSMatt Macy bplist_iterate(to_free, delete_blkptr_cb, spa, tx); 2633eda14cbcSMatt Macy dsl_deadlist_remove_entry(ll, key, tx); 2634eda14cbcSMatt Macy } 2635eda14cbcSMatt Macy 2636eda14cbcSMatt Macy typedef struct livelist_delete_arg { 2637eda14cbcSMatt Macy spa_t *spa; 2638eda14cbcSMatt Macy uint64_t ll_obj; 2639eda14cbcSMatt Macy uint64_t zap_obj; 2640eda14cbcSMatt Macy } livelist_delete_arg_t; 2641eda14cbcSMatt Macy 2642eda14cbcSMatt Macy static void 2643eda14cbcSMatt Macy livelist_delete_sync(void *arg, dmu_tx_t *tx) 2644eda14cbcSMatt Macy { 2645eda14cbcSMatt Macy livelist_delete_arg_t *lda = arg; 2646eda14cbcSMatt Macy spa_t *spa = lda->spa; 2647eda14cbcSMatt Macy uint64_t ll_obj = lda->ll_obj; 2648eda14cbcSMatt Macy uint64_t zap_obj = lda->zap_obj; 2649eda14cbcSMatt Macy objset_t *mos = spa->spa_meta_objset; 2650eda14cbcSMatt Macy uint64_t count; 2651eda14cbcSMatt Macy 2652eda14cbcSMatt Macy /* free the livelist and decrement the feature count */ 2653eda14cbcSMatt Macy VERIFY0(zap_remove_int(mos, zap_obj, ll_obj, tx)); 2654eda14cbcSMatt Macy dsl_deadlist_free(mos, ll_obj, tx); 2655eda14cbcSMatt Macy spa_feature_decr(spa, SPA_FEATURE_LIVELIST, tx); 2656eda14cbcSMatt Macy VERIFY0(zap_count(mos, zap_obj, &count)); 2657eda14cbcSMatt Macy if (count == 0) { 2658eda14cbcSMatt Macy /* no more livelists to delete */ 2659eda14cbcSMatt Macy VERIFY0(zap_remove(mos, DMU_POOL_DIRECTORY_OBJECT, 2660eda14cbcSMatt Macy DMU_POOL_DELETED_CLONES, tx)); 2661eda14cbcSMatt Macy VERIFY0(zap_destroy(mos, zap_obj, tx)); 2662eda14cbcSMatt Macy spa->spa_livelists_to_delete = 0; 2663eda14cbcSMatt Macy spa_notify_waiters(spa); 2664eda14cbcSMatt Macy } 2665eda14cbcSMatt Macy } 2666eda14cbcSMatt Macy 2667eda14cbcSMatt Macy /* 2668eda14cbcSMatt Macy * Load in the value for the livelist to be removed and open it. Then, 2669eda14cbcSMatt Macy * load its first sublist and determine which block pointers should actually 2670eda14cbcSMatt Macy * be freed. Then, call a synctask which performs the actual frees and updates 2671eda14cbcSMatt Macy * the pool-wide livelist data. 2672eda14cbcSMatt Macy */ 2673eda14cbcSMatt Macy static void 2674eda14cbcSMatt Macy spa_livelist_delete_cb(void *arg, zthr_t *z) 2675eda14cbcSMatt Macy { 2676eda14cbcSMatt Macy spa_t *spa = arg; 2677eda14cbcSMatt Macy uint64_t ll_obj = 0, count; 2678eda14cbcSMatt Macy objset_t *mos = spa->spa_meta_objset; 2679eda14cbcSMatt Macy uint64_t zap_obj = spa->spa_livelists_to_delete; 2680eda14cbcSMatt Macy /* 2681eda14cbcSMatt Macy * Determine the next livelist to delete. This function should only 2682eda14cbcSMatt Macy * be called if there is at least one deleted clone. 2683eda14cbcSMatt Macy */ 2684eda14cbcSMatt Macy VERIFY0(dsl_get_next_livelist_obj(mos, zap_obj, &ll_obj)); 2685eda14cbcSMatt Macy VERIFY0(zap_count(mos, ll_obj, &count)); 2686eda14cbcSMatt Macy if (count > 0) { 26872c48331dSMatt Macy dsl_deadlist_t *ll; 2688eda14cbcSMatt Macy dsl_deadlist_entry_t *dle; 2689eda14cbcSMatt Macy bplist_t to_free; 26902c48331dSMatt Macy ll = kmem_zalloc(sizeof (dsl_deadlist_t), KM_SLEEP); 26912c48331dSMatt Macy dsl_deadlist_open(ll, mos, ll_obj); 26922c48331dSMatt Macy dle = dsl_deadlist_first(ll); 2693eda14cbcSMatt Macy ASSERT3P(dle, !=, NULL); 2694eda14cbcSMatt Macy bplist_create(&to_free); 2695eda14cbcSMatt Macy int err = dsl_process_sub_livelist(&dle->dle_bpobj, &to_free, 2696eda14cbcSMatt Macy z, NULL); 2697eda14cbcSMatt Macy if (err == 0) { 2698eda14cbcSMatt Macy sublist_delete_arg_t sync_arg = { 2699eda14cbcSMatt Macy .spa = spa, 27002c48331dSMatt Macy .ll = ll, 2701eda14cbcSMatt Macy .key = dle->dle_mintxg, 2702eda14cbcSMatt Macy .to_free = &to_free 2703eda14cbcSMatt Macy }; 2704eda14cbcSMatt Macy zfs_dbgmsg("deleting sublist (id %llu) from" 270533b8c039SMartin Matuska " livelist %llu, %lld remaining", 270633b8c039SMartin Matuska (u_longlong_t)dle->dle_bpobj.bpo_object, 270733b8c039SMartin Matuska (u_longlong_t)ll_obj, (longlong_t)count - 1); 2708eda14cbcSMatt Macy VERIFY0(dsl_sync_task(spa_name(spa), NULL, 2709eda14cbcSMatt Macy sublist_delete_sync, &sync_arg, 0, 2710eda14cbcSMatt Macy ZFS_SPACE_CHECK_DESTROY)); 2711eda14cbcSMatt Macy } else { 2712eda14cbcSMatt Macy VERIFY3U(err, ==, EINTR); 2713eda14cbcSMatt Macy } 2714eda14cbcSMatt Macy bplist_clear(&to_free); 2715eda14cbcSMatt Macy bplist_destroy(&to_free); 27162c48331dSMatt Macy dsl_deadlist_close(ll); 27172c48331dSMatt Macy kmem_free(ll, sizeof (dsl_deadlist_t)); 2718eda14cbcSMatt Macy } else { 2719eda14cbcSMatt Macy livelist_delete_arg_t sync_arg = { 2720eda14cbcSMatt Macy .spa = spa, 2721eda14cbcSMatt Macy .ll_obj = ll_obj, 2722eda14cbcSMatt Macy .zap_obj = zap_obj 2723eda14cbcSMatt Macy }; 272433b8c039SMartin Matuska zfs_dbgmsg("deletion of livelist %llu completed", 272533b8c039SMartin Matuska (u_longlong_t)ll_obj); 2726eda14cbcSMatt Macy VERIFY0(dsl_sync_task(spa_name(spa), NULL, livelist_delete_sync, 2727eda14cbcSMatt Macy &sync_arg, 0, ZFS_SPACE_CHECK_DESTROY)); 2728eda14cbcSMatt Macy } 2729eda14cbcSMatt Macy } 2730eda14cbcSMatt Macy 2731eda14cbcSMatt Macy static void 2732eda14cbcSMatt Macy spa_start_livelist_destroy_thread(spa_t *spa) 2733eda14cbcSMatt Macy { 2734eda14cbcSMatt Macy ASSERT3P(spa->spa_livelist_delete_zthr, ==, NULL); 2735eda14cbcSMatt Macy spa->spa_livelist_delete_zthr = 2736eda14cbcSMatt Macy zthr_create("z_livelist_destroy", 27372faf504dSMartin Matuska spa_livelist_delete_cb_check, spa_livelist_delete_cb, spa, 27382faf504dSMartin Matuska minclsyspri); 2739eda14cbcSMatt Macy } 2740eda14cbcSMatt Macy 2741eda14cbcSMatt Macy typedef struct livelist_new_arg { 2742eda14cbcSMatt Macy bplist_t *allocs; 2743eda14cbcSMatt Macy bplist_t *frees; 2744eda14cbcSMatt Macy } livelist_new_arg_t; 2745eda14cbcSMatt Macy 2746eda14cbcSMatt Macy static int 2747eda14cbcSMatt Macy livelist_track_new_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed, 2748eda14cbcSMatt Macy dmu_tx_t *tx) 2749eda14cbcSMatt Macy { 2750eda14cbcSMatt Macy ASSERT(tx == NULL); 2751eda14cbcSMatt Macy livelist_new_arg_t *lna = arg; 2752eda14cbcSMatt Macy if (bp_freed) { 2753eda14cbcSMatt Macy bplist_append(lna->frees, bp); 2754eda14cbcSMatt Macy } else { 2755eda14cbcSMatt Macy bplist_append(lna->allocs, bp); 2756eda14cbcSMatt Macy zfs_livelist_condense_new_alloc++; 2757eda14cbcSMatt Macy } 2758eda14cbcSMatt Macy return (0); 2759eda14cbcSMatt Macy } 2760eda14cbcSMatt Macy 2761eda14cbcSMatt Macy typedef struct livelist_condense_arg { 2762eda14cbcSMatt Macy spa_t *spa; 2763eda14cbcSMatt Macy bplist_t to_keep; 2764eda14cbcSMatt Macy uint64_t first_size; 2765eda14cbcSMatt Macy uint64_t next_size; 2766eda14cbcSMatt Macy } livelist_condense_arg_t; 2767eda14cbcSMatt Macy 2768eda14cbcSMatt Macy static void 2769eda14cbcSMatt Macy spa_livelist_condense_sync(void *arg, dmu_tx_t *tx) 2770eda14cbcSMatt Macy { 2771eda14cbcSMatt Macy livelist_condense_arg_t *lca = arg; 2772eda14cbcSMatt Macy spa_t *spa = lca->spa; 2773eda14cbcSMatt Macy bplist_t new_frees; 2774eda14cbcSMatt Macy dsl_dataset_t *ds = spa->spa_to_condense.ds; 2775eda14cbcSMatt Macy 2776eda14cbcSMatt Macy /* Have we been cancelled? */ 2777eda14cbcSMatt Macy if (spa->spa_to_condense.cancelled) { 2778eda14cbcSMatt Macy zfs_livelist_condense_sync_cancel++; 2779eda14cbcSMatt Macy goto out; 2780eda14cbcSMatt Macy } 2781eda14cbcSMatt Macy 2782eda14cbcSMatt Macy dsl_deadlist_entry_t *first = spa->spa_to_condense.first; 2783eda14cbcSMatt Macy dsl_deadlist_entry_t *next = spa->spa_to_condense.next; 2784eda14cbcSMatt Macy dsl_deadlist_t *ll = &ds->ds_dir->dd_livelist; 2785eda14cbcSMatt Macy 2786eda14cbcSMatt Macy /* 2787eda14cbcSMatt Macy * It's possible that the livelist was changed while the zthr was 2788eda14cbcSMatt Macy * running. Therefore, we need to check for new blkptrs in the two 2789eda14cbcSMatt Macy * entries being condensed and continue to track them in the livelist. 2790eda14cbcSMatt Macy * Because of the way we handle remapped blkptrs (see dbuf_remap_impl), 2791eda14cbcSMatt Macy * it's possible that the newly added blkptrs are FREEs or ALLOCs so 2792eda14cbcSMatt Macy * we need to sort them into two different bplists. 2793eda14cbcSMatt Macy */ 2794eda14cbcSMatt Macy uint64_t first_obj = first->dle_bpobj.bpo_object; 2795eda14cbcSMatt Macy uint64_t next_obj = next->dle_bpobj.bpo_object; 2796eda14cbcSMatt Macy uint64_t cur_first_size = first->dle_bpobj.bpo_phys->bpo_num_blkptrs; 2797eda14cbcSMatt Macy uint64_t cur_next_size = next->dle_bpobj.bpo_phys->bpo_num_blkptrs; 2798eda14cbcSMatt Macy 2799eda14cbcSMatt Macy bplist_create(&new_frees); 2800eda14cbcSMatt Macy livelist_new_arg_t new_bps = { 2801eda14cbcSMatt Macy .allocs = &lca->to_keep, 2802eda14cbcSMatt Macy .frees = &new_frees, 2803eda14cbcSMatt Macy }; 2804eda14cbcSMatt Macy 2805eda14cbcSMatt Macy if (cur_first_size > lca->first_size) { 2806eda14cbcSMatt Macy VERIFY0(livelist_bpobj_iterate_from_nofree(&first->dle_bpobj, 2807eda14cbcSMatt Macy livelist_track_new_cb, &new_bps, lca->first_size)); 2808eda14cbcSMatt Macy } 2809eda14cbcSMatt Macy if (cur_next_size > lca->next_size) { 2810eda14cbcSMatt Macy VERIFY0(livelist_bpobj_iterate_from_nofree(&next->dle_bpobj, 2811eda14cbcSMatt Macy livelist_track_new_cb, &new_bps, lca->next_size)); 2812eda14cbcSMatt Macy } 2813eda14cbcSMatt Macy 2814eda14cbcSMatt Macy dsl_deadlist_clear_entry(first, ll, tx); 2815eda14cbcSMatt Macy ASSERT(bpobj_is_empty(&first->dle_bpobj)); 2816eda14cbcSMatt Macy dsl_deadlist_remove_entry(ll, next->dle_mintxg, tx); 2817eda14cbcSMatt Macy 2818eda14cbcSMatt Macy bplist_iterate(&lca->to_keep, dsl_deadlist_insert_alloc_cb, ll, tx); 2819eda14cbcSMatt Macy bplist_iterate(&new_frees, dsl_deadlist_insert_free_cb, ll, tx); 2820eda14cbcSMatt Macy bplist_destroy(&new_frees); 2821eda14cbcSMatt Macy 2822eda14cbcSMatt Macy char dsname[ZFS_MAX_DATASET_NAME_LEN]; 2823eda14cbcSMatt Macy dsl_dataset_name(ds, dsname); 2824eda14cbcSMatt Macy zfs_dbgmsg("txg %llu condensing livelist of %s (id %llu), bpobj %llu " 2825eda14cbcSMatt Macy "(%llu blkptrs) and bpobj %llu (%llu blkptrs) -> bpobj %llu " 282633b8c039SMartin Matuska "(%llu blkptrs)", (u_longlong_t)tx->tx_txg, dsname, 282733b8c039SMartin Matuska (u_longlong_t)ds->ds_object, (u_longlong_t)first_obj, 282833b8c039SMartin Matuska (u_longlong_t)cur_first_size, (u_longlong_t)next_obj, 282933b8c039SMartin Matuska (u_longlong_t)cur_next_size, 283033b8c039SMartin Matuska (u_longlong_t)first->dle_bpobj.bpo_object, 283133b8c039SMartin Matuska (u_longlong_t)first->dle_bpobj.bpo_phys->bpo_num_blkptrs); 2832eda14cbcSMatt Macy out: 2833eda14cbcSMatt Macy dmu_buf_rele(ds->ds_dbuf, spa); 2834eda14cbcSMatt Macy spa->spa_to_condense.ds = NULL; 2835eda14cbcSMatt Macy bplist_clear(&lca->to_keep); 2836eda14cbcSMatt Macy bplist_destroy(&lca->to_keep); 2837eda14cbcSMatt Macy kmem_free(lca, sizeof (livelist_condense_arg_t)); 2838eda14cbcSMatt Macy spa->spa_to_condense.syncing = B_FALSE; 2839eda14cbcSMatt Macy } 2840eda14cbcSMatt Macy 2841eda14cbcSMatt Macy static void 2842eda14cbcSMatt Macy spa_livelist_condense_cb(void *arg, zthr_t *t) 2843eda14cbcSMatt Macy { 2844eda14cbcSMatt Macy while (zfs_livelist_condense_zthr_pause && 2845eda14cbcSMatt Macy !(zthr_has_waiters(t) || zthr_iscancelled(t))) 2846eda14cbcSMatt Macy delay(1); 2847eda14cbcSMatt Macy 2848eda14cbcSMatt Macy spa_t *spa = arg; 2849eda14cbcSMatt Macy dsl_deadlist_entry_t *first = spa->spa_to_condense.first; 2850eda14cbcSMatt Macy dsl_deadlist_entry_t *next = spa->spa_to_condense.next; 2851eda14cbcSMatt Macy uint64_t first_size, next_size; 2852eda14cbcSMatt Macy 2853eda14cbcSMatt Macy livelist_condense_arg_t *lca = 2854eda14cbcSMatt Macy kmem_alloc(sizeof (livelist_condense_arg_t), KM_SLEEP); 2855eda14cbcSMatt Macy bplist_create(&lca->to_keep); 2856eda14cbcSMatt Macy 2857eda14cbcSMatt Macy /* 2858eda14cbcSMatt Macy * Process the livelists (matching FREEs and ALLOCs) in open context 2859eda14cbcSMatt Macy * so we have minimal work in syncing context to condense. 2860eda14cbcSMatt Macy * 2861eda14cbcSMatt Macy * We save bpobj sizes (first_size and next_size) to use later in 2862eda14cbcSMatt Macy * syncing context to determine if entries were added to these sublists 2863eda14cbcSMatt Macy * while in open context. This is possible because the clone is still 2864eda14cbcSMatt Macy * active and open for normal writes and we want to make sure the new, 2865eda14cbcSMatt Macy * unprocessed blockpointers are inserted into the livelist normally. 2866eda14cbcSMatt Macy * 2867eda14cbcSMatt Macy * Note that dsl_process_sub_livelist() both stores the size number of 2868eda14cbcSMatt Macy * blockpointers and iterates over them while the bpobj's lock held, so 2869eda14cbcSMatt Macy * the sizes returned to us are consistent which what was actually 2870eda14cbcSMatt Macy * processed. 2871eda14cbcSMatt Macy */ 2872eda14cbcSMatt Macy int err = dsl_process_sub_livelist(&first->dle_bpobj, &lca->to_keep, t, 2873eda14cbcSMatt Macy &first_size); 2874eda14cbcSMatt Macy if (err == 0) 2875eda14cbcSMatt Macy err = dsl_process_sub_livelist(&next->dle_bpobj, &lca->to_keep, 2876eda14cbcSMatt Macy t, &next_size); 2877eda14cbcSMatt Macy 2878eda14cbcSMatt Macy if (err == 0) { 2879eda14cbcSMatt Macy while (zfs_livelist_condense_sync_pause && 2880eda14cbcSMatt Macy !(zthr_has_waiters(t) || zthr_iscancelled(t))) 2881eda14cbcSMatt Macy delay(1); 2882eda14cbcSMatt Macy 2883eda14cbcSMatt Macy dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); 2884eda14cbcSMatt Macy dmu_tx_mark_netfree(tx); 2885eda14cbcSMatt Macy dmu_tx_hold_space(tx, 1); 2886eda14cbcSMatt Macy err = dmu_tx_assign(tx, TXG_NOWAIT | TXG_NOTHROTTLE); 2887eda14cbcSMatt Macy if (err == 0) { 2888eda14cbcSMatt Macy /* 2889eda14cbcSMatt Macy * Prevent the condense zthr restarting before 2890eda14cbcSMatt Macy * the synctask completes. 2891eda14cbcSMatt Macy */ 2892eda14cbcSMatt Macy spa->spa_to_condense.syncing = B_TRUE; 2893eda14cbcSMatt Macy lca->spa = spa; 2894eda14cbcSMatt Macy lca->first_size = first_size; 2895eda14cbcSMatt Macy lca->next_size = next_size; 2896eda14cbcSMatt Macy dsl_sync_task_nowait(spa_get_dsl(spa), 28972c48331dSMatt Macy spa_livelist_condense_sync, lca, tx); 2898eda14cbcSMatt Macy dmu_tx_commit(tx); 2899eda14cbcSMatt Macy return; 2900eda14cbcSMatt Macy } 2901eda14cbcSMatt Macy } 2902eda14cbcSMatt Macy /* 2903eda14cbcSMatt Macy * Condensing can not continue: either it was externally stopped or 2904eda14cbcSMatt Macy * we were unable to assign to a tx because the pool has run out of 2905eda14cbcSMatt Macy * space. In the second case, we'll just end up trying to condense 2906eda14cbcSMatt Macy * again in a later txg. 2907eda14cbcSMatt Macy */ 2908eda14cbcSMatt Macy ASSERT(err != 0); 2909eda14cbcSMatt Macy bplist_clear(&lca->to_keep); 2910eda14cbcSMatt Macy bplist_destroy(&lca->to_keep); 2911eda14cbcSMatt Macy kmem_free(lca, sizeof (livelist_condense_arg_t)); 2912eda14cbcSMatt Macy dmu_buf_rele(spa->spa_to_condense.ds->ds_dbuf, spa); 2913eda14cbcSMatt Macy spa->spa_to_condense.ds = NULL; 2914eda14cbcSMatt Macy if (err == EINTR) 2915eda14cbcSMatt Macy zfs_livelist_condense_zthr_cancel++; 2916eda14cbcSMatt Macy } 2917eda14cbcSMatt Macy 2918eda14cbcSMatt Macy /* 2919eda14cbcSMatt Macy * Check that there is something to condense but that a condense is not 2920eda14cbcSMatt Macy * already in progress and that condensing has not been cancelled. 2921eda14cbcSMatt Macy */ 2922eda14cbcSMatt Macy static boolean_t 2923eda14cbcSMatt Macy spa_livelist_condense_cb_check(void *arg, zthr_t *z) 2924eda14cbcSMatt Macy { 2925e92ffd9bSMartin Matuska (void) z; 2926eda14cbcSMatt Macy spa_t *spa = arg; 2927eda14cbcSMatt Macy if ((spa->spa_to_condense.ds != NULL) && 2928eda14cbcSMatt Macy (spa->spa_to_condense.syncing == B_FALSE) && 2929eda14cbcSMatt Macy (spa->spa_to_condense.cancelled == B_FALSE)) { 2930eda14cbcSMatt Macy return (B_TRUE); 2931eda14cbcSMatt Macy } 2932eda14cbcSMatt Macy return (B_FALSE); 2933eda14cbcSMatt Macy } 2934eda14cbcSMatt Macy 2935eda14cbcSMatt Macy static void 2936eda14cbcSMatt Macy spa_start_livelist_condensing_thread(spa_t *spa) 2937eda14cbcSMatt Macy { 2938eda14cbcSMatt Macy spa->spa_to_condense.ds = NULL; 2939eda14cbcSMatt Macy spa->spa_to_condense.first = NULL; 2940eda14cbcSMatt Macy spa->spa_to_condense.next = NULL; 2941eda14cbcSMatt Macy spa->spa_to_condense.syncing = B_FALSE; 2942eda14cbcSMatt Macy spa->spa_to_condense.cancelled = B_FALSE; 2943eda14cbcSMatt Macy 2944eda14cbcSMatt Macy ASSERT3P(spa->spa_livelist_condense_zthr, ==, NULL); 2945eda14cbcSMatt Macy spa->spa_livelist_condense_zthr = 2946eda14cbcSMatt Macy zthr_create("z_livelist_condense", 2947eda14cbcSMatt Macy spa_livelist_condense_cb_check, 29482faf504dSMartin Matuska spa_livelist_condense_cb, spa, minclsyspri); 2949eda14cbcSMatt Macy } 2950eda14cbcSMatt Macy 2951eda14cbcSMatt Macy static void 2952eda14cbcSMatt Macy spa_spawn_aux_threads(spa_t *spa) 2953eda14cbcSMatt Macy { 2954eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 2955eda14cbcSMatt Macy 2956eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 2957eda14cbcSMatt Macy 2958eda14cbcSMatt Macy spa_start_indirect_condensing_thread(spa); 2959eda14cbcSMatt Macy spa_start_livelist_destroy_thread(spa); 2960eda14cbcSMatt Macy spa_start_livelist_condensing_thread(spa); 2961eda14cbcSMatt Macy 2962eda14cbcSMatt Macy ASSERT3P(spa->spa_checkpoint_discard_zthr, ==, NULL); 2963eda14cbcSMatt Macy spa->spa_checkpoint_discard_zthr = 2964eda14cbcSMatt Macy zthr_create("z_checkpoint_discard", 2965eda14cbcSMatt Macy spa_checkpoint_discard_thread_check, 29662faf504dSMartin Matuska spa_checkpoint_discard_thread, spa, minclsyspri); 2967eda14cbcSMatt Macy } 2968eda14cbcSMatt Macy 2969eda14cbcSMatt Macy /* 2970eda14cbcSMatt Macy * Fix up config after a partly-completed split. This is done with the 2971eda14cbcSMatt Macy * ZPOOL_CONFIG_SPLIT nvlist. Both the splitting pool and the split-off 2972eda14cbcSMatt Macy * pool have that entry in their config, but only the splitting one contains 2973eda14cbcSMatt Macy * a list of all the guids of the vdevs that are being split off. 2974eda14cbcSMatt Macy * 2975eda14cbcSMatt Macy * This function determines what to do with that list: either rejoin 2976eda14cbcSMatt Macy * all the disks to the pool, or complete the splitting process. To attempt 2977eda14cbcSMatt Macy * the rejoin, each disk that is offlined is marked online again, and 2978eda14cbcSMatt Macy * we do a reopen() call. If the vdev label for every disk that was 2979eda14cbcSMatt Macy * marked online indicates it was successfully split off (VDEV_AUX_SPLIT_POOL) 2980eda14cbcSMatt Macy * then we call vdev_split() on each disk, and complete the split. 2981eda14cbcSMatt Macy * 2982eda14cbcSMatt Macy * Otherwise we leave the config alone, with all the vdevs in place in 2983eda14cbcSMatt Macy * the original pool. 2984eda14cbcSMatt Macy */ 2985eda14cbcSMatt Macy static void 2986eda14cbcSMatt Macy spa_try_repair(spa_t *spa, nvlist_t *config) 2987eda14cbcSMatt Macy { 2988eda14cbcSMatt Macy uint_t extracted; 2989eda14cbcSMatt Macy uint64_t *glist; 2990eda14cbcSMatt Macy uint_t i, gcount; 2991eda14cbcSMatt Macy nvlist_t *nvl; 2992eda14cbcSMatt Macy vdev_t **vd; 2993eda14cbcSMatt Macy boolean_t attempt_reopen; 2994eda14cbcSMatt Macy 2995eda14cbcSMatt Macy if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) != 0) 2996eda14cbcSMatt Macy return; 2997eda14cbcSMatt Macy 2998eda14cbcSMatt Macy /* check that the config is complete */ 2999eda14cbcSMatt Macy if (nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, 3000eda14cbcSMatt Macy &glist, &gcount) != 0) 3001eda14cbcSMatt Macy return; 3002eda14cbcSMatt Macy 3003eda14cbcSMatt Macy vd = kmem_zalloc(gcount * sizeof (vdev_t *), KM_SLEEP); 3004eda14cbcSMatt Macy 3005eda14cbcSMatt Macy /* attempt to online all the vdevs & validate */ 3006eda14cbcSMatt Macy attempt_reopen = B_TRUE; 3007eda14cbcSMatt Macy for (i = 0; i < gcount; i++) { 3008eda14cbcSMatt Macy if (glist[i] == 0) /* vdev is hole */ 3009eda14cbcSMatt Macy continue; 3010eda14cbcSMatt Macy 3011eda14cbcSMatt Macy vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE); 3012eda14cbcSMatt Macy if (vd[i] == NULL) { 3013eda14cbcSMatt Macy /* 3014eda14cbcSMatt Macy * Don't bother attempting to reopen the disks; 3015eda14cbcSMatt Macy * just do the split. 3016eda14cbcSMatt Macy */ 3017eda14cbcSMatt Macy attempt_reopen = B_FALSE; 3018eda14cbcSMatt Macy } else { 3019eda14cbcSMatt Macy /* attempt to re-online it */ 3020eda14cbcSMatt Macy vd[i]->vdev_offline = B_FALSE; 3021eda14cbcSMatt Macy } 3022eda14cbcSMatt Macy } 3023eda14cbcSMatt Macy 3024eda14cbcSMatt Macy if (attempt_reopen) { 3025eda14cbcSMatt Macy vdev_reopen(spa->spa_root_vdev); 3026eda14cbcSMatt Macy 3027eda14cbcSMatt Macy /* check each device to see what state it's in */ 3028eda14cbcSMatt Macy for (extracted = 0, i = 0; i < gcount; i++) { 3029eda14cbcSMatt Macy if (vd[i] != NULL && 3030eda14cbcSMatt Macy vd[i]->vdev_stat.vs_aux != VDEV_AUX_SPLIT_POOL) 3031eda14cbcSMatt Macy break; 3032eda14cbcSMatt Macy ++extracted; 3033eda14cbcSMatt Macy } 3034eda14cbcSMatt Macy } 3035eda14cbcSMatt Macy 3036eda14cbcSMatt Macy /* 3037eda14cbcSMatt Macy * If every disk has been moved to the new pool, or if we never 3038eda14cbcSMatt Macy * even attempted to look at them, then we split them off for 3039eda14cbcSMatt Macy * good. 3040eda14cbcSMatt Macy */ 3041eda14cbcSMatt Macy if (!attempt_reopen || gcount == extracted) { 3042eda14cbcSMatt Macy for (i = 0; i < gcount; i++) 3043eda14cbcSMatt Macy if (vd[i] != NULL) 3044eda14cbcSMatt Macy vdev_split(vd[i]); 3045eda14cbcSMatt Macy vdev_reopen(spa->spa_root_vdev); 3046eda14cbcSMatt Macy } 3047eda14cbcSMatt Macy 3048eda14cbcSMatt Macy kmem_free(vd, gcount * sizeof (vdev_t *)); 3049eda14cbcSMatt Macy } 3050eda14cbcSMatt Macy 3051eda14cbcSMatt Macy static int 3052eda14cbcSMatt Macy spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type) 3053eda14cbcSMatt Macy { 3054a0b956f5SMartin Matuska const char *ereport = FM_EREPORT_ZFS_POOL; 3055eda14cbcSMatt Macy int error; 3056eda14cbcSMatt Macy 3057eda14cbcSMatt Macy spa->spa_load_state = state; 3058eda14cbcSMatt Macy (void) spa_import_progress_set_state(spa_guid(spa), 3059eda14cbcSMatt Macy spa_load_state(spa)); 3060eda14cbcSMatt Macy 3061eda14cbcSMatt Macy gethrestime(&spa->spa_loaded_ts); 3062eda14cbcSMatt Macy error = spa_load_impl(spa, type, &ereport); 3063eda14cbcSMatt Macy 3064eda14cbcSMatt Macy /* 3065eda14cbcSMatt Macy * Don't count references from objsets that are already closed 3066eda14cbcSMatt Macy * and are making their way through the eviction process. 3067eda14cbcSMatt Macy */ 3068eda14cbcSMatt Macy spa_evicting_os_wait(spa); 3069eda14cbcSMatt Macy spa->spa_minref = zfs_refcount_count(&spa->spa_refcount); 3070eda14cbcSMatt Macy if (error) { 3071eda14cbcSMatt Macy if (error != EEXIST) { 3072eda14cbcSMatt Macy spa->spa_loaded_ts.tv_sec = 0; 3073eda14cbcSMatt Macy spa->spa_loaded_ts.tv_nsec = 0; 3074eda14cbcSMatt Macy } 3075eda14cbcSMatt Macy if (error != EBADF) { 3076eac7052fSMatt Macy (void) zfs_ereport_post(ereport, spa, 30772c48331dSMatt Macy NULL, NULL, NULL, 0); 3078eda14cbcSMatt Macy } 3079eda14cbcSMatt Macy } 3080eda14cbcSMatt Macy spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE; 3081eda14cbcSMatt Macy spa->spa_ena = 0; 3082eda14cbcSMatt Macy 3083eda14cbcSMatt Macy (void) spa_import_progress_set_state(spa_guid(spa), 3084eda14cbcSMatt Macy spa_load_state(spa)); 3085eda14cbcSMatt Macy 3086eda14cbcSMatt Macy return (error); 3087eda14cbcSMatt Macy } 3088eda14cbcSMatt Macy 3089eda14cbcSMatt Macy #ifdef ZFS_DEBUG 3090eda14cbcSMatt Macy /* 3091eda14cbcSMatt Macy * Count the number of per-vdev ZAPs associated with all of the vdevs in the 3092eda14cbcSMatt Macy * vdev tree rooted in the given vd, and ensure that each ZAP is present in the 3093eda14cbcSMatt Macy * spa's per-vdev ZAP list. 3094eda14cbcSMatt Macy */ 3095eda14cbcSMatt Macy static uint64_t 3096eda14cbcSMatt Macy vdev_count_verify_zaps(vdev_t *vd) 3097eda14cbcSMatt Macy { 3098eda14cbcSMatt Macy spa_t *spa = vd->vdev_spa; 3099eda14cbcSMatt Macy uint64_t total = 0; 3100eda14cbcSMatt Macy 3101d411c1d6SMartin Matuska if (spa_feature_is_active(vd->vdev_spa, SPA_FEATURE_AVZ_V2) && 3102d411c1d6SMartin Matuska vd->vdev_root_zap != 0) { 3103d411c1d6SMartin Matuska total++; 3104d411c1d6SMartin Matuska ASSERT0(zap_lookup_int(spa->spa_meta_objset, 3105d411c1d6SMartin Matuska spa->spa_all_vdev_zaps, vd->vdev_root_zap)); 3106d411c1d6SMartin Matuska } 3107eda14cbcSMatt Macy if (vd->vdev_top_zap != 0) { 3108eda14cbcSMatt Macy total++; 3109eda14cbcSMatt Macy ASSERT0(zap_lookup_int(spa->spa_meta_objset, 3110eda14cbcSMatt Macy spa->spa_all_vdev_zaps, vd->vdev_top_zap)); 3111eda14cbcSMatt Macy } 3112eda14cbcSMatt Macy if (vd->vdev_leaf_zap != 0) { 3113eda14cbcSMatt Macy total++; 3114eda14cbcSMatt Macy ASSERT0(zap_lookup_int(spa->spa_meta_objset, 3115eda14cbcSMatt Macy spa->spa_all_vdev_zaps, vd->vdev_leaf_zap)); 3116eda14cbcSMatt Macy } 3117eda14cbcSMatt Macy 3118eda14cbcSMatt Macy for (uint64_t i = 0; i < vd->vdev_children; i++) { 3119eda14cbcSMatt Macy total += vdev_count_verify_zaps(vd->vdev_child[i]); 3120eda14cbcSMatt Macy } 3121eda14cbcSMatt Macy 3122eda14cbcSMatt Macy return (total); 3123eda14cbcSMatt Macy } 3124e92ffd9bSMartin Matuska #else 3125e92ffd9bSMartin Matuska #define vdev_count_verify_zaps(vd) ((void) sizeof (vd), 0) 3126eda14cbcSMatt Macy #endif 3127eda14cbcSMatt Macy 3128eda14cbcSMatt Macy /* 3129eda14cbcSMatt Macy * Determine whether the activity check is required. 3130eda14cbcSMatt Macy */ 3131eda14cbcSMatt Macy static boolean_t 3132eda14cbcSMatt Macy spa_activity_check_required(spa_t *spa, uberblock_t *ub, nvlist_t *label, 3133eda14cbcSMatt Macy nvlist_t *config) 3134eda14cbcSMatt Macy { 3135eda14cbcSMatt Macy uint64_t state = 0; 3136eda14cbcSMatt Macy uint64_t hostid = 0; 3137eda14cbcSMatt Macy uint64_t tryconfig_txg = 0; 3138eda14cbcSMatt Macy uint64_t tryconfig_timestamp = 0; 3139eda14cbcSMatt Macy uint16_t tryconfig_mmp_seq = 0; 3140eda14cbcSMatt Macy nvlist_t *nvinfo; 3141eda14cbcSMatt Macy 3142eda14cbcSMatt Macy if (nvlist_exists(config, ZPOOL_CONFIG_LOAD_INFO)) { 3143eda14cbcSMatt Macy nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO); 3144eda14cbcSMatt Macy (void) nvlist_lookup_uint64(nvinfo, ZPOOL_CONFIG_MMP_TXG, 3145eda14cbcSMatt Macy &tryconfig_txg); 3146eda14cbcSMatt Macy (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_TIMESTAMP, 3147eda14cbcSMatt Macy &tryconfig_timestamp); 3148eda14cbcSMatt Macy (void) nvlist_lookup_uint16(nvinfo, ZPOOL_CONFIG_MMP_SEQ, 3149eda14cbcSMatt Macy &tryconfig_mmp_seq); 3150eda14cbcSMatt Macy } 3151eda14cbcSMatt Macy 3152eda14cbcSMatt Macy (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, &state); 3153eda14cbcSMatt Macy 3154eda14cbcSMatt Macy /* 3155eda14cbcSMatt Macy * Disable the MMP activity check - This is used by zdb which 3156eda14cbcSMatt Macy * is intended to be used on potentially active pools. 3157eda14cbcSMatt Macy */ 3158eda14cbcSMatt Macy if (spa->spa_import_flags & ZFS_IMPORT_SKIP_MMP) 3159eda14cbcSMatt Macy return (B_FALSE); 3160eda14cbcSMatt Macy 3161eda14cbcSMatt Macy /* 3162eda14cbcSMatt Macy * Skip the activity check when the MMP feature is disabled. 3163eda14cbcSMatt Macy */ 3164eda14cbcSMatt Macy if (ub->ub_mmp_magic == MMP_MAGIC && ub->ub_mmp_delay == 0) 3165eda14cbcSMatt Macy return (B_FALSE); 3166eda14cbcSMatt Macy 3167eda14cbcSMatt Macy /* 3168eda14cbcSMatt Macy * If the tryconfig_ values are nonzero, they are the results of an 3169eda14cbcSMatt Macy * earlier tryimport. If they all match the uberblock we just found, 3170eda14cbcSMatt Macy * then the pool has not changed and we return false so we do not test 3171eda14cbcSMatt Macy * a second time. 3172eda14cbcSMatt Macy */ 3173eda14cbcSMatt Macy if (tryconfig_txg && tryconfig_txg == ub->ub_txg && 3174eda14cbcSMatt Macy tryconfig_timestamp && tryconfig_timestamp == ub->ub_timestamp && 3175eda14cbcSMatt Macy tryconfig_mmp_seq && tryconfig_mmp_seq == 3176eda14cbcSMatt Macy (MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0)) 3177eda14cbcSMatt Macy return (B_FALSE); 3178eda14cbcSMatt Macy 3179eda14cbcSMatt Macy /* 3180eda14cbcSMatt Macy * Allow the activity check to be skipped when importing the pool 3181eda14cbcSMatt Macy * on the same host which last imported it. Since the hostid from 3182eda14cbcSMatt Macy * configuration may be stale use the one read from the label. 3183eda14cbcSMatt Macy */ 3184eda14cbcSMatt Macy if (nvlist_exists(label, ZPOOL_CONFIG_HOSTID)) 3185eda14cbcSMatt Macy hostid = fnvlist_lookup_uint64(label, ZPOOL_CONFIG_HOSTID); 3186eda14cbcSMatt Macy 3187eda14cbcSMatt Macy if (hostid == spa_get_hostid(spa)) 3188eda14cbcSMatt Macy return (B_FALSE); 3189eda14cbcSMatt Macy 3190eda14cbcSMatt Macy /* 3191eda14cbcSMatt Macy * Skip the activity test when the pool was cleanly exported. 3192eda14cbcSMatt Macy */ 3193eda14cbcSMatt Macy if (state != POOL_STATE_ACTIVE) 3194eda14cbcSMatt Macy return (B_FALSE); 3195eda14cbcSMatt Macy 3196eda14cbcSMatt Macy return (B_TRUE); 3197eda14cbcSMatt Macy } 3198eda14cbcSMatt Macy 3199eda14cbcSMatt Macy /* 3200eda14cbcSMatt Macy * Nanoseconds the activity check must watch for changes on-disk. 3201eda14cbcSMatt Macy */ 3202eda14cbcSMatt Macy static uint64_t 3203eda14cbcSMatt Macy spa_activity_check_duration(spa_t *spa, uberblock_t *ub) 3204eda14cbcSMatt Macy { 3205eda14cbcSMatt Macy uint64_t import_intervals = MAX(zfs_multihost_import_intervals, 1); 3206eda14cbcSMatt Macy uint64_t multihost_interval = MSEC2NSEC( 3207eda14cbcSMatt Macy MMP_INTERVAL_OK(zfs_multihost_interval)); 3208eda14cbcSMatt Macy uint64_t import_delay = MAX(NANOSEC, import_intervals * 3209eda14cbcSMatt Macy multihost_interval); 3210eda14cbcSMatt Macy 3211eda14cbcSMatt Macy /* 3212eda14cbcSMatt Macy * Local tunables determine a minimum duration except for the case 3213eda14cbcSMatt Macy * where we know when the remote host will suspend the pool if MMP 3214eda14cbcSMatt Macy * writes do not land. 3215eda14cbcSMatt Macy * 3216eda14cbcSMatt Macy * See Big Theory comment at the top of mmp.c for the reasoning behind 3217eda14cbcSMatt Macy * these cases and times. 3218eda14cbcSMatt Macy */ 3219eda14cbcSMatt Macy 3220eda14cbcSMatt Macy ASSERT(MMP_IMPORT_SAFETY_FACTOR >= 100); 3221eda14cbcSMatt Macy 3222eda14cbcSMatt Macy if (MMP_INTERVAL_VALID(ub) && MMP_FAIL_INT_VALID(ub) && 3223eda14cbcSMatt Macy MMP_FAIL_INT(ub) > 0) { 3224eda14cbcSMatt Macy 3225eda14cbcSMatt Macy /* MMP on remote host will suspend pool after failed writes */ 3226eda14cbcSMatt Macy import_delay = MMP_FAIL_INT(ub) * MSEC2NSEC(MMP_INTERVAL(ub)) * 3227eda14cbcSMatt Macy MMP_IMPORT_SAFETY_FACTOR / 100; 3228eda14cbcSMatt Macy 3229eda14cbcSMatt Macy zfs_dbgmsg("fail_intvals>0 import_delay=%llu ub_mmp " 3230eda14cbcSMatt Macy "mmp_fails=%llu ub_mmp mmp_interval=%llu " 323133b8c039SMartin Matuska "import_intervals=%llu", (u_longlong_t)import_delay, 323233b8c039SMartin Matuska (u_longlong_t)MMP_FAIL_INT(ub), 323333b8c039SMartin Matuska (u_longlong_t)MMP_INTERVAL(ub), 323433b8c039SMartin Matuska (u_longlong_t)import_intervals); 3235eda14cbcSMatt Macy 3236eda14cbcSMatt Macy } else if (MMP_INTERVAL_VALID(ub) && MMP_FAIL_INT_VALID(ub) && 3237eda14cbcSMatt Macy MMP_FAIL_INT(ub) == 0) { 3238eda14cbcSMatt Macy 3239eda14cbcSMatt Macy /* MMP on remote host will never suspend pool */ 3240eda14cbcSMatt Macy import_delay = MAX(import_delay, (MSEC2NSEC(MMP_INTERVAL(ub)) + 3241eda14cbcSMatt Macy ub->ub_mmp_delay) * import_intervals); 3242eda14cbcSMatt Macy 3243eda14cbcSMatt Macy zfs_dbgmsg("fail_intvals=0 import_delay=%llu ub_mmp " 3244eda14cbcSMatt Macy "mmp_interval=%llu ub_mmp_delay=%llu " 324533b8c039SMartin Matuska "import_intervals=%llu", (u_longlong_t)import_delay, 324633b8c039SMartin Matuska (u_longlong_t)MMP_INTERVAL(ub), 324733b8c039SMartin Matuska (u_longlong_t)ub->ub_mmp_delay, 324833b8c039SMartin Matuska (u_longlong_t)import_intervals); 3249eda14cbcSMatt Macy 3250eda14cbcSMatt Macy } else if (MMP_VALID(ub)) { 3251eda14cbcSMatt Macy /* 3252eda14cbcSMatt Macy * zfs-0.7 compatibility case 3253eda14cbcSMatt Macy */ 3254eda14cbcSMatt Macy 3255eda14cbcSMatt Macy import_delay = MAX(import_delay, (multihost_interval + 3256eda14cbcSMatt Macy ub->ub_mmp_delay) * import_intervals); 3257eda14cbcSMatt Macy 3258eda14cbcSMatt Macy zfs_dbgmsg("import_delay=%llu ub_mmp_delay=%llu " 325933b8c039SMartin Matuska "import_intervals=%llu leaves=%u", 326033b8c039SMartin Matuska (u_longlong_t)import_delay, 326133b8c039SMartin Matuska (u_longlong_t)ub->ub_mmp_delay, 326233b8c039SMartin Matuska (u_longlong_t)import_intervals, 3263eda14cbcSMatt Macy vdev_count_leaves(spa)); 3264eda14cbcSMatt Macy } else { 3265eda14cbcSMatt Macy /* Using local tunings is the only reasonable option */ 3266eda14cbcSMatt Macy zfs_dbgmsg("pool last imported on non-MMP aware " 3267eda14cbcSMatt Macy "host using import_delay=%llu multihost_interval=%llu " 326833b8c039SMartin Matuska "import_intervals=%llu", (u_longlong_t)import_delay, 326933b8c039SMartin Matuska (u_longlong_t)multihost_interval, 327033b8c039SMartin Matuska (u_longlong_t)import_intervals); 3271eda14cbcSMatt Macy } 3272eda14cbcSMatt Macy 3273eda14cbcSMatt Macy return (import_delay); 3274eda14cbcSMatt Macy } 3275eda14cbcSMatt Macy 3276eda14cbcSMatt Macy /* 3277eda14cbcSMatt Macy * Perform the import activity check. If the user canceled the import or 3278eda14cbcSMatt Macy * we detected activity then fail. 3279eda14cbcSMatt Macy */ 3280eda14cbcSMatt Macy static int 3281eda14cbcSMatt Macy spa_activity_check(spa_t *spa, uberblock_t *ub, nvlist_t *config) 3282eda14cbcSMatt Macy { 3283eda14cbcSMatt Macy uint64_t txg = ub->ub_txg; 3284eda14cbcSMatt Macy uint64_t timestamp = ub->ub_timestamp; 3285eda14cbcSMatt Macy uint64_t mmp_config = ub->ub_mmp_config; 3286eda14cbcSMatt Macy uint16_t mmp_seq = MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0; 3287eda14cbcSMatt Macy uint64_t import_delay; 3288eda14cbcSMatt Macy hrtime_t import_expire; 3289eda14cbcSMatt Macy nvlist_t *mmp_label = NULL; 3290eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 3291eda14cbcSMatt Macy kcondvar_t cv; 3292eda14cbcSMatt Macy kmutex_t mtx; 3293eda14cbcSMatt Macy int error = 0; 3294eda14cbcSMatt Macy 3295eda14cbcSMatt Macy cv_init(&cv, NULL, CV_DEFAULT, NULL); 3296eda14cbcSMatt Macy mutex_init(&mtx, NULL, MUTEX_DEFAULT, NULL); 3297eda14cbcSMatt Macy mutex_enter(&mtx); 3298eda14cbcSMatt Macy 3299eda14cbcSMatt Macy /* 3300eda14cbcSMatt Macy * If ZPOOL_CONFIG_MMP_TXG is present an activity check was performed 3301eda14cbcSMatt Macy * during the earlier tryimport. If the txg recorded there is 0 then 3302eda14cbcSMatt Macy * the pool is known to be active on another host. 3303eda14cbcSMatt Macy * 3304eda14cbcSMatt Macy * Otherwise, the pool might be in use on another host. Check for 3305eda14cbcSMatt Macy * changes in the uberblocks on disk if necessary. 3306eda14cbcSMatt Macy */ 3307eda14cbcSMatt Macy if (nvlist_exists(config, ZPOOL_CONFIG_LOAD_INFO)) { 3308eda14cbcSMatt Macy nvlist_t *nvinfo = fnvlist_lookup_nvlist(config, 3309eda14cbcSMatt Macy ZPOOL_CONFIG_LOAD_INFO); 3310eda14cbcSMatt Macy 3311eda14cbcSMatt Macy if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_TXG) && 3312eda14cbcSMatt Macy fnvlist_lookup_uint64(nvinfo, ZPOOL_CONFIG_MMP_TXG) == 0) { 3313eda14cbcSMatt Macy vdev_uberblock_load(rvd, ub, &mmp_label); 3314eda14cbcSMatt Macy error = SET_ERROR(EREMOTEIO); 3315eda14cbcSMatt Macy goto out; 3316eda14cbcSMatt Macy } 3317eda14cbcSMatt Macy } 3318eda14cbcSMatt Macy 3319eda14cbcSMatt Macy import_delay = spa_activity_check_duration(spa, ub); 3320eda14cbcSMatt Macy 3321eda14cbcSMatt Macy /* Add a small random factor in case of simultaneous imports (0-25%) */ 332233b8c039SMartin Matuska import_delay += import_delay * random_in_range(250) / 1000; 3323eda14cbcSMatt Macy 3324eda14cbcSMatt Macy import_expire = gethrtime() + import_delay; 3325eda14cbcSMatt Macy 3326eda14cbcSMatt Macy while (gethrtime() < import_expire) { 3327eda14cbcSMatt Macy (void) spa_import_progress_set_mmp_check(spa_guid(spa), 3328eda14cbcSMatt Macy NSEC2SEC(import_expire - gethrtime())); 3329eda14cbcSMatt Macy 3330eda14cbcSMatt Macy vdev_uberblock_load(rvd, ub, &mmp_label); 3331eda14cbcSMatt Macy 3332eda14cbcSMatt Macy if (txg != ub->ub_txg || timestamp != ub->ub_timestamp || 3333eda14cbcSMatt Macy mmp_seq != (MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0)) { 3334eda14cbcSMatt Macy zfs_dbgmsg("multihost activity detected " 3335eda14cbcSMatt Macy "txg %llu ub_txg %llu " 3336eda14cbcSMatt Macy "timestamp %llu ub_timestamp %llu " 3337eda14cbcSMatt Macy "mmp_config %#llx ub_mmp_config %#llx", 333833b8c039SMartin Matuska (u_longlong_t)txg, (u_longlong_t)ub->ub_txg, 333933b8c039SMartin Matuska (u_longlong_t)timestamp, 334033b8c039SMartin Matuska (u_longlong_t)ub->ub_timestamp, 334133b8c039SMartin Matuska (u_longlong_t)mmp_config, 334233b8c039SMartin Matuska (u_longlong_t)ub->ub_mmp_config); 3343eda14cbcSMatt Macy 3344eda14cbcSMatt Macy error = SET_ERROR(EREMOTEIO); 3345eda14cbcSMatt Macy break; 3346eda14cbcSMatt Macy } 3347eda14cbcSMatt Macy 3348eda14cbcSMatt Macy if (mmp_label) { 3349eda14cbcSMatt Macy nvlist_free(mmp_label); 3350eda14cbcSMatt Macy mmp_label = NULL; 3351eda14cbcSMatt Macy } 3352eda14cbcSMatt Macy 3353eda14cbcSMatt Macy error = cv_timedwait_sig(&cv, &mtx, ddi_get_lbolt() + hz); 3354eda14cbcSMatt Macy if (error != -1) { 3355eda14cbcSMatt Macy error = SET_ERROR(EINTR); 3356eda14cbcSMatt Macy break; 3357eda14cbcSMatt Macy } 3358eda14cbcSMatt Macy error = 0; 3359eda14cbcSMatt Macy } 3360eda14cbcSMatt Macy 3361eda14cbcSMatt Macy out: 3362eda14cbcSMatt Macy mutex_exit(&mtx); 3363eda14cbcSMatt Macy mutex_destroy(&mtx); 3364eda14cbcSMatt Macy cv_destroy(&cv); 3365eda14cbcSMatt Macy 3366eda14cbcSMatt Macy /* 3367eda14cbcSMatt Macy * If the pool is determined to be active store the status in the 3368eda14cbcSMatt Macy * spa->spa_load_info nvlist. If the remote hostname or hostid are 3369eda14cbcSMatt Macy * available from configuration read from disk store them as well. 3370eda14cbcSMatt Macy * This allows 'zpool import' to generate a more useful message. 3371eda14cbcSMatt Macy * 3372eda14cbcSMatt Macy * ZPOOL_CONFIG_MMP_STATE - observed pool status (mandatory) 3373eda14cbcSMatt Macy * ZPOOL_CONFIG_MMP_HOSTNAME - hostname from the active pool 3374eda14cbcSMatt Macy * ZPOOL_CONFIG_MMP_HOSTID - hostid from the active pool 3375eda14cbcSMatt Macy */ 3376eda14cbcSMatt Macy if (error == EREMOTEIO) { 3377a0b956f5SMartin Matuska const char *hostname = "<unknown>"; 3378eda14cbcSMatt Macy uint64_t hostid = 0; 3379eda14cbcSMatt Macy 3380eda14cbcSMatt Macy if (mmp_label) { 3381eda14cbcSMatt Macy if (nvlist_exists(mmp_label, ZPOOL_CONFIG_HOSTNAME)) { 3382eda14cbcSMatt Macy hostname = fnvlist_lookup_string(mmp_label, 3383eda14cbcSMatt Macy ZPOOL_CONFIG_HOSTNAME); 3384eda14cbcSMatt Macy fnvlist_add_string(spa->spa_load_info, 3385eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_HOSTNAME, hostname); 3386eda14cbcSMatt Macy } 3387eda14cbcSMatt Macy 3388eda14cbcSMatt Macy if (nvlist_exists(mmp_label, ZPOOL_CONFIG_HOSTID)) { 3389eda14cbcSMatt Macy hostid = fnvlist_lookup_uint64(mmp_label, 3390eda14cbcSMatt Macy ZPOOL_CONFIG_HOSTID); 3391eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 3392eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_HOSTID, hostid); 3393eda14cbcSMatt Macy } 3394eda14cbcSMatt Macy } 3395eda14cbcSMatt Macy 3396eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 3397eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_STATE, MMP_STATE_ACTIVE); 3398eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 3399eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_TXG, 0); 3400eda14cbcSMatt Macy 3401eda14cbcSMatt Macy error = spa_vdev_err(rvd, VDEV_AUX_ACTIVE, EREMOTEIO); 3402eda14cbcSMatt Macy } 3403eda14cbcSMatt Macy 3404eda14cbcSMatt Macy if (mmp_label) 3405eda14cbcSMatt Macy nvlist_free(mmp_label); 3406eda14cbcSMatt Macy 3407eda14cbcSMatt Macy return (error); 3408eda14cbcSMatt Macy } 3409eda14cbcSMatt Macy 3410eda14cbcSMatt Macy static int 3411eda14cbcSMatt Macy spa_verify_host(spa_t *spa, nvlist_t *mos_config) 3412eda14cbcSMatt Macy { 3413eda14cbcSMatt Macy uint64_t hostid; 34142a58b312SMartin Matuska const char *hostname; 3415eda14cbcSMatt Macy uint64_t myhostid = 0; 3416eda14cbcSMatt Macy 3417eda14cbcSMatt Macy if (!spa_is_root(spa) && nvlist_lookup_uint64(mos_config, 3418eda14cbcSMatt Macy ZPOOL_CONFIG_HOSTID, &hostid) == 0) { 3419eda14cbcSMatt Macy hostname = fnvlist_lookup_string(mos_config, 3420eda14cbcSMatt Macy ZPOOL_CONFIG_HOSTNAME); 3421eda14cbcSMatt Macy 3422eda14cbcSMatt Macy myhostid = zone_get_hostid(NULL); 3423eda14cbcSMatt Macy 3424eda14cbcSMatt Macy if (hostid != 0 && myhostid != 0 && hostid != myhostid) { 3425eda14cbcSMatt Macy cmn_err(CE_WARN, "pool '%s' could not be " 3426eda14cbcSMatt Macy "loaded as it was last accessed by " 3427eda14cbcSMatt Macy "another system (host: %s hostid: 0x%llx). " 3428ac0bf12eSMatt Macy "See: https://openzfs.github.io/openzfs-docs/msg/" 3429ac0bf12eSMatt Macy "ZFS-8000-EY", 3430eda14cbcSMatt Macy spa_name(spa), hostname, (u_longlong_t)hostid); 3431eda14cbcSMatt Macy spa_load_failed(spa, "hostid verification failed: pool " 3432eda14cbcSMatt Macy "last accessed by host: %s (hostid: 0x%llx)", 3433eda14cbcSMatt Macy hostname, (u_longlong_t)hostid); 3434eda14cbcSMatt Macy return (SET_ERROR(EBADF)); 3435eda14cbcSMatt Macy } 3436eda14cbcSMatt Macy } 3437eda14cbcSMatt Macy 3438eda14cbcSMatt Macy return (0); 3439eda14cbcSMatt Macy } 3440eda14cbcSMatt Macy 3441eda14cbcSMatt Macy static int 3442eda14cbcSMatt Macy spa_ld_parse_config(spa_t *spa, spa_import_type_t type) 3443eda14cbcSMatt Macy { 3444eda14cbcSMatt Macy int error = 0; 3445eda14cbcSMatt Macy nvlist_t *nvtree, *nvl, *config = spa->spa_config; 3446eda14cbcSMatt Macy int parse; 3447eda14cbcSMatt Macy vdev_t *rvd; 3448eda14cbcSMatt Macy uint64_t pool_guid; 34492a58b312SMartin Matuska const char *comment; 34502a58b312SMartin Matuska const char *compatibility; 3451eda14cbcSMatt Macy 3452eda14cbcSMatt Macy /* 3453eda14cbcSMatt Macy * Versioning wasn't explicitly added to the label until later, so if 3454eda14cbcSMatt Macy * it's not present treat it as the initial version. 3455eda14cbcSMatt Macy */ 3456eda14cbcSMatt Macy if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 3457eda14cbcSMatt Macy &spa->spa_ubsync.ub_version) != 0) 3458eda14cbcSMatt Macy spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL; 3459eda14cbcSMatt Macy 3460eda14cbcSMatt Macy if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) { 3461eda14cbcSMatt Macy spa_load_failed(spa, "invalid config provided: '%s' missing", 3462eda14cbcSMatt Macy ZPOOL_CONFIG_POOL_GUID); 3463eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 3464eda14cbcSMatt Macy } 3465eda14cbcSMatt Macy 3466eda14cbcSMatt Macy /* 3467eda14cbcSMatt Macy * If we are doing an import, ensure that the pool is not already 3468eda14cbcSMatt Macy * imported by checking if its pool guid already exists in the 3469eda14cbcSMatt Macy * spa namespace. 3470eda14cbcSMatt Macy * 3471eda14cbcSMatt Macy * The only case that we allow an already imported pool to be 3472eda14cbcSMatt Macy * imported again, is when the pool is checkpointed and we want to 3473eda14cbcSMatt Macy * look at its checkpointed state from userland tools like zdb. 3474eda14cbcSMatt Macy */ 3475eda14cbcSMatt Macy #ifdef _KERNEL 3476eda14cbcSMatt Macy if ((spa->spa_load_state == SPA_LOAD_IMPORT || 3477eda14cbcSMatt Macy spa->spa_load_state == SPA_LOAD_TRYIMPORT) && 3478eda14cbcSMatt Macy spa_guid_exists(pool_guid, 0)) { 3479eda14cbcSMatt Macy #else 3480eda14cbcSMatt Macy if ((spa->spa_load_state == SPA_LOAD_IMPORT || 3481eda14cbcSMatt Macy spa->spa_load_state == SPA_LOAD_TRYIMPORT) && 3482eda14cbcSMatt Macy spa_guid_exists(pool_guid, 0) && 3483eda14cbcSMatt Macy !spa_importing_readonly_checkpoint(spa)) { 3484eda14cbcSMatt Macy #endif 3485eda14cbcSMatt Macy spa_load_failed(spa, "a pool with guid %llu is already open", 3486eda14cbcSMatt Macy (u_longlong_t)pool_guid); 3487eda14cbcSMatt Macy return (SET_ERROR(EEXIST)); 3488eda14cbcSMatt Macy } 3489eda14cbcSMatt Macy 3490eda14cbcSMatt Macy spa->spa_config_guid = pool_guid; 3491eda14cbcSMatt Macy 3492eda14cbcSMatt Macy nvlist_free(spa->spa_load_info); 3493eda14cbcSMatt Macy spa->spa_load_info = fnvlist_alloc(); 3494eda14cbcSMatt Macy 3495eda14cbcSMatt Macy ASSERT(spa->spa_comment == NULL); 3496eda14cbcSMatt Macy if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0) 3497eda14cbcSMatt Macy spa->spa_comment = spa_strdup(comment); 3498eda14cbcSMatt Macy 3499ee36e25aSMartin Matuska ASSERT(spa->spa_compatibility == NULL); 3500ee36e25aSMartin Matuska if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMPATIBILITY, 3501ee36e25aSMartin Matuska &compatibility) == 0) 3502ee36e25aSMartin Matuska spa->spa_compatibility = spa_strdup(compatibility); 3503ee36e25aSMartin Matuska 3504eda14cbcSMatt Macy (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, 3505eda14cbcSMatt Macy &spa->spa_config_txg); 3506eda14cbcSMatt Macy 3507eda14cbcSMatt Macy if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) == 0) 3508eda14cbcSMatt Macy spa->spa_config_splitting = fnvlist_dup(nvl); 3509eda14cbcSMatt Macy 3510eda14cbcSMatt Macy if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvtree)) { 3511eda14cbcSMatt Macy spa_load_failed(spa, "invalid config provided: '%s' missing", 3512eda14cbcSMatt Macy ZPOOL_CONFIG_VDEV_TREE); 3513eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 3514eda14cbcSMatt Macy } 3515eda14cbcSMatt Macy 3516eda14cbcSMatt Macy /* 3517eda14cbcSMatt Macy * Create "The Godfather" zio to hold all async IOs 3518eda14cbcSMatt Macy */ 3519eda14cbcSMatt Macy spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *), 3520eda14cbcSMatt Macy KM_SLEEP); 3521eda14cbcSMatt Macy for (int i = 0; i < max_ncpus; i++) { 3522eda14cbcSMatt Macy spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL, 3523eda14cbcSMatt Macy ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | 3524eda14cbcSMatt Macy ZIO_FLAG_GODFATHER); 3525eda14cbcSMatt Macy } 3526eda14cbcSMatt Macy 3527eda14cbcSMatt Macy /* 3528eda14cbcSMatt Macy * Parse the configuration into a vdev tree. We explicitly set the 3529eda14cbcSMatt Macy * value that will be returned by spa_version() since parsing the 3530eda14cbcSMatt Macy * configuration requires knowing the version number. 3531eda14cbcSMatt Macy */ 3532eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3533eda14cbcSMatt Macy parse = (type == SPA_IMPORT_EXISTING ? 3534eda14cbcSMatt Macy VDEV_ALLOC_LOAD : VDEV_ALLOC_SPLIT); 3535eda14cbcSMatt Macy error = spa_config_parse(spa, &rvd, nvtree, NULL, 0, parse); 3536eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 3537eda14cbcSMatt Macy 3538eda14cbcSMatt Macy if (error != 0) { 3539eda14cbcSMatt Macy spa_load_failed(spa, "unable to parse config [error=%d]", 3540eda14cbcSMatt Macy error); 3541eda14cbcSMatt Macy return (error); 3542eda14cbcSMatt Macy } 3543eda14cbcSMatt Macy 3544eda14cbcSMatt Macy ASSERT(spa->spa_root_vdev == rvd); 3545eda14cbcSMatt Macy ASSERT3U(spa->spa_min_ashift, >=, SPA_MINBLOCKSHIFT); 3546eda14cbcSMatt Macy ASSERT3U(spa->spa_max_ashift, <=, SPA_MAXBLOCKSHIFT); 3547eda14cbcSMatt Macy 3548eda14cbcSMatt Macy if (type != SPA_IMPORT_ASSEMBLE) { 3549eda14cbcSMatt Macy ASSERT(spa_guid(spa) == pool_guid); 3550eda14cbcSMatt Macy } 3551eda14cbcSMatt Macy 3552eda14cbcSMatt Macy return (0); 3553eda14cbcSMatt Macy } 3554eda14cbcSMatt Macy 3555eda14cbcSMatt Macy /* 3556eda14cbcSMatt Macy * Recursively open all vdevs in the vdev tree. This function is called twice: 3557eda14cbcSMatt Macy * first with the untrusted config, then with the trusted config. 3558eda14cbcSMatt Macy */ 3559eda14cbcSMatt Macy static int 3560eda14cbcSMatt Macy spa_ld_open_vdevs(spa_t *spa) 3561eda14cbcSMatt Macy { 3562eda14cbcSMatt Macy int error = 0; 3563eda14cbcSMatt Macy 3564eda14cbcSMatt Macy /* 3565eda14cbcSMatt Macy * spa_missing_tvds_allowed defines how many top-level vdevs can be 3566eda14cbcSMatt Macy * missing/unopenable for the root vdev to be still considered openable. 3567eda14cbcSMatt Macy */ 3568eda14cbcSMatt Macy if (spa->spa_trust_config) { 3569eda14cbcSMatt Macy spa->spa_missing_tvds_allowed = zfs_max_missing_tvds; 3570eda14cbcSMatt Macy } else if (spa->spa_config_source == SPA_CONFIG_SRC_CACHEFILE) { 3571eda14cbcSMatt Macy spa->spa_missing_tvds_allowed = zfs_max_missing_tvds_cachefile; 3572eda14cbcSMatt Macy } else if (spa->spa_config_source == SPA_CONFIG_SRC_SCAN) { 3573eda14cbcSMatt Macy spa->spa_missing_tvds_allowed = zfs_max_missing_tvds_scan; 3574eda14cbcSMatt Macy } else { 3575eda14cbcSMatt Macy spa->spa_missing_tvds_allowed = 0; 3576eda14cbcSMatt Macy } 3577eda14cbcSMatt Macy 3578eda14cbcSMatt Macy spa->spa_missing_tvds_allowed = 3579eda14cbcSMatt Macy MAX(zfs_max_missing_tvds, spa->spa_missing_tvds_allowed); 3580eda14cbcSMatt Macy 3581eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3582eda14cbcSMatt Macy error = vdev_open(spa->spa_root_vdev); 3583eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 3584eda14cbcSMatt Macy 3585eda14cbcSMatt Macy if (spa->spa_missing_tvds != 0) { 3586eda14cbcSMatt Macy spa_load_note(spa, "vdev tree has %lld missing top-level " 3587eda14cbcSMatt Macy "vdevs.", (u_longlong_t)spa->spa_missing_tvds); 3588eda14cbcSMatt Macy if (spa->spa_trust_config && (spa->spa_mode & SPA_MODE_WRITE)) { 3589eda14cbcSMatt Macy /* 3590eda14cbcSMatt Macy * Although theoretically we could allow users to open 3591eda14cbcSMatt Macy * incomplete pools in RW mode, we'd need to add a lot 3592eda14cbcSMatt Macy * of extra logic (e.g. adjust pool space to account 3593eda14cbcSMatt Macy * for missing vdevs). 3594eda14cbcSMatt Macy * This limitation also prevents users from accidentally 3595eda14cbcSMatt Macy * opening the pool in RW mode during data recovery and 3596eda14cbcSMatt Macy * damaging it further. 3597eda14cbcSMatt Macy */ 3598eda14cbcSMatt Macy spa_load_note(spa, "pools with missing top-level " 3599eda14cbcSMatt Macy "vdevs can only be opened in read-only mode."); 3600eda14cbcSMatt Macy error = SET_ERROR(ENXIO); 3601eda14cbcSMatt Macy } else { 3602eda14cbcSMatt Macy spa_load_note(spa, "current settings allow for maximum " 3603eda14cbcSMatt Macy "%lld missing top-level vdevs at this stage.", 3604eda14cbcSMatt Macy (u_longlong_t)spa->spa_missing_tvds_allowed); 3605eda14cbcSMatt Macy } 3606eda14cbcSMatt Macy } 3607eda14cbcSMatt Macy if (error != 0) { 3608eda14cbcSMatt Macy spa_load_failed(spa, "unable to open vdev tree [error=%d]", 3609eda14cbcSMatt Macy error); 3610eda14cbcSMatt Macy } 3611eda14cbcSMatt Macy if (spa->spa_missing_tvds != 0 || error != 0) 3612eda14cbcSMatt Macy vdev_dbgmsg_print_tree(spa->spa_root_vdev, 2); 3613eda14cbcSMatt Macy 3614eda14cbcSMatt Macy return (error); 3615eda14cbcSMatt Macy } 3616eda14cbcSMatt Macy 3617eda14cbcSMatt Macy /* 3618eda14cbcSMatt Macy * We need to validate the vdev labels against the configuration that 3619eda14cbcSMatt Macy * we have in hand. This function is called twice: first with an untrusted 3620eda14cbcSMatt Macy * config, then with a trusted config. The validation is more strict when the 3621eda14cbcSMatt Macy * config is trusted. 3622eda14cbcSMatt Macy */ 3623eda14cbcSMatt Macy static int 3624eda14cbcSMatt Macy spa_ld_validate_vdevs(spa_t *spa) 3625eda14cbcSMatt Macy { 3626eda14cbcSMatt Macy int error = 0; 3627eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 3628eda14cbcSMatt Macy 3629eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3630eda14cbcSMatt Macy error = vdev_validate(rvd); 3631eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 3632eda14cbcSMatt Macy 3633eda14cbcSMatt Macy if (error != 0) { 3634eda14cbcSMatt Macy spa_load_failed(spa, "vdev_validate failed [error=%d]", error); 3635eda14cbcSMatt Macy return (error); 3636eda14cbcSMatt Macy } 3637eda14cbcSMatt Macy 3638eda14cbcSMatt Macy if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) { 3639eda14cbcSMatt Macy spa_load_failed(spa, "cannot open vdev tree after invalidating " 3640eda14cbcSMatt Macy "some vdevs"); 3641eda14cbcSMatt Macy vdev_dbgmsg_print_tree(rvd, 2); 3642eda14cbcSMatt Macy return (SET_ERROR(ENXIO)); 3643eda14cbcSMatt Macy } 3644eda14cbcSMatt Macy 3645eda14cbcSMatt Macy return (0); 3646eda14cbcSMatt Macy } 3647eda14cbcSMatt Macy 3648eda14cbcSMatt Macy static void 3649eda14cbcSMatt Macy spa_ld_select_uberblock_done(spa_t *spa, uberblock_t *ub) 3650eda14cbcSMatt Macy { 3651eda14cbcSMatt Macy spa->spa_state = POOL_STATE_ACTIVE; 3652eda14cbcSMatt Macy spa->spa_ubsync = spa->spa_uberblock; 3653eda14cbcSMatt Macy spa->spa_verify_min_txg = spa->spa_extreme_rewind ? 3654eda14cbcSMatt Macy TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1; 3655eda14cbcSMatt Macy spa->spa_first_txg = spa->spa_last_ubsync_txg ? 3656eda14cbcSMatt Macy spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1; 3657eda14cbcSMatt Macy spa->spa_claim_max_txg = spa->spa_first_txg; 3658eda14cbcSMatt Macy spa->spa_prev_software_version = ub->ub_software_version; 3659eda14cbcSMatt Macy } 3660eda14cbcSMatt Macy 3661eda14cbcSMatt Macy static int 3662eda14cbcSMatt Macy spa_ld_select_uberblock(spa_t *spa, spa_import_type_t type) 3663eda14cbcSMatt Macy { 3664eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 3665eda14cbcSMatt Macy nvlist_t *label; 3666eda14cbcSMatt Macy uberblock_t *ub = &spa->spa_uberblock; 3667eda14cbcSMatt Macy boolean_t activity_check = B_FALSE; 3668eda14cbcSMatt Macy 3669eda14cbcSMatt Macy /* 3670eda14cbcSMatt Macy * If we are opening the checkpointed state of the pool by 3671eda14cbcSMatt Macy * rewinding to it, at this point we will have written the 3672eda14cbcSMatt Macy * checkpointed uberblock to the vdev labels, so searching 3673eda14cbcSMatt Macy * the labels will find the right uberblock. However, if 3674eda14cbcSMatt Macy * we are opening the checkpointed state read-only, we have 3675eda14cbcSMatt Macy * not modified the labels. Therefore, we must ignore the 3676eda14cbcSMatt Macy * labels and continue using the spa_uberblock that was set 3677eda14cbcSMatt Macy * by spa_ld_checkpoint_rewind. 3678eda14cbcSMatt Macy * 3679eda14cbcSMatt Macy * Note that it would be fine to ignore the labels when 3680eda14cbcSMatt Macy * rewinding (opening writeable) as well. However, if we 3681eda14cbcSMatt Macy * crash just after writing the labels, we will end up 3682eda14cbcSMatt Macy * searching the labels. Doing so in the common case means 3683eda14cbcSMatt Macy * that this code path gets exercised normally, rather than 3684eda14cbcSMatt Macy * just in the edge case. 3685eda14cbcSMatt Macy */ 3686eda14cbcSMatt Macy if (ub->ub_checkpoint_txg != 0 && 3687eda14cbcSMatt Macy spa_importing_readonly_checkpoint(spa)) { 3688eda14cbcSMatt Macy spa_ld_select_uberblock_done(spa, ub); 3689eda14cbcSMatt Macy return (0); 3690eda14cbcSMatt Macy } 3691eda14cbcSMatt Macy 3692eda14cbcSMatt Macy /* 3693eda14cbcSMatt Macy * Find the best uberblock. 3694eda14cbcSMatt Macy */ 3695eda14cbcSMatt Macy vdev_uberblock_load(rvd, ub, &label); 3696eda14cbcSMatt Macy 3697eda14cbcSMatt Macy /* 3698eda14cbcSMatt Macy * If we weren't able to find a single valid uberblock, return failure. 3699eda14cbcSMatt Macy */ 3700eda14cbcSMatt Macy if (ub->ub_txg == 0) { 3701eda14cbcSMatt Macy nvlist_free(label); 3702eda14cbcSMatt Macy spa_load_failed(spa, "no valid uberblock found"); 3703eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, ENXIO)); 3704eda14cbcSMatt Macy } 3705eda14cbcSMatt Macy 3706eda14cbcSMatt Macy if (spa->spa_load_max_txg != UINT64_MAX) { 3707eda14cbcSMatt Macy (void) spa_import_progress_set_max_txg(spa_guid(spa), 3708eda14cbcSMatt Macy (u_longlong_t)spa->spa_load_max_txg); 3709eda14cbcSMatt Macy } 3710eda14cbcSMatt Macy spa_load_note(spa, "using uberblock with txg=%llu", 3711eda14cbcSMatt Macy (u_longlong_t)ub->ub_txg); 3712eda14cbcSMatt Macy 3713eda14cbcSMatt Macy 3714eda14cbcSMatt Macy /* 3715eda14cbcSMatt Macy * For pools which have the multihost property on determine if the 3716eda14cbcSMatt Macy * pool is truly inactive and can be safely imported. Prevent 3717eda14cbcSMatt Macy * hosts which don't have a hostid set from importing the pool. 3718eda14cbcSMatt Macy */ 3719eda14cbcSMatt Macy activity_check = spa_activity_check_required(spa, ub, label, 3720eda14cbcSMatt Macy spa->spa_config); 3721eda14cbcSMatt Macy if (activity_check) { 3722eda14cbcSMatt Macy if (ub->ub_mmp_magic == MMP_MAGIC && ub->ub_mmp_delay && 3723eda14cbcSMatt Macy spa_get_hostid(spa) == 0) { 3724eda14cbcSMatt Macy nvlist_free(label); 3725eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 3726eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_STATE, MMP_STATE_NO_HOSTID); 3727eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_ACTIVE, EREMOTEIO)); 3728eda14cbcSMatt Macy } 3729eda14cbcSMatt Macy 3730eda14cbcSMatt Macy int error = spa_activity_check(spa, ub, spa->spa_config); 3731eda14cbcSMatt Macy if (error) { 3732eda14cbcSMatt Macy nvlist_free(label); 3733eda14cbcSMatt Macy return (error); 3734eda14cbcSMatt Macy } 3735eda14cbcSMatt Macy 3736eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 3737eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_STATE, MMP_STATE_INACTIVE); 3738eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 3739eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_TXG, ub->ub_txg); 3740eda14cbcSMatt Macy fnvlist_add_uint16(spa->spa_load_info, 3741eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_SEQ, 3742eda14cbcSMatt Macy (MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0)); 3743eda14cbcSMatt Macy } 3744eda14cbcSMatt Macy 3745eda14cbcSMatt Macy /* 3746eda14cbcSMatt Macy * If the pool has an unsupported version we can't open it. 3747eda14cbcSMatt Macy */ 3748eda14cbcSMatt Macy if (!SPA_VERSION_IS_SUPPORTED(ub->ub_version)) { 3749eda14cbcSMatt Macy nvlist_free(label); 3750eda14cbcSMatt Macy spa_load_failed(spa, "version %llu is not supported", 3751eda14cbcSMatt Macy (u_longlong_t)ub->ub_version); 3752eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_VERSION_NEWER, ENOTSUP)); 3753eda14cbcSMatt Macy } 3754eda14cbcSMatt Macy 3755eda14cbcSMatt Macy if (ub->ub_version >= SPA_VERSION_FEATURES) { 3756eda14cbcSMatt Macy nvlist_t *features; 3757eda14cbcSMatt Macy 3758eda14cbcSMatt Macy /* 3759eda14cbcSMatt Macy * If we weren't able to find what's necessary for reading the 3760eda14cbcSMatt Macy * MOS in the label, return failure. 3761eda14cbcSMatt Macy */ 3762eda14cbcSMatt Macy if (label == NULL) { 3763eda14cbcSMatt Macy spa_load_failed(spa, "label config unavailable"); 3764eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 3765eda14cbcSMatt Macy ENXIO)); 3766eda14cbcSMatt Macy } 3767eda14cbcSMatt Macy 3768eda14cbcSMatt Macy if (nvlist_lookup_nvlist(label, ZPOOL_CONFIG_FEATURES_FOR_READ, 3769eda14cbcSMatt Macy &features) != 0) { 3770eda14cbcSMatt Macy nvlist_free(label); 3771eda14cbcSMatt Macy spa_load_failed(spa, "invalid label: '%s' missing", 3772eda14cbcSMatt Macy ZPOOL_CONFIG_FEATURES_FOR_READ); 3773eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 3774eda14cbcSMatt Macy ENXIO)); 3775eda14cbcSMatt Macy } 3776eda14cbcSMatt Macy 3777eda14cbcSMatt Macy /* 3778eda14cbcSMatt Macy * Update our in-core representation with the definitive values 3779eda14cbcSMatt Macy * from the label. 3780eda14cbcSMatt Macy */ 3781eda14cbcSMatt Macy nvlist_free(spa->spa_label_features); 378281b22a98SMartin Matuska spa->spa_label_features = fnvlist_dup(features); 3783eda14cbcSMatt Macy } 3784eda14cbcSMatt Macy 3785eda14cbcSMatt Macy nvlist_free(label); 3786eda14cbcSMatt Macy 3787eda14cbcSMatt Macy /* 3788eda14cbcSMatt Macy * Look through entries in the label nvlist's features_for_read. If 3789eda14cbcSMatt Macy * there is a feature listed there which we don't understand then we 3790eda14cbcSMatt Macy * cannot open a pool. 3791eda14cbcSMatt Macy */ 3792eda14cbcSMatt Macy if (ub->ub_version >= SPA_VERSION_FEATURES) { 3793eda14cbcSMatt Macy nvlist_t *unsup_feat; 3794eda14cbcSMatt Macy 379581b22a98SMartin Matuska unsup_feat = fnvlist_alloc(); 3796eda14cbcSMatt Macy 3797eda14cbcSMatt Macy for (nvpair_t *nvp = nvlist_next_nvpair(spa->spa_label_features, 3798eda14cbcSMatt Macy NULL); nvp != NULL; 3799eda14cbcSMatt Macy nvp = nvlist_next_nvpair(spa->spa_label_features, nvp)) { 3800eda14cbcSMatt Macy if (!zfeature_is_supported(nvpair_name(nvp))) { 380181b22a98SMartin Matuska fnvlist_add_string(unsup_feat, 380281b22a98SMartin Matuska nvpair_name(nvp), ""); 3803eda14cbcSMatt Macy } 3804eda14cbcSMatt Macy } 3805eda14cbcSMatt Macy 3806eda14cbcSMatt Macy if (!nvlist_empty(unsup_feat)) { 380781b22a98SMartin Matuska fnvlist_add_nvlist(spa->spa_load_info, 380881b22a98SMartin Matuska ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat); 3809eda14cbcSMatt Macy nvlist_free(unsup_feat); 3810eda14cbcSMatt Macy spa_load_failed(spa, "some features are unsupported"); 3811eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT, 3812eda14cbcSMatt Macy ENOTSUP)); 3813eda14cbcSMatt Macy } 3814eda14cbcSMatt Macy 3815eda14cbcSMatt Macy nvlist_free(unsup_feat); 3816eda14cbcSMatt Macy } 3817eda14cbcSMatt Macy 3818eda14cbcSMatt Macy if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) { 3819eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3820eda14cbcSMatt Macy spa_try_repair(spa, spa->spa_config); 3821eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 3822eda14cbcSMatt Macy nvlist_free(spa->spa_config_splitting); 3823eda14cbcSMatt Macy spa->spa_config_splitting = NULL; 3824eda14cbcSMatt Macy } 3825eda14cbcSMatt Macy 3826eda14cbcSMatt Macy /* 3827eda14cbcSMatt Macy * Initialize internal SPA structures. 3828eda14cbcSMatt Macy */ 3829eda14cbcSMatt Macy spa_ld_select_uberblock_done(spa, ub); 3830eda14cbcSMatt Macy 3831eda14cbcSMatt Macy return (0); 3832eda14cbcSMatt Macy } 3833eda14cbcSMatt Macy 3834eda14cbcSMatt Macy static int 3835eda14cbcSMatt Macy spa_ld_open_rootbp(spa_t *spa) 3836eda14cbcSMatt Macy { 3837eda14cbcSMatt Macy int error = 0; 3838eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 3839eda14cbcSMatt Macy 3840eda14cbcSMatt Macy error = dsl_pool_init(spa, spa->spa_first_txg, &spa->spa_dsl_pool); 3841eda14cbcSMatt Macy if (error != 0) { 3842eda14cbcSMatt Macy spa_load_failed(spa, "unable to open rootbp in dsl_pool_init " 3843eda14cbcSMatt Macy "[error=%d]", error); 3844eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 3845eda14cbcSMatt Macy } 3846eda14cbcSMatt Macy spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset; 3847eda14cbcSMatt Macy 3848eda14cbcSMatt Macy return (0); 3849eda14cbcSMatt Macy } 3850eda14cbcSMatt Macy 3851eda14cbcSMatt Macy static int 3852eda14cbcSMatt Macy spa_ld_trusted_config(spa_t *spa, spa_import_type_t type, 3853eda14cbcSMatt Macy boolean_t reloading) 3854eda14cbcSMatt Macy { 3855eda14cbcSMatt Macy vdev_t *mrvd, *rvd = spa->spa_root_vdev; 3856eda14cbcSMatt Macy nvlist_t *nv, *mos_config, *policy; 3857eda14cbcSMatt Macy int error = 0, copy_error; 3858eda14cbcSMatt Macy uint64_t healthy_tvds, healthy_tvds_mos; 3859eda14cbcSMatt Macy uint64_t mos_config_txg; 3860eda14cbcSMatt Macy 3861eda14cbcSMatt Macy if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object, B_TRUE) 3862eda14cbcSMatt Macy != 0) 3863eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 3864eda14cbcSMatt Macy 3865eda14cbcSMatt Macy /* 3866eda14cbcSMatt Macy * If we're assembling a pool from a split, the config provided is 3867eda14cbcSMatt Macy * already trusted so there is nothing to do. 3868eda14cbcSMatt Macy */ 3869eda14cbcSMatt Macy if (type == SPA_IMPORT_ASSEMBLE) 3870eda14cbcSMatt Macy return (0); 3871eda14cbcSMatt Macy 3872eda14cbcSMatt Macy healthy_tvds = spa_healthy_core_tvds(spa); 3873eda14cbcSMatt Macy 3874eda14cbcSMatt Macy if (load_nvlist(spa, spa->spa_config_object, &mos_config) 3875eda14cbcSMatt Macy != 0) { 3876eda14cbcSMatt Macy spa_load_failed(spa, "unable to retrieve MOS config"); 3877eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 3878eda14cbcSMatt Macy } 3879eda14cbcSMatt Macy 3880eda14cbcSMatt Macy /* 3881eda14cbcSMatt Macy * If we are doing an open, pool owner wasn't verified yet, thus do 3882eda14cbcSMatt Macy * the verification here. 3883eda14cbcSMatt Macy */ 3884eda14cbcSMatt Macy if (spa->spa_load_state == SPA_LOAD_OPEN) { 3885eda14cbcSMatt Macy error = spa_verify_host(spa, mos_config); 3886eda14cbcSMatt Macy if (error != 0) { 3887eda14cbcSMatt Macy nvlist_free(mos_config); 3888eda14cbcSMatt Macy return (error); 3889eda14cbcSMatt Macy } 3890eda14cbcSMatt Macy } 3891eda14cbcSMatt Macy 3892eda14cbcSMatt Macy nv = fnvlist_lookup_nvlist(mos_config, ZPOOL_CONFIG_VDEV_TREE); 3893eda14cbcSMatt Macy 3894eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 3895eda14cbcSMatt Macy 3896eda14cbcSMatt Macy /* 3897eda14cbcSMatt Macy * Build a new vdev tree from the trusted config 3898eda14cbcSMatt Macy */ 38997877fdebSMatt Macy error = spa_config_parse(spa, &mrvd, nv, NULL, 0, VDEV_ALLOC_LOAD); 39007877fdebSMatt Macy if (error != 0) { 39017877fdebSMatt Macy nvlist_free(mos_config); 39027877fdebSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 39037877fdebSMatt Macy spa_load_failed(spa, "spa_config_parse failed [error=%d]", 39047877fdebSMatt Macy error); 39057877fdebSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error)); 39067877fdebSMatt Macy } 3907eda14cbcSMatt Macy 3908eda14cbcSMatt Macy /* 3909eda14cbcSMatt Macy * Vdev paths in the MOS may be obsolete. If the untrusted config was 3910eda14cbcSMatt Macy * obtained by scanning /dev/dsk, then it will have the right vdev 3911eda14cbcSMatt Macy * paths. We update the trusted MOS config with this information. 3912eda14cbcSMatt Macy * We first try to copy the paths with vdev_copy_path_strict, which 3913eda14cbcSMatt Macy * succeeds only when both configs have exactly the same vdev tree. 3914eda14cbcSMatt Macy * If that fails, we fall back to a more flexible method that has a 3915eda14cbcSMatt Macy * best effort policy. 3916eda14cbcSMatt Macy */ 3917eda14cbcSMatt Macy copy_error = vdev_copy_path_strict(rvd, mrvd); 3918eda14cbcSMatt Macy if (copy_error != 0 || spa_load_print_vdev_tree) { 3919eda14cbcSMatt Macy spa_load_note(spa, "provided vdev tree:"); 3920eda14cbcSMatt Macy vdev_dbgmsg_print_tree(rvd, 2); 3921eda14cbcSMatt Macy spa_load_note(spa, "MOS vdev tree:"); 3922eda14cbcSMatt Macy vdev_dbgmsg_print_tree(mrvd, 2); 3923eda14cbcSMatt Macy } 3924eda14cbcSMatt Macy if (copy_error != 0) { 3925eda14cbcSMatt Macy spa_load_note(spa, "vdev_copy_path_strict failed, falling " 3926eda14cbcSMatt Macy "back to vdev_copy_path_relaxed"); 3927eda14cbcSMatt Macy vdev_copy_path_relaxed(rvd, mrvd); 3928eda14cbcSMatt Macy } 3929eda14cbcSMatt Macy 3930eda14cbcSMatt Macy vdev_close(rvd); 3931eda14cbcSMatt Macy vdev_free(rvd); 3932eda14cbcSMatt Macy spa->spa_root_vdev = mrvd; 3933eda14cbcSMatt Macy rvd = mrvd; 3934eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 3935eda14cbcSMatt Macy 3936eda14cbcSMatt Macy /* 3937b2526e8bSMartin Matuska * If 'zpool import' used a cached config, then the on-disk hostid and 3938b2526e8bSMartin Matuska * hostname may be different to the cached config in ways that should 3939b2526e8bSMartin Matuska * prevent import. Userspace can't discover this without a scan, but 3940b2526e8bSMartin Matuska * we know, so we add these values to LOAD_INFO so the caller can know 3941b2526e8bSMartin Matuska * the difference. 3942b2526e8bSMartin Matuska * 3943b2526e8bSMartin Matuska * Note that we have to do this before the config is regenerated, 3944b2526e8bSMartin Matuska * because the new config will have the hostid and hostname for this 3945b2526e8bSMartin Matuska * host, in readiness for import. 3946b2526e8bSMartin Matuska */ 3947b2526e8bSMartin Matuska if (nvlist_exists(mos_config, ZPOOL_CONFIG_HOSTID)) 3948b2526e8bSMartin Matuska fnvlist_add_uint64(spa->spa_load_info, ZPOOL_CONFIG_HOSTID, 3949b2526e8bSMartin Matuska fnvlist_lookup_uint64(mos_config, ZPOOL_CONFIG_HOSTID)); 3950b2526e8bSMartin Matuska if (nvlist_exists(mos_config, ZPOOL_CONFIG_HOSTNAME)) 3951b2526e8bSMartin Matuska fnvlist_add_string(spa->spa_load_info, ZPOOL_CONFIG_HOSTNAME, 3952b2526e8bSMartin Matuska fnvlist_lookup_string(mos_config, ZPOOL_CONFIG_HOSTNAME)); 3953b2526e8bSMartin Matuska 3954b2526e8bSMartin Matuska /* 3955eda14cbcSMatt Macy * We will use spa_config if we decide to reload the spa or if spa_load 3956eda14cbcSMatt Macy * fails and we rewind. We must thus regenerate the config using the 3957eda14cbcSMatt Macy * MOS information with the updated paths. ZPOOL_LOAD_POLICY is used to 3958eda14cbcSMatt Macy * pass settings on how to load the pool and is not stored in the MOS. 3959eda14cbcSMatt Macy * We copy it over to our new, trusted config. 3960eda14cbcSMatt Macy */ 3961eda14cbcSMatt Macy mos_config_txg = fnvlist_lookup_uint64(mos_config, 3962eda14cbcSMatt Macy ZPOOL_CONFIG_POOL_TXG); 3963eda14cbcSMatt Macy nvlist_free(mos_config); 3964eda14cbcSMatt Macy mos_config = spa_config_generate(spa, NULL, mos_config_txg, B_FALSE); 3965eda14cbcSMatt Macy if (nvlist_lookup_nvlist(spa->spa_config, ZPOOL_LOAD_POLICY, 3966eda14cbcSMatt Macy &policy) == 0) 3967eda14cbcSMatt Macy fnvlist_add_nvlist(mos_config, ZPOOL_LOAD_POLICY, policy); 3968eda14cbcSMatt Macy spa_config_set(spa, mos_config); 3969eda14cbcSMatt Macy spa->spa_config_source = SPA_CONFIG_SRC_MOS; 3970eda14cbcSMatt Macy 3971eda14cbcSMatt Macy /* 3972eda14cbcSMatt Macy * Now that we got the config from the MOS, we should be more strict 3973eda14cbcSMatt Macy * in checking blkptrs and can make assumptions about the consistency 3974eda14cbcSMatt Macy * of the vdev tree. spa_trust_config must be set to true before opening 3975eda14cbcSMatt Macy * vdevs in order for them to be writeable. 3976eda14cbcSMatt Macy */ 3977eda14cbcSMatt Macy spa->spa_trust_config = B_TRUE; 3978eda14cbcSMatt Macy 3979eda14cbcSMatt Macy /* 3980eda14cbcSMatt Macy * Open and validate the new vdev tree 3981eda14cbcSMatt Macy */ 3982eda14cbcSMatt Macy error = spa_ld_open_vdevs(spa); 3983eda14cbcSMatt Macy if (error != 0) 3984eda14cbcSMatt Macy return (error); 3985eda14cbcSMatt Macy 3986eda14cbcSMatt Macy error = spa_ld_validate_vdevs(spa); 3987eda14cbcSMatt Macy if (error != 0) 3988eda14cbcSMatt Macy return (error); 3989eda14cbcSMatt Macy 3990eda14cbcSMatt Macy if (copy_error != 0 || spa_load_print_vdev_tree) { 3991eda14cbcSMatt Macy spa_load_note(spa, "final vdev tree:"); 3992eda14cbcSMatt Macy vdev_dbgmsg_print_tree(rvd, 2); 3993eda14cbcSMatt Macy } 3994eda14cbcSMatt Macy 3995eda14cbcSMatt Macy if (spa->spa_load_state != SPA_LOAD_TRYIMPORT && 3996eda14cbcSMatt Macy !spa->spa_extreme_rewind && zfs_max_missing_tvds == 0) { 3997eda14cbcSMatt Macy /* 3998eda14cbcSMatt Macy * Sanity check to make sure that we are indeed loading the 3999eda14cbcSMatt Macy * latest uberblock. If we missed SPA_SYNC_MIN_VDEVS tvds 4000eda14cbcSMatt Macy * in the config provided and they happened to be the only ones 4001eda14cbcSMatt Macy * to have the latest uberblock, we could involuntarily perform 4002eda14cbcSMatt Macy * an extreme rewind. 4003eda14cbcSMatt Macy */ 4004eda14cbcSMatt Macy healthy_tvds_mos = spa_healthy_core_tvds(spa); 4005eda14cbcSMatt Macy if (healthy_tvds_mos - healthy_tvds >= 4006eda14cbcSMatt Macy SPA_SYNC_MIN_VDEVS) { 4007eda14cbcSMatt Macy spa_load_note(spa, "config provided misses too many " 4008eda14cbcSMatt Macy "top-level vdevs compared to MOS (%lld vs %lld). ", 4009eda14cbcSMatt Macy (u_longlong_t)healthy_tvds, 4010eda14cbcSMatt Macy (u_longlong_t)healthy_tvds_mos); 4011eda14cbcSMatt Macy spa_load_note(spa, "vdev tree:"); 4012eda14cbcSMatt Macy vdev_dbgmsg_print_tree(rvd, 2); 4013eda14cbcSMatt Macy if (reloading) { 4014eda14cbcSMatt Macy spa_load_failed(spa, "config was already " 4015eda14cbcSMatt Macy "provided from MOS. Aborting."); 4016eda14cbcSMatt Macy return (spa_vdev_err(rvd, 4017eda14cbcSMatt Macy VDEV_AUX_CORRUPT_DATA, EIO)); 4018eda14cbcSMatt Macy } 4019eda14cbcSMatt Macy spa_load_note(spa, "spa must be reloaded using MOS " 4020eda14cbcSMatt Macy "config"); 4021eda14cbcSMatt Macy return (SET_ERROR(EAGAIN)); 4022eda14cbcSMatt Macy } 4023eda14cbcSMatt Macy } 4024eda14cbcSMatt Macy 4025eda14cbcSMatt Macy error = spa_check_for_missing_logs(spa); 4026eda14cbcSMatt Macy if (error != 0) 4027eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, ENXIO)); 4028eda14cbcSMatt Macy 4029eda14cbcSMatt Macy if (rvd->vdev_guid_sum != spa->spa_uberblock.ub_guid_sum) { 4030eda14cbcSMatt Macy spa_load_failed(spa, "uberblock guid sum doesn't match MOS " 4031eda14cbcSMatt Macy "guid sum (%llu != %llu)", 4032eda14cbcSMatt Macy (u_longlong_t)spa->spa_uberblock.ub_guid_sum, 4033eda14cbcSMatt Macy (u_longlong_t)rvd->vdev_guid_sum); 4034eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, 4035eda14cbcSMatt Macy ENXIO)); 4036eda14cbcSMatt Macy } 4037eda14cbcSMatt Macy 4038eda14cbcSMatt Macy return (0); 4039eda14cbcSMatt Macy } 4040eda14cbcSMatt Macy 4041eda14cbcSMatt Macy static int 4042eda14cbcSMatt Macy spa_ld_open_indirect_vdev_metadata(spa_t *spa) 4043eda14cbcSMatt Macy { 4044eda14cbcSMatt Macy int error = 0; 4045eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4046eda14cbcSMatt Macy 4047eda14cbcSMatt Macy /* 4048eda14cbcSMatt Macy * Everything that we read before spa_remove_init() must be stored 4049eda14cbcSMatt Macy * on concreted vdevs. Therefore we do this as early as possible. 4050eda14cbcSMatt Macy */ 4051eda14cbcSMatt Macy error = spa_remove_init(spa); 4052eda14cbcSMatt Macy if (error != 0) { 4053eda14cbcSMatt Macy spa_load_failed(spa, "spa_remove_init failed [error=%d]", 4054eda14cbcSMatt Macy error); 4055eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4056eda14cbcSMatt Macy } 4057eda14cbcSMatt Macy 4058eda14cbcSMatt Macy /* 4059eda14cbcSMatt Macy * Retrieve information needed to condense indirect vdev mappings. 4060eda14cbcSMatt Macy */ 4061eda14cbcSMatt Macy error = spa_condense_init(spa); 4062eda14cbcSMatt Macy if (error != 0) { 4063eda14cbcSMatt Macy spa_load_failed(spa, "spa_condense_init failed [error=%d]", 4064eda14cbcSMatt Macy error); 4065eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error)); 4066eda14cbcSMatt Macy } 4067eda14cbcSMatt Macy 4068eda14cbcSMatt Macy return (0); 4069eda14cbcSMatt Macy } 4070eda14cbcSMatt Macy 4071eda14cbcSMatt Macy static int 4072eda14cbcSMatt Macy spa_ld_check_features(spa_t *spa, boolean_t *missing_feat_writep) 4073eda14cbcSMatt Macy { 4074eda14cbcSMatt Macy int error = 0; 4075eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4076eda14cbcSMatt Macy 4077eda14cbcSMatt Macy if (spa_version(spa) >= SPA_VERSION_FEATURES) { 4078eda14cbcSMatt Macy boolean_t missing_feat_read = B_FALSE; 4079eda14cbcSMatt Macy nvlist_t *unsup_feat, *enabled_feat; 4080eda14cbcSMatt Macy 4081eda14cbcSMatt Macy if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_READ, 4082eda14cbcSMatt Macy &spa->spa_feat_for_read_obj, B_TRUE) != 0) { 4083eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4084eda14cbcSMatt Macy } 4085eda14cbcSMatt Macy 4086eda14cbcSMatt Macy if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_WRITE, 4087eda14cbcSMatt Macy &spa->spa_feat_for_write_obj, B_TRUE) != 0) { 4088eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4089eda14cbcSMatt Macy } 4090eda14cbcSMatt Macy 4091eda14cbcSMatt Macy if (spa_dir_prop(spa, DMU_POOL_FEATURE_DESCRIPTIONS, 4092eda14cbcSMatt Macy &spa->spa_feat_desc_obj, B_TRUE) != 0) { 4093eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4094eda14cbcSMatt Macy } 4095eda14cbcSMatt Macy 4096eda14cbcSMatt Macy enabled_feat = fnvlist_alloc(); 4097eda14cbcSMatt Macy unsup_feat = fnvlist_alloc(); 4098eda14cbcSMatt Macy 4099eda14cbcSMatt Macy if (!spa_features_check(spa, B_FALSE, 4100eda14cbcSMatt Macy unsup_feat, enabled_feat)) 4101eda14cbcSMatt Macy missing_feat_read = B_TRUE; 4102eda14cbcSMatt Macy 4103eda14cbcSMatt Macy if (spa_writeable(spa) || 4104eda14cbcSMatt Macy spa->spa_load_state == SPA_LOAD_TRYIMPORT) { 4105eda14cbcSMatt Macy if (!spa_features_check(spa, B_TRUE, 4106eda14cbcSMatt Macy unsup_feat, enabled_feat)) { 4107eda14cbcSMatt Macy *missing_feat_writep = B_TRUE; 4108eda14cbcSMatt Macy } 4109eda14cbcSMatt Macy } 4110eda14cbcSMatt Macy 4111eda14cbcSMatt Macy fnvlist_add_nvlist(spa->spa_load_info, 4112eda14cbcSMatt Macy ZPOOL_CONFIG_ENABLED_FEAT, enabled_feat); 4113eda14cbcSMatt Macy 4114eda14cbcSMatt Macy if (!nvlist_empty(unsup_feat)) { 4115eda14cbcSMatt Macy fnvlist_add_nvlist(spa->spa_load_info, 4116eda14cbcSMatt Macy ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat); 4117eda14cbcSMatt Macy } 4118eda14cbcSMatt Macy 4119eda14cbcSMatt Macy fnvlist_free(enabled_feat); 4120eda14cbcSMatt Macy fnvlist_free(unsup_feat); 4121eda14cbcSMatt Macy 4122eda14cbcSMatt Macy if (!missing_feat_read) { 4123eda14cbcSMatt Macy fnvlist_add_boolean(spa->spa_load_info, 4124eda14cbcSMatt Macy ZPOOL_CONFIG_CAN_RDONLY); 4125eda14cbcSMatt Macy } 4126eda14cbcSMatt Macy 4127eda14cbcSMatt Macy /* 4128eda14cbcSMatt Macy * If the state is SPA_LOAD_TRYIMPORT, our objective is 4129eda14cbcSMatt Macy * twofold: to determine whether the pool is available for 4130eda14cbcSMatt Macy * import in read-write mode and (if it is not) whether the 4131eda14cbcSMatt Macy * pool is available for import in read-only mode. If the pool 4132eda14cbcSMatt Macy * is available for import in read-write mode, it is displayed 4133eda14cbcSMatt Macy * as available in userland; if it is not available for import 4134eda14cbcSMatt Macy * in read-only mode, it is displayed as unavailable in 4135eda14cbcSMatt Macy * userland. If the pool is available for import in read-only 4136eda14cbcSMatt Macy * mode but not read-write mode, it is displayed as unavailable 4137eda14cbcSMatt Macy * in userland with a special note that the pool is actually 4138eda14cbcSMatt Macy * available for open in read-only mode. 4139eda14cbcSMatt Macy * 4140eda14cbcSMatt Macy * As a result, if the state is SPA_LOAD_TRYIMPORT and we are 4141eda14cbcSMatt Macy * missing a feature for write, we must first determine whether 4142eda14cbcSMatt Macy * the pool can be opened read-only before returning to 4143eda14cbcSMatt Macy * userland in order to know whether to display the 4144eda14cbcSMatt Macy * abovementioned note. 4145eda14cbcSMatt Macy */ 4146eda14cbcSMatt Macy if (missing_feat_read || (*missing_feat_writep && 4147eda14cbcSMatt Macy spa_writeable(spa))) { 4148eda14cbcSMatt Macy spa_load_failed(spa, "pool uses unsupported features"); 4149eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT, 4150eda14cbcSMatt Macy ENOTSUP)); 4151eda14cbcSMatt Macy } 4152eda14cbcSMatt Macy 4153eda14cbcSMatt Macy /* 4154eda14cbcSMatt Macy * Load refcounts for ZFS features from disk into an in-memory 4155eda14cbcSMatt Macy * cache during SPA initialization. 4156eda14cbcSMatt Macy */ 4157eda14cbcSMatt Macy for (spa_feature_t i = 0; i < SPA_FEATURES; i++) { 4158eda14cbcSMatt Macy uint64_t refcount; 4159eda14cbcSMatt Macy 4160eda14cbcSMatt Macy error = feature_get_refcount_from_disk(spa, 4161eda14cbcSMatt Macy &spa_feature_table[i], &refcount); 4162eda14cbcSMatt Macy if (error == 0) { 4163eda14cbcSMatt Macy spa->spa_feat_refcount_cache[i] = refcount; 4164eda14cbcSMatt Macy } else if (error == ENOTSUP) { 4165eda14cbcSMatt Macy spa->spa_feat_refcount_cache[i] = 4166eda14cbcSMatt Macy SPA_FEATURE_DISABLED; 4167eda14cbcSMatt Macy } else { 4168eda14cbcSMatt Macy spa_load_failed(spa, "error getting refcount " 4169eda14cbcSMatt Macy "for feature %s [error=%d]", 4170eda14cbcSMatt Macy spa_feature_table[i].fi_guid, error); 4171eda14cbcSMatt Macy return (spa_vdev_err(rvd, 4172eda14cbcSMatt Macy VDEV_AUX_CORRUPT_DATA, EIO)); 4173eda14cbcSMatt Macy } 4174eda14cbcSMatt Macy } 4175eda14cbcSMatt Macy } 4176eda14cbcSMatt Macy 4177eda14cbcSMatt Macy if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) { 4178eda14cbcSMatt Macy if (spa_dir_prop(spa, DMU_POOL_FEATURE_ENABLED_TXG, 4179eda14cbcSMatt Macy &spa->spa_feat_enabled_txg_obj, B_TRUE) != 0) 4180eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4181eda14cbcSMatt Macy } 4182eda14cbcSMatt Macy 4183eda14cbcSMatt Macy /* 4184eda14cbcSMatt Macy * Encryption was added before bookmark_v2, even though bookmark_v2 4185eda14cbcSMatt Macy * is now a dependency. If this pool has encryption enabled without 4186eda14cbcSMatt Macy * bookmark_v2, trigger an errata message. 4187eda14cbcSMatt Macy */ 4188eda14cbcSMatt Macy if (spa_feature_is_enabled(spa, SPA_FEATURE_ENCRYPTION) && 4189eda14cbcSMatt Macy !spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_V2)) { 4190eda14cbcSMatt Macy spa->spa_errata = ZPOOL_ERRATA_ZOL_8308_ENCRYPTION; 4191eda14cbcSMatt Macy } 4192eda14cbcSMatt Macy 4193eda14cbcSMatt Macy return (0); 4194eda14cbcSMatt Macy } 4195eda14cbcSMatt Macy 4196eda14cbcSMatt Macy static int 4197eda14cbcSMatt Macy spa_ld_load_special_directories(spa_t *spa) 4198eda14cbcSMatt Macy { 4199eda14cbcSMatt Macy int error = 0; 4200eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4201eda14cbcSMatt Macy 4202eda14cbcSMatt Macy spa->spa_is_initializing = B_TRUE; 4203eda14cbcSMatt Macy error = dsl_pool_open(spa->spa_dsl_pool); 4204eda14cbcSMatt Macy spa->spa_is_initializing = B_FALSE; 4205eda14cbcSMatt Macy if (error != 0) { 4206eda14cbcSMatt Macy spa_load_failed(spa, "dsl_pool_open failed [error=%d]", error); 4207eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4208eda14cbcSMatt Macy } 4209eda14cbcSMatt Macy 4210eda14cbcSMatt Macy return (0); 4211eda14cbcSMatt Macy } 4212eda14cbcSMatt Macy 4213eda14cbcSMatt Macy static int 4214eda14cbcSMatt Macy spa_ld_get_props(spa_t *spa) 4215eda14cbcSMatt Macy { 4216eda14cbcSMatt Macy int error = 0; 4217eda14cbcSMatt Macy uint64_t obj; 4218eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4219eda14cbcSMatt Macy 4220eda14cbcSMatt Macy /* Grab the checksum salt from the MOS. */ 4221eda14cbcSMatt Macy error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 4222eda14cbcSMatt Macy DMU_POOL_CHECKSUM_SALT, 1, 4223eda14cbcSMatt Macy sizeof (spa->spa_cksum_salt.zcs_bytes), 4224eda14cbcSMatt Macy spa->spa_cksum_salt.zcs_bytes); 4225eda14cbcSMatt Macy if (error == ENOENT) { 4226eda14cbcSMatt Macy /* Generate a new salt for subsequent use */ 4227eda14cbcSMatt Macy (void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes, 4228eda14cbcSMatt Macy sizeof (spa->spa_cksum_salt.zcs_bytes)); 4229eda14cbcSMatt Macy } else if (error != 0) { 4230eda14cbcSMatt Macy spa_load_failed(spa, "unable to retrieve checksum salt from " 4231eda14cbcSMatt Macy "MOS [error=%d]", error); 4232eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4233eda14cbcSMatt Macy } 4234eda14cbcSMatt Macy 4235eda14cbcSMatt Macy if (spa_dir_prop(spa, DMU_POOL_SYNC_BPOBJ, &obj, B_TRUE) != 0) 4236eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4237eda14cbcSMatt Macy error = bpobj_open(&spa->spa_deferred_bpobj, spa->spa_meta_objset, obj); 4238eda14cbcSMatt Macy if (error != 0) { 4239eda14cbcSMatt Macy spa_load_failed(spa, "error opening deferred-frees bpobj " 4240eda14cbcSMatt Macy "[error=%d]", error); 4241eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4242eda14cbcSMatt Macy } 4243eda14cbcSMatt Macy 4244eda14cbcSMatt Macy /* 4245eda14cbcSMatt Macy * Load the bit that tells us to use the new accounting function 4246eda14cbcSMatt Macy * (raid-z deflation). If we have an older pool, this will not 4247eda14cbcSMatt Macy * be present. 4248eda14cbcSMatt Macy */ 4249eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate, B_FALSE); 4250eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4251eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4252eda14cbcSMatt Macy 4253eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_CREATION_VERSION, 4254eda14cbcSMatt Macy &spa->spa_creation_version, B_FALSE); 4255eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4256eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4257eda14cbcSMatt Macy 4258eda14cbcSMatt Macy /* 4259eda14cbcSMatt Macy * Load the persistent error log. If we have an older pool, this will 4260eda14cbcSMatt Macy * not be present. 4261eda14cbcSMatt Macy */ 4262eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last, 4263eda14cbcSMatt Macy B_FALSE); 4264eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4265eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4266eda14cbcSMatt Macy 4267eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB, 4268eda14cbcSMatt Macy &spa->spa_errlog_scrub, B_FALSE); 4269eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4270eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4271eda14cbcSMatt Macy 4272eda14cbcSMatt Macy /* 4273eda14cbcSMatt Macy * Load the livelist deletion field. If a livelist is queued for 4274eda14cbcSMatt Macy * deletion, indicate that in the spa 4275eda14cbcSMatt Macy */ 4276eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_DELETED_CLONES, 4277eda14cbcSMatt Macy &spa->spa_livelists_to_delete, B_FALSE); 4278eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4279eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4280eda14cbcSMatt Macy 4281eda14cbcSMatt Macy /* 4282eda14cbcSMatt Macy * Load the history object. If we have an older pool, this 4283eda14cbcSMatt Macy * will not be present. 4284eda14cbcSMatt Macy */ 4285eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history, B_FALSE); 4286eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4287eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4288eda14cbcSMatt Macy 4289eda14cbcSMatt Macy /* 4290eda14cbcSMatt Macy * Load the per-vdev ZAP map. If we have an older pool, this will not 4291eda14cbcSMatt Macy * be present; in this case, defer its creation to a later time to 4292eda14cbcSMatt Macy * avoid dirtying the MOS this early / out of sync context. See 4293eda14cbcSMatt Macy * spa_sync_config_object. 4294eda14cbcSMatt Macy */ 4295eda14cbcSMatt Macy 4296eda14cbcSMatt Macy /* The sentinel is only available in the MOS config. */ 4297eda14cbcSMatt Macy nvlist_t *mos_config; 4298eda14cbcSMatt Macy if (load_nvlist(spa, spa->spa_config_object, &mos_config) != 0) { 4299eda14cbcSMatt Macy spa_load_failed(spa, "unable to retrieve MOS config"); 4300eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4301eda14cbcSMatt Macy } 4302eda14cbcSMatt Macy 4303eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_VDEV_ZAP_MAP, 4304eda14cbcSMatt Macy &spa->spa_all_vdev_zaps, B_FALSE); 4305eda14cbcSMatt Macy 4306eda14cbcSMatt Macy if (error == ENOENT) { 4307eda14cbcSMatt Macy VERIFY(!nvlist_exists(mos_config, 4308eda14cbcSMatt Macy ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS)); 4309eda14cbcSMatt Macy spa->spa_avz_action = AVZ_ACTION_INITIALIZE; 4310eda14cbcSMatt Macy ASSERT0(vdev_count_verify_zaps(spa->spa_root_vdev)); 4311eda14cbcSMatt Macy } else if (error != 0) { 4312a0b956f5SMartin Matuska nvlist_free(mos_config); 4313eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4314eda14cbcSMatt Macy } else if (!nvlist_exists(mos_config, ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS)) { 4315eda14cbcSMatt Macy /* 4316eda14cbcSMatt Macy * An older version of ZFS overwrote the sentinel value, so 4317eda14cbcSMatt Macy * we have orphaned per-vdev ZAPs in the MOS. Defer their 4318eda14cbcSMatt Macy * destruction to later; see spa_sync_config_object. 4319eda14cbcSMatt Macy */ 4320eda14cbcSMatt Macy spa->spa_avz_action = AVZ_ACTION_DESTROY; 4321eda14cbcSMatt Macy /* 4322eda14cbcSMatt Macy * We're assuming that no vdevs have had their ZAPs created 4323eda14cbcSMatt Macy * before this. Better be sure of it. 4324eda14cbcSMatt Macy */ 4325eda14cbcSMatt Macy ASSERT0(vdev_count_verify_zaps(spa->spa_root_vdev)); 4326eda14cbcSMatt Macy } 4327eda14cbcSMatt Macy nvlist_free(mos_config); 4328eda14cbcSMatt Macy 4329eda14cbcSMatt Macy spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 4330eda14cbcSMatt Macy 4331eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object, 4332eda14cbcSMatt Macy B_FALSE); 4333eda14cbcSMatt Macy if (error && error != ENOENT) 4334eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4335eda14cbcSMatt Macy 4336eda14cbcSMatt Macy if (error == 0) { 43371f88aa09SMartin Matuska uint64_t autoreplace = 0; 4338eda14cbcSMatt Macy 4339eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs); 4340eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace); 4341eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation); 4342eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode); 4343eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand); 4344eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_MULTIHOST, &spa->spa_multihost); 4345eda14cbcSMatt Macy spa_prop_find(spa, ZPOOL_PROP_AUTOTRIM, &spa->spa_autotrim); 4346eda14cbcSMatt Macy spa->spa_autoreplace = (autoreplace != 0); 4347eda14cbcSMatt Macy } 4348eda14cbcSMatt Macy 4349eda14cbcSMatt Macy /* 4350eda14cbcSMatt Macy * If we are importing a pool with missing top-level vdevs, 4351eda14cbcSMatt Macy * we enforce that the pool doesn't panic or get suspended on 4352eda14cbcSMatt Macy * error since the likelihood of missing data is extremely high. 4353eda14cbcSMatt Macy */ 4354eda14cbcSMatt Macy if (spa->spa_missing_tvds > 0 && 4355eda14cbcSMatt Macy spa->spa_failmode != ZIO_FAILURE_MODE_CONTINUE && 4356eda14cbcSMatt Macy spa->spa_load_state != SPA_LOAD_TRYIMPORT) { 4357eda14cbcSMatt Macy spa_load_note(spa, "forcing failmode to 'continue' " 4358eda14cbcSMatt Macy "as some top level vdevs are missing"); 4359eda14cbcSMatt Macy spa->spa_failmode = ZIO_FAILURE_MODE_CONTINUE; 4360eda14cbcSMatt Macy } 4361eda14cbcSMatt Macy 4362eda14cbcSMatt Macy return (0); 4363eda14cbcSMatt Macy } 4364eda14cbcSMatt Macy 4365eda14cbcSMatt Macy static int 4366eda14cbcSMatt Macy spa_ld_open_aux_vdevs(spa_t *spa, spa_import_type_t type) 4367eda14cbcSMatt Macy { 4368eda14cbcSMatt Macy int error = 0; 4369eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4370eda14cbcSMatt Macy 4371eda14cbcSMatt Macy /* 4372eda14cbcSMatt Macy * If we're assembling the pool from the split-off vdevs of 4373eda14cbcSMatt Macy * an existing pool, we don't want to attach the spares & cache 4374eda14cbcSMatt Macy * devices. 4375eda14cbcSMatt Macy */ 4376eda14cbcSMatt Macy 4377eda14cbcSMatt Macy /* 4378eda14cbcSMatt Macy * Load any hot spares for this pool. 4379eda14cbcSMatt Macy */ 4380eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object, 4381eda14cbcSMatt Macy B_FALSE); 4382eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4383eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4384eda14cbcSMatt Macy if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 4385eda14cbcSMatt Macy ASSERT(spa_version(spa) >= SPA_VERSION_SPARES); 4386eda14cbcSMatt Macy if (load_nvlist(spa, spa->spa_spares.sav_object, 4387eda14cbcSMatt Macy &spa->spa_spares.sav_config) != 0) { 4388eda14cbcSMatt Macy spa_load_failed(spa, "error loading spares nvlist"); 4389eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4390eda14cbcSMatt Macy } 4391eda14cbcSMatt Macy 4392eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4393eda14cbcSMatt Macy spa_load_spares(spa); 4394eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 4395eda14cbcSMatt Macy } else if (error == 0) { 4396eda14cbcSMatt Macy spa->spa_spares.sav_sync = B_TRUE; 4397eda14cbcSMatt Macy } 4398eda14cbcSMatt Macy 4399eda14cbcSMatt Macy /* 4400eda14cbcSMatt Macy * Load any level 2 ARC devices for this pool. 4401eda14cbcSMatt Macy */ 4402eda14cbcSMatt Macy error = spa_dir_prop(spa, DMU_POOL_L2CACHE, 4403eda14cbcSMatt Macy &spa->spa_l2cache.sav_object, B_FALSE); 4404eda14cbcSMatt Macy if (error != 0 && error != ENOENT) 4405eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4406eda14cbcSMatt Macy if (error == 0 && type != SPA_IMPORT_ASSEMBLE) { 4407eda14cbcSMatt Macy ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE); 4408eda14cbcSMatt Macy if (load_nvlist(spa, spa->spa_l2cache.sav_object, 4409eda14cbcSMatt Macy &spa->spa_l2cache.sav_config) != 0) { 4410eda14cbcSMatt Macy spa_load_failed(spa, "error loading l2cache nvlist"); 4411eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4412eda14cbcSMatt Macy } 4413eda14cbcSMatt Macy 4414eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4415eda14cbcSMatt Macy spa_load_l2cache(spa); 4416eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 4417eda14cbcSMatt Macy } else if (error == 0) { 4418eda14cbcSMatt Macy spa->spa_l2cache.sav_sync = B_TRUE; 4419eda14cbcSMatt Macy } 4420eda14cbcSMatt Macy 4421eda14cbcSMatt Macy return (0); 4422eda14cbcSMatt Macy } 4423eda14cbcSMatt Macy 4424eda14cbcSMatt Macy static int 4425eda14cbcSMatt Macy spa_ld_load_vdev_metadata(spa_t *spa) 4426eda14cbcSMatt Macy { 4427eda14cbcSMatt Macy int error = 0; 4428eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4429eda14cbcSMatt Macy 4430eda14cbcSMatt Macy /* 4431eda14cbcSMatt Macy * If the 'multihost' property is set, then never allow a pool to 4432eda14cbcSMatt Macy * be imported when the system hostid is zero. The exception to 4433eda14cbcSMatt Macy * this rule is zdb which is always allowed to access pools. 4434eda14cbcSMatt Macy */ 4435eda14cbcSMatt Macy if (spa_multihost(spa) && spa_get_hostid(spa) == 0 && 4436eda14cbcSMatt Macy (spa->spa_import_flags & ZFS_IMPORT_SKIP_MMP) == 0) { 4437eda14cbcSMatt Macy fnvlist_add_uint64(spa->spa_load_info, 4438eda14cbcSMatt Macy ZPOOL_CONFIG_MMP_STATE, MMP_STATE_NO_HOSTID); 4439eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_ACTIVE, EREMOTEIO)); 4440eda14cbcSMatt Macy } 4441eda14cbcSMatt Macy 4442eda14cbcSMatt Macy /* 4443eda14cbcSMatt Macy * If the 'autoreplace' property is set, then post a resource notifying 4444eda14cbcSMatt Macy * the ZFS DE that it should not issue any faults for unopenable 4445eda14cbcSMatt Macy * devices. We also iterate over the vdevs, and post a sysevent for any 4446eda14cbcSMatt Macy * unopenable vdevs so that the normal autoreplace handler can take 4447eda14cbcSMatt Macy * over. 4448eda14cbcSMatt Macy */ 4449eda14cbcSMatt Macy if (spa->spa_autoreplace && spa->spa_load_state != SPA_LOAD_TRYIMPORT) { 4450eda14cbcSMatt Macy spa_check_removed(spa->spa_root_vdev); 4451eda14cbcSMatt Macy /* 4452eda14cbcSMatt Macy * For the import case, this is done in spa_import(), because 4453eda14cbcSMatt Macy * at this point we're using the spare definitions from 4454eda14cbcSMatt Macy * the MOS config, not necessarily from the userland config. 4455eda14cbcSMatt Macy */ 4456eda14cbcSMatt Macy if (spa->spa_load_state != SPA_LOAD_IMPORT) { 4457eda14cbcSMatt Macy spa_aux_check_removed(&spa->spa_spares); 4458eda14cbcSMatt Macy spa_aux_check_removed(&spa->spa_l2cache); 4459eda14cbcSMatt Macy } 4460eda14cbcSMatt Macy } 4461eda14cbcSMatt Macy 4462eda14cbcSMatt Macy /* 4463eda14cbcSMatt Macy * Load the vdev metadata such as metaslabs, DTLs, spacemap object, etc. 4464eda14cbcSMatt Macy */ 4465eda14cbcSMatt Macy error = vdev_load(rvd); 4466eda14cbcSMatt Macy if (error != 0) { 4467eda14cbcSMatt Macy spa_load_failed(spa, "vdev_load failed [error=%d]", error); 4468eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error)); 4469eda14cbcSMatt Macy } 4470eda14cbcSMatt Macy 4471eda14cbcSMatt Macy error = spa_ld_log_spacemaps(spa); 4472eda14cbcSMatt Macy if (error != 0) { 4473716fd348SMartin Matuska spa_load_failed(spa, "spa_ld_log_spacemaps failed [error=%d]", 4474eda14cbcSMatt Macy error); 4475eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error)); 4476eda14cbcSMatt Macy } 4477eda14cbcSMatt Macy 4478eda14cbcSMatt Macy /* 4479eda14cbcSMatt Macy * Propagate the leaf DTLs we just loaded all the way up the vdev tree. 4480eda14cbcSMatt Macy */ 4481eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4482eda14cbcSMatt Macy vdev_dtl_reassess(rvd, 0, 0, B_FALSE, B_FALSE); 4483eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 4484eda14cbcSMatt Macy 4485eda14cbcSMatt Macy return (0); 4486eda14cbcSMatt Macy } 4487eda14cbcSMatt Macy 4488eda14cbcSMatt Macy static int 4489eda14cbcSMatt Macy spa_ld_load_dedup_tables(spa_t *spa) 4490eda14cbcSMatt Macy { 4491eda14cbcSMatt Macy int error = 0; 4492eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4493eda14cbcSMatt Macy 4494eda14cbcSMatt Macy error = ddt_load(spa); 4495eda14cbcSMatt Macy if (error != 0) { 4496eda14cbcSMatt Macy spa_load_failed(spa, "ddt_load failed [error=%d]", error); 4497eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 4498eda14cbcSMatt Macy } 4499eda14cbcSMatt Macy 4500eda14cbcSMatt Macy return (0); 4501eda14cbcSMatt Macy } 4502eda14cbcSMatt Macy 4503eda14cbcSMatt Macy static int 45042a58b312SMartin Matuska spa_ld_load_brt(spa_t *spa) 45052a58b312SMartin Matuska { 45062a58b312SMartin Matuska int error = 0; 45072a58b312SMartin Matuska vdev_t *rvd = spa->spa_root_vdev; 45082a58b312SMartin Matuska 45092a58b312SMartin Matuska error = brt_load(spa); 45102a58b312SMartin Matuska if (error != 0) { 45112a58b312SMartin Matuska spa_load_failed(spa, "brt_load failed [error=%d]", error); 45122a58b312SMartin Matuska return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO)); 45132a58b312SMartin Matuska } 45142a58b312SMartin Matuska 45152a58b312SMartin Matuska return (0); 45162a58b312SMartin Matuska } 45172a58b312SMartin Matuska 45182a58b312SMartin Matuska static int 4519a0b956f5SMartin Matuska spa_ld_verify_logs(spa_t *spa, spa_import_type_t type, const char **ereport) 4520eda14cbcSMatt Macy { 4521eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4522eda14cbcSMatt Macy 4523eda14cbcSMatt Macy if (type != SPA_IMPORT_ASSEMBLE && spa_writeable(spa)) { 4524eda14cbcSMatt Macy boolean_t missing = spa_check_logs(spa); 4525eda14cbcSMatt Macy if (missing) { 4526eda14cbcSMatt Macy if (spa->spa_missing_tvds != 0) { 4527eda14cbcSMatt Macy spa_load_note(spa, "spa_check_logs failed " 4528eda14cbcSMatt Macy "so dropping the logs"); 4529eda14cbcSMatt Macy } else { 4530eda14cbcSMatt Macy *ereport = FM_EREPORT_ZFS_LOG_REPLAY; 4531eda14cbcSMatt Macy spa_load_failed(spa, "spa_check_logs failed"); 4532eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_BAD_LOG, 4533eda14cbcSMatt Macy ENXIO)); 4534eda14cbcSMatt Macy } 4535eda14cbcSMatt Macy } 4536eda14cbcSMatt Macy } 4537eda14cbcSMatt Macy 4538eda14cbcSMatt Macy return (0); 4539eda14cbcSMatt Macy } 4540eda14cbcSMatt Macy 4541eda14cbcSMatt Macy static int 4542eda14cbcSMatt Macy spa_ld_verify_pool_data(spa_t *spa) 4543eda14cbcSMatt Macy { 4544eda14cbcSMatt Macy int error = 0; 4545eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4546eda14cbcSMatt Macy 4547eda14cbcSMatt Macy /* 4548eda14cbcSMatt Macy * We've successfully opened the pool, verify that we're ready 4549eda14cbcSMatt Macy * to start pushing transactions. 4550eda14cbcSMatt Macy */ 4551eda14cbcSMatt Macy if (spa->spa_load_state != SPA_LOAD_TRYIMPORT) { 4552eda14cbcSMatt Macy error = spa_load_verify(spa); 4553eda14cbcSMatt Macy if (error != 0) { 4554eda14cbcSMatt Macy spa_load_failed(spa, "spa_load_verify failed " 4555eda14cbcSMatt Macy "[error=%d]", error); 4556eda14cbcSMatt Macy return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, 4557eda14cbcSMatt Macy error)); 4558eda14cbcSMatt Macy } 4559eda14cbcSMatt Macy } 4560eda14cbcSMatt Macy 4561eda14cbcSMatt Macy return (0); 4562eda14cbcSMatt Macy } 4563eda14cbcSMatt Macy 4564eda14cbcSMatt Macy static void 4565eda14cbcSMatt Macy spa_ld_claim_log_blocks(spa_t *spa) 4566eda14cbcSMatt Macy { 4567eda14cbcSMatt Macy dmu_tx_t *tx; 4568eda14cbcSMatt Macy dsl_pool_t *dp = spa_get_dsl(spa); 4569eda14cbcSMatt Macy 4570eda14cbcSMatt Macy /* 4571eda14cbcSMatt Macy * Claim log blocks that haven't been committed yet. 4572eda14cbcSMatt Macy * This must all happen in a single txg. 4573eda14cbcSMatt Macy * Note: spa_claim_max_txg is updated by spa_claim_notify(), 4574eda14cbcSMatt Macy * invoked from zil_claim_log_block()'s i/o done callback. 4575eda14cbcSMatt Macy * Price of rollback is that we abandon the log. 4576eda14cbcSMatt Macy */ 4577eda14cbcSMatt Macy spa->spa_claiming = B_TRUE; 4578eda14cbcSMatt Macy 4579eda14cbcSMatt Macy tx = dmu_tx_create_assigned(dp, spa_first_txg(spa)); 4580eda14cbcSMatt Macy (void) dmu_objset_find_dp(dp, dp->dp_root_dir_obj, 4581eda14cbcSMatt Macy zil_claim, tx, DS_FIND_CHILDREN); 4582eda14cbcSMatt Macy dmu_tx_commit(tx); 4583eda14cbcSMatt Macy 4584eda14cbcSMatt Macy spa->spa_claiming = B_FALSE; 4585eda14cbcSMatt Macy 4586eda14cbcSMatt Macy spa_set_log_state(spa, SPA_LOG_GOOD); 4587eda14cbcSMatt Macy } 4588eda14cbcSMatt Macy 4589eda14cbcSMatt Macy static void 4590eda14cbcSMatt Macy spa_ld_check_for_config_update(spa_t *spa, uint64_t config_cache_txg, 4591eda14cbcSMatt Macy boolean_t update_config_cache) 4592eda14cbcSMatt Macy { 4593eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4594eda14cbcSMatt Macy int need_update = B_FALSE; 4595eda14cbcSMatt Macy 4596eda14cbcSMatt Macy /* 4597eda14cbcSMatt Macy * If the config cache is stale, or we have uninitialized 4598eda14cbcSMatt Macy * metaslabs (see spa_vdev_add()), then update the config. 4599eda14cbcSMatt Macy * 4600eda14cbcSMatt Macy * If this is a verbatim import, trust the current 4601eda14cbcSMatt Macy * in-core spa_config and update the disk labels. 4602eda14cbcSMatt Macy */ 4603eda14cbcSMatt Macy if (update_config_cache || config_cache_txg != spa->spa_config_txg || 4604eda14cbcSMatt Macy spa->spa_load_state == SPA_LOAD_IMPORT || 4605eda14cbcSMatt Macy spa->spa_load_state == SPA_LOAD_RECOVER || 4606eda14cbcSMatt Macy (spa->spa_import_flags & ZFS_IMPORT_VERBATIM)) 4607eda14cbcSMatt Macy need_update = B_TRUE; 4608eda14cbcSMatt Macy 4609eda14cbcSMatt Macy for (int c = 0; c < rvd->vdev_children; c++) 4610eda14cbcSMatt Macy if (rvd->vdev_child[c]->vdev_ms_array == 0) 4611eda14cbcSMatt Macy need_update = B_TRUE; 4612eda14cbcSMatt Macy 4613eda14cbcSMatt Macy /* 4614eda14cbcSMatt Macy * Update the config cache asynchronously in case we're the 4615eda14cbcSMatt Macy * root pool, in which case the config cache isn't writable yet. 4616eda14cbcSMatt Macy */ 4617eda14cbcSMatt Macy if (need_update) 4618eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 4619eda14cbcSMatt Macy } 4620eda14cbcSMatt Macy 4621eda14cbcSMatt Macy static void 4622eda14cbcSMatt Macy spa_ld_prepare_for_reload(spa_t *spa) 4623eda14cbcSMatt Macy { 4624eda14cbcSMatt Macy spa_mode_t mode = spa->spa_mode; 4625eda14cbcSMatt Macy int async_suspended = spa->spa_async_suspended; 4626eda14cbcSMatt Macy 4627eda14cbcSMatt Macy spa_unload(spa); 4628eda14cbcSMatt Macy spa_deactivate(spa); 4629eda14cbcSMatt Macy spa_activate(spa, mode); 4630eda14cbcSMatt Macy 4631eda14cbcSMatt Macy /* 4632eda14cbcSMatt Macy * We save the value of spa_async_suspended as it gets reset to 0 by 4633eda14cbcSMatt Macy * spa_unload(). We want to restore it back to the original value before 4634eda14cbcSMatt Macy * returning as we might be calling spa_async_resume() later. 4635eda14cbcSMatt Macy */ 4636eda14cbcSMatt Macy spa->spa_async_suspended = async_suspended; 4637eda14cbcSMatt Macy } 4638eda14cbcSMatt Macy 4639eda14cbcSMatt Macy static int 4640eda14cbcSMatt Macy spa_ld_read_checkpoint_txg(spa_t *spa) 4641eda14cbcSMatt Macy { 4642eda14cbcSMatt Macy uberblock_t checkpoint; 4643eda14cbcSMatt Macy int error = 0; 4644eda14cbcSMatt Macy 4645eda14cbcSMatt Macy ASSERT0(spa->spa_checkpoint_txg); 4646eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4647eda14cbcSMatt Macy 4648eda14cbcSMatt Macy error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 4649eda14cbcSMatt Macy DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t), 4650eda14cbcSMatt Macy sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint); 4651eda14cbcSMatt Macy 4652eda14cbcSMatt Macy if (error == ENOENT) 4653eda14cbcSMatt Macy return (0); 4654eda14cbcSMatt Macy 4655eda14cbcSMatt Macy if (error != 0) 4656eda14cbcSMatt Macy return (error); 4657eda14cbcSMatt Macy 4658eda14cbcSMatt Macy ASSERT3U(checkpoint.ub_txg, !=, 0); 4659eda14cbcSMatt Macy ASSERT3U(checkpoint.ub_checkpoint_txg, !=, 0); 4660eda14cbcSMatt Macy ASSERT3U(checkpoint.ub_timestamp, !=, 0); 4661eda14cbcSMatt Macy spa->spa_checkpoint_txg = checkpoint.ub_txg; 4662eda14cbcSMatt Macy spa->spa_checkpoint_info.sci_timestamp = checkpoint.ub_timestamp; 4663eda14cbcSMatt Macy 4664eda14cbcSMatt Macy return (0); 4665eda14cbcSMatt Macy } 4666eda14cbcSMatt Macy 4667eda14cbcSMatt Macy static int 4668eda14cbcSMatt Macy spa_ld_mos_init(spa_t *spa, spa_import_type_t type) 4669eda14cbcSMatt Macy { 4670eda14cbcSMatt Macy int error = 0; 4671eda14cbcSMatt Macy 4672eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4673eda14cbcSMatt Macy ASSERT(spa->spa_config_source != SPA_CONFIG_SRC_NONE); 4674eda14cbcSMatt Macy 4675eda14cbcSMatt Macy /* 4676eda14cbcSMatt Macy * Never trust the config that is provided unless we are assembling 4677eda14cbcSMatt Macy * a pool following a split. 4678eda14cbcSMatt Macy * This means don't trust blkptrs and the vdev tree in general. This 4679eda14cbcSMatt Macy * also effectively puts the spa in read-only mode since 4680eda14cbcSMatt Macy * spa_writeable() checks for spa_trust_config to be true. 4681eda14cbcSMatt Macy * We will later load a trusted config from the MOS. 4682eda14cbcSMatt Macy */ 4683eda14cbcSMatt Macy if (type != SPA_IMPORT_ASSEMBLE) 4684eda14cbcSMatt Macy spa->spa_trust_config = B_FALSE; 4685eda14cbcSMatt Macy 4686eda14cbcSMatt Macy /* 4687eda14cbcSMatt Macy * Parse the config provided to create a vdev tree. 4688eda14cbcSMatt Macy */ 4689eda14cbcSMatt Macy error = spa_ld_parse_config(spa, type); 4690eda14cbcSMatt Macy if (error != 0) 4691eda14cbcSMatt Macy return (error); 4692eda14cbcSMatt Macy 4693eda14cbcSMatt Macy spa_import_progress_add(spa); 4694eda14cbcSMatt Macy 4695eda14cbcSMatt Macy /* 4696eda14cbcSMatt Macy * Now that we have the vdev tree, try to open each vdev. This involves 4697eda14cbcSMatt Macy * opening the underlying physical device, retrieving its geometry and 4698eda14cbcSMatt Macy * probing the vdev with a dummy I/O. The state of each vdev will be set 4699eda14cbcSMatt Macy * based on the success of those operations. After this we'll be ready 4700eda14cbcSMatt Macy * to read from the vdevs. 4701eda14cbcSMatt Macy */ 4702eda14cbcSMatt Macy error = spa_ld_open_vdevs(spa); 4703eda14cbcSMatt Macy if (error != 0) 4704eda14cbcSMatt Macy return (error); 4705eda14cbcSMatt Macy 4706eda14cbcSMatt Macy /* 4707eda14cbcSMatt Macy * Read the label of each vdev and make sure that the GUIDs stored 4708eda14cbcSMatt Macy * there match the GUIDs in the config provided. 4709eda14cbcSMatt Macy * If we're assembling a new pool that's been split off from an 4710eda14cbcSMatt Macy * existing pool, the labels haven't yet been updated so we skip 4711eda14cbcSMatt Macy * validation for now. 4712eda14cbcSMatt Macy */ 4713eda14cbcSMatt Macy if (type != SPA_IMPORT_ASSEMBLE) { 4714eda14cbcSMatt Macy error = spa_ld_validate_vdevs(spa); 4715eda14cbcSMatt Macy if (error != 0) 4716eda14cbcSMatt Macy return (error); 4717eda14cbcSMatt Macy } 4718eda14cbcSMatt Macy 4719eda14cbcSMatt Macy /* 4720eda14cbcSMatt Macy * Read all vdev labels to find the best uberblock (i.e. latest, 4721eda14cbcSMatt Macy * unless spa_load_max_txg is set) and store it in spa_uberblock. We 4722eda14cbcSMatt Macy * get the list of features required to read blkptrs in the MOS from 4723eda14cbcSMatt Macy * the vdev label with the best uberblock and verify that our version 4724eda14cbcSMatt Macy * of zfs supports them all. 4725eda14cbcSMatt Macy */ 4726eda14cbcSMatt Macy error = spa_ld_select_uberblock(spa, type); 4727eda14cbcSMatt Macy if (error != 0) 4728eda14cbcSMatt Macy return (error); 4729eda14cbcSMatt Macy 4730eda14cbcSMatt Macy /* 4731eda14cbcSMatt Macy * Pass that uberblock to the dsl_pool layer which will open the root 4732eda14cbcSMatt Macy * blkptr. This blkptr points to the latest version of the MOS and will 4733eda14cbcSMatt Macy * allow us to read its contents. 4734eda14cbcSMatt Macy */ 4735eda14cbcSMatt Macy error = spa_ld_open_rootbp(spa); 4736eda14cbcSMatt Macy if (error != 0) 4737eda14cbcSMatt Macy return (error); 4738eda14cbcSMatt Macy 4739eda14cbcSMatt Macy return (0); 4740eda14cbcSMatt Macy } 4741eda14cbcSMatt Macy 4742eda14cbcSMatt Macy static int 4743eda14cbcSMatt Macy spa_ld_checkpoint_rewind(spa_t *spa) 4744eda14cbcSMatt Macy { 4745eda14cbcSMatt Macy uberblock_t checkpoint; 4746eda14cbcSMatt Macy int error = 0; 4747eda14cbcSMatt Macy 4748eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4749eda14cbcSMatt Macy ASSERT(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT); 4750eda14cbcSMatt Macy 4751eda14cbcSMatt Macy error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 4752eda14cbcSMatt Macy DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t), 4753eda14cbcSMatt Macy sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint); 4754eda14cbcSMatt Macy 4755eda14cbcSMatt Macy if (error != 0) { 4756eda14cbcSMatt Macy spa_load_failed(spa, "unable to retrieve checkpointed " 4757eda14cbcSMatt Macy "uberblock from the MOS config [error=%d]", error); 4758eda14cbcSMatt Macy 4759eda14cbcSMatt Macy if (error == ENOENT) 4760eda14cbcSMatt Macy error = ZFS_ERR_NO_CHECKPOINT; 4761eda14cbcSMatt Macy 4762eda14cbcSMatt Macy return (error); 4763eda14cbcSMatt Macy } 4764eda14cbcSMatt Macy 4765eda14cbcSMatt Macy ASSERT3U(checkpoint.ub_txg, <, spa->spa_uberblock.ub_txg); 4766eda14cbcSMatt Macy ASSERT3U(checkpoint.ub_txg, ==, checkpoint.ub_checkpoint_txg); 4767eda14cbcSMatt Macy 4768eda14cbcSMatt Macy /* 4769eda14cbcSMatt Macy * We need to update the txg and timestamp of the checkpointed 4770eda14cbcSMatt Macy * uberblock to be higher than the latest one. This ensures that 4771eda14cbcSMatt Macy * the checkpointed uberblock is selected if we were to close and 4772eda14cbcSMatt Macy * reopen the pool right after we've written it in the vdev labels. 4773eda14cbcSMatt Macy * (also see block comment in vdev_uberblock_compare) 4774eda14cbcSMatt Macy */ 4775eda14cbcSMatt Macy checkpoint.ub_txg = spa->spa_uberblock.ub_txg + 1; 4776eda14cbcSMatt Macy checkpoint.ub_timestamp = gethrestime_sec(); 4777eda14cbcSMatt Macy 4778eda14cbcSMatt Macy /* 4779eda14cbcSMatt Macy * Set current uberblock to be the checkpointed uberblock. 4780eda14cbcSMatt Macy */ 4781eda14cbcSMatt Macy spa->spa_uberblock = checkpoint; 4782eda14cbcSMatt Macy 4783eda14cbcSMatt Macy /* 4784eda14cbcSMatt Macy * If we are doing a normal rewind, then the pool is open for 4785eda14cbcSMatt Macy * writing and we sync the "updated" checkpointed uberblock to 4786eda14cbcSMatt Macy * disk. Once this is done, we've basically rewound the whole 4787eda14cbcSMatt Macy * pool and there is no way back. 4788eda14cbcSMatt Macy * 4789eda14cbcSMatt Macy * There are cases when we don't want to attempt and sync the 4790eda14cbcSMatt Macy * checkpointed uberblock to disk because we are opening a 4791eda14cbcSMatt Macy * pool as read-only. Specifically, verifying the checkpointed 4792eda14cbcSMatt Macy * state with zdb, and importing the checkpointed state to get 4793eda14cbcSMatt Macy * a "preview" of its content. 4794eda14cbcSMatt Macy */ 4795eda14cbcSMatt Macy if (spa_writeable(spa)) { 4796eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 4797eda14cbcSMatt Macy 4798eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 4799eda14cbcSMatt Macy vdev_t *svd[SPA_SYNC_MIN_VDEVS] = { NULL }; 4800eda14cbcSMatt Macy int svdcount = 0; 4801eda14cbcSMatt Macy int children = rvd->vdev_children; 480233b8c039SMartin Matuska int c0 = random_in_range(children); 4803eda14cbcSMatt Macy 4804eda14cbcSMatt Macy for (int c = 0; c < children; c++) { 4805eda14cbcSMatt Macy vdev_t *vd = rvd->vdev_child[(c0 + c) % children]; 4806eda14cbcSMatt Macy 4807eda14cbcSMatt Macy /* Stop when revisiting the first vdev */ 4808eda14cbcSMatt Macy if (c > 0 && svd[0] == vd) 4809eda14cbcSMatt Macy break; 4810eda14cbcSMatt Macy 4811eda14cbcSMatt Macy if (vd->vdev_ms_array == 0 || vd->vdev_islog || 4812eda14cbcSMatt Macy !vdev_is_concrete(vd)) 4813eda14cbcSMatt Macy continue; 4814eda14cbcSMatt Macy 4815eda14cbcSMatt Macy svd[svdcount++] = vd; 4816eda14cbcSMatt Macy if (svdcount == SPA_SYNC_MIN_VDEVS) 4817eda14cbcSMatt Macy break; 4818eda14cbcSMatt Macy } 4819eda14cbcSMatt Macy error = vdev_config_sync(svd, svdcount, spa->spa_first_txg); 4820eda14cbcSMatt Macy if (error == 0) 4821eda14cbcSMatt Macy spa->spa_last_synced_guid = rvd->vdev_guid; 4822eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 4823eda14cbcSMatt Macy 4824eda14cbcSMatt Macy if (error != 0) { 4825eda14cbcSMatt Macy spa_load_failed(spa, "failed to write checkpointed " 4826eda14cbcSMatt Macy "uberblock to the vdev labels [error=%d]", error); 4827eda14cbcSMatt Macy return (error); 4828eda14cbcSMatt Macy } 4829eda14cbcSMatt Macy } 4830eda14cbcSMatt Macy 4831eda14cbcSMatt Macy return (0); 4832eda14cbcSMatt Macy } 4833eda14cbcSMatt Macy 4834eda14cbcSMatt Macy static int 4835eda14cbcSMatt Macy spa_ld_mos_with_trusted_config(spa_t *spa, spa_import_type_t type, 4836eda14cbcSMatt Macy boolean_t *update_config_cache) 4837eda14cbcSMatt Macy { 4838eda14cbcSMatt Macy int error; 4839eda14cbcSMatt Macy 4840eda14cbcSMatt Macy /* 4841eda14cbcSMatt Macy * Parse the config for pool, open and validate vdevs, 4842eda14cbcSMatt Macy * select an uberblock, and use that uberblock to open 4843eda14cbcSMatt Macy * the MOS. 4844eda14cbcSMatt Macy */ 4845eda14cbcSMatt Macy error = spa_ld_mos_init(spa, type); 4846eda14cbcSMatt Macy if (error != 0) 4847eda14cbcSMatt Macy return (error); 4848eda14cbcSMatt Macy 4849eda14cbcSMatt Macy /* 4850eda14cbcSMatt Macy * Retrieve the trusted config stored in the MOS and use it to create 4851eda14cbcSMatt Macy * a new, exact version of the vdev tree, then reopen all vdevs. 4852eda14cbcSMatt Macy */ 4853eda14cbcSMatt Macy error = spa_ld_trusted_config(spa, type, B_FALSE); 4854eda14cbcSMatt Macy if (error == EAGAIN) { 4855eda14cbcSMatt Macy if (update_config_cache != NULL) 4856eda14cbcSMatt Macy *update_config_cache = B_TRUE; 4857eda14cbcSMatt Macy 4858eda14cbcSMatt Macy /* 4859eda14cbcSMatt Macy * Redo the loading process with the trusted config if it is 4860eda14cbcSMatt Macy * too different from the untrusted config. 4861eda14cbcSMatt Macy */ 4862eda14cbcSMatt Macy spa_ld_prepare_for_reload(spa); 4863eda14cbcSMatt Macy spa_load_note(spa, "RELOADING"); 4864eda14cbcSMatt Macy error = spa_ld_mos_init(spa, type); 4865eda14cbcSMatt Macy if (error != 0) 4866eda14cbcSMatt Macy return (error); 4867eda14cbcSMatt Macy 4868eda14cbcSMatt Macy error = spa_ld_trusted_config(spa, type, B_TRUE); 4869eda14cbcSMatt Macy if (error != 0) 4870eda14cbcSMatt Macy return (error); 4871eda14cbcSMatt Macy 4872eda14cbcSMatt Macy } else if (error != 0) { 4873eda14cbcSMatt Macy return (error); 4874eda14cbcSMatt Macy } 4875eda14cbcSMatt Macy 4876eda14cbcSMatt Macy return (0); 4877eda14cbcSMatt Macy } 4878eda14cbcSMatt Macy 4879eda14cbcSMatt Macy /* 4880eda14cbcSMatt Macy * Load an existing storage pool, using the config provided. This config 4881eda14cbcSMatt Macy * describes which vdevs are part of the pool and is later validated against 4882eda14cbcSMatt Macy * partial configs present in each vdev's label and an entire copy of the 4883eda14cbcSMatt Macy * config stored in the MOS. 4884eda14cbcSMatt Macy */ 4885eda14cbcSMatt Macy static int 4886a0b956f5SMartin Matuska spa_load_impl(spa_t *spa, spa_import_type_t type, const char **ereport) 4887eda14cbcSMatt Macy { 4888eda14cbcSMatt Macy int error = 0; 4889eda14cbcSMatt Macy boolean_t missing_feat_write = B_FALSE; 4890eda14cbcSMatt Macy boolean_t checkpoint_rewind = 4891eda14cbcSMatt Macy (spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT); 4892eda14cbcSMatt Macy boolean_t update_config_cache = B_FALSE; 4893eda14cbcSMatt Macy 4894eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 4895eda14cbcSMatt Macy ASSERT(spa->spa_config_source != SPA_CONFIG_SRC_NONE); 4896eda14cbcSMatt Macy 4897eda14cbcSMatt Macy spa_load_note(spa, "LOADING"); 4898eda14cbcSMatt Macy 4899eda14cbcSMatt Macy error = spa_ld_mos_with_trusted_config(spa, type, &update_config_cache); 4900eda14cbcSMatt Macy if (error != 0) 4901eda14cbcSMatt Macy return (error); 4902eda14cbcSMatt Macy 4903eda14cbcSMatt Macy /* 4904eda14cbcSMatt Macy * If we are rewinding to the checkpoint then we need to repeat 4905eda14cbcSMatt Macy * everything we've done so far in this function but this time 4906eda14cbcSMatt Macy * selecting the checkpointed uberblock and using that to open 4907eda14cbcSMatt Macy * the MOS. 4908eda14cbcSMatt Macy */ 4909eda14cbcSMatt Macy if (checkpoint_rewind) { 4910eda14cbcSMatt Macy /* 4911eda14cbcSMatt Macy * If we are rewinding to the checkpoint update config cache 4912eda14cbcSMatt Macy * anyway. 4913eda14cbcSMatt Macy */ 4914eda14cbcSMatt Macy update_config_cache = B_TRUE; 4915eda14cbcSMatt Macy 4916eda14cbcSMatt Macy /* 4917eda14cbcSMatt Macy * Extract the checkpointed uberblock from the current MOS 4918eda14cbcSMatt Macy * and use this as the pool's uberblock from now on. If the 4919eda14cbcSMatt Macy * pool is imported as writeable we also write the checkpoint 4920eda14cbcSMatt Macy * uberblock to the labels, making the rewind permanent. 4921eda14cbcSMatt Macy */ 4922eda14cbcSMatt Macy error = spa_ld_checkpoint_rewind(spa); 4923eda14cbcSMatt Macy if (error != 0) 4924eda14cbcSMatt Macy return (error); 4925eda14cbcSMatt Macy 4926eda14cbcSMatt Macy /* 4927eda14cbcSMatt Macy * Redo the loading process again with the 4928eda14cbcSMatt Macy * checkpointed uberblock. 4929eda14cbcSMatt Macy */ 4930eda14cbcSMatt Macy spa_ld_prepare_for_reload(spa); 4931eda14cbcSMatt Macy spa_load_note(spa, "LOADING checkpointed uberblock"); 4932eda14cbcSMatt Macy error = spa_ld_mos_with_trusted_config(spa, type, NULL); 4933eda14cbcSMatt Macy if (error != 0) 4934eda14cbcSMatt Macy return (error); 4935eda14cbcSMatt Macy } 4936eda14cbcSMatt Macy 4937eda14cbcSMatt Macy /* 4938eda14cbcSMatt Macy * Retrieve the checkpoint txg if the pool has a checkpoint. 4939eda14cbcSMatt Macy */ 4940eda14cbcSMatt Macy error = spa_ld_read_checkpoint_txg(spa); 4941eda14cbcSMatt Macy if (error != 0) 4942eda14cbcSMatt Macy return (error); 4943eda14cbcSMatt Macy 4944eda14cbcSMatt Macy /* 4945eda14cbcSMatt Macy * Retrieve the mapping of indirect vdevs. Those vdevs were removed 4946eda14cbcSMatt Macy * from the pool and their contents were re-mapped to other vdevs. Note 4947eda14cbcSMatt Macy * that everything that we read before this step must have been 4948eda14cbcSMatt Macy * rewritten on concrete vdevs after the last device removal was 4949eda14cbcSMatt Macy * initiated. Otherwise we could be reading from indirect vdevs before 4950eda14cbcSMatt Macy * we have loaded their mappings. 4951eda14cbcSMatt Macy */ 4952eda14cbcSMatt Macy error = spa_ld_open_indirect_vdev_metadata(spa); 4953eda14cbcSMatt Macy if (error != 0) 4954eda14cbcSMatt Macy return (error); 4955eda14cbcSMatt Macy 4956eda14cbcSMatt Macy /* 4957eda14cbcSMatt Macy * Retrieve the full list of active features from the MOS and check if 4958eda14cbcSMatt Macy * they are all supported. 4959eda14cbcSMatt Macy */ 4960eda14cbcSMatt Macy error = spa_ld_check_features(spa, &missing_feat_write); 4961eda14cbcSMatt Macy if (error != 0) 4962eda14cbcSMatt Macy return (error); 4963eda14cbcSMatt Macy 4964eda14cbcSMatt Macy /* 4965eda14cbcSMatt Macy * Load several special directories from the MOS needed by the dsl_pool 4966eda14cbcSMatt Macy * layer. 4967eda14cbcSMatt Macy */ 4968eda14cbcSMatt Macy error = spa_ld_load_special_directories(spa); 4969eda14cbcSMatt Macy if (error != 0) 4970eda14cbcSMatt Macy return (error); 4971eda14cbcSMatt Macy 4972eda14cbcSMatt Macy /* 4973eda14cbcSMatt Macy * Retrieve pool properties from the MOS. 4974eda14cbcSMatt Macy */ 4975eda14cbcSMatt Macy error = spa_ld_get_props(spa); 4976eda14cbcSMatt Macy if (error != 0) 4977eda14cbcSMatt Macy return (error); 4978eda14cbcSMatt Macy 4979eda14cbcSMatt Macy /* 4980eda14cbcSMatt Macy * Retrieve the list of auxiliary devices - cache devices and spares - 4981eda14cbcSMatt Macy * and open them. 4982eda14cbcSMatt Macy */ 4983eda14cbcSMatt Macy error = spa_ld_open_aux_vdevs(spa, type); 4984eda14cbcSMatt Macy if (error != 0) 4985eda14cbcSMatt Macy return (error); 4986eda14cbcSMatt Macy 4987eda14cbcSMatt Macy /* 4988eda14cbcSMatt Macy * Load the metadata for all vdevs. Also check if unopenable devices 4989eda14cbcSMatt Macy * should be autoreplaced. 4990eda14cbcSMatt Macy */ 4991eda14cbcSMatt Macy error = spa_ld_load_vdev_metadata(spa); 4992eda14cbcSMatt Macy if (error != 0) 4993eda14cbcSMatt Macy return (error); 4994eda14cbcSMatt Macy 4995eda14cbcSMatt Macy error = spa_ld_load_dedup_tables(spa); 4996eda14cbcSMatt Macy if (error != 0) 4997eda14cbcSMatt Macy return (error); 4998eda14cbcSMatt Macy 49992a58b312SMartin Matuska error = spa_ld_load_brt(spa); 50002a58b312SMartin Matuska if (error != 0) 50012a58b312SMartin Matuska return (error); 50022a58b312SMartin Matuska 5003eda14cbcSMatt Macy /* 5004eda14cbcSMatt Macy * Verify the logs now to make sure we don't have any unexpected errors 5005eda14cbcSMatt Macy * when we claim log blocks later. 5006eda14cbcSMatt Macy */ 5007eda14cbcSMatt Macy error = spa_ld_verify_logs(spa, type, ereport); 5008eda14cbcSMatt Macy if (error != 0) 5009eda14cbcSMatt Macy return (error); 5010eda14cbcSMatt Macy 5011eda14cbcSMatt Macy if (missing_feat_write) { 5012eda14cbcSMatt Macy ASSERT(spa->spa_load_state == SPA_LOAD_TRYIMPORT); 5013eda14cbcSMatt Macy 5014eda14cbcSMatt Macy /* 5015eda14cbcSMatt Macy * At this point, we know that we can open the pool in 5016eda14cbcSMatt Macy * read-only mode but not read-write mode. We now have enough 5017eda14cbcSMatt Macy * information and can return to userland. 5018eda14cbcSMatt Macy */ 5019eda14cbcSMatt Macy return (spa_vdev_err(spa->spa_root_vdev, VDEV_AUX_UNSUP_FEAT, 5020eda14cbcSMatt Macy ENOTSUP)); 5021eda14cbcSMatt Macy } 5022eda14cbcSMatt Macy 5023eda14cbcSMatt Macy /* 5024eda14cbcSMatt Macy * Traverse the last txgs to make sure the pool was left off in a safe 5025eda14cbcSMatt Macy * state. When performing an extreme rewind, we verify the whole pool, 5026eda14cbcSMatt Macy * which can take a very long time. 5027eda14cbcSMatt Macy */ 5028eda14cbcSMatt Macy error = spa_ld_verify_pool_data(spa); 5029eda14cbcSMatt Macy if (error != 0) 5030eda14cbcSMatt Macy return (error); 5031eda14cbcSMatt Macy 5032eda14cbcSMatt Macy /* 5033eda14cbcSMatt Macy * Calculate the deflated space for the pool. This must be done before 5034eda14cbcSMatt Macy * we write anything to the pool because we'd need to update the space 5035eda14cbcSMatt Macy * accounting using the deflated sizes. 5036eda14cbcSMatt Macy */ 5037eda14cbcSMatt Macy spa_update_dspace(spa); 5038eda14cbcSMatt Macy 5039eda14cbcSMatt Macy /* 5040eda14cbcSMatt Macy * We have now retrieved all the information we needed to open the 5041eda14cbcSMatt Macy * pool. If we are importing the pool in read-write mode, a few 5042eda14cbcSMatt Macy * additional steps must be performed to finish the import. 5043eda14cbcSMatt Macy */ 5044eda14cbcSMatt Macy if (spa_writeable(spa) && (spa->spa_load_state == SPA_LOAD_RECOVER || 5045eda14cbcSMatt Macy spa->spa_load_max_txg == UINT64_MAX)) { 5046eda14cbcSMatt Macy uint64_t config_cache_txg = spa->spa_config_txg; 5047eda14cbcSMatt Macy 5048eda14cbcSMatt Macy ASSERT(spa->spa_load_state != SPA_LOAD_TRYIMPORT); 5049eda14cbcSMatt Macy 5050eda14cbcSMatt Macy /* 5051eda14cbcSMatt Macy * In case of a checkpoint rewind, log the original txg 5052eda14cbcSMatt Macy * of the checkpointed uberblock. 5053eda14cbcSMatt Macy */ 5054eda14cbcSMatt Macy if (checkpoint_rewind) { 5055eda14cbcSMatt Macy spa_history_log_internal(spa, "checkpoint rewind", 5056eda14cbcSMatt Macy NULL, "rewound state to txg=%llu", 5057eda14cbcSMatt Macy (u_longlong_t)spa->spa_uberblock.ub_checkpoint_txg); 5058eda14cbcSMatt Macy } 5059eda14cbcSMatt Macy 5060eda14cbcSMatt Macy /* 5061eda14cbcSMatt Macy * Traverse the ZIL and claim all blocks. 5062eda14cbcSMatt Macy */ 5063eda14cbcSMatt Macy spa_ld_claim_log_blocks(spa); 5064eda14cbcSMatt Macy 5065eda14cbcSMatt Macy /* 5066eda14cbcSMatt Macy * Kick-off the syncing thread. 5067eda14cbcSMatt Macy */ 5068eda14cbcSMatt Macy spa->spa_sync_on = B_TRUE; 5069eda14cbcSMatt Macy txg_sync_start(spa->spa_dsl_pool); 5070eda14cbcSMatt Macy mmp_thread_start(spa); 5071eda14cbcSMatt Macy 5072eda14cbcSMatt Macy /* 5073eda14cbcSMatt Macy * Wait for all claims to sync. We sync up to the highest 5074eda14cbcSMatt Macy * claimed log block birth time so that claimed log blocks 5075eda14cbcSMatt Macy * don't appear to be from the future. spa_claim_max_txg 5076eda14cbcSMatt Macy * will have been set for us by ZIL traversal operations 5077eda14cbcSMatt Macy * performed above. 5078eda14cbcSMatt Macy */ 5079eda14cbcSMatt Macy txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg); 5080eda14cbcSMatt Macy 5081eda14cbcSMatt Macy /* 5082eda14cbcSMatt Macy * Check if we need to request an update of the config. On the 5083eda14cbcSMatt Macy * next sync, we would update the config stored in vdev labels 5084eda14cbcSMatt Macy * and the cachefile (by default /etc/zfs/zpool.cache). 5085eda14cbcSMatt Macy */ 5086eda14cbcSMatt Macy spa_ld_check_for_config_update(spa, config_cache_txg, 5087eda14cbcSMatt Macy update_config_cache); 5088eda14cbcSMatt Macy 5089eda14cbcSMatt Macy /* 5090eda14cbcSMatt Macy * Check if a rebuild was in progress and if so resume it. 5091eda14cbcSMatt Macy * Then check all DTLs to see if anything needs resilvering. 5092eda14cbcSMatt Macy * The resilver will be deferred if a rebuild was started. 5093eda14cbcSMatt Macy */ 5094eda14cbcSMatt Macy if (vdev_rebuild_active(spa->spa_root_vdev)) { 5095eda14cbcSMatt Macy vdev_rebuild_restart(spa); 5096eda14cbcSMatt Macy } else if (!dsl_scan_resilvering(spa->spa_dsl_pool) && 5097eda14cbcSMatt Macy vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) { 5098eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_RESILVER); 5099eda14cbcSMatt Macy } 5100eda14cbcSMatt Macy 5101eda14cbcSMatt Macy /* 5102eda14cbcSMatt Macy * Log the fact that we booted up (so that we can detect if 5103eda14cbcSMatt Macy * we rebooted in the middle of an operation). 5104eda14cbcSMatt Macy */ 5105eda14cbcSMatt Macy spa_history_log_version(spa, "open", NULL); 5106eda14cbcSMatt Macy 5107eda14cbcSMatt Macy spa_restart_removal(spa); 5108eda14cbcSMatt Macy spa_spawn_aux_threads(spa); 5109eda14cbcSMatt Macy 5110eda14cbcSMatt Macy /* 5111eda14cbcSMatt Macy * Delete any inconsistent datasets. 5112eda14cbcSMatt Macy * 5113eda14cbcSMatt Macy * Note: 5114eda14cbcSMatt Macy * Since we may be issuing deletes for clones here, 5115eda14cbcSMatt Macy * we make sure to do so after we've spawned all the 5116eda14cbcSMatt Macy * auxiliary threads above (from which the livelist 5117eda14cbcSMatt Macy * deletion zthr is part of). 5118eda14cbcSMatt Macy */ 5119eda14cbcSMatt Macy (void) dmu_objset_find(spa_name(spa), 5120eda14cbcSMatt Macy dsl_destroy_inconsistent, NULL, DS_FIND_CHILDREN); 5121eda14cbcSMatt Macy 5122eda14cbcSMatt Macy /* 5123eda14cbcSMatt Macy * Clean up any stale temporary dataset userrefs. 5124eda14cbcSMatt Macy */ 5125eda14cbcSMatt Macy dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool); 5126eda14cbcSMatt Macy 5127eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 5128eda14cbcSMatt Macy vdev_initialize_restart(spa->spa_root_vdev); 5129eda14cbcSMatt Macy vdev_trim_restart(spa->spa_root_vdev); 5130eda14cbcSMatt Macy vdev_autotrim_restart(spa); 5131eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 5132eda14cbcSMatt Macy } 5133eda14cbcSMatt Macy 5134eda14cbcSMatt Macy spa_import_progress_remove(spa_guid(spa)); 5135eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_L2CACHE_REBUILD); 5136eda14cbcSMatt Macy 5137eda14cbcSMatt Macy spa_load_note(spa, "LOADED"); 5138eda14cbcSMatt Macy 5139eda14cbcSMatt Macy return (0); 5140eda14cbcSMatt Macy } 5141eda14cbcSMatt Macy 5142eda14cbcSMatt Macy static int 5143eda14cbcSMatt Macy spa_load_retry(spa_t *spa, spa_load_state_t state) 5144eda14cbcSMatt Macy { 5145eda14cbcSMatt Macy spa_mode_t mode = spa->spa_mode; 5146eda14cbcSMatt Macy 5147eda14cbcSMatt Macy spa_unload(spa); 5148eda14cbcSMatt Macy spa_deactivate(spa); 5149eda14cbcSMatt Macy 5150eda14cbcSMatt Macy spa->spa_load_max_txg = spa->spa_uberblock.ub_txg - 1; 5151eda14cbcSMatt Macy 5152eda14cbcSMatt Macy spa_activate(spa, mode); 5153eda14cbcSMatt Macy spa_async_suspend(spa); 5154eda14cbcSMatt Macy 5155eda14cbcSMatt Macy spa_load_note(spa, "spa_load_retry: rewind, max txg: %llu", 5156eda14cbcSMatt Macy (u_longlong_t)spa->spa_load_max_txg); 5157eda14cbcSMatt Macy 5158eda14cbcSMatt Macy return (spa_load(spa, state, SPA_IMPORT_EXISTING)); 5159eda14cbcSMatt Macy } 5160eda14cbcSMatt Macy 5161eda14cbcSMatt Macy /* 5162eda14cbcSMatt Macy * If spa_load() fails this function will try loading prior txg's. If 5163eda14cbcSMatt Macy * 'state' is SPA_LOAD_RECOVER and one of these loads succeeds the pool 5164eda14cbcSMatt Macy * will be rewound to that txg. If 'state' is not SPA_LOAD_RECOVER this 5165eda14cbcSMatt Macy * function will not rewind the pool and will return the same error as 5166eda14cbcSMatt Macy * spa_load(). 5167eda14cbcSMatt Macy */ 5168eda14cbcSMatt Macy static int 5169eda14cbcSMatt Macy spa_load_best(spa_t *spa, spa_load_state_t state, uint64_t max_request, 5170eda14cbcSMatt Macy int rewind_flags) 5171eda14cbcSMatt Macy { 5172eda14cbcSMatt Macy nvlist_t *loadinfo = NULL; 5173eda14cbcSMatt Macy nvlist_t *config = NULL; 5174eda14cbcSMatt Macy int load_error, rewind_error; 5175eda14cbcSMatt Macy uint64_t safe_rewind_txg; 5176eda14cbcSMatt Macy uint64_t min_txg; 5177eda14cbcSMatt Macy 5178eda14cbcSMatt Macy if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) { 5179eda14cbcSMatt Macy spa->spa_load_max_txg = spa->spa_load_txg; 5180eda14cbcSMatt Macy spa_set_log_state(spa, SPA_LOG_CLEAR); 5181eda14cbcSMatt Macy } else { 5182eda14cbcSMatt Macy spa->spa_load_max_txg = max_request; 5183eda14cbcSMatt Macy if (max_request != UINT64_MAX) 5184eda14cbcSMatt Macy spa->spa_extreme_rewind = B_TRUE; 5185eda14cbcSMatt Macy } 5186eda14cbcSMatt Macy 5187eda14cbcSMatt Macy load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING); 5188eda14cbcSMatt Macy if (load_error == 0) 5189eda14cbcSMatt Macy return (0); 5190eda14cbcSMatt Macy if (load_error == ZFS_ERR_NO_CHECKPOINT) { 5191eda14cbcSMatt Macy /* 5192eda14cbcSMatt Macy * When attempting checkpoint-rewind on a pool with no 5193eda14cbcSMatt Macy * checkpoint, we should not attempt to load uberblocks 5194eda14cbcSMatt Macy * from previous txgs when spa_load fails. 5195eda14cbcSMatt Macy */ 5196eda14cbcSMatt Macy ASSERT(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT); 5197eda14cbcSMatt Macy spa_import_progress_remove(spa_guid(spa)); 5198eda14cbcSMatt Macy return (load_error); 5199eda14cbcSMatt Macy } 5200eda14cbcSMatt Macy 5201eda14cbcSMatt Macy if (spa->spa_root_vdev != NULL) 5202eda14cbcSMatt Macy config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 5203eda14cbcSMatt Macy 5204eda14cbcSMatt Macy spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg; 5205eda14cbcSMatt Macy spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp; 5206eda14cbcSMatt Macy 5207eda14cbcSMatt Macy if (rewind_flags & ZPOOL_NEVER_REWIND) { 5208eda14cbcSMatt Macy nvlist_free(config); 5209eda14cbcSMatt Macy spa_import_progress_remove(spa_guid(spa)); 5210eda14cbcSMatt Macy return (load_error); 5211eda14cbcSMatt Macy } 5212eda14cbcSMatt Macy 5213eda14cbcSMatt Macy if (state == SPA_LOAD_RECOVER) { 5214eda14cbcSMatt Macy /* Price of rolling back is discarding txgs, including log */ 5215eda14cbcSMatt Macy spa_set_log_state(spa, SPA_LOG_CLEAR); 5216eda14cbcSMatt Macy } else { 5217eda14cbcSMatt Macy /* 5218eda14cbcSMatt Macy * If we aren't rolling back save the load info from our first 5219eda14cbcSMatt Macy * import attempt so that we can restore it after attempting 5220eda14cbcSMatt Macy * to rewind. 5221eda14cbcSMatt Macy */ 5222eda14cbcSMatt Macy loadinfo = spa->spa_load_info; 5223eda14cbcSMatt Macy spa->spa_load_info = fnvlist_alloc(); 5224eda14cbcSMatt Macy } 5225eda14cbcSMatt Macy 5226eda14cbcSMatt Macy spa->spa_load_max_txg = spa->spa_last_ubsync_txg; 5227eda14cbcSMatt Macy safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE; 5228eda14cbcSMatt Macy min_txg = (rewind_flags & ZPOOL_EXTREME_REWIND) ? 5229eda14cbcSMatt Macy TXG_INITIAL : safe_rewind_txg; 5230eda14cbcSMatt Macy 5231eda14cbcSMatt Macy /* 5232eda14cbcSMatt Macy * Continue as long as we're finding errors, we're still within 5233eda14cbcSMatt Macy * the acceptable rewind range, and we're still finding uberblocks 5234eda14cbcSMatt Macy */ 5235eda14cbcSMatt Macy while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg && 5236eda14cbcSMatt Macy spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) { 5237eda14cbcSMatt Macy if (spa->spa_load_max_txg < safe_rewind_txg) 5238eda14cbcSMatt Macy spa->spa_extreme_rewind = B_TRUE; 5239eda14cbcSMatt Macy rewind_error = spa_load_retry(spa, state); 5240eda14cbcSMatt Macy } 5241eda14cbcSMatt Macy 5242eda14cbcSMatt Macy spa->spa_extreme_rewind = B_FALSE; 5243eda14cbcSMatt Macy spa->spa_load_max_txg = UINT64_MAX; 5244eda14cbcSMatt Macy 5245eda14cbcSMatt Macy if (config && (rewind_error || state != SPA_LOAD_RECOVER)) 5246eda14cbcSMatt Macy spa_config_set(spa, config); 5247eda14cbcSMatt Macy else 5248eda14cbcSMatt Macy nvlist_free(config); 5249eda14cbcSMatt Macy 5250eda14cbcSMatt Macy if (state == SPA_LOAD_RECOVER) { 5251eda14cbcSMatt Macy ASSERT3P(loadinfo, ==, NULL); 5252eda14cbcSMatt Macy spa_import_progress_remove(spa_guid(spa)); 5253eda14cbcSMatt Macy return (rewind_error); 5254eda14cbcSMatt Macy } else { 5255eda14cbcSMatt Macy /* Store the rewind info as part of the initial load info */ 5256eda14cbcSMatt Macy fnvlist_add_nvlist(loadinfo, ZPOOL_CONFIG_REWIND_INFO, 5257eda14cbcSMatt Macy spa->spa_load_info); 5258eda14cbcSMatt Macy 5259eda14cbcSMatt Macy /* Restore the initial load info */ 5260eda14cbcSMatt Macy fnvlist_free(spa->spa_load_info); 5261eda14cbcSMatt Macy spa->spa_load_info = loadinfo; 5262eda14cbcSMatt Macy 5263eda14cbcSMatt Macy spa_import_progress_remove(spa_guid(spa)); 5264eda14cbcSMatt Macy return (load_error); 5265eda14cbcSMatt Macy } 5266eda14cbcSMatt Macy } 5267eda14cbcSMatt Macy 5268eda14cbcSMatt Macy /* 5269eda14cbcSMatt Macy * Pool Open/Import 5270eda14cbcSMatt Macy * 5271eda14cbcSMatt Macy * The import case is identical to an open except that the configuration is sent 5272eda14cbcSMatt Macy * down from userland, instead of grabbed from the configuration cache. For the 5273eda14cbcSMatt Macy * case of an open, the pool configuration will exist in the 5274eda14cbcSMatt Macy * POOL_STATE_UNINITIALIZED state. 5275eda14cbcSMatt Macy * 5276eda14cbcSMatt Macy * The stats information (gen/count/ustats) is used to gather vdev statistics at 5277eda14cbcSMatt Macy * the same time open the pool, without having to keep around the spa_t in some 5278eda14cbcSMatt Macy * ambiguous state. 5279eda14cbcSMatt Macy */ 5280eda14cbcSMatt Macy static int 5281a0b956f5SMartin Matuska spa_open_common(const char *pool, spa_t **spapp, const void *tag, 5282a0b956f5SMartin Matuska nvlist_t *nvpolicy, nvlist_t **config) 5283eda14cbcSMatt Macy { 5284eda14cbcSMatt Macy spa_t *spa; 5285eda14cbcSMatt Macy spa_load_state_t state = SPA_LOAD_OPEN; 5286eda14cbcSMatt Macy int error; 5287eda14cbcSMatt Macy int locked = B_FALSE; 5288eda14cbcSMatt Macy int firstopen = B_FALSE; 5289eda14cbcSMatt Macy 5290eda14cbcSMatt Macy *spapp = NULL; 5291eda14cbcSMatt Macy 5292eda14cbcSMatt Macy /* 5293eda14cbcSMatt Macy * As disgusting as this is, we need to support recursive calls to this 5294eda14cbcSMatt Macy * function because dsl_dir_open() is called during spa_load(), and ends 5295eda14cbcSMatt Macy * up calling spa_open() again. The real fix is to figure out how to 5296eda14cbcSMatt Macy * avoid dsl_dir_open() calling this in the first place. 5297eda14cbcSMatt Macy */ 5298eda14cbcSMatt Macy if (MUTEX_NOT_HELD(&spa_namespace_lock)) { 5299eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 5300eda14cbcSMatt Macy locked = B_TRUE; 5301eda14cbcSMatt Macy } 5302eda14cbcSMatt Macy 5303eda14cbcSMatt Macy if ((spa = spa_lookup(pool)) == NULL) { 5304eda14cbcSMatt Macy if (locked) 5305eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5306eda14cbcSMatt Macy return (SET_ERROR(ENOENT)); 5307eda14cbcSMatt Macy } 5308eda14cbcSMatt Macy 5309eda14cbcSMatt Macy if (spa->spa_state == POOL_STATE_UNINITIALIZED) { 5310eda14cbcSMatt Macy zpool_load_policy_t policy; 5311eda14cbcSMatt Macy 5312eda14cbcSMatt Macy firstopen = B_TRUE; 5313eda14cbcSMatt Macy 5314eda14cbcSMatt Macy zpool_get_load_policy(nvpolicy ? nvpolicy : spa->spa_config, 5315eda14cbcSMatt Macy &policy); 5316eda14cbcSMatt Macy if (policy.zlp_rewind & ZPOOL_DO_REWIND) 5317eda14cbcSMatt Macy state = SPA_LOAD_RECOVER; 5318eda14cbcSMatt Macy 5319eda14cbcSMatt Macy spa_activate(spa, spa_mode_global); 5320eda14cbcSMatt Macy 5321eda14cbcSMatt Macy if (state != SPA_LOAD_RECOVER) 5322eda14cbcSMatt Macy spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 5323eda14cbcSMatt Macy spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE; 5324eda14cbcSMatt Macy 5325eda14cbcSMatt Macy zfs_dbgmsg("spa_open_common: opening %s", pool); 5326eda14cbcSMatt Macy error = spa_load_best(spa, state, policy.zlp_txg, 5327eda14cbcSMatt Macy policy.zlp_rewind); 5328eda14cbcSMatt Macy 5329eda14cbcSMatt Macy if (error == EBADF) { 5330eda14cbcSMatt Macy /* 5331eda14cbcSMatt Macy * If vdev_validate() returns failure (indicated by 5332eda14cbcSMatt Macy * EBADF), it indicates that one of the vdevs indicates 5333eda14cbcSMatt Macy * that the pool has been exported or destroyed. If 5334eda14cbcSMatt Macy * this is the case, the config cache is out of sync and 5335eda14cbcSMatt Macy * we should remove the pool from the namespace. 5336eda14cbcSMatt Macy */ 5337eda14cbcSMatt Macy spa_unload(spa); 5338eda14cbcSMatt Macy spa_deactivate(spa); 5339be181ee2SMartin Matuska spa_write_cachefile(spa, B_TRUE, B_TRUE, B_FALSE); 5340eda14cbcSMatt Macy spa_remove(spa); 5341eda14cbcSMatt Macy if (locked) 5342eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5343eda14cbcSMatt Macy return (SET_ERROR(ENOENT)); 5344eda14cbcSMatt Macy } 5345eda14cbcSMatt Macy 5346eda14cbcSMatt Macy if (error) { 5347eda14cbcSMatt Macy /* 5348eda14cbcSMatt Macy * We can't open the pool, but we still have useful 5349eda14cbcSMatt Macy * information: the state of each vdev after the 5350eda14cbcSMatt Macy * attempted vdev_open(). Return this to the user. 5351eda14cbcSMatt Macy */ 5352eda14cbcSMatt Macy if (config != NULL && spa->spa_config) { 535381b22a98SMartin Matuska *config = fnvlist_dup(spa->spa_config); 535481b22a98SMartin Matuska fnvlist_add_nvlist(*config, 5355eda14cbcSMatt Macy ZPOOL_CONFIG_LOAD_INFO, 535681b22a98SMartin Matuska spa->spa_load_info); 5357eda14cbcSMatt Macy } 5358eda14cbcSMatt Macy spa_unload(spa); 5359eda14cbcSMatt Macy spa_deactivate(spa); 5360eda14cbcSMatt Macy spa->spa_last_open_failed = error; 5361eda14cbcSMatt Macy if (locked) 5362eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5363eda14cbcSMatt Macy *spapp = NULL; 5364eda14cbcSMatt Macy return (error); 5365eda14cbcSMatt Macy } 5366eda14cbcSMatt Macy } 5367eda14cbcSMatt Macy 5368eda14cbcSMatt Macy spa_open_ref(spa, tag); 5369eda14cbcSMatt Macy 5370eda14cbcSMatt Macy if (config != NULL) 5371eda14cbcSMatt Macy *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 5372eda14cbcSMatt Macy 5373eda14cbcSMatt Macy /* 5374eda14cbcSMatt Macy * If we've recovered the pool, pass back any information we 5375eda14cbcSMatt Macy * gathered while doing the load. 5376eda14cbcSMatt Macy */ 5377dbd5678dSMartin Matuska if (state == SPA_LOAD_RECOVER && config != NULL) { 537881b22a98SMartin Matuska fnvlist_add_nvlist(*config, ZPOOL_CONFIG_LOAD_INFO, 537981b22a98SMartin Matuska spa->spa_load_info); 5380eda14cbcSMatt Macy } 5381eda14cbcSMatt Macy 5382eda14cbcSMatt Macy if (locked) { 5383eda14cbcSMatt Macy spa->spa_last_open_failed = 0; 5384eda14cbcSMatt Macy spa->spa_last_ubsync_txg = 0; 5385eda14cbcSMatt Macy spa->spa_load_txg = 0; 5386eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5387eda14cbcSMatt Macy } 5388eda14cbcSMatt Macy 5389eda14cbcSMatt Macy if (firstopen) 5390eda14cbcSMatt Macy zvol_create_minors_recursive(spa_name(spa)); 5391eda14cbcSMatt Macy 5392eda14cbcSMatt Macy *spapp = spa; 5393eda14cbcSMatt Macy 5394eda14cbcSMatt Macy return (0); 5395eda14cbcSMatt Macy } 5396eda14cbcSMatt Macy 5397eda14cbcSMatt Macy int 5398a0b956f5SMartin Matuska spa_open_rewind(const char *name, spa_t **spapp, const void *tag, 5399a0b956f5SMartin Matuska nvlist_t *policy, nvlist_t **config) 5400eda14cbcSMatt Macy { 5401eda14cbcSMatt Macy return (spa_open_common(name, spapp, tag, policy, config)); 5402eda14cbcSMatt Macy } 5403eda14cbcSMatt Macy 5404eda14cbcSMatt Macy int 5405a0b956f5SMartin Matuska spa_open(const char *name, spa_t **spapp, const void *tag) 5406eda14cbcSMatt Macy { 5407eda14cbcSMatt Macy return (spa_open_common(name, spapp, tag, NULL, NULL)); 5408eda14cbcSMatt Macy } 5409eda14cbcSMatt Macy 5410eda14cbcSMatt Macy /* 5411eda14cbcSMatt Macy * Lookup the given spa_t, incrementing the inject count in the process, 5412eda14cbcSMatt Macy * preventing it from being exported or destroyed. 5413eda14cbcSMatt Macy */ 5414eda14cbcSMatt Macy spa_t * 5415eda14cbcSMatt Macy spa_inject_addref(char *name) 5416eda14cbcSMatt Macy { 5417eda14cbcSMatt Macy spa_t *spa; 5418eda14cbcSMatt Macy 5419eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 5420eda14cbcSMatt Macy if ((spa = spa_lookup(name)) == NULL) { 5421eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5422eda14cbcSMatt Macy return (NULL); 5423eda14cbcSMatt Macy } 5424eda14cbcSMatt Macy spa->spa_inject_ref++; 5425eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5426eda14cbcSMatt Macy 5427eda14cbcSMatt Macy return (spa); 5428eda14cbcSMatt Macy } 5429eda14cbcSMatt Macy 5430eda14cbcSMatt Macy void 5431eda14cbcSMatt Macy spa_inject_delref(spa_t *spa) 5432eda14cbcSMatt Macy { 5433eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 5434eda14cbcSMatt Macy spa->spa_inject_ref--; 5435eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5436eda14cbcSMatt Macy } 5437eda14cbcSMatt Macy 5438eda14cbcSMatt Macy /* 5439eda14cbcSMatt Macy * Add spares device information to the nvlist. 5440eda14cbcSMatt Macy */ 5441eda14cbcSMatt Macy static void 5442eda14cbcSMatt Macy spa_add_spares(spa_t *spa, nvlist_t *config) 5443eda14cbcSMatt Macy { 5444eda14cbcSMatt Macy nvlist_t **spares; 5445eda14cbcSMatt Macy uint_t i, nspares; 5446eda14cbcSMatt Macy nvlist_t *nvroot; 5447eda14cbcSMatt Macy uint64_t guid; 5448eda14cbcSMatt Macy vdev_stat_t *vs; 5449eda14cbcSMatt Macy uint_t vsc; 5450eda14cbcSMatt Macy uint64_t pool; 5451eda14cbcSMatt Macy 5452eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 5453eda14cbcSMatt Macy 5454eda14cbcSMatt Macy if (spa->spa_spares.sav_count == 0) 5455eda14cbcSMatt Macy return; 5456eda14cbcSMatt Macy 545781b22a98SMartin Matuska nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 545881b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, 545981b22a98SMartin Matuska ZPOOL_CONFIG_SPARES, &spares, &nspares)); 5460eda14cbcSMatt Macy if (nspares != 0) { 5461681ce946SMartin Matuska fnvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 5462681ce946SMartin Matuska (const nvlist_t * const *)spares, nspares); 546381b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 546481b22a98SMartin Matuska &spares, &nspares)); 5465eda14cbcSMatt Macy 5466eda14cbcSMatt Macy /* 5467eda14cbcSMatt Macy * Go through and find any spares which have since been 5468eda14cbcSMatt Macy * repurposed as an active spare. If this is the case, update 5469eda14cbcSMatt Macy * their status appropriately. 5470eda14cbcSMatt Macy */ 5471eda14cbcSMatt Macy for (i = 0; i < nspares; i++) { 547281b22a98SMartin Matuska guid = fnvlist_lookup_uint64(spares[i], 547381b22a98SMartin Matuska ZPOOL_CONFIG_GUID); 54742a58b312SMartin Matuska VERIFY0(nvlist_lookup_uint64_array(spares[i], 54752a58b312SMartin Matuska ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc)); 5476eda14cbcSMatt Macy if (spa_spare_exists(guid, &pool, NULL) && 5477eda14cbcSMatt Macy pool != 0ULL) { 5478eda14cbcSMatt Macy vs->vs_state = VDEV_STATE_CANT_OPEN; 5479eda14cbcSMatt Macy vs->vs_aux = VDEV_AUX_SPARED; 54802a58b312SMartin Matuska } else { 54812a58b312SMartin Matuska vs->vs_state = 54822a58b312SMartin Matuska spa->spa_spares.sav_vdevs[i]->vdev_state; 5483eda14cbcSMatt Macy } 5484eda14cbcSMatt Macy } 5485eda14cbcSMatt Macy } 5486eda14cbcSMatt Macy } 5487eda14cbcSMatt Macy 5488eda14cbcSMatt Macy /* 5489eda14cbcSMatt Macy * Add l2cache device information to the nvlist, including vdev stats. 5490eda14cbcSMatt Macy */ 5491eda14cbcSMatt Macy static void 5492eda14cbcSMatt Macy spa_add_l2cache(spa_t *spa, nvlist_t *config) 5493eda14cbcSMatt Macy { 5494eda14cbcSMatt Macy nvlist_t **l2cache; 5495eda14cbcSMatt Macy uint_t i, j, nl2cache; 5496eda14cbcSMatt Macy nvlist_t *nvroot; 5497eda14cbcSMatt Macy uint64_t guid; 5498eda14cbcSMatt Macy vdev_t *vd; 5499eda14cbcSMatt Macy vdev_stat_t *vs; 5500eda14cbcSMatt Macy uint_t vsc; 5501eda14cbcSMatt Macy 5502eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 5503eda14cbcSMatt Macy 5504eda14cbcSMatt Macy if (spa->spa_l2cache.sav_count == 0) 5505eda14cbcSMatt Macy return; 5506eda14cbcSMatt Macy 550781b22a98SMartin Matuska nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 550881b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, 550981b22a98SMartin Matuska ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache)); 5510eda14cbcSMatt Macy if (nl2cache != 0) { 5511681ce946SMartin Matuska fnvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 5512681ce946SMartin Matuska (const nvlist_t * const *)l2cache, nl2cache); 551381b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 551481b22a98SMartin Matuska &l2cache, &nl2cache)); 5515eda14cbcSMatt Macy 5516eda14cbcSMatt Macy /* 5517eda14cbcSMatt Macy * Update level 2 cache device stats. 5518eda14cbcSMatt Macy */ 5519eda14cbcSMatt Macy 5520eda14cbcSMatt Macy for (i = 0; i < nl2cache; i++) { 552181b22a98SMartin Matuska guid = fnvlist_lookup_uint64(l2cache[i], 552281b22a98SMartin Matuska ZPOOL_CONFIG_GUID); 5523eda14cbcSMatt Macy 5524eda14cbcSMatt Macy vd = NULL; 5525eda14cbcSMatt Macy for (j = 0; j < spa->spa_l2cache.sav_count; j++) { 5526eda14cbcSMatt Macy if (guid == 5527eda14cbcSMatt Macy spa->spa_l2cache.sav_vdevs[j]->vdev_guid) { 5528eda14cbcSMatt Macy vd = spa->spa_l2cache.sav_vdevs[j]; 5529eda14cbcSMatt Macy break; 5530eda14cbcSMatt Macy } 5531eda14cbcSMatt Macy } 5532eda14cbcSMatt Macy ASSERT(vd != NULL); 5533eda14cbcSMatt Macy 553481b22a98SMartin Matuska VERIFY0(nvlist_lookup_uint64_array(l2cache[i], 553581b22a98SMartin Matuska ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc)); 5536eda14cbcSMatt Macy vdev_get_stats(vd, vs); 5537eda14cbcSMatt Macy vdev_config_generate_stats(vd, l2cache[i]); 5538eda14cbcSMatt Macy 5539eda14cbcSMatt Macy } 5540eda14cbcSMatt Macy } 5541eda14cbcSMatt Macy } 5542eda14cbcSMatt Macy 5543eda14cbcSMatt Macy static void 5544eda14cbcSMatt Macy spa_feature_stats_from_disk(spa_t *spa, nvlist_t *features) 5545eda14cbcSMatt Macy { 5546eda14cbcSMatt Macy zap_cursor_t zc; 5547eda14cbcSMatt Macy zap_attribute_t za; 5548eda14cbcSMatt Macy 5549eda14cbcSMatt Macy if (spa->spa_feat_for_read_obj != 0) { 5550eda14cbcSMatt Macy for (zap_cursor_init(&zc, spa->spa_meta_objset, 5551eda14cbcSMatt Macy spa->spa_feat_for_read_obj); 5552eda14cbcSMatt Macy zap_cursor_retrieve(&zc, &za) == 0; 5553eda14cbcSMatt Macy zap_cursor_advance(&zc)) { 5554eda14cbcSMatt Macy ASSERT(za.za_integer_length == sizeof (uint64_t) && 5555eda14cbcSMatt Macy za.za_num_integers == 1); 5556eda14cbcSMatt Macy VERIFY0(nvlist_add_uint64(features, za.za_name, 5557eda14cbcSMatt Macy za.za_first_integer)); 5558eda14cbcSMatt Macy } 5559eda14cbcSMatt Macy zap_cursor_fini(&zc); 5560eda14cbcSMatt Macy } 5561eda14cbcSMatt Macy 5562eda14cbcSMatt Macy if (spa->spa_feat_for_write_obj != 0) { 5563eda14cbcSMatt Macy for (zap_cursor_init(&zc, spa->spa_meta_objset, 5564eda14cbcSMatt Macy spa->spa_feat_for_write_obj); 5565eda14cbcSMatt Macy zap_cursor_retrieve(&zc, &za) == 0; 5566eda14cbcSMatt Macy zap_cursor_advance(&zc)) { 5567eda14cbcSMatt Macy ASSERT(za.za_integer_length == sizeof (uint64_t) && 5568eda14cbcSMatt Macy za.za_num_integers == 1); 5569eda14cbcSMatt Macy VERIFY0(nvlist_add_uint64(features, za.za_name, 5570eda14cbcSMatt Macy za.za_first_integer)); 5571eda14cbcSMatt Macy } 5572eda14cbcSMatt Macy zap_cursor_fini(&zc); 5573eda14cbcSMatt Macy } 5574eda14cbcSMatt Macy } 5575eda14cbcSMatt Macy 5576eda14cbcSMatt Macy static void 5577eda14cbcSMatt Macy spa_feature_stats_from_cache(spa_t *spa, nvlist_t *features) 5578eda14cbcSMatt Macy { 5579eda14cbcSMatt Macy int i; 5580eda14cbcSMatt Macy 5581eda14cbcSMatt Macy for (i = 0; i < SPA_FEATURES; i++) { 5582eda14cbcSMatt Macy zfeature_info_t feature = spa_feature_table[i]; 5583eda14cbcSMatt Macy uint64_t refcount; 5584eda14cbcSMatt Macy 5585eda14cbcSMatt Macy if (feature_get_refcount(spa, &feature, &refcount) != 0) 5586eda14cbcSMatt Macy continue; 5587eda14cbcSMatt Macy 5588eda14cbcSMatt Macy VERIFY0(nvlist_add_uint64(features, feature.fi_guid, refcount)); 5589eda14cbcSMatt Macy } 5590eda14cbcSMatt Macy } 5591eda14cbcSMatt Macy 5592eda14cbcSMatt Macy /* 5593eda14cbcSMatt Macy * Store a list of pool features and their reference counts in the 5594eda14cbcSMatt Macy * config. 5595eda14cbcSMatt Macy * 5596eda14cbcSMatt Macy * The first time this is called on a spa, allocate a new nvlist, fetch 5597eda14cbcSMatt Macy * the pool features and reference counts from disk, then save the list 5598eda14cbcSMatt Macy * in the spa. In subsequent calls on the same spa use the saved nvlist 5599eda14cbcSMatt Macy * and refresh its values from the cached reference counts. This 5600eda14cbcSMatt Macy * ensures we don't block here on I/O on a suspended pool so 'zpool 5601eda14cbcSMatt Macy * clear' can resume the pool. 5602eda14cbcSMatt Macy */ 5603eda14cbcSMatt Macy static void 5604eda14cbcSMatt Macy spa_add_feature_stats(spa_t *spa, nvlist_t *config) 5605eda14cbcSMatt Macy { 5606eda14cbcSMatt Macy nvlist_t *features; 5607eda14cbcSMatt Macy 5608eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); 5609eda14cbcSMatt Macy 5610eda14cbcSMatt Macy mutex_enter(&spa->spa_feat_stats_lock); 5611eda14cbcSMatt Macy features = spa->spa_feat_stats; 5612eda14cbcSMatt Macy 5613eda14cbcSMatt Macy if (features != NULL) { 5614eda14cbcSMatt Macy spa_feature_stats_from_cache(spa, features); 5615eda14cbcSMatt Macy } else { 5616eda14cbcSMatt Macy VERIFY0(nvlist_alloc(&features, NV_UNIQUE_NAME, KM_SLEEP)); 5617eda14cbcSMatt Macy spa->spa_feat_stats = features; 5618eda14cbcSMatt Macy spa_feature_stats_from_disk(spa, features); 5619eda14cbcSMatt Macy } 5620eda14cbcSMatt Macy 5621eda14cbcSMatt Macy VERIFY0(nvlist_add_nvlist(config, ZPOOL_CONFIG_FEATURE_STATS, 5622eda14cbcSMatt Macy features)); 5623eda14cbcSMatt Macy 5624eda14cbcSMatt Macy mutex_exit(&spa->spa_feat_stats_lock); 5625eda14cbcSMatt Macy } 5626eda14cbcSMatt Macy 5627eda14cbcSMatt Macy int 5628eda14cbcSMatt Macy spa_get_stats(const char *name, nvlist_t **config, 5629eda14cbcSMatt Macy char *altroot, size_t buflen) 5630eda14cbcSMatt Macy { 5631eda14cbcSMatt Macy int error; 5632eda14cbcSMatt Macy spa_t *spa; 5633eda14cbcSMatt Macy 5634eda14cbcSMatt Macy *config = NULL; 5635eda14cbcSMatt Macy error = spa_open_common(name, &spa, FTAG, NULL, config); 5636eda14cbcSMatt Macy 5637eda14cbcSMatt Macy if (spa != NULL) { 5638eda14cbcSMatt Macy /* 5639eda14cbcSMatt Macy * This still leaves a window of inconsistency where the spares 5640eda14cbcSMatt Macy * or l2cache devices could change and the config would be 5641eda14cbcSMatt Macy * self-inconsistent. 5642eda14cbcSMatt Macy */ 5643eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 5644eda14cbcSMatt Macy 5645eda14cbcSMatt Macy if (*config != NULL) { 5646eda14cbcSMatt Macy uint64_t loadtimes[2]; 5647eda14cbcSMatt Macy 5648eda14cbcSMatt Macy loadtimes[0] = spa->spa_loaded_ts.tv_sec; 5649eda14cbcSMatt Macy loadtimes[1] = spa->spa_loaded_ts.tv_nsec; 565081b22a98SMartin Matuska fnvlist_add_uint64_array(*config, 565181b22a98SMartin Matuska ZPOOL_CONFIG_LOADED_TIME, loadtimes, 2); 5652eda14cbcSMatt Macy 565381b22a98SMartin Matuska fnvlist_add_uint64(*config, 5654eda14cbcSMatt Macy ZPOOL_CONFIG_ERRCOUNT, 565515f0b8c3SMartin Matuska spa_approx_errlog_size(spa)); 5656eda14cbcSMatt Macy 5657eda14cbcSMatt Macy if (spa_suspended(spa)) { 565881b22a98SMartin Matuska fnvlist_add_uint64(*config, 5659eda14cbcSMatt Macy ZPOOL_CONFIG_SUSPENDED, 566081b22a98SMartin Matuska spa->spa_failmode); 566181b22a98SMartin Matuska fnvlist_add_uint64(*config, 5662eda14cbcSMatt Macy ZPOOL_CONFIG_SUSPENDED_REASON, 566381b22a98SMartin Matuska spa->spa_suspended); 5664eda14cbcSMatt Macy } 5665eda14cbcSMatt Macy 5666eda14cbcSMatt Macy spa_add_spares(spa, *config); 5667eda14cbcSMatt Macy spa_add_l2cache(spa, *config); 5668eda14cbcSMatt Macy spa_add_feature_stats(spa, *config); 5669eda14cbcSMatt Macy } 5670eda14cbcSMatt Macy } 5671eda14cbcSMatt Macy 5672eda14cbcSMatt Macy /* 5673eda14cbcSMatt Macy * We want to get the alternate root even for faulted pools, so we cheat 5674eda14cbcSMatt Macy * and call spa_lookup() directly. 5675eda14cbcSMatt Macy */ 5676eda14cbcSMatt Macy if (altroot) { 5677eda14cbcSMatt Macy if (spa == NULL) { 5678eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 5679eda14cbcSMatt Macy spa = spa_lookup(name); 5680eda14cbcSMatt Macy if (spa) 5681eda14cbcSMatt Macy spa_altroot(spa, altroot, buflen); 5682eda14cbcSMatt Macy else 5683eda14cbcSMatt Macy altroot[0] = '\0'; 5684eda14cbcSMatt Macy spa = NULL; 5685eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5686eda14cbcSMatt Macy } else { 5687eda14cbcSMatt Macy spa_altroot(spa, altroot, buflen); 5688eda14cbcSMatt Macy } 5689eda14cbcSMatt Macy } 5690eda14cbcSMatt Macy 5691eda14cbcSMatt Macy if (spa != NULL) { 5692eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 5693eda14cbcSMatt Macy spa_close(spa, FTAG); 5694eda14cbcSMatt Macy } 5695eda14cbcSMatt Macy 5696eda14cbcSMatt Macy return (error); 5697eda14cbcSMatt Macy } 5698eda14cbcSMatt Macy 5699eda14cbcSMatt Macy /* 5700eda14cbcSMatt Macy * Validate that the auxiliary device array is well formed. We must have an 5701eda14cbcSMatt Macy * array of nvlists, each which describes a valid leaf vdev. If this is an 5702eda14cbcSMatt Macy * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be 5703eda14cbcSMatt Macy * specified, as long as they are well-formed. 5704eda14cbcSMatt Macy */ 5705eda14cbcSMatt Macy static int 5706eda14cbcSMatt Macy spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode, 5707eda14cbcSMatt Macy spa_aux_vdev_t *sav, const char *config, uint64_t version, 5708eda14cbcSMatt Macy vdev_labeltype_t label) 5709eda14cbcSMatt Macy { 5710eda14cbcSMatt Macy nvlist_t **dev; 5711eda14cbcSMatt Macy uint_t i, ndev; 5712eda14cbcSMatt Macy vdev_t *vd; 5713eda14cbcSMatt Macy int error; 5714eda14cbcSMatt Macy 5715eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 5716eda14cbcSMatt Macy 5717eda14cbcSMatt Macy /* 5718eda14cbcSMatt Macy * It's acceptable to have no devs specified. 5719eda14cbcSMatt Macy */ 5720eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0) 5721eda14cbcSMatt Macy return (0); 5722eda14cbcSMatt Macy 5723eda14cbcSMatt Macy if (ndev == 0) 5724eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 5725eda14cbcSMatt Macy 5726eda14cbcSMatt Macy /* 5727eda14cbcSMatt Macy * Make sure the pool is formatted with a version that supports this 5728eda14cbcSMatt Macy * device type. 5729eda14cbcSMatt Macy */ 5730eda14cbcSMatt Macy if (spa_version(spa) < version) 5731eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 5732eda14cbcSMatt Macy 5733eda14cbcSMatt Macy /* 5734eda14cbcSMatt Macy * Set the pending device list so we correctly handle device in-use 5735eda14cbcSMatt Macy * checking. 5736eda14cbcSMatt Macy */ 5737eda14cbcSMatt Macy sav->sav_pending = dev; 5738eda14cbcSMatt Macy sav->sav_npending = ndev; 5739eda14cbcSMatt Macy 5740eda14cbcSMatt Macy for (i = 0; i < ndev; i++) { 5741eda14cbcSMatt Macy if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0, 5742eda14cbcSMatt Macy mode)) != 0) 5743eda14cbcSMatt Macy goto out; 5744eda14cbcSMatt Macy 5745eda14cbcSMatt Macy if (!vd->vdev_ops->vdev_op_leaf) { 5746eda14cbcSMatt Macy vdev_free(vd); 5747eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 5748eda14cbcSMatt Macy goto out; 5749eda14cbcSMatt Macy } 5750eda14cbcSMatt Macy 5751eda14cbcSMatt Macy vd->vdev_top = vd; 5752eda14cbcSMatt Macy 5753eda14cbcSMatt Macy if ((error = vdev_open(vd)) == 0 && 5754eda14cbcSMatt Macy (error = vdev_label_init(vd, crtxg, label)) == 0) { 575581b22a98SMartin Matuska fnvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID, 575681b22a98SMartin Matuska vd->vdev_guid); 5757eda14cbcSMatt Macy } 5758eda14cbcSMatt Macy 5759eda14cbcSMatt Macy vdev_free(vd); 5760eda14cbcSMatt Macy 5761eda14cbcSMatt Macy if (error && 5762eda14cbcSMatt Macy (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE)) 5763eda14cbcSMatt Macy goto out; 5764eda14cbcSMatt Macy else 5765eda14cbcSMatt Macy error = 0; 5766eda14cbcSMatt Macy } 5767eda14cbcSMatt Macy 5768eda14cbcSMatt Macy out: 5769eda14cbcSMatt Macy sav->sav_pending = NULL; 5770eda14cbcSMatt Macy sav->sav_npending = 0; 5771eda14cbcSMatt Macy return (error); 5772eda14cbcSMatt Macy } 5773eda14cbcSMatt Macy 5774eda14cbcSMatt Macy static int 5775eda14cbcSMatt Macy spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode) 5776eda14cbcSMatt Macy { 5777eda14cbcSMatt Macy int error; 5778eda14cbcSMatt Macy 5779eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); 5780eda14cbcSMatt Macy 5781eda14cbcSMatt Macy if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode, 5782eda14cbcSMatt Macy &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES, 5783eda14cbcSMatt Macy VDEV_LABEL_SPARE)) != 0) { 5784eda14cbcSMatt Macy return (error); 5785eda14cbcSMatt Macy } 5786eda14cbcSMatt Macy 5787eda14cbcSMatt Macy return (spa_validate_aux_devs(spa, nvroot, crtxg, mode, 5788eda14cbcSMatt Macy &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE, 5789eda14cbcSMatt Macy VDEV_LABEL_L2CACHE)); 5790eda14cbcSMatt Macy } 5791eda14cbcSMatt Macy 5792eda14cbcSMatt Macy static void 5793eda14cbcSMatt Macy spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs, 5794eda14cbcSMatt Macy const char *config) 5795eda14cbcSMatt Macy { 5796eda14cbcSMatt Macy int i; 5797eda14cbcSMatt Macy 5798eda14cbcSMatt Macy if (sav->sav_config != NULL) { 5799eda14cbcSMatt Macy nvlist_t **olddevs; 5800eda14cbcSMatt Macy uint_t oldndevs; 5801eda14cbcSMatt Macy nvlist_t **newdevs; 5802eda14cbcSMatt Macy 5803eda14cbcSMatt Macy /* 5804eda14cbcSMatt Macy * Generate new dev list by concatenating with the 5805eda14cbcSMatt Macy * current dev list. 5806eda14cbcSMatt Macy */ 580781b22a98SMartin Matuska VERIFY0(nvlist_lookup_nvlist_array(sav->sav_config, config, 580881b22a98SMartin Matuska &olddevs, &oldndevs)); 5809eda14cbcSMatt Macy 5810eda14cbcSMatt Macy newdevs = kmem_alloc(sizeof (void *) * 5811eda14cbcSMatt Macy (ndevs + oldndevs), KM_SLEEP); 5812eda14cbcSMatt Macy for (i = 0; i < oldndevs; i++) 581381b22a98SMartin Matuska newdevs[i] = fnvlist_dup(olddevs[i]); 5814eda14cbcSMatt Macy for (i = 0; i < ndevs; i++) 581581b22a98SMartin Matuska newdevs[i + oldndevs] = fnvlist_dup(devs[i]); 5816eda14cbcSMatt Macy 581781b22a98SMartin Matuska fnvlist_remove(sav->sav_config, config); 5818eda14cbcSMatt Macy 5819681ce946SMartin Matuska fnvlist_add_nvlist_array(sav->sav_config, config, 5820681ce946SMartin Matuska (const nvlist_t * const *)newdevs, ndevs + oldndevs); 5821eda14cbcSMatt Macy for (i = 0; i < oldndevs + ndevs; i++) 5822eda14cbcSMatt Macy nvlist_free(newdevs[i]); 5823eda14cbcSMatt Macy kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *)); 5824eda14cbcSMatt Macy } else { 5825eda14cbcSMatt Macy /* 5826eda14cbcSMatt Macy * Generate a new dev list. 5827eda14cbcSMatt Macy */ 582881b22a98SMartin Matuska sav->sav_config = fnvlist_alloc(); 5829681ce946SMartin Matuska fnvlist_add_nvlist_array(sav->sav_config, config, 5830681ce946SMartin Matuska (const nvlist_t * const *)devs, ndevs); 5831eda14cbcSMatt Macy } 5832eda14cbcSMatt Macy } 5833eda14cbcSMatt Macy 5834eda14cbcSMatt Macy /* 5835eda14cbcSMatt Macy * Stop and drop level 2 ARC devices 5836eda14cbcSMatt Macy */ 5837eda14cbcSMatt Macy void 5838eda14cbcSMatt Macy spa_l2cache_drop(spa_t *spa) 5839eda14cbcSMatt Macy { 5840eda14cbcSMatt Macy vdev_t *vd; 5841eda14cbcSMatt Macy int i; 5842eda14cbcSMatt Macy spa_aux_vdev_t *sav = &spa->spa_l2cache; 5843eda14cbcSMatt Macy 5844eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) { 5845eda14cbcSMatt Macy uint64_t pool; 5846eda14cbcSMatt Macy 5847eda14cbcSMatt Macy vd = sav->sav_vdevs[i]; 5848eda14cbcSMatt Macy ASSERT(vd != NULL); 5849eda14cbcSMatt Macy 5850eda14cbcSMatt Macy if (spa_l2cache_exists(vd->vdev_guid, &pool) && 5851eda14cbcSMatt Macy pool != 0ULL && l2arc_vdev_present(vd)) 5852eda14cbcSMatt Macy l2arc_remove_vdev(vd); 5853eda14cbcSMatt Macy } 5854eda14cbcSMatt Macy } 5855eda14cbcSMatt Macy 5856eda14cbcSMatt Macy /* 5857eda14cbcSMatt Macy * Verify encryption parameters for spa creation. If we are encrypting, we must 5858eda14cbcSMatt Macy * have the encryption feature flag enabled. 5859eda14cbcSMatt Macy */ 5860eda14cbcSMatt Macy static int 5861eda14cbcSMatt Macy spa_create_check_encryption_params(dsl_crypto_params_t *dcp, 5862eda14cbcSMatt Macy boolean_t has_encryption) 5863eda14cbcSMatt Macy { 5864eda14cbcSMatt Macy if (dcp->cp_crypt != ZIO_CRYPT_OFF && 5865eda14cbcSMatt Macy dcp->cp_crypt != ZIO_CRYPT_INHERIT && 5866eda14cbcSMatt Macy !has_encryption) 5867eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 5868eda14cbcSMatt Macy 5869eda14cbcSMatt Macy return (dmu_objset_create_crypt_check(NULL, dcp, NULL)); 5870eda14cbcSMatt Macy } 5871eda14cbcSMatt Macy 5872eda14cbcSMatt Macy /* 5873eda14cbcSMatt Macy * Pool Creation 5874eda14cbcSMatt Macy */ 5875eda14cbcSMatt Macy int 5876eda14cbcSMatt Macy spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props, 5877eda14cbcSMatt Macy nvlist_t *zplprops, dsl_crypto_params_t *dcp) 5878eda14cbcSMatt Macy { 5879eda14cbcSMatt Macy spa_t *spa; 58802a58b312SMartin Matuska const char *altroot = NULL; 5881eda14cbcSMatt Macy vdev_t *rvd; 5882eda14cbcSMatt Macy dsl_pool_t *dp; 5883eda14cbcSMatt Macy dmu_tx_t *tx; 5884eda14cbcSMatt Macy int error = 0; 5885eda14cbcSMatt Macy uint64_t txg = TXG_INITIAL; 5886eda14cbcSMatt Macy nvlist_t **spares, **l2cache; 5887eda14cbcSMatt Macy uint_t nspares, nl2cache; 58887877fdebSMatt Macy uint64_t version, obj, ndraid = 0; 5889eda14cbcSMatt Macy boolean_t has_features; 5890eda14cbcSMatt Macy boolean_t has_encryption; 5891eda14cbcSMatt Macy boolean_t has_allocclass; 5892eda14cbcSMatt Macy spa_feature_t feat; 58932a58b312SMartin Matuska const char *feat_name; 58942a58b312SMartin Matuska const char *poolname; 5895eda14cbcSMatt Macy nvlist_t *nvl; 5896eda14cbcSMatt Macy 5897eda14cbcSMatt Macy if (props == NULL || 5898eda14cbcSMatt Macy nvlist_lookup_string(props, "tname", &poolname) != 0) 5899eda14cbcSMatt Macy poolname = (char *)pool; 5900eda14cbcSMatt Macy 5901eda14cbcSMatt Macy /* 5902eda14cbcSMatt Macy * If this pool already exists, return failure. 5903eda14cbcSMatt Macy */ 5904eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 5905eda14cbcSMatt Macy if (spa_lookup(poolname) != NULL) { 5906eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5907eda14cbcSMatt Macy return (SET_ERROR(EEXIST)); 5908eda14cbcSMatt Macy } 5909eda14cbcSMatt Macy 5910eda14cbcSMatt Macy /* 5911eda14cbcSMatt Macy * Allocate a new spa_t structure. 5912eda14cbcSMatt Macy */ 5913eda14cbcSMatt Macy nvl = fnvlist_alloc(); 5914eda14cbcSMatt Macy fnvlist_add_string(nvl, ZPOOL_CONFIG_POOL_NAME, pool); 5915eda14cbcSMatt Macy (void) nvlist_lookup_string(props, 5916eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 5917eda14cbcSMatt Macy spa = spa_add(poolname, nvl, altroot); 5918eda14cbcSMatt Macy fnvlist_free(nvl); 5919eda14cbcSMatt Macy spa_activate(spa, spa_mode_global); 5920eda14cbcSMatt Macy 5921eda14cbcSMatt Macy if (props && (error = spa_prop_validate(spa, props))) { 5922eda14cbcSMatt Macy spa_deactivate(spa); 5923eda14cbcSMatt Macy spa_remove(spa); 5924eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5925eda14cbcSMatt Macy return (error); 5926eda14cbcSMatt Macy } 5927eda14cbcSMatt Macy 5928eda14cbcSMatt Macy /* 5929eda14cbcSMatt Macy * Temporary pool names should never be written to disk. 5930eda14cbcSMatt Macy */ 5931eda14cbcSMatt Macy if (poolname != pool) 5932eda14cbcSMatt Macy spa->spa_import_flags |= ZFS_IMPORT_TEMP_NAME; 5933eda14cbcSMatt Macy 5934eda14cbcSMatt Macy has_features = B_FALSE; 5935eda14cbcSMatt Macy has_encryption = B_FALSE; 5936eda14cbcSMatt Macy has_allocclass = B_FALSE; 5937eda14cbcSMatt Macy for (nvpair_t *elem = nvlist_next_nvpair(props, NULL); 5938eda14cbcSMatt Macy elem != NULL; elem = nvlist_next_nvpair(props, elem)) { 5939eda14cbcSMatt Macy if (zpool_prop_feature(nvpair_name(elem))) { 5940eda14cbcSMatt Macy has_features = B_TRUE; 5941eda14cbcSMatt Macy 5942eda14cbcSMatt Macy feat_name = strchr(nvpair_name(elem), '@') + 1; 5943eda14cbcSMatt Macy VERIFY0(zfeature_lookup_name(feat_name, &feat)); 5944eda14cbcSMatt Macy if (feat == SPA_FEATURE_ENCRYPTION) 5945eda14cbcSMatt Macy has_encryption = B_TRUE; 5946eda14cbcSMatt Macy if (feat == SPA_FEATURE_ALLOCATION_CLASSES) 5947eda14cbcSMatt Macy has_allocclass = B_TRUE; 5948eda14cbcSMatt Macy } 5949eda14cbcSMatt Macy } 5950eda14cbcSMatt Macy 5951eda14cbcSMatt Macy /* verify encryption params, if they were provided */ 5952eda14cbcSMatt Macy if (dcp != NULL) { 5953eda14cbcSMatt Macy error = spa_create_check_encryption_params(dcp, has_encryption); 5954eda14cbcSMatt Macy if (error != 0) { 5955eda14cbcSMatt Macy spa_deactivate(spa); 5956eda14cbcSMatt Macy spa_remove(spa); 5957eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5958eda14cbcSMatt Macy return (error); 5959eda14cbcSMatt Macy } 5960eda14cbcSMatt Macy } 5961eda14cbcSMatt Macy if (!has_allocclass && zfs_special_devs(nvroot, NULL)) { 5962eda14cbcSMatt Macy spa_deactivate(spa); 5963eda14cbcSMatt Macy spa_remove(spa); 5964eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 5965eda14cbcSMatt Macy return (ENOTSUP); 5966eda14cbcSMatt Macy } 5967eda14cbcSMatt Macy 5968eda14cbcSMatt Macy if (has_features || nvlist_lookup_uint64(props, 5969eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_VERSION), &version) != 0) { 5970eda14cbcSMatt Macy version = SPA_VERSION; 5971eda14cbcSMatt Macy } 5972eda14cbcSMatt Macy ASSERT(SPA_VERSION_IS_SUPPORTED(version)); 5973eda14cbcSMatt Macy 5974eda14cbcSMatt Macy spa->spa_first_txg = txg; 5975eda14cbcSMatt Macy spa->spa_uberblock.ub_txg = txg - 1; 5976eda14cbcSMatt Macy spa->spa_uberblock.ub_version = version; 5977eda14cbcSMatt Macy spa->spa_ubsync = spa->spa_uberblock; 5978eda14cbcSMatt Macy spa->spa_load_state = SPA_LOAD_CREATE; 5979eda14cbcSMatt Macy spa->spa_removing_phys.sr_state = DSS_NONE; 5980eda14cbcSMatt Macy spa->spa_removing_phys.sr_removing_vdev = -1; 5981eda14cbcSMatt Macy spa->spa_removing_phys.sr_prev_indirect_vdev = -1; 5982eda14cbcSMatt Macy spa->spa_indirect_vdevs_loaded = B_TRUE; 5983eda14cbcSMatt Macy 5984eda14cbcSMatt Macy /* 5985eda14cbcSMatt Macy * Create "The Godfather" zio to hold all async IOs 5986eda14cbcSMatt Macy */ 5987eda14cbcSMatt Macy spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *), 5988eda14cbcSMatt Macy KM_SLEEP); 5989eda14cbcSMatt Macy for (int i = 0; i < max_ncpus; i++) { 5990eda14cbcSMatt Macy spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL, 5991eda14cbcSMatt Macy ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | 5992eda14cbcSMatt Macy ZIO_FLAG_GODFATHER); 5993eda14cbcSMatt Macy } 5994eda14cbcSMatt Macy 5995eda14cbcSMatt Macy /* 5996eda14cbcSMatt Macy * Create the root vdev. 5997eda14cbcSMatt Macy */ 5998eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 5999eda14cbcSMatt Macy 6000eda14cbcSMatt Macy error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD); 6001eda14cbcSMatt Macy 6002eda14cbcSMatt Macy ASSERT(error != 0 || rvd != NULL); 6003eda14cbcSMatt Macy ASSERT(error != 0 || spa->spa_root_vdev == rvd); 6004eda14cbcSMatt Macy 6005eda14cbcSMatt Macy if (error == 0 && !zfs_allocatable_devs(nvroot)) 6006eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 6007eda14cbcSMatt Macy 6008eda14cbcSMatt Macy if (error == 0 && 6009eda14cbcSMatt Macy (error = vdev_create(rvd, txg, B_FALSE)) == 0 && 60107877fdebSMatt Macy (error = vdev_draid_spare_create(nvroot, rvd, &ndraid, 0)) == 0 && 60117877fdebSMatt Macy (error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) == 0) { 6012eda14cbcSMatt Macy /* 6013eda14cbcSMatt Macy * instantiate the metaslab groups (this will dirty the vdevs) 6014eda14cbcSMatt Macy * we can no longer error exit past this point 6015eda14cbcSMatt Macy */ 6016eda14cbcSMatt Macy for (int c = 0; error == 0 && c < rvd->vdev_children; c++) { 6017eda14cbcSMatt Macy vdev_t *vd = rvd->vdev_child[c]; 6018eda14cbcSMatt Macy 6019eda14cbcSMatt Macy vdev_metaslab_set_size(vd); 6020eda14cbcSMatt Macy vdev_expand(vd, txg); 6021eda14cbcSMatt Macy } 6022eda14cbcSMatt Macy } 6023eda14cbcSMatt Macy 6024eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6025eda14cbcSMatt Macy 6026eda14cbcSMatt Macy if (error != 0) { 6027eda14cbcSMatt Macy spa_unload(spa); 6028eda14cbcSMatt Macy spa_deactivate(spa); 6029eda14cbcSMatt Macy spa_remove(spa); 6030eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6031eda14cbcSMatt Macy return (error); 6032eda14cbcSMatt Macy } 6033eda14cbcSMatt Macy 6034eda14cbcSMatt Macy /* 6035eda14cbcSMatt Macy * Get the list of spares, if specified. 6036eda14cbcSMatt Macy */ 6037eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 6038eda14cbcSMatt Macy &spares, &nspares) == 0) { 603981b22a98SMartin Matuska spa->spa_spares.sav_config = fnvlist_alloc(); 604081b22a98SMartin Matuska fnvlist_add_nvlist_array(spa->spa_spares.sav_config, 6041681ce946SMartin Matuska ZPOOL_CONFIG_SPARES, (const nvlist_t * const *)spares, 6042681ce946SMartin Matuska nspares); 6043eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6044eda14cbcSMatt Macy spa_load_spares(spa); 6045eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6046eda14cbcSMatt Macy spa->spa_spares.sav_sync = B_TRUE; 6047eda14cbcSMatt Macy } 6048eda14cbcSMatt Macy 6049eda14cbcSMatt Macy /* 6050eda14cbcSMatt Macy * Get the list of level 2 cache devices, if specified. 6051eda14cbcSMatt Macy */ 6052eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 6053eda14cbcSMatt Macy &l2cache, &nl2cache) == 0) { 6054681ce946SMartin Matuska VERIFY0(nvlist_alloc(&spa->spa_l2cache.sav_config, 6055681ce946SMartin Matuska NV_UNIQUE_NAME, KM_SLEEP)); 605681b22a98SMartin Matuska fnvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 6057681ce946SMartin Matuska ZPOOL_CONFIG_L2CACHE, (const nvlist_t * const *)l2cache, 6058681ce946SMartin Matuska nl2cache); 6059eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6060eda14cbcSMatt Macy spa_load_l2cache(spa); 6061eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6062eda14cbcSMatt Macy spa->spa_l2cache.sav_sync = B_TRUE; 6063eda14cbcSMatt Macy } 6064eda14cbcSMatt Macy 6065eda14cbcSMatt Macy spa->spa_is_initializing = B_TRUE; 6066eda14cbcSMatt Macy spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, dcp, txg); 6067eda14cbcSMatt Macy spa->spa_is_initializing = B_FALSE; 6068eda14cbcSMatt Macy 6069eda14cbcSMatt Macy /* 6070eda14cbcSMatt Macy * Create DDTs (dedup tables). 6071eda14cbcSMatt Macy */ 6072eda14cbcSMatt Macy ddt_create(spa); 60732a58b312SMartin Matuska /* 60742a58b312SMartin Matuska * Create BRT table and BRT table object. 60752a58b312SMartin Matuska */ 60762a58b312SMartin Matuska brt_create(spa); 6077eda14cbcSMatt Macy 6078eda14cbcSMatt Macy spa_update_dspace(spa); 6079eda14cbcSMatt Macy 6080eda14cbcSMatt Macy tx = dmu_tx_create_assigned(dp, txg); 6081eda14cbcSMatt Macy 6082eda14cbcSMatt Macy /* 6083eda14cbcSMatt Macy * Create the pool's history object. 6084eda14cbcSMatt Macy */ 6085eda14cbcSMatt Macy if (version >= SPA_VERSION_ZPOOL_HISTORY && !spa->spa_history) 6086eda14cbcSMatt Macy spa_history_create_obj(spa, tx); 6087eda14cbcSMatt Macy 6088eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_CREATE); 6089eda14cbcSMatt Macy spa_history_log_version(spa, "create", tx); 6090eda14cbcSMatt Macy 6091eda14cbcSMatt Macy /* 6092eda14cbcSMatt Macy * Create the pool config object. 6093eda14cbcSMatt Macy */ 6094eda14cbcSMatt Macy spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset, 6095eda14cbcSMatt Macy DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE, 6096eda14cbcSMatt Macy DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx); 6097eda14cbcSMatt Macy 6098eda14cbcSMatt Macy if (zap_add(spa->spa_meta_objset, 6099eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, 6100eda14cbcSMatt Macy sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) { 6101eda14cbcSMatt Macy cmn_err(CE_PANIC, "failed to add pool config"); 6102eda14cbcSMatt Macy } 6103eda14cbcSMatt Macy 6104eda14cbcSMatt Macy if (zap_add(spa->spa_meta_objset, 6105eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CREATION_VERSION, 6106eda14cbcSMatt Macy sizeof (uint64_t), 1, &version, tx) != 0) { 6107eda14cbcSMatt Macy cmn_err(CE_PANIC, "failed to add pool version"); 6108eda14cbcSMatt Macy } 6109eda14cbcSMatt Macy 6110eda14cbcSMatt Macy /* Newly created pools with the right version are always deflated. */ 6111eda14cbcSMatt Macy if (version >= SPA_VERSION_RAIDZ_DEFLATE) { 6112eda14cbcSMatt Macy spa->spa_deflate = TRUE; 6113eda14cbcSMatt Macy if (zap_add(spa->spa_meta_objset, 6114eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 6115eda14cbcSMatt Macy sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) { 6116eda14cbcSMatt Macy cmn_err(CE_PANIC, "failed to add deflate"); 6117eda14cbcSMatt Macy } 6118eda14cbcSMatt Macy } 6119eda14cbcSMatt Macy 6120eda14cbcSMatt Macy /* 6121eda14cbcSMatt Macy * Create the deferred-free bpobj. Turn off compression 6122eda14cbcSMatt Macy * because sync-to-convergence takes longer if the blocksize 6123eda14cbcSMatt Macy * keeps changing. 6124eda14cbcSMatt Macy */ 6125eda14cbcSMatt Macy obj = bpobj_alloc(spa->spa_meta_objset, 1 << 14, tx); 6126eda14cbcSMatt Macy dmu_object_set_compress(spa->spa_meta_objset, obj, 6127eda14cbcSMatt Macy ZIO_COMPRESS_OFF, tx); 6128eda14cbcSMatt Macy if (zap_add(spa->spa_meta_objset, 6129eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPOBJ, 6130eda14cbcSMatt Macy sizeof (uint64_t), 1, &obj, tx) != 0) { 6131eda14cbcSMatt Macy cmn_err(CE_PANIC, "failed to add bpobj"); 6132eda14cbcSMatt Macy } 6133eda14cbcSMatt Macy VERIFY3U(0, ==, bpobj_open(&spa->spa_deferred_bpobj, 6134eda14cbcSMatt Macy spa->spa_meta_objset, obj)); 6135eda14cbcSMatt Macy 6136eda14cbcSMatt Macy /* 6137eda14cbcSMatt Macy * Generate some random noise for salted checksums to operate on. 6138eda14cbcSMatt Macy */ 6139eda14cbcSMatt Macy (void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes, 6140eda14cbcSMatt Macy sizeof (spa->spa_cksum_salt.zcs_bytes)); 6141eda14cbcSMatt Macy 6142eda14cbcSMatt Macy /* 6143eda14cbcSMatt Macy * Set pool properties. 6144eda14cbcSMatt Macy */ 6145eda14cbcSMatt Macy spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS); 6146eda14cbcSMatt Macy spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); 6147eda14cbcSMatt Macy spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE); 6148eda14cbcSMatt Macy spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND); 6149eda14cbcSMatt Macy spa->spa_multihost = zpool_prop_default_numeric(ZPOOL_PROP_MULTIHOST); 6150eda14cbcSMatt Macy spa->spa_autotrim = zpool_prop_default_numeric(ZPOOL_PROP_AUTOTRIM); 6151eda14cbcSMatt Macy 6152eda14cbcSMatt Macy if (props != NULL) { 6153eda14cbcSMatt Macy spa_configfile_set(spa, props, B_FALSE); 6154eda14cbcSMatt Macy spa_sync_props(props, tx); 6155eda14cbcSMatt Macy } 6156eda14cbcSMatt Macy 61577877fdebSMatt Macy for (int i = 0; i < ndraid; i++) 61587877fdebSMatt Macy spa_feature_incr(spa, SPA_FEATURE_DRAID, tx); 61597877fdebSMatt Macy 6160eda14cbcSMatt Macy dmu_tx_commit(tx); 6161eda14cbcSMatt Macy 6162eda14cbcSMatt Macy spa->spa_sync_on = B_TRUE; 6163eda14cbcSMatt Macy txg_sync_start(dp); 6164eda14cbcSMatt Macy mmp_thread_start(spa); 6165eda14cbcSMatt Macy txg_wait_synced(dp, txg); 6166eda14cbcSMatt Macy 6167eda14cbcSMatt Macy spa_spawn_aux_threads(spa); 6168eda14cbcSMatt Macy 6169be181ee2SMartin Matuska spa_write_cachefile(spa, B_FALSE, B_TRUE, B_TRUE); 6170eda14cbcSMatt Macy 6171eda14cbcSMatt Macy /* 6172eda14cbcSMatt Macy * Don't count references from objsets that are already closed 6173eda14cbcSMatt Macy * and are making their way through the eviction process. 6174eda14cbcSMatt Macy */ 6175eda14cbcSMatt Macy spa_evicting_os_wait(spa); 6176eda14cbcSMatt Macy spa->spa_minref = zfs_refcount_count(&spa->spa_refcount); 6177eda14cbcSMatt Macy spa->spa_load_state = SPA_LOAD_NONE; 6178eda14cbcSMatt Macy 6179c03c5b1cSMartin Matuska spa_import_os(spa); 6180c03c5b1cSMartin Matuska 6181eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6182eda14cbcSMatt Macy 6183eda14cbcSMatt Macy return (0); 6184eda14cbcSMatt Macy } 6185eda14cbcSMatt Macy 6186eda14cbcSMatt Macy /* 6187eda14cbcSMatt Macy * Import a non-root pool into the system. 6188eda14cbcSMatt Macy */ 6189eda14cbcSMatt Macy int 6190eda14cbcSMatt Macy spa_import(char *pool, nvlist_t *config, nvlist_t *props, uint64_t flags) 6191eda14cbcSMatt Macy { 6192eda14cbcSMatt Macy spa_t *spa; 61932a58b312SMartin Matuska const char *altroot = NULL; 6194eda14cbcSMatt Macy spa_load_state_t state = SPA_LOAD_IMPORT; 6195eda14cbcSMatt Macy zpool_load_policy_t policy; 6196eda14cbcSMatt Macy spa_mode_t mode = spa_mode_global; 6197eda14cbcSMatt Macy uint64_t readonly = B_FALSE; 6198eda14cbcSMatt Macy int error; 6199eda14cbcSMatt Macy nvlist_t *nvroot; 6200eda14cbcSMatt Macy nvlist_t **spares, **l2cache; 6201eda14cbcSMatt Macy uint_t nspares, nl2cache; 6202eda14cbcSMatt Macy 6203eda14cbcSMatt Macy /* 6204eda14cbcSMatt Macy * If a pool with this name exists, return failure. 6205eda14cbcSMatt Macy */ 6206eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 6207eda14cbcSMatt Macy if (spa_lookup(pool) != NULL) { 6208eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6209eda14cbcSMatt Macy return (SET_ERROR(EEXIST)); 6210eda14cbcSMatt Macy } 6211eda14cbcSMatt Macy 6212eda14cbcSMatt Macy /* 6213eda14cbcSMatt Macy * Create and initialize the spa structure. 6214eda14cbcSMatt Macy */ 6215eda14cbcSMatt Macy (void) nvlist_lookup_string(props, 6216eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 6217eda14cbcSMatt Macy (void) nvlist_lookup_uint64(props, 6218eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly); 6219eda14cbcSMatt Macy if (readonly) 6220eda14cbcSMatt Macy mode = SPA_MODE_READ; 6221eda14cbcSMatt Macy spa = spa_add(pool, config, altroot); 6222eda14cbcSMatt Macy spa->spa_import_flags = flags; 6223eda14cbcSMatt Macy 6224eda14cbcSMatt Macy /* 6225eda14cbcSMatt Macy * Verbatim import - Take a pool and insert it into the namespace 6226eda14cbcSMatt Macy * as if it had been loaded at boot. 6227eda14cbcSMatt Macy */ 6228eda14cbcSMatt Macy if (spa->spa_import_flags & ZFS_IMPORT_VERBATIM) { 6229eda14cbcSMatt Macy if (props != NULL) 6230eda14cbcSMatt Macy spa_configfile_set(spa, props, B_FALSE); 6231eda14cbcSMatt Macy 6232be181ee2SMartin Matuska spa_write_cachefile(spa, B_FALSE, B_TRUE, B_FALSE); 6233eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_IMPORT); 6234eda14cbcSMatt Macy zfs_dbgmsg("spa_import: verbatim import of %s", pool); 6235eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6236eda14cbcSMatt Macy return (0); 6237eda14cbcSMatt Macy } 6238eda14cbcSMatt Macy 6239eda14cbcSMatt Macy spa_activate(spa, mode); 6240eda14cbcSMatt Macy 6241eda14cbcSMatt Macy /* 6242eda14cbcSMatt Macy * Don't start async tasks until we know everything is healthy. 6243eda14cbcSMatt Macy */ 6244eda14cbcSMatt Macy spa_async_suspend(spa); 6245eda14cbcSMatt Macy 6246eda14cbcSMatt Macy zpool_get_load_policy(config, &policy); 6247eda14cbcSMatt Macy if (policy.zlp_rewind & ZPOOL_DO_REWIND) 6248eda14cbcSMatt Macy state = SPA_LOAD_RECOVER; 6249eda14cbcSMatt Macy 6250eda14cbcSMatt Macy spa->spa_config_source = SPA_CONFIG_SRC_TRYIMPORT; 6251eda14cbcSMatt Macy 6252eda14cbcSMatt Macy if (state != SPA_LOAD_RECOVER) { 6253eda14cbcSMatt Macy spa->spa_last_ubsync_txg = spa->spa_load_txg = 0; 6254eda14cbcSMatt Macy zfs_dbgmsg("spa_import: importing %s", pool); 6255eda14cbcSMatt Macy } else { 6256eda14cbcSMatt Macy zfs_dbgmsg("spa_import: importing %s, max_txg=%lld " 6257eda14cbcSMatt Macy "(RECOVERY MODE)", pool, (longlong_t)policy.zlp_txg); 6258eda14cbcSMatt Macy } 6259eda14cbcSMatt Macy error = spa_load_best(spa, state, policy.zlp_txg, policy.zlp_rewind); 6260eda14cbcSMatt Macy 6261eda14cbcSMatt Macy /* 6262eda14cbcSMatt Macy * Propagate anything learned while loading the pool and pass it 6263eda14cbcSMatt Macy * back to caller (i.e. rewind info, missing devices, etc). 6264eda14cbcSMatt Macy */ 626581b22a98SMartin Matuska fnvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, spa->spa_load_info); 6266eda14cbcSMatt Macy 6267eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6268eda14cbcSMatt Macy /* 6269eda14cbcSMatt Macy * Toss any existing sparelist, as it doesn't have any validity 6270eda14cbcSMatt Macy * anymore, and conflicts with spa_has_spare(). 6271eda14cbcSMatt Macy */ 6272eda14cbcSMatt Macy if (spa->spa_spares.sav_config) { 6273eda14cbcSMatt Macy nvlist_free(spa->spa_spares.sav_config); 6274eda14cbcSMatt Macy spa->spa_spares.sav_config = NULL; 6275eda14cbcSMatt Macy spa_load_spares(spa); 6276eda14cbcSMatt Macy } 6277eda14cbcSMatt Macy if (spa->spa_l2cache.sav_config) { 6278eda14cbcSMatt Macy nvlist_free(spa->spa_l2cache.sav_config); 6279eda14cbcSMatt Macy spa->spa_l2cache.sav_config = NULL; 6280eda14cbcSMatt Macy spa_load_l2cache(spa); 6281eda14cbcSMatt Macy } 6282eda14cbcSMatt Macy 628381b22a98SMartin Matuska nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 6284eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6285eda14cbcSMatt Macy 6286eda14cbcSMatt Macy if (props != NULL) 6287eda14cbcSMatt Macy spa_configfile_set(spa, props, B_FALSE); 6288eda14cbcSMatt Macy 6289eda14cbcSMatt Macy if (error != 0 || (props && spa_writeable(spa) && 6290eda14cbcSMatt Macy (error = spa_prop_set(spa, props)))) { 6291eda14cbcSMatt Macy spa_unload(spa); 6292eda14cbcSMatt Macy spa_deactivate(spa); 6293eda14cbcSMatt Macy spa_remove(spa); 6294eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6295eda14cbcSMatt Macy return (error); 6296eda14cbcSMatt Macy } 6297eda14cbcSMatt Macy 6298eda14cbcSMatt Macy spa_async_resume(spa); 6299eda14cbcSMatt Macy 6300eda14cbcSMatt Macy /* 6301eda14cbcSMatt Macy * Override any spares and level 2 cache devices as specified by 6302eda14cbcSMatt Macy * the user, as these may have correct device names/devids, etc. 6303eda14cbcSMatt Macy */ 6304eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 6305eda14cbcSMatt Macy &spares, &nspares) == 0) { 6306eda14cbcSMatt Macy if (spa->spa_spares.sav_config) 630781b22a98SMartin Matuska fnvlist_remove(spa->spa_spares.sav_config, 630881b22a98SMartin Matuska ZPOOL_CONFIG_SPARES); 6309eda14cbcSMatt Macy else 631081b22a98SMartin Matuska spa->spa_spares.sav_config = fnvlist_alloc(); 631181b22a98SMartin Matuska fnvlist_add_nvlist_array(spa->spa_spares.sav_config, 6312681ce946SMartin Matuska ZPOOL_CONFIG_SPARES, (const nvlist_t * const *)spares, 6313681ce946SMartin Matuska nspares); 6314eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6315eda14cbcSMatt Macy spa_load_spares(spa); 6316eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6317eda14cbcSMatt Macy spa->spa_spares.sav_sync = B_TRUE; 6318eda14cbcSMatt Macy } 6319eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 6320eda14cbcSMatt Macy &l2cache, &nl2cache) == 0) { 6321eda14cbcSMatt Macy if (spa->spa_l2cache.sav_config) 632281b22a98SMartin Matuska fnvlist_remove(spa->spa_l2cache.sav_config, 632381b22a98SMartin Matuska ZPOOL_CONFIG_L2CACHE); 6324eda14cbcSMatt Macy else 632581b22a98SMartin Matuska spa->spa_l2cache.sav_config = fnvlist_alloc(); 632681b22a98SMartin Matuska fnvlist_add_nvlist_array(spa->spa_l2cache.sav_config, 6327681ce946SMartin Matuska ZPOOL_CONFIG_L2CACHE, (const nvlist_t * const *)l2cache, 6328681ce946SMartin Matuska nl2cache); 6329eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6330eda14cbcSMatt Macy spa_load_l2cache(spa); 6331eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6332eda14cbcSMatt Macy spa->spa_l2cache.sav_sync = B_TRUE; 6333eda14cbcSMatt Macy } 6334eda14cbcSMatt Macy 6335eda14cbcSMatt Macy /* 6336eda14cbcSMatt Macy * Check for any removed devices. 6337eda14cbcSMatt Macy */ 6338eda14cbcSMatt Macy if (spa->spa_autoreplace) { 6339eda14cbcSMatt Macy spa_aux_check_removed(&spa->spa_spares); 6340eda14cbcSMatt Macy spa_aux_check_removed(&spa->spa_l2cache); 6341eda14cbcSMatt Macy } 6342eda14cbcSMatt Macy 6343eda14cbcSMatt Macy if (spa_writeable(spa)) { 6344eda14cbcSMatt Macy /* 6345eda14cbcSMatt Macy * Update the config cache to include the newly-imported pool. 6346eda14cbcSMatt Macy */ 6347eda14cbcSMatt Macy spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 6348eda14cbcSMatt Macy } 6349eda14cbcSMatt Macy 6350eda14cbcSMatt Macy /* 6351eda14cbcSMatt Macy * It's possible that the pool was expanded while it was exported. 6352eda14cbcSMatt Macy * We kick off an async task to handle this for us. 6353eda14cbcSMatt Macy */ 6354eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_AUTOEXPAND); 6355eda14cbcSMatt Macy 6356eda14cbcSMatt Macy spa_history_log_version(spa, "import", NULL); 6357eda14cbcSMatt Macy 6358eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_IMPORT); 6359eda14cbcSMatt Macy 6360eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6361eda14cbcSMatt Macy 6362eda14cbcSMatt Macy zvol_create_minors_recursive(pool); 6363eda14cbcSMatt Macy 6364c03c5b1cSMartin Matuska spa_import_os(spa); 6365c03c5b1cSMartin Matuska 6366eda14cbcSMatt Macy return (0); 6367eda14cbcSMatt Macy } 6368eda14cbcSMatt Macy 6369eda14cbcSMatt Macy nvlist_t * 6370eda14cbcSMatt Macy spa_tryimport(nvlist_t *tryconfig) 6371eda14cbcSMatt Macy { 6372eda14cbcSMatt Macy nvlist_t *config = NULL; 63732a58b312SMartin Matuska const char *poolname, *cachefile; 6374eda14cbcSMatt Macy spa_t *spa; 6375eda14cbcSMatt Macy uint64_t state; 6376eda14cbcSMatt Macy int error; 6377eda14cbcSMatt Macy zpool_load_policy_t policy; 6378eda14cbcSMatt Macy 6379eda14cbcSMatt Macy if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) 6380eda14cbcSMatt Macy return (NULL); 6381eda14cbcSMatt Macy 6382eda14cbcSMatt Macy if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state)) 6383eda14cbcSMatt Macy return (NULL); 6384eda14cbcSMatt Macy 6385eda14cbcSMatt Macy /* 6386eda14cbcSMatt Macy * Create and initialize the spa structure. 6387eda14cbcSMatt Macy */ 6388eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 6389eda14cbcSMatt Macy spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL); 6390eda14cbcSMatt Macy spa_activate(spa, SPA_MODE_READ); 6391eda14cbcSMatt Macy 6392eda14cbcSMatt Macy /* 6393eda14cbcSMatt Macy * Rewind pool if a max txg was provided. 6394eda14cbcSMatt Macy */ 6395eda14cbcSMatt Macy zpool_get_load_policy(spa->spa_config, &policy); 6396eda14cbcSMatt Macy if (policy.zlp_txg != UINT64_MAX) { 6397eda14cbcSMatt Macy spa->spa_load_max_txg = policy.zlp_txg; 6398eda14cbcSMatt Macy spa->spa_extreme_rewind = B_TRUE; 6399eda14cbcSMatt Macy zfs_dbgmsg("spa_tryimport: importing %s, max_txg=%lld", 6400eda14cbcSMatt Macy poolname, (longlong_t)policy.zlp_txg); 6401eda14cbcSMatt Macy } else { 6402eda14cbcSMatt Macy zfs_dbgmsg("spa_tryimport: importing %s", poolname); 6403eda14cbcSMatt Macy } 6404eda14cbcSMatt Macy 6405eda14cbcSMatt Macy if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_CACHEFILE, &cachefile) 6406eda14cbcSMatt Macy == 0) { 6407eda14cbcSMatt Macy zfs_dbgmsg("spa_tryimport: using cachefile '%s'", cachefile); 6408eda14cbcSMatt Macy spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE; 6409eda14cbcSMatt Macy } else { 6410eda14cbcSMatt Macy spa->spa_config_source = SPA_CONFIG_SRC_SCAN; 6411eda14cbcSMatt Macy } 6412eda14cbcSMatt Macy 6413e639e0d2SMartin Matuska /* 6414e639e0d2SMartin Matuska * spa_import() relies on a pool config fetched by spa_try_import() 6415e639e0d2SMartin Matuska * for spare/cache devices. Import flags are not passed to 6416e639e0d2SMartin Matuska * spa_tryimport(), which makes it return early due to a missing log 6417e639e0d2SMartin Matuska * device and missing retrieving the cache device and spare eventually. 6418e639e0d2SMartin Matuska * Passing ZFS_IMPORT_MISSING_LOG to spa_tryimport() makes it fetch 6419e639e0d2SMartin Matuska * the correct configuration regardless of the missing log device. 6420e639e0d2SMartin Matuska */ 6421e639e0d2SMartin Matuska spa->spa_import_flags |= ZFS_IMPORT_MISSING_LOG; 6422e639e0d2SMartin Matuska 6423eda14cbcSMatt Macy error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING); 6424eda14cbcSMatt Macy 6425eda14cbcSMatt Macy /* 6426eda14cbcSMatt Macy * If 'tryconfig' was at least parsable, return the current config. 6427eda14cbcSMatt Macy */ 6428eda14cbcSMatt Macy if (spa->spa_root_vdev != NULL) { 6429eda14cbcSMatt Macy config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); 643081b22a98SMartin Matuska fnvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, poolname); 643181b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, state); 643281b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP, 643381b22a98SMartin Matuska spa->spa_uberblock.ub_timestamp); 643481b22a98SMartin Matuska fnvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, 643581b22a98SMartin Matuska spa->spa_load_info); 643681b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_ERRATA, 643781b22a98SMartin Matuska spa->spa_errata); 6438eda14cbcSMatt Macy 6439eda14cbcSMatt Macy /* 6440eda14cbcSMatt Macy * If the bootfs property exists on this pool then we 6441eda14cbcSMatt Macy * copy it out so that external consumers can tell which 6442eda14cbcSMatt Macy * pools are bootable. 6443eda14cbcSMatt Macy */ 6444eda14cbcSMatt Macy if ((!error || error == EEXIST) && spa->spa_bootfs) { 6445eda14cbcSMatt Macy char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 6446eda14cbcSMatt Macy 6447eda14cbcSMatt Macy /* 6448eda14cbcSMatt Macy * We have to play games with the name since the 6449eda14cbcSMatt Macy * pool was opened as TRYIMPORT_NAME. 6450eda14cbcSMatt Macy */ 6451eda14cbcSMatt Macy if (dsl_dsobj_to_dsname(spa_name(spa), 6452eda14cbcSMatt Macy spa->spa_bootfs, tmpname) == 0) { 6453eda14cbcSMatt Macy char *cp; 6454eda14cbcSMatt Macy char *dsname; 6455eda14cbcSMatt Macy 6456eda14cbcSMatt Macy dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 6457eda14cbcSMatt Macy 6458eda14cbcSMatt Macy cp = strchr(tmpname, '/'); 6459eda14cbcSMatt Macy if (cp == NULL) { 6460eda14cbcSMatt Macy (void) strlcpy(dsname, tmpname, 6461eda14cbcSMatt Macy MAXPATHLEN); 6462eda14cbcSMatt Macy } else { 6463eda14cbcSMatt Macy (void) snprintf(dsname, MAXPATHLEN, 6464eda14cbcSMatt Macy "%s/%s", poolname, ++cp); 6465eda14cbcSMatt Macy } 646681b22a98SMartin Matuska fnvlist_add_string(config, ZPOOL_CONFIG_BOOTFS, 646781b22a98SMartin Matuska dsname); 6468eda14cbcSMatt Macy kmem_free(dsname, MAXPATHLEN); 6469eda14cbcSMatt Macy } 6470eda14cbcSMatt Macy kmem_free(tmpname, MAXPATHLEN); 6471eda14cbcSMatt Macy } 6472eda14cbcSMatt Macy 6473eda14cbcSMatt Macy /* 6474eda14cbcSMatt Macy * Add the list of hot spares and level 2 cache devices. 6475eda14cbcSMatt Macy */ 6476eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 6477eda14cbcSMatt Macy spa_add_spares(spa, config); 6478eda14cbcSMatt Macy spa_add_l2cache(spa, config); 6479eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 6480eda14cbcSMatt Macy } 6481eda14cbcSMatt Macy 6482eda14cbcSMatt Macy spa_unload(spa); 6483eda14cbcSMatt Macy spa_deactivate(spa); 6484eda14cbcSMatt Macy spa_remove(spa); 6485eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6486eda14cbcSMatt Macy 6487eda14cbcSMatt Macy return (config); 6488eda14cbcSMatt Macy } 6489eda14cbcSMatt Macy 6490eda14cbcSMatt Macy /* 6491eda14cbcSMatt Macy * Pool export/destroy 6492eda14cbcSMatt Macy * 6493eda14cbcSMatt Macy * The act of destroying or exporting a pool is very simple. We make sure there 6494eda14cbcSMatt Macy * is no more pending I/O and any references to the pool are gone. Then, we 6495eda14cbcSMatt Macy * update the pool state and sync all the labels to disk, removing the 6496eda14cbcSMatt Macy * configuration from the cache afterwards. If the 'hardforce' flag is set, then 6497eda14cbcSMatt Macy * we don't sync the labels or remove the configuration cache. 6498eda14cbcSMatt Macy */ 6499eda14cbcSMatt Macy static int 6500180f8225SMatt Macy spa_export_common(const char *pool, int new_state, nvlist_t **oldconfig, 6501eda14cbcSMatt Macy boolean_t force, boolean_t hardforce) 6502eda14cbcSMatt Macy { 6503184c1b94SMartin Matuska int error; 6504eda14cbcSMatt Macy spa_t *spa; 6505eda14cbcSMatt Macy 6506eda14cbcSMatt Macy if (oldconfig) 6507eda14cbcSMatt Macy *oldconfig = NULL; 6508eda14cbcSMatt Macy 6509eda14cbcSMatt Macy if (!(spa_mode_global & SPA_MODE_WRITE)) 6510eda14cbcSMatt Macy return (SET_ERROR(EROFS)); 6511eda14cbcSMatt Macy 6512eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 6513eda14cbcSMatt Macy if ((spa = spa_lookup(pool)) == NULL) { 6514eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6515eda14cbcSMatt Macy return (SET_ERROR(ENOENT)); 6516eda14cbcSMatt Macy } 6517eda14cbcSMatt Macy 6518eda14cbcSMatt Macy if (spa->spa_is_exporting) { 6519eda14cbcSMatt Macy /* the pool is being exported by another thread */ 6520eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6521eda14cbcSMatt Macy return (SET_ERROR(ZFS_ERR_EXPORT_IN_PROGRESS)); 6522eda14cbcSMatt Macy } 6523eda14cbcSMatt Macy spa->spa_is_exporting = B_TRUE; 6524eda14cbcSMatt Macy 6525eda14cbcSMatt Macy /* 6526eda14cbcSMatt Macy * Put a hold on the pool, drop the namespace lock, stop async tasks, 6527eda14cbcSMatt Macy * reacquire the namespace lock, and see if we can export. 6528eda14cbcSMatt Macy */ 6529eda14cbcSMatt Macy spa_open_ref(spa, FTAG); 6530eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6531eda14cbcSMatt Macy spa_async_suspend(spa); 6532eda14cbcSMatt Macy if (spa->spa_zvol_taskq) { 6533eda14cbcSMatt Macy zvol_remove_minors(spa, spa_name(spa), B_TRUE); 6534eda14cbcSMatt Macy taskq_wait(spa->spa_zvol_taskq); 6535eda14cbcSMatt Macy } 6536eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 6537eda14cbcSMatt Macy spa_close(spa, FTAG); 6538eda14cbcSMatt Macy 6539eda14cbcSMatt Macy if (spa->spa_state == POOL_STATE_UNINITIALIZED) 6540eda14cbcSMatt Macy goto export_spa; 6541eda14cbcSMatt Macy /* 6542eda14cbcSMatt Macy * The pool will be in core if it's openable, in which case we can 6543eda14cbcSMatt Macy * modify its state. Objsets may be open only because they're dirty, 6544eda14cbcSMatt Macy * so we have to force it to sync before checking spa_refcnt. 6545eda14cbcSMatt Macy */ 6546eda14cbcSMatt Macy if (spa->spa_sync_on) { 6547eda14cbcSMatt Macy txg_wait_synced(spa->spa_dsl_pool, 0); 6548eda14cbcSMatt Macy spa_evicting_os_wait(spa); 6549eda14cbcSMatt Macy } 6550eda14cbcSMatt Macy 6551eda14cbcSMatt Macy /* 6552eda14cbcSMatt Macy * A pool cannot be exported or destroyed if there are active 6553eda14cbcSMatt Macy * references. If we are resetting a pool, allow references by 6554eda14cbcSMatt Macy * fault injection handlers. 6555eda14cbcSMatt Macy */ 6556184c1b94SMartin Matuska if (!spa_refcount_zero(spa) || (spa->spa_inject_ref != 0)) { 6557184c1b94SMartin Matuska error = SET_ERROR(EBUSY); 6558184c1b94SMartin Matuska goto fail; 6559eda14cbcSMatt Macy } 6560eda14cbcSMatt Macy 6561eda14cbcSMatt Macy if (spa->spa_sync_on) { 6562be181ee2SMartin Matuska vdev_t *rvd = spa->spa_root_vdev; 6563eda14cbcSMatt Macy /* 6564eda14cbcSMatt Macy * A pool cannot be exported if it has an active shared spare. 6565eda14cbcSMatt Macy * This is to prevent other pools stealing the active spare 6566eda14cbcSMatt Macy * from an exported pool. At user's own will, such pool can 6567eda14cbcSMatt Macy * be forcedly exported. 6568eda14cbcSMatt Macy */ 6569eda14cbcSMatt Macy if (!force && new_state == POOL_STATE_EXPORTED && 6570eda14cbcSMatt Macy spa_has_active_shared_spare(spa)) { 6571184c1b94SMartin Matuska error = SET_ERROR(EXDEV); 6572184c1b94SMartin Matuska goto fail; 6573eda14cbcSMatt Macy } 6574eda14cbcSMatt Macy 6575eda14cbcSMatt Macy /* 6576eda14cbcSMatt Macy * We're about to export or destroy this pool. Make sure 6577eda14cbcSMatt Macy * we stop all initialization and trim activity here before 6578eda14cbcSMatt Macy * we set the spa_final_txg. This will ensure that all 6579eda14cbcSMatt Macy * dirty data resulting from the initialization is 6580eda14cbcSMatt Macy * committed to disk before we unload the pool. 6581eda14cbcSMatt Macy */ 6582eda14cbcSMatt Macy vdev_initialize_stop_all(rvd, VDEV_INITIALIZE_ACTIVE); 6583eda14cbcSMatt Macy vdev_trim_stop_all(rvd, VDEV_TRIM_ACTIVE); 6584eda14cbcSMatt Macy vdev_autotrim_stop_all(spa); 6585eda14cbcSMatt Macy vdev_rebuild_stop_all(spa); 6586eda14cbcSMatt Macy 6587eda14cbcSMatt Macy /* 6588eda14cbcSMatt Macy * We want this to be reflected on every label, 6589eda14cbcSMatt Macy * so mark them all dirty. spa_unload() will do the 6590eda14cbcSMatt Macy * final sync that pushes these changes out. 6591eda14cbcSMatt Macy */ 6592eda14cbcSMatt Macy if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) { 6593eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6594eda14cbcSMatt Macy spa->spa_state = new_state; 6595be181ee2SMartin Matuska vdev_config_dirty(rvd); 6596c03c5b1cSMartin Matuska spa_config_exit(spa, SCL_ALL, FTAG); 6597c03c5b1cSMartin Matuska } 6598c03c5b1cSMartin Matuska 6599c03c5b1cSMartin Matuska /* 6600c03c5b1cSMartin Matuska * If the log space map feature is enabled and the pool is 6601c03c5b1cSMartin Matuska * getting exported (but not destroyed), we want to spend some 6602c03c5b1cSMartin Matuska * time flushing as many metaslabs as we can in an attempt to 6603c03c5b1cSMartin Matuska * destroy log space maps and save import time. This has to be 6604c03c5b1cSMartin Matuska * done before we set the spa_final_txg, otherwise 6605c03c5b1cSMartin Matuska * spa_sync() -> spa_flush_metaslabs() may dirty the final TXGs. 6606c03c5b1cSMartin Matuska * spa_should_flush_logs_on_unload() should be called after 6607c03c5b1cSMartin Matuska * spa_state has been set to the new_state. 6608c03c5b1cSMartin Matuska */ 6609c03c5b1cSMartin Matuska if (spa_should_flush_logs_on_unload(spa)) 6610c03c5b1cSMartin Matuska spa_unload_log_sm_flush_all(spa); 6611c03c5b1cSMartin Matuska 6612c03c5b1cSMartin Matuska if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) { 6613c03c5b1cSMartin Matuska spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 6614eda14cbcSMatt Macy spa->spa_final_txg = spa_last_synced_txg(spa) + 6615eda14cbcSMatt Macy TXG_DEFER_SIZE + 1; 6616eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 6617eda14cbcSMatt Macy } 6618eda14cbcSMatt Macy } 6619eda14cbcSMatt Macy 6620eda14cbcSMatt Macy export_spa: 6621c03c5b1cSMartin Matuska spa_export_os(spa); 6622c03c5b1cSMartin Matuska 6623eda14cbcSMatt Macy if (new_state == POOL_STATE_DESTROYED) 6624eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_DESTROY); 6625eda14cbcSMatt Macy else if (new_state == POOL_STATE_EXPORTED) 6626eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_EXPORT); 6627eda14cbcSMatt Macy 6628eda14cbcSMatt Macy if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 6629eda14cbcSMatt Macy spa_unload(spa); 6630eda14cbcSMatt Macy spa_deactivate(spa); 6631eda14cbcSMatt Macy } 6632eda14cbcSMatt Macy 6633eda14cbcSMatt Macy if (oldconfig && spa->spa_config) 663481b22a98SMartin Matuska *oldconfig = fnvlist_dup(spa->spa_config); 6635eda14cbcSMatt Macy 6636eda14cbcSMatt Macy if (new_state != POOL_STATE_UNINITIALIZED) { 6637eda14cbcSMatt Macy if (!hardforce) 6638be181ee2SMartin Matuska spa_write_cachefile(spa, B_TRUE, B_TRUE, B_FALSE); 6639eda14cbcSMatt Macy spa_remove(spa); 6640eda14cbcSMatt Macy } else { 6641eda14cbcSMatt Macy /* 6642eda14cbcSMatt Macy * If spa_remove() is not called for this spa_t and 6643eda14cbcSMatt Macy * there is any possibility that it can be reused, 6644eda14cbcSMatt Macy * we make sure to reset the exporting flag. 6645eda14cbcSMatt Macy */ 6646eda14cbcSMatt Macy spa->spa_is_exporting = B_FALSE; 6647eda14cbcSMatt Macy } 6648eda14cbcSMatt Macy 6649eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6650eda14cbcSMatt Macy return (0); 6651184c1b94SMartin Matuska 6652184c1b94SMartin Matuska fail: 6653184c1b94SMartin Matuska spa->spa_is_exporting = B_FALSE; 6654184c1b94SMartin Matuska spa_async_resume(spa); 6655184c1b94SMartin Matuska mutex_exit(&spa_namespace_lock); 6656184c1b94SMartin Matuska return (error); 6657eda14cbcSMatt Macy } 6658eda14cbcSMatt Macy 6659eda14cbcSMatt Macy /* 6660eda14cbcSMatt Macy * Destroy a storage pool. 6661eda14cbcSMatt Macy */ 6662eda14cbcSMatt Macy int 6663180f8225SMatt Macy spa_destroy(const char *pool) 6664eda14cbcSMatt Macy { 6665eda14cbcSMatt Macy return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL, 6666eda14cbcSMatt Macy B_FALSE, B_FALSE)); 6667eda14cbcSMatt Macy } 6668eda14cbcSMatt Macy 6669eda14cbcSMatt Macy /* 6670eda14cbcSMatt Macy * Export a storage pool. 6671eda14cbcSMatt Macy */ 6672eda14cbcSMatt Macy int 6673180f8225SMatt Macy spa_export(const char *pool, nvlist_t **oldconfig, boolean_t force, 6674eda14cbcSMatt Macy boolean_t hardforce) 6675eda14cbcSMatt Macy { 6676eda14cbcSMatt Macy return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig, 6677eda14cbcSMatt Macy force, hardforce)); 6678eda14cbcSMatt Macy } 6679eda14cbcSMatt Macy 6680eda14cbcSMatt Macy /* 6681eda14cbcSMatt Macy * Similar to spa_export(), this unloads the spa_t without actually removing it 6682eda14cbcSMatt Macy * from the namespace in any way. 6683eda14cbcSMatt Macy */ 6684eda14cbcSMatt Macy int 6685180f8225SMatt Macy spa_reset(const char *pool) 6686eda14cbcSMatt Macy { 6687eda14cbcSMatt Macy return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL, 6688eda14cbcSMatt Macy B_FALSE, B_FALSE)); 6689eda14cbcSMatt Macy } 6690eda14cbcSMatt Macy 6691eda14cbcSMatt Macy /* 6692eda14cbcSMatt Macy * ========================================================================== 6693eda14cbcSMatt Macy * Device manipulation 6694eda14cbcSMatt Macy * ========================================================================== 6695eda14cbcSMatt Macy */ 6696eda14cbcSMatt Macy 6697eda14cbcSMatt Macy /* 66987877fdebSMatt Macy * This is called as a synctask to increment the draid feature flag 66997877fdebSMatt Macy */ 67007877fdebSMatt Macy static void 67017877fdebSMatt Macy spa_draid_feature_incr(void *arg, dmu_tx_t *tx) 67027877fdebSMatt Macy { 67037877fdebSMatt Macy spa_t *spa = dmu_tx_pool(tx)->dp_spa; 67047877fdebSMatt Macy int draid = (int)(uintptr_t)arg; 67057877fdebSMatt Macy 67067877fdebSMatt Macy for (int c = 0; c < draid; c++) 67077877fdebSMatt Macy spa_feature_incr(spa, SPA_FEATURE_DRAID, tx); 67087877fdebSMatt Macy } 67097877fdebSMatt Macy 67107877fdebSMatt Macy /* 6711eda14cbcSMatt Macy * Add a device to a storage pool. 6712eda14cbcSMatt Macy */ 6713eda14cbcSMatt Macy int 6714eda14cbcSMatt Macy spa_vdev_add(spa_t *spa, nvlist_t *nvroot) 6715eda14cbcSMatt Macy { 67167877fdebSMatt Macy uint64_t txg, ndraid = 0; 6717eda14cbcSMatt Macy int error; 6718eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 6719eda14cbcSMatt Macy vdev_t *vd, *tvd; 6720eda14cbcSMatt Macy nvlist_t **spares, **l2cache; 6721eda14cbcSMatt Macy uint_t nspares, nl2cache; 6722eda14cbcSMatt Macy 6723eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 6724eda14cbcSMatt Macy 6725eda14cbcSMatt Macy txg = spa_vdev_enter(spa); 6726eda14cbcSMatt Macy 6727eda14cbcSMatt Macy if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0, 6728eda14cbcSMatt Macy VDEV_ALLOC_ADD)) != 0) 6729eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, error)); 6730eda14cbcSMatt Macy 6731eda14cbcSMatt Macy spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */ 6732eda14cbcSMatt Macy 6733eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares, 6734eda14cbcSMatt Macy &nspares) != 0) 6735eda14cbcSMatt Macy nspares = 0; 6736eda14cbcSMatt Macy 6737eda14cbcSMatt Macy if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache, 6738eda14cbcSMatt Macy &nl2cache) != 0) 6739eda14cbcSMatt Macy nl2cache = 0; 6740eda14cbcSMatt Macy 6741eda14cbcSMatt Macy if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) 6742eda14cbcSMatt Macy return (spa_vdev_exit(spa, vd, txg, EINVAL)); 6743eda14cbcSMatt Macy 6744eda14cbcSMatt Macy if (vd->vdev_children != 0 && 67457877fdebSMatt Macy (error = vdev_create(vd, txg, B_FALSE)) != 0) { 6746eda14cbcSMatt Macy return (spa_vdev_exit(spa, vd, txg, error)); 67477877fdebSMatt Macy } 67487877fdebSMatt Macy 67497877fdebSMatt Macy /* 67507877fdebSMatt Macy * The virtual dRAID spares must be added after vdev tree is created 675116038816SMartin Matuska * and the vdev guids are generated. The guid of their associated 67527877fdebSMatt Macy * dRAID is stored in the config and used when opening the spare. 67537877fdebSMatt Macy */ 67547877fdebSMatt Macy if ((error = vdev_draid_spare_create(nvroot, vd, &ndraid, 67557877fdebSMatt Macy rvd->vdev_children)) == 0) { 67567877fdebSMatt Macy if (ndraid > 0 && nvlist_lookup_nvlist_array(nvroot, 67577877fdebSMatt Macy ZPOOL_CONFIG_SPARES, &spares, &nspares) != 0) 67587877fdebSMatt Macy nspares = 0; 67597877fdebSMatt Macy } else { 67607877fdebSMatt Macy return (spa_vdev_exit(spa, vd, txg, error)); 67617877fdebSMatt Macy } 6762eda14cbcSMatt Macy 6763eda14cbcSMatt Macy /* 6764eda14cbcSMatt Macy * We must validate the spares and l2cache devices after checking the 6765eda14cbcSMatt Macy * children. Otherwise, vdev_inuse() will blindly overwrite the spare. 6766eda14cbcSMatt Macy */ 6767eda14cbcSMatt Macy if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) 6768eda14cbcSMatt Macy return (spa_vdev_exit(spa, vd, txg, error)); 6769eda14cbcSMatt Macy 6770eda14cbcSMatt Macy /* 6771eda14cbcSMatt Macy * If we are in the middle of a device removal, we can only add 6772eda14cbcSMatt Macy * devices which match the existing devices in the pool. 6773eda14cbcSMatt Macy * If we are in the middle of a removal, or have some indirect 67747877fdebSMatt Macy * vdevs, we can not add raidz or dRAID top levels. 6775eda14cbcSMatt Macy */ 6776eda14cbcSMatt Macy if (spa->spa_vdev_removal != NULL || 6777eda14cbcSMatt Macy spa->spa_removing_phys.sr_prev_indirect_vdev != -1) { 6778eda14cbcSMatt Macy for (int c = 0; c < vd->vdev_children; c++) { 6779eda14cbcSMatt Macy tvd = vd->vdev_child[c]; 6780eda14cbcSMatt Macy if (spa->spa_vdev_removal != NULL && 6781eda14cbcSMatt Macy tvd->vdev_ashift != spa->spa_max_ashift) { 6782eda14cbcSMatt Macy return (spa_vdev_exit(spa, vd, txg, EINVAL)); 6783eda14cbcSMatt Macy } 67847877fdebSMatt Macy /* Fail if top level vdev is raidz or a dRAID */ 67857877fdebSMatt Macy if (vdev_get_nparity(tvd) != 0) 6786eda14cbcSMatt Macy return (spa_vdev_exit(spa, vd, txg, EINVAL)); 67877877fdebSMatt Macy 6788eda14cbcSMatt Macy /* 6789eda14cbcSMatt Macy * Need the top level mirror to be 6790eda14cbcSMatt Macy * a mirror of leaf vdevs only 6791eda14cbcSMatt Macy */ 6792eda14cbcSMatt Macy if (tvd->vdev_ops == &vdev_mirror_ops) { 6793eda14cbcSMatt Macy for (uint64_t cid = 0; 6794eda14cbcSMatt Macy cid < tvd->vdev_children; cid++) { 6795eda14cbcSMatt Macy vdev_t *cvd = tvd->vdev_child[cid]; 6796eda14cbcSMatt Macy if (!cvd->vdev_ops->vdev_op_leaf) { 6797eda14cbcSMatt Macy return (spa_vdev_exit(spa, vd, 6798eda14cbcSMatt Macy txg, EINVAL)); 6799eda14cbcSMatt Macy } 6800eda14cbcSMatt Macy } 6801eda14cbcSMatt Macy } 6802eda14cbcSMatt Macy } 6803eda14cbcSMatt Macy } 6804eda14cbcSMatt Macy 6805eda14cbcSMatt Macy for (int c = 0; c < vd->vdev_children; c++) { 6806eda14cbcSMatt Macy tvd = vd->vdev_child[c]; 6807eda14cbcSMatt Macy vdev_remove_child(vd, tvd); 6808eda14cbcSMatt Macy tvd->vdev_id = rvd->vdev_children; 6809eda14cbcSMatt Macy vdev_add_child(rvd, tvd); 6810eda14cbcSMatt Macy vdev_config_dirty(tvd); 6811eda14cbcSMatt Macy } 6812eda14cbcSMatt Macy 6813eda14cbcSMatt Macy if (nspares != 0) { 6814eda14cbcSMatt Macy spa_set_aux_vdevs(&spa->spa_spares, spares, nspares, 6815eda14cbcSMatt Macy ZPOOL_CONFIG_SPARES); 6816eda14cbcSMatt Macy spa_load_spares(spa); 6817eda14cbcSMatt Macy spa->spa_spares.sav_sync = B_TRUE; 6818eda14cbcSMatt Macy } 6819eda14cbcSMatt Macy 6820eda14cbcSMatt Macy if (nl2cache != 0) { 6821eda14cbcSMatt Macy spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache, 6822eda14cbcSMatt Macy ZPOOL_CONFIG_L2CACHE); 6823eda14cbcSMatt Macy spa_load_l2cache(spa); 6824eda14cbcSMatt Macy spa->spa_l2cache.sav_sync = B_TRUE; 6825eda14cbcSMatt Macy } 6826eda14cbcSMatt Macy 6827eda14cbcSMatt Macy /* 68287877fdebSMatt Macy * We can't increment a feature while holding spa_vdev so we 68297877fdebSMatt Macy * have to do it in a synctask. 68307877fdebSMatt Macy */ 68317877fdebSMatt Macy if (ndraid != 0) { 68327877fdebSMatt Macy dmu_tx_t *tx; 68337877fdebSMatt Macy 68347877fdebSMatt Macy tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg); 68357877fdebSMatt Macy dsl_sync_task_nowait(spa->spa_dsl_pool, spa_draid_feature_incr, 68367877fdebSMatt Macy (void *)(uintptr_t)ndraid, tx); 68377877fdebSMatt Macy dmu_tx_commit(tx); 68387877fdebSMatt Macy } 68397877fdebSMatt Macy 68407877fdebSMatt Macy /* 6841eda14cbcSMatt Macy * We have to be careful when adding new vdevs to an existing pool. 6842eda14cbcSMatt Macy * If other threads start allocating from these vdevs before we 6843eda14cbcSMatt Macy * sync the config cache, and we lose power, then upon reboot we may 6844eda14cbcSMatt Macy * fail to open the pool because there are DVAs that the config cache 6845eda14cbcSMatt Macy * can't translate. Therefore, we first add the vdevs without 6846eda14cbcSMatt Macy * initializing metaslabs; sync the config cache (via spa_vdev_exit()); 6847eda14cbcSMatt Macy * and then let spa_config_update() initialize the new metaslabs. 6848eda14cbcSMatt Macy * 6849eda14cbcSMatt Macy * spa_load() checks for added-but-not-initialized vdevs, so that 6850eda14cbcSMatt Macy * if we lose power at any point in this sequence, the remaining 6851eda14cbcSMatt Macy * steps will be completed the next time we load the pool. 6852eda14cbcSMatt Macy */ 6853eda14cbcSMatt Macy (void) spa_vdev_exit(spa, vd, txg, 0); 6854eda14cbcSMatt Macy 6855eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 6856eda14cbcSMatt Macy spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 6857eda14cbcSMatt Macy spa_event_notify(spa, NULL, NULL, ESC_ZFS_VDEV_ADD); 6858eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 6859eda14cbcSMatt Macy 6860eda14cbcSMatt Macy return (0); 6861eda14cbcSMatt Macy } 6862eda14cbcSMatt Macy 6863eda14cbcSMatt Macy /* 6864eda14cbcSMatt Macy * Attach a device to a mirror. The arguments are the path to any device 6865eda14cbcSMatt Macy * in the mirror, and the nvroot for the new device. If the path specifies 6866eda14cbcSMatt Macy * a device that is not mirrored, we automatically insert the mirror vdev. 6867eda14cbcSMatt Macy * 6868eda14cbcSMatt Macy * If 'replacing' is specified, the new device is intended to replace the 6869eda14cbcSMatt Macy * existing device; in this case the two devices are made into their own 6870eda14cbcSMatt Macy * mirror using the 'replacing' vdev, which is functionally identical to 6871eda14cbcSMatt Macy * the mirror vdev (it actually reuses all the same ops) but has a few 6872eda14cbcSMatt Macy * extra rules: you can't attach to it after it's been created, and upon 6873eda14cbcSMatt Macy * completion of resilvering, the first disk (the one being replaced) 6874eda14cbcSMatt Macy * is automatically detached. 6875eda14cbcSMatt Macy * 6876eda14cbcSMatt Macy * If 'rebuild' is specified, then sequential reconstruction (a.ka. rebuild) 6877eda14cbcSMatt Macy * should be performed instead of traditional healing reconstruction. From 6878eda14cbcSMatt Macy * an administrators perspective these are both resilver operations. 6879eda14cbcSMatt Macy */ 6880eda14cbcSMatt Macy int 6881eda14cbcSMatt Macy spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing, 6882eda14cbcSMatt Macy int rebuild) 6883eda14cbcSMatt Macy { 6884eda14cbcSMatt Macy uint64_t txg, dtl_max_txg; 6885eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 6886eda14cbcSMatt Macy vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd; 6887eda14cbcSMatt Macy vdev_ops_t *pvops; 6888eda14cbcSMatt Macy char *oldvdpath, *newvdpath; 6889eda14cbcSMatt Macy int newvd_isspare; 6890eda14cbcSMatt Macy int error; 6891eda14cbcSMatt Macy 6892eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 6893eda14cbcSMatt Macy 6894eda14cbcSMatt Macy txg = spa_vdev_enter(spa); 6895eda14cbcSMatt Macy 6896eda14cbcSMatt Macy oldvd = spa_lookup_by_guid(spa, guid, B_FALSE); 6897eda14cbcSMatt Macy 6898eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 6899eda14cbcSMatt Macy if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) { 6900eda14cbcSMatt Macy error = (spa_has_checkpoint(spa)) ? 6901eda14cbcSMatt Macy ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT; 6902eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, error)); 6903eda14cbcSMatt Macy } 6904eda14cbcSMatt Macy 6905eda14cbcSMatt Macy if (rebuild) { 6906eda14cbcSMatt Macy if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD)) 6907eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 6908eda14cbcSMatt Macy 69094e8d558cSMartin Matuska if (dsl_scan_resilvering(spa_get_dsl(spa)) || 69104e8d558cSMartin Matuska dsl_scan_resilver_scheduled(spa_get_dsl(spa))) { 6911eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, 6912eda14cbcSMatt Macy ZFS_ERR_RESILVER_IN_PROGRESS)); 69134e8d558cSMartin Matuska } 6914eda14cbcSMatt Macy } else { 6915eda14cbcSMatt Macy if (vdev_rebuild_active(rvd)) 6916eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, 6917eda14cbcSMatt Macy ZFS_ERR_REBUILD_IN_PROGRESS)); 6918eda14cbcSMatt Macy } 6919eda14cbcSMatt Macy 6920eda14cbcSMatt Macy if (spa->spa_vdev_removal != NULL) 6921eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 6922eda14cbcSMatt Macy 6923eda14cbcSMatt Macy if (oldvd == NULL) 6924eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 6925eda14cbcSMatt Macy 6926eda14cbcSMatt Macy if (!oldvd->vdev_ops->vdev_op_leaf) 6927eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 6928eda14cbcSMatt Macy 6929eda14cbcSMatt Macy pvd = oldvd->vdev_parent; 6930eda14cbcSMatt Macy 6931dbd5678dSMartin Matuska if (spa_config_parse(spa, &newrootvd, nvroot, NULL, 0, 6932dbd5678dSMartin Matuska VDEV_ALLOC_ATTACH) != 0) 6933eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 6934eda14cbcSMatt Macy 6935eda14cbcSMatt Macy if (newrootvd->vdev_children != 1) 6936eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 6937eda14cbcSMatt Macy 6938eda14cbcSMatt Macy newvd = newrootvd->vdev_child[0]; 6939eda14cbcSMatt Macy 6940eda14cbcSMatt Macy if (!newvd->vdev_ops->vdev_op_leaf) 6941eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); 6942eda14cbcSMatt Macy 6943eda14cbcSMatt Macy if ((error = vdev_create(newrootvd, txg, replacing)) != 0) 6944eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, error)); 6945eda14cbcSMatt Macy 6946eda14cbcSMatt Macy /* 6947dbd5678dSMartin Matuska * log, dedup and special vdevs should not be replaced by spares. 6948eda14cbcSMatt Macy */ 6949dbd5678dSMartin Matuska if ((oldvd->vdev_top->vdev_alloc_bias != VDEV_BIAS_NONE || 6950dbd5678dSMartin Matuska oldvd->vdev_top->vdev_islog) && newvd->vdev_isspare) { 6951eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 6952dbd5678dSMartin Matuska } 6953eda14cbcSMatt Macy 69547877fdebSMatt Macy /* 69557877fdebSMatt Macy * A dRAID spare can only replace a child of its parent dRAID vdev. 69567877fdebSMatt Macy */ 69577877fdebSMatt Macy if (newvd->vdev_ops == &vdev_draid_spare_ops && 69587877fdebSMatt Macy oldvd->vdev_top != vdev_draid_spare_get_parent(newvd)) { 69597877fdebSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 69607877fdebSMatt Macy } 69617877fdebSMatt Macy 6962eda14cbcSMatt Macy if (rebuild) { 6963eda14cbcSMatt Macy /* 69647877fdebSMatt Macy * For rebuilds, the top vdev must support reconstruction 6965eda14cbcSMatt Macy * using only space maps. This means the only allowable 69667877fdebSMatt Macy * vdevs types are the root vdev, a mirror, or dRAID. 6967eda14cbcSMatt Macy */ 69687877fdebSMatt Macy tvd = pvd; 69697877fdebSMatt Macy if (pvd->vdev_top != NULL) 69707877fdebSMatt Macy tvd = pvd->vdev_top; 69717877fdebSMatt Macy 69727877fdebSMatt Macy if (tvd->vdev_ops != &vdev_mirror_ops && 69737877fdebSMatt Macy tvd->vdev_ops != &vdev_root_ops && 69747877fdebSMatt Macy tvd->vdev_ops != &vdev_draid_ops) { 6975eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 6976eda14cbcSMatt Macy } 6977eda14cbcSMatt Macy } 6978eda14cbcSMatt Macy 6979eda14cbcSMatt Macy if (!replacing) { 6980eda14cbcSMatt Macy /* 6981eda14cbcSMatt Macy * For attach, the only allowable parent is a mirror or the root 6982eda14cbcSMatt Macy * vdev. 6983eda14cbcSMatt Macy */ 6984eda14cbcSMatt Macy if (pvd->vdev_ops != &vdev_mirror_ops && 6985eda14cbcSMatt Macy pvd->vdev_ops != &vdev_root_ops) 6986eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 6987eda14cbcSMatt Macy 6988eda14cbcSMatt Macy pvops = &vdev_mirror_ops; 6989eda14cbcSMatt Macy } else { 6990eda14cbcSMatt Macy /* 6991eda14cbcSMatt Macy * Active hot spares can only be replaced by inactive hot 6992eda14cbcSMatt Macy * spares. 6993eda14cbcSMatt Macy */ 6994eda14cbcSMatt Macy if (pvd->vdev_ops == &vdev_spare_ops && 6995eda14cbcSMatt Macy oldvd->vdev_isspare && 6996eda14cbcSMatt Macy !spa_has_spare(spa, newvd->vdev_guid)) 6997eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 6998eda14cbcSMatt Macy 6999eda14cbcSMatt Macy /* 7000eda14cbcSMatt Macy * If the source is a hot spare, and the parent isn't already a 7001eda14cbcSMatt Macy * spare, then we want to create a new hot spare. Otherwise, we 7002eda14cbcSMatt Macy * want to create a replacing vdev. The user is not allowed to 7003eda14cbcSMatt Macy * attach to a spared vdev child unless the 'isspare' state is 7004eda14cbcSMatt Macy * the same (spare replaces spare, non-spare replaces 7005eda14cbcSMatt Macy * non-spare). 7006eda14cbcSMatt Macy */ 7007eda14cbcSMatt Macy if (pvd->vdev_ops == &vdev_replacing_ops && 7008eda14cbcSMatt Macy spa_version(spa) < SPA_VERSION_MULTI_REPLACE) { 7009eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 7010eda14cbcSMatt Macy } else if (pvd->vdev_ops == &vdev_spare_ops && 7011eda14cbcSMatt Macy newvd->vdev_isspare != oldvd->vdev_isspare) { 7012eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 7013eda14cbcSMatt Macy } 7014eda14cbcSMatt Macy 7015eda14cbcSMatt Macy if (newvd->vdev_isspare) 7016eda14cbcSMatt Macy pvops = &vdev_spare_ops; 7017eda14cbcSMatt Macy else 7018eda14cbcSMatt Macy pvops = &vdev_replacing_ops; 7019eda14cbcSMatt Macy } 7020eda14cbcSMatt Macy 7021eda14cbcSMatt Macy /* 7022eda14cbcSMatt Macy * Make sure the new device is big enough. 7023eda14cbcSMatt Macy */ 7024eda14cbcSMatt Macy if (newvd->vdev_asize < vdev_get_min_asize(oldvd)) 7025eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW)); 7026eda14cbcSMatt Macy 7027eda14cbcSMatt Macy /* 7028eda14cbcSMatt Macy * The new device cannot have a higher alignment requirement 7029eda14cbcSMatt Macy * than the top-level vdev. 7030eda14cbcSMatt Macy */ 7031eda14cbcSMatt Macy if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift) 7032eda14cbcSMatt Macy return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); 7033eda14cbcSMatt Macy 7034eda14cbcSMatt Macy /* 7035eda14cbcSMatt Macy * If this is an in-place replacement, update oldvd's path and devid 7036eda14cbcSMatt Macy * to make it distinguishable from newvd, and unopenable from now on. 7037eda14cbcSMatt Macy */ 7038eda14cbcSMatt Macy if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) { 7039eda14cbcSMatt Macy spa_strfree(oldvd->vdev_path); 7040eda14cbcSMatt Macy oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5, 7041eda14cbcSMatt Macy KM_SLEEP); 7042eda14cbcSMatt Macy (void) snprintf(oldvd->vdev_path, strlen(newvd->vdev_path) + 5, 7043eda14cbcSMatt Macy "%s/%s", newvd->vdev_path, "old"); 7044eda14cbcSMatt Macy if (oldvd->vdev_devid != NULL) { 7045eda14cbcSMatt Macy spa_strfree(oldvd->vdev_devid); 7046eda14cbcSMatt Macy oldvd->vdev_devid = NULL; 7047eda14cbcSMatt Macy } 7048eda14cbcSMatt Macy } 7049eda14cbcSMatt Macy 7050eda14cbcSMatt Macy /* 7051eda14cbcSMatt Macy * If the parent is not a mirror, or if we're replacing, insert the new 7052eda14cbcSMatt Macy * mirror/replacing/spare vdev above oldvd. 7053eda14cbcSMatt Macy */ 7054eda14cbcSMatt Macy if (pvd->vdev_ops != pvops) 7055eda14cbcSMatt Macy pvd = vdev_add_parent(oldvd, pvops); 7056eda14cbcSMatt Macy 7057eda14cbcSMatt Macy ASSERT(pvd->vdev_top->vdev_parent == rvd); 7058eda14cbcSMatt Macy ASSERT(pvd->vdev_ops == pvops); 7059eda14cbcSMatt Macy ASSERT(oldvd->vdev_parent == pvd); 7060eda14cbcSMatt Macy 7061eda14cbcSMatt Macy /* 7062eda14cbcSMatt Macy * Extract the new device from its root and add it to pvd. 7063eda14cbcSMatt Macy */ 7064eda14cbcSMatt Macy vdev_remove_child(newrootvd, newvd); 7065eda14cbcSMatt Macy newvd->vdev_id = pvd->vdev_children; 7066eda14cbcSMatt Macy newvd->vdev_crtxg = oldvd->vdev_crtxg; 7067eda14cbcSMatt Macy vdev_add_child(pvd, newvd); 7068eda14cbcSMatt Macy 7069eda14cbcSMatt Macy /* 7070eda14cbcSMatt Macy * Reevaluate the parent vdev state. 7071eda14cbcSMatt Macy */ 7072eda14cbcSMatt Macy vdev_propagate_state(pvd); 7073eda14cbcSMatt Macy 7074eda14cbcSMatt Macy tvd = newvd->vdev_top; 7075eda14cbcSMatt Macy ASSERT(pvd->vdev_top == tvd); 7076eda14cbcSMatt Macy ASSERT(tvd->vdev_parent == rvd); 7077eda14cbcSMatt Macy 7078eda14cbcSMatt Macy vdev_config_dirty(tvd); 7079eda14cbcSMatt Macy 7080eda14cbcSMatt Macy /* 7081eda14cbcSMatt Macy * Set newvd's DTL to [TXG_INITIAL, dtl_max_txg) so that we account 7082eda14cbcSMatt Macy * for any dmu_sync-ed blocks. It will propagate upward when 7083eda14cbcSMatt Macy * spa_vdev_exit() calls vdev_dtl_reassess(). 7084eda14cbcSMatt Macy */ 7085eda14cbcSMatt Macy dtl_max_txg = txg + TXG_CONCURRENT_STATES; 7086eda14cbcSMatt Macy 7087eda14cbcSMatt Macy vdev_dtl_dirty(newvd, DTL_MISSING, 7088eda14cbcSMatt Macy TXG_INITIAL, dtl_max_txg - TXG_INITIAL); 7089eda14cbcSMatt Macy 7090eda14cbcSMatt Macy if (newvd->vdev_isspare) { 7091eda14cbcSMatt Macy spa_spare_activate(newvd); 7092eda14cbcSMatt Macy spa_event_notify(spa, newvd, NULL, ESC_ZFS_VDEV_SPARE); 7093eda14cbcSMatt Macy } 7094eda14cbcSMatt Macy 7095eda14cbcSMatt Macy oldvdpath = spa_strdup(oldvd->vdev_path); 7096eda14cbcSMatt Macy newvdpath = spa_strdup(newvd->vdev_path); 7097eda14cbcSMatt Macy newvd_isspare = newvd->vdev_isspare; 7098eda14cbcSMatt Macy 7099eda14cbcSMatt Macy /* 7100eda14cbcSMatt Macy * Mark newvd's DTL dirty in this txg. 7101eda14cbcSMatt Macy */ 7102eda14cbcSMatt Macy vdev_dirty(tvd, VDD_DTL, newvd, txg); 7103eda14cbcSMatt Macy 7104eda14cbcSMatt Macy /* 7105eda14cbcSMatt Macy * Schedule the resilver or rebuild to restart in the future. We do 7106eda14cbcSMatt Macy * this to ensure that dmu_sync-ed blocks have been stitched into the 7107eda14cbcSMatt Macy * respective datasets. 7108eda14cbcSMatt Macy */ 7109eda14cbcSMatt Macy if (rebuild) { 7110eda14cbcSMatt Macy newvd->vdev_rebuild_txg = txg; 7111eda14cbcSMatt Macy 7112eda14cbcSMatt Macy vdev_rebuild(tvd); 7113eda14cbcSMatt Macy } else { 7114eda14cbcSMatt Macy newvd->vdev_resilver_txg = txg; 7115eda14cbcSMatt Macy 7116eda14cbcSMatt Macy if (dsl_scan_resilvering(spa_get_dsl(spa)) && 7117eda14cbcSMatt Macy spa_feature_is_enabled(spa, SPA_FEATURE_RESILVER_DEFER)) { 7118eda14cbcSMatt Macy vdev_defer_resilver(newvd); 7119eda14cbcSMatt Macy } else { 7120eda14cbcSMatt Macy dsl_scan_restart_resilver(spa->spa_dsl_pool, 7121eda14cbcSMatt Macy dtl_max_txg); 7122eda14cbcSMatt Macy } 7123eda14cbcSMatt Macy } 7124eda14cbcSMatt Macy 7125eda14cbcSMatt Macy if (spa->spa_bootfs) 7126eda14cbcSMatt Macy spa_event_notify(spa, newvd, NULL, ESC_ZFS_BOOTFS_VDEV_ATTACH); 7127eda14cbcSMatt Macy 7128eda14cbcSMatt Macy spa_event_notify(spa, newvd, NULL, ESC_ZFS_VDEV_ATTACH); 7129eda14cbcSMatt Macy 7130eda14cbcSMatt Macy /* 7131eda14cbcSMatt Macy * Commit the config 7132eda14cbcSMatt Macy */ 7133eda14cbcSMatt Macy (void) spa_vdev_exit(spa, newrootvd, dtl_max_txg, 0); 7134eda14cbcSMatt Macy 7135eda14cbcSMatt Macy spa_history_log_internal(spa, "vdev attach", NULL, 7136eda14cbcSMatt Macy "%s vdev=%s %s vdev=%s", 7137eda14cbcSMatt Macy replacing && newvd_isspare ? "spare in" : 7138eda14cbcSMatt Macy replacing ? "replace" : "attach", newvdpath, 7139eda14cbcSMatt Macy replacing ? "for" : "to", oldvdpath); 7140eda14cbcSMatt Macy 7141eda14cbcSMatt Macy spa_strfree(oldvdpath); 7142eda14cbcSMatt Macy spa_strfree(newvdpath); 7143eda14cbcSMatt Macy 7144eda14cbcSMatt Macy return (0); 7145eda14cbcSMatt Macy } 7146eda14cbcSMatt Macy 7147eda14cbcSMatt Macy /* 7148eda14cbcSMatt Macy * Detach a device from a mirror or replacing vdev. 7149eda14cbcSMatt Macy * 7150eda14cbcSMatt Macy * If 'replace_done' is specified, only detach if the parent 7151d411c1d6SMartin Matuska * is a replacing or a spare vdev. 7152eda14cbcSMatt Macy */ 7153eda14cbcSMatt Macy int 7154eda14cbcSMatt Macy spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done) 7155eda14cbcSMatt Macy { 7156eda14cbcSMatt Macy uint64_t txg; 7157eda14cbcSMatt Macy int error; 7158eda14cbcSMatt Macy vdev_t *rvd __maybe_unused = spa->spa_root_vdev; 7159eda14cbcSMatt Macy vdev_t *vd, *pvd, *cvd, *tvd; 7160eda14cbcSMatt Macy boolean_t unspare = B_FALSE; 7161eda14cbcSMatt Macy uint64_t unspare_guid = 0; 7162eda14cbcSMatt Macy char *vdpath; 7163eda14cbcSMatt Macy 7164eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 7165eda14cbcSMatt Macy 7166eda14cbcSMatt Macy txg = spa_vdev_detach_enter(spa, guid); 7167eda14cbcSMatt Macy 7168eda14cbcSMatt Macy vd = spa_lookup_by_guid(spa, guid, B_FALSE); 7169eda14cbcSMatt Macy 7170eda14cbcSMatt Macy /* 7171eda14cbcSMatt Macy * Besides being called directly from the userland through the 7172eda14cbcSMatt Macy * ioctl interface, spa_vdev_detach() can be potentially called 7173eda14cbcSMatt Macy * at the end of spa_vdev_resilver_done(). 7174eda14cbcSMatt Macy * 7175eda14cbcSMatt Macy * In the regular case, when we have a checkpoint this shouldn't 7176eda14cbcSMatt Macy * happen as we never empty the DTLs of a vdev during the scrub 7177eda14cbcSMatt Macy * [see comment in dsl_scan_done()]. Thus spa_vdev_resilvering_done() 7178eda14cbcSMatt Macy * should never get here when we have a checkpoint. 7179eda14cbcSMatt Macy * 7180eda14cbcSMatt Macy * That said, even in a case when we checkpoint the pool exactly 7181eda14cbcSMatt Macy * as spa_vdev_resilver_done() calls this function everything 7182eda14cbcSMatt Macy * should be fine as the resilver will return right away. 7183eda14cbcSMatt Macy */ 7184eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 7185eda14cbcSMatt Macy if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) { 7186eda14cbcSMatt Macy error = (spa_has_checkpoint(spa)) ? 7187eda14cbcSMatt Macy ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT; 7188eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, error)); 7189eda14cbcSMatt Macy } 7190eda14cbcSMatt Macy 7191eda14cbcSMatt Macy if (vd == NULL) 7192eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENODEV)); 7193eda14cbcSMatt Macy 7194eda14cbcSMatt Macy if (!vd->vdev_ops->vdev_op_leaf) 7195eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 7196eda14cbcSMatt Macy 7197eda14cbcSMatt Macy pvd = vd->vdev_parent; 7198eda14cbcSMatt Macy 7199eda14cbcSMatt Macy /* 7200eda14cbcSMatt Macy * If the parent/child relationship is not as expected, don't do it. 7201eda14cbcSMatt Macy * Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing 7202eda14cbcSMatt Macy * vdev that's replacing B with C. The user's intent in replacing 7203eda14cbcSMatt Macy * is to go from M(A,B) to M(A,C). If the user decides to cancel 7204eda14cbcSMatt Macy * the replace by detaching C, the expected behavior is to end up 7205eda14cbcSMatt Macy * M(A,B). But suppose that right after deciding to detach C, 7206eda14cbcSMatt Macy * the replacement of B completes. We would have M(A,C), and then 7207eda14cbcSMatt Macy * ask to detach C, which would leave us with just A -- not what 7208eda14cbcSMatt Macy * the user wanted. To prevent this, we make sure that the 7209eda14cbcSMatt Macy * parent/child relationship hasn't changed -- in this example, 7210eda14cbcSMatt Macy * that C's parent is still the replacing vdev R. 7211eda14cbcSMatt Macy */ 7212eda14cbcSMatt Macy if (pvd->vdev_guid != pguid && pguid != 0) 7213eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 7214eda14cbcSMatt Macy 7215eda14cbcSMatt Macy /* 7216eda14cbcSMatt Macy * Only 'replacing' or 'spare' vdevs can be replaced. 7217eda14cbcSMatt Macy */ 7218eda14cbcSMatt Macy if (replace_done && pvd->vdev_ops != &vdev_replacing_ops && 7219eda14cbcSMatt Macy pvd->vdev_ops != &vdev_spare_ops) 7220eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 7221eda14cbcSMatt Macy 7222eda14cbcSMatt Macy ASSERT(pvd->vdev_ops != &vdev_spare_ops || 7223eda14cbcSMatt Macy spa_version(spa) >= SPA_VERSION_SPARES); 7224eda14cbcSMatt Macy 7225eda14cbcSMatt Macy /* 7226eda14cbcSMatt Macy * Only mirror, replacing, and spare vdevs support detach. 7227eda14cbcSMatt Macy */ 7228eda14cbcSMatt Macy if (pvd->vdev_ops != &vdev_replacing_ops && 7229eda14cbcSMatt Macy pvd->vdev_ops != &vdev_mirror_ops && 7230eda14cbcSMatt Macy pvd->vdev_ops != &vdev_spare_ops) 7231eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); 7232eda14cbcSMatt Macy 7233eda14cbcSMatt Macy /* 7234eda14cbcSMatt Macy * If this device has the only valid copy of some data, 7235eda14cbcSMatt Macy * we cannot safely detach it. 7236eda14cbcSMatt Macy */ 7237eda14cbcSMatt Macy if (vdev_dtl_required(vd)) 7238eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EBUSY)); 7239eda14cbcSMatt Macy 7240eda14cbcSMatt Macy ASSERT(pvd->vdev_children >= 2); 7241eda14cbcSMatt Macy 7242eda14cbcSMatt Macy /* 7243eda14cbcSMatt Macy * If we are detaching the second disk from a replacing vdev, then 7244eda14cbcSMatt Macy * check to see if we changed the original vdev's path to have "/old" 7245eda14cbcSMatt Macy * at the end in spa_vdev_attach(). If so, undo that change now. 7246eda14cbcSMatt Macy */ 7247eda14cbcSMatt Macy if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id > 0 && 7248eda14cbcSMatt Macy vd->vdev_path != NULL) { 7249eda14cbcSMatt Macy size_t len = strlen(vd->vdev_path); 7250eda14cbcSMatt Macy 7251eda14cbcSMatt Macy for (int c = 0; c < pvd->vdev_children; c++) { 7252eda14cbcSMatt Macy cvd = pvd->vdev_child[c]; 7253eda14cbcSMatt Macy 7254eda14cbcSMatt Macy if (cvd == vd || cvd->vdev_path == NULL) 7255eda14cbcSMatt Macy continue; 7256eda14cbcSMatt Macy 7257eda14cbcSMatt Macy if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 && 7258eda14cbcSMatt Macy strcmp(cvd->vdev_path + len, "/old") == 0) { 7259eda14cbcSMatt Macy spa_strfree(cvd->vdev_path); 7260eda14cbcSMatt Macy cvd->vdev_path = spa_strdup(vd->vdev_path); 7261eda14cbcSMatt Macy break; 7262eda14cbcSMatt Macy } 7263eda14cbcSMatt Macy } 7264eda14cbcSMatt Macy } 7265eda14cbcSMatt Macy 7266eda14cbcSMatt Macy /* 72677877fdebSMatt Macy * If we are detaching the original disk from a normal spare, then it 72687877fdebSMatt Macy * implies that the spare should become a real disk, and be removed 72697877fdebSMatt Macy * from the active spare list for the pool. dRAID spares on the 72707877fdebSMatt Macy * other hand are coupled to the pool and thus should never be removed 72717877fdebSMatt Macy * from the spares list. 7272eda14cbcSMatt Macy */ 72737877fdebSMatt Macy if (pvd->vdev_ops == &vdev_spare_ops && vd->vdev_id == 0) { 72747877fdebSMatt Macy vdev_t *last_cvd = pvd->vdev_child[pvd->vdev_children - 1]; 72757877fdebSMatt Macy 72767877fdebSMatt Macy if (last_cvd->vdev_isspare && 72777877fdebSMatt Macy last_cvd->vdev_ops != &vdev_draid_spare_ops) { 7278eda14cbcSMatt Macy unspare = B_TRUE; 72797877fdebSMatt Macy } 72807877fdebSMatt Macy } 7281eda14cbcSMatt Macy 7282eda14cbcSMatt Macy /* 7283eda14cbcSMatt Macy * Erase the disk labels so the disk can be used for other things. 7284eda14cbcSMatt Macy * This must be done after all other error cases are handled, 7285eda14cbcSMatt Macy * but before we disembowel vd (so we can still do I/O to it). 7286eda14cbcSMatt Macy * But if we can't do it, don't treat the error as fatal -- 7287eda14cbcSMatt Macy * it may be that the unwritability of the disk is the reason 7288eda14cbcSMatt Macy * it's being detached! 7289eda14cbcSMatt Macy */ 7290dbd5678dSMartin Matuska (void) vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); 7291eda14cbcSMatt Macy 7292eda14cbcSMatt Macy /* 7293eda14cbcSMatt Macy * Remove vd from its parent and compact the parent's children. 7294eda14cbcSMatt Macy */ 7295eda14cbcSMatt Macy vdev_remove_child(pvd, vd); 7296eda14cbcSMatt Macy vdev_compact_children(pvd); 7297eda14cbcSMatt Macy 7298eda14cbcSMatt Macy /* 7299eda14cbcSMatt Macy * Remember one of the remaining children so we can get tvd below. 7300eda14cbcSMatt Macy */ 7301eda14cbcSMatt Macy cvd = pvd->vdev_child[pvd->vdev_children - 1]; 7302eda14cbcSMatt Macy 7303eda14cbcSMatt Macy /* 7304eda14cbcSMatt Macy * If we need to remove the remaining child from the list of hot spares, 7305eda14cbcSMatt Macy * do it now, marking the vdev as no longer a spare in the process. 7306eda14cbcSMatt Macy * We must do this before vdev_remove_parent(), because that can 7307eda14cbcSMatt Macy * change the GUID if it creates a new toplevel GUID. For a similar 7308eda14cbcSMatt Macy * reason, we must remove the spare now, in the same txg as the detach; 7309eda14cbcSMatt Macy * otherwise someone could attach a new sibling, change the GUID, and 7310eda14cbcSMatt Macy * the subsequent attempt to spa_vdev_remove(unspare_guid) would fail. 7311eda14cbcSMatt Macy */ 7312eda14cbcSMatt Macy if (unspare) { 7313eda14cbcSMatt Macy ASSERT(cvd->vdev_isspare); 7314eda14cbcSMatt Macy spa_spare_remove(cvd); 7315eda14cbcSMatt Macy unspare_guid = cvd->vdev_guid; 7316eda14cbcSMatt Macy (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); 7317eda14cbcSMatt Macy cvd->vdev_unspare = B_TRUE; 7318eda14cbcSMatt Macy } 7319eda14cbcSMatt Macy 7320eda14cbcSMatt Macy /* 7321eda14cbcSMatt Macy * If the parent mirror/replacing vdev only has one child, 7322eda14cbcSMatt Macy * the parent is no longer needed. Remove it from the tree. 7323eda14cbcSMatt Macy */ 7324eda14cbcSMatt Macy if (pvd->vdev_children == 1) { 7325eda14cbcSMatt Macy if (pvd->vdev_ops == &vdev_spare_ops) 7326eda14cbcSMatt Macy cvd->vdev_unspare = B_FALSE; 7327eda14cbcSMatt Macy vdev_remove_parent(cvd); 7328eda14cbcSMatt Macy } 7329eda14cbcSMatt Macy 7330eda14cbcSMatt Macy /* 7331eda14cbcSMatt Macy * We don't set tvd until now because the parent we just removed 7332eda14cbcSMatt Macy * may have been the previous top-level vdev. 7333eda14cbcSMatt Macy */ 7334eda14cbcSMatt Macy tvd = cvd->vdev_top; 7335eda14cbcSMatt Macy ASSERT(tvd->vdev_parent == rvd); 7336eda14cbcSMatt Macy 7337eda14cbcSMatt Macy /* 7338eda14cbcSMatt Macy * Reevaluate the parent vdev state. 7339eda14cbcSMatt Macy */ 7340eda14cbcSMatt Macy vdev_propagate_state(cvd); 7341eda14cbcSMatt Macy 7342eda14cbcSMatt Macy /* 7343eda14cbcSMatt Macy * If the 'autoexpand' property is set on the pool then automatically 7344eda14cbcSMatt Macy * try to expand the size of the pool. For example if the device we 7345eda14cbcSMatt Macy * just detached was smaller than the others, it may be possible to 7346eda14cbcSMatt Macy * add metaslabs (i.e. grow the pool). We need to reopen the vdev 7347eda14cbcSMatt Macy * first so that we can obtain the updated sizes of the leaf vdevs. 7348eda14cbcSMatt Macy */ 7349eda14cbcSMatt Macy if (spa->spa_autoexpand) { 7350eda14cbcSMatt Macy vdev_reopen(tvd); 7351eda14cbcSMatt Macy vdev_expand(tvd, txg); 7352eda14cbcSMatt Macy } 7353eda14cbcSMatt Macy 7354eda14cbcSMatt Macy vdev_config_dirty(tvd); 7355eda14cbcSMatt Macy 7356eda14cbcSMatt Macy /* 7357eda14cbcSMatt Macy * Mark vd's DTL as dirty in this txg. vdev_dtl_sync() will see that 7358eda14cbcSMatt Macy * vd->vdev_detached is set and free vd's DTL object in syncing context. 7359eda14cbcSMatt Macy * But first make sure we're not on any *other* txg's DTL list, to 7360eda14cbcSMatt Macy * prevent vd from being accessed after it's freed. 7361eda14cbcSMatt Macy */ 7362eda14cbcSMatt Macy vdpath = spa_strdup(vd->vdev_path ? vd->vdev_path : "none"); 7363eda14cbcSMatt Macy for (int t = 0; t < TXG_SIZE; t++) 7364eda14cbcSMatt Macy (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t); 7365eda14cbcSMatt Macy vd->vdev_detached = B_TRUE; 7366eda14cbcSMatt Macy vdev_dirty(tvd, VDD_DTL, vd, txg); 7367eda14cbcSMatt Macy 7368eda14cbcSMatt Macy spa_event_notify(spa, vd, NULL, ESC_ZFS_VDEV_REMOVE); 7369eda14cbcSMatt Macy spa_notify_waiters(spa); 7370eda14cbcSMatt Macy 7371eda14cbcSMatt Macy /* hang on to the spa before we release the lock */ 7372eda14cbcSMatt Macy spa_open_ref(spa, FTAG); 7373eda14cbcSMatt Macy 7374eda14cbcSMatt Macy error = spa_vdev_exit(spa, vd, txg, 0); 7375eda14cbcSMatt Macy 7376eda14cbcSMatt Macy spa_history_log_internal(spa, "detach", NULL, 7377eda14cbcSMatt Macy "vdev=%s", vdpath); 7378eda14cbcSMatt Macy spa_strfree(vdpath); 7379eda14cbcSMatt Macy 7380eda14cbcSMatt Macy /* 7381eda14cbcSMatt Macy * If this was the removal of the original device in a hot spare vdev, 7382eda14cbcSMatt Macy * then we want to go through and remove the device from the hot spare 7383eda14cbcSMatt Macy * list of every other pool. 7384eda14cbcSMatt Macy */ 7385eda14cbcSMatt Macy if (unspare) { 7386eda14cbcSMatt Macy spa_t *altspa = NULL; 7387eda14cbcSMatt Macy 7388eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 7389eda14cbcSMatt Macy while ((altspa = spa_next(altspa)) != NULL) { 7390eda14cbcSMatt Macy if (altspa->spa_state != POOL_STATE_ACTIVE || 7391eda14cbcSMatt Macy altspa == spa) 7392eda14cbcSMatt Macy continue; 7393eda14cbcSMatt Macy 7394eda14cbcSMatt Macy spa_open_ref(altspa, FTAG); 7395eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 7396eda14cbcSMatt Macy (void) spa_vdev_remove(altspa, unspare_guid, B_TRUE); 7397eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 7398eda14cbcSMatt Macy spa_close(altspa, FTAG); 7399eda14cbcSMatt Macy } 7400eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 7401eda14cbcSMatt Macy 7402eda14cbcSMatt Macy /* search the rest of the vdevs for spares to remove */ 7403eda14cbcSMatt Macy spa_vdev_resilver_done(spa); 7404eda14cbcSMatt Macy } 7405eda14cbcSMatt Macy 7406eda14cbcSMatt Macy /* all done with the spa; OK to release */ 7407eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 7408eda14cbcSMatt Macy spa_close(spa, FTAG); 7409eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 7410eda14cbcSMatt Macy 7411eda14cbcSMatt Macy return (error); 7412eda14cbcSMatt Macy } 7413eda14cbcSMatt Macy 7414eda14cbcSMatt Macy static int 7415eda14cbcSMatt Macy spa_vdev_initialize_impl(spa_t *spa, uint64_t guid, uint64_t cmd_type, 7416eda14cbcSMatt Macy list_t *vd_list) 7417eda14cbcSMatt Macy { 7418eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 7419eda14cbcSMatt Macy 7420eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 7421eda14cbcSMatt Macy 7422eda14cbcSMatt Macy /* Look up vdev and ensure it's a leaf. */ 7423eda14cbcSMatt Macy vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE); 7424eda14cbcSMatt Macy if (vd == NULL || vd->vdev_detached) { 7425eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7426eda14cbcSMatt Macy return (SET_ERROR(ENODEV)); 7427eda14cbcSMatt Macy } else if (!vd->vdev_ops->vdev_op_leaf || !vdev_is_concrete(vd)) { 7428eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7429eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 7430eda14cbcSMatt Macy } else if (!vdev_writeable(vd)) { 7431eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7432eda14cbcSMatt Macy return (SET_ERROR(EROFS)); 7433eda14cbcSMatt Macy } 7434eda14cbcSMatt Macy mutex_enter(&vd->vdev_initialize_lock); 7435eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7436eda14cbcSMatt Macy 7437eda14cbcSMatt Macy /* 7438eda14cbcSMatt Macy * When we activate an initialize action we check to see 7439eda14cbcSMatt Macy * if the vdev_initialize_thread is NULL. We do this instead 7440eda14cbcSMatt Macy * of using the vdev_initialize_state since there might be 7441eda14cbcSMatt Macy * a previous initialization process which has completed but 7442eda14cbcSMatt Macy * the thread is not exited. 7443eda14cbcSMatt Macy */ 7444eda14cbcSMatt Macy if (cmd_type == POOL_INITIALIZE_START && 7445eda14cbcSMatt Macy (vd->vdev_initialize_thread != NULL || 7446eda14cbcSMatt Macy vd->vdev_top->vdev_removing)) { 7447eda14cbcSMatt Macy mutex_exit(&vd->vdev_initialize_lock); 7448eda14cbcSMatt Macy return (SET_ERROR(EBUSY)); 7449eda14cbcSMatt Macy } else if (cmd_type == POOL_INITIALIZE_CANCEL && 7450eda14cbcSMatt Macy (vd->vdev_initialize_state != VDEV_INITIALIZE_ACTIVE && 7451eda14cbcSMatt Macy vd->vdev_initialize_state != VDEV_INITIALIZE_SUSPENDED)) { 7452eda14cbcSMatt Macy mutex_exit(&vd->vdev_initialize_lock); 7453eda14cbcSMatt Macy return (SET_ERROR(ESRCH)); 7454eda14cbcSMatt Macy } else if (cmd_type == POOL_INITIALIZE_SUSPEND && 7455eda14cbcSMatt Macy vd->vdev_initialize_state != VDEV_INITIALIZE_ACTIVE) { 7456eda14cbcSMatt Macy mutex_exit(&vd->vdev_initialize_lock); 7457eda14cbcSMatt Macy return (SET_ERROR(ESRCH)); 7458c0a83fe0SMartin Matuska } else if (cmd_type == POOL_INITIALIZE_UNINIT && 7459c0a83fe0SMartin Matuska vd->vdev_initialize_thread != NULL) { 7460c0a83fe0SMartin Matuska mutex_exit(&vd->vdev_initialize_lock); 7461c0a83fe0SMartin Matuska return (SET_ERROR(EBUSY)); 7462eda14cbcSMatt Macy } 7463eda14cbcSMatt Macy 7464eda14cbcSMatt Macy switch (cmd_type) { 7465eda14cbcSMatt Macy case POOL_INITIALIZE_START: 7466eda14cbcSMatt Macy vdev_initialize(vd); 7467eda14cbcSMatt Macy break; 7468eda14cbcSMatt Macy case POOL_INITIALIZE_CANCEL: 7469eda14cbcSMatt Macy vdev_initialize_stop(vd, VDEV_INITIALIZE_CANCELED, vd_list); 7470eda14cbcSMatt Macy break; 7471eda14cbcSMatt Macy case POOL_INITIALIZE_SUSPEND: 7472eda14cbcSMatt Macy vdev_initialize_stop(vd, VDEV_INITIALIZE_SUSPENDED, vd_list); 7473eda14cbcSMatt Macy break; 7474c0a83fe0SMartin Matuska case POOL_INITIALIZE_UNINIT: 7475c0a83fe0SMartin Matuska vdev_uninitialize(vd); 7476c0a83fe0SMartin Matuska break; 7477eda14cbcSMatt Macy default: 7478eda14cbcSMatt Macy panic("invalid cmd_type %llu", (unsigned long long)cmd_type); 7479eda14cbcSMatt Macy } 7480eda14cbcSMatt Macy mutex_exit(&vd->vdev_initialize_lock); 7481eda14cbcSMatt Macy 7482eda14cbcSMatt Macy return (0); 7483eda14cbcSMatt Macy } 7484eda14cbcSMatt Macy 7485eda14cbcSMatt Macy int 7486eda14cbcSMatt Macy spa_vdev_initialize(spa_t *spa, nvlist_t *nv, uint64_t cmd_type, 7487eda14cbcSMatt Macy nvlist_t *vdev_errlist) 7488eda14cbcSMatt Macy { 7489eda14cbcSMatt Macy int total_errors = 0; 7490eda14cbcSMatt Macy list_t vd_list; 7491eda14cbcSMatt Macy 7492eda14cbcSMatt Macy list_create(&vd_list, sizeof (vdev_t), 7493eda14cbcSMatt Macy offsetof(vdev_t, vdev_initialize_node)); 7494eda14cbcSMatt Macy 7495eda14cbcSMatt Macy /* 7496eda14cbcSMatt Macy * We hold the namespace lock through the whole function 7497eda14cbcSMatt Macy * to prevent any changes to the pool while we're starting or 7498eda14cbcSMatt Macy * stopping initialization. The config and state locks are held so that 7499eda14cbcSMatt Macy * we can properly assess the vdev state before we commit to 7500eda14cbcSMatt Macy * the initializing operation. 7501eda14cbcSMatt Macy */ 7502eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 7503eda14cbcSMatt Macy 7504eda14cbcSMatt Macy for (nvpair_t *pair = nvlist_next_nvpair(nv, NULL); 7505eda14cbcSMatt Macy pair != NULL; pair = nvlist_next_nvpair(nv, pair)) { 7506eda14cbcSMatt Macy uint64_t vdev_guid = fnvpair_value_uint64(pair); 7507eda14cbcSMatt Macy 7508eda14cbcSMatt Macy int error = spa_vdev_initialize_impl(spa, vdev_guid, cmd_type, 7509eda14cbcSMatt Macy &vd_list); 7510eda14cbcSMatt Macy if (error != 0) { 7511eda14cbcSMatt Macy char guid_as_str[MAXNAMELEN]; 7512eda14cbcSMatt Macy 7513eda14cbcSMatt Macy (void) snprintf(guid_as_str, sizeof (guid_as_str), 7514eda14cbcSMatt Macy "%llu", (unsigned long long)vdev_guid); 7515eda14cbcSMatt Macy fnvlist_add_int64(vdev_errlist, guid_as_str, error); 7516eda14cbcSMatt Macy total_errors++; 7517eda14cbcSMatt Macy } 7518eda14cbcSMatt Macy } 7519eda14cbcSMatt Macy 7520eda14cbcSMatt Macy /* Wait for all initialize threads to stop. */ 7521eda14cbcSMatt Macy vdev_initialize_stop_wait(spa, &vd_list); 7522eda14cbcSMatt Macy 7523eda14cbcSMatt Macy /* Sync out the initializing state */ 7524eda14cbcSMatt Macy txg_wait_synced(spa->spa_dsl_pool, 0); 7525eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 7526eda14cbcSMatt Macy 7527eda14cbcSMatt Macy list_destroy(&vd_list); 7528eda14cbcSMatt Macy 7529eda14cbcSMatt Macy return (total_errors); 7530eda14cbcSMatt Macy } 7531eda14cbcSMatt Macy 7532eda14cbcSMatt Macy static int 7533eda14cbcSMatt Macy spa_vdev_trim_impl(spa_t *spa, uint64_t guid, uint64_t cmd_type, 7534eda14cbcSMatt Macy uint64_t rate, boolean_t partial, boolean_t secure, list_t *vd_list) 7535eda14cbcSMatt Macy { 7536eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 7537eda14cbcSMatt Macy 7538eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 7539eda14cbcSMatt Macy 7540eda14cbcSMatt Macy /* Look up vdev and ensure it's a leaf. */ 7541eda14cbcSMatt Macy vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE); 7542eda14cbcSMatt Macy if (vd == NULL || vd->vdev_detached) { 7543eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7544eda14cbcSMatt Macy return (SET_ERROR(ENODEV)); 7545eda14cbcSMatt Macy } else if (!vd->vdev_ops->vdev_op_leaf || !vdev_is_concrete(vd)) { 7546eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7547eda14cbcSMatt Macy return (SET_ERROR(EINVAL)); 7548eda14cbcSMatt Macy } else if (!vdev_writeable(vd)) { 7549eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7550eda14cbcSMatt Macy return (SET_ERROR(EROFS)); 7551eda14cbcSMatt Macy } else if (!vd->vdev_has_trim) { 7552eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7553eda14cbcSMatt Macy return (SET_ERROR(EOPNOTSUPP)); 7554eda14cbcSMatt Macy } else if (secure && !vd->vdev_has_securetrim) { 7555eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7556eda14cbcSMatt Macy return (SET_ERROR(EOPNOTSUPP)); 7557eda14cbcSMatt Macy } 7558eda14cbcSMatt Macy mutex_enter(&vd->vdev_trim_lock); 7559eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 7560eda14cbcSMatt Macy 7561eda14cbcSMatt Macy /* 7562eda14cbcSMatt Macy * When we activate a TRIM action we check to see if the 7563eda14cbcSMatt Macy * vdev_trim_thread is NULL. We do this instead of using the 7564eda14cbcSMatt Macy * vdev_trim_state since there might be a previous TRIM process 7565eda14cbcSMatt Macy * which has completed but the thread is not exited. 7566eda14cbcSMatt Macy */ 7567eda14cbcSMatt Macy if (cmd_type == POOL_TRIM_START && 7568eda14cbcSMatt Macy (vd->vdev_trim_thread != NULL || vd->vdev_top->vdev_removing)) { 7569eda14cbcSMatt Macy mutex_exit(&vd->vdev_trim_lock); 7570eda14cbcSMatt Macy return (SET_ERROR(EBUSY)); 7571eda14cbcSMatt Macy } else if (cmd_type == POOL_TRIM_CANCEL && 7572eda14cbcSMatt Macy (vd->vdev_trim_state != VDEV_TRIM_ACTIVE && 7573eda14cbcSMatt Macy vd->vdev_trim_state != VDEV_TRIM_SUSPENDED)) { 7574eda14cbcSMatt Macy mutex_exit(&vd->vdev_trim_lock); 7575eda14cbcSMatt Macy return (SET_ERROR(ESRCH)); 7576eda14cbcSMatt Macy } else if (cmd_type == POOL_TRIM_SUSPEND && 7577eda14cbcSMatt Macy vd->vdev_trim_state != VDEV_TRIM_ACTIVE) { 7578eda14cbcSMatt Macy mutex_exit(&vd->vdev_trim_lock); 7579eda14cbcSMatt Macy return (SET_ERROR(ESRCH)); 7580eda14cbcSMatt Macy } 7581eda14cbcSMatt Macy 7582eda14cbcSMatt Macy switch (cmd_type) { 7583eda14cbcSMatt Macy case POOL_TRIM_START: 7584eda14cbcSMatt Macy vdev_trim(vd, rate, partial, secure); 7585eda14cbcSMatt Macy break; 7586eda14cbcSMatt Macy case POOL_TRIM_CANCEL: 7587eda14cbcSMatt Macy vdev_trim_stop(vd, VDEV_TRIM_CANCELED, vd_list); 7588eda14cbcSMatt Macy break; 7589eda14cbcSMatt Macy case POOL_TRIM_SUSPEND: 7590eda14cbcSMatt Macy vdev_trim_stop(vd, VDEV_TRIM_SUSPENDED, vd_list); 7591eda14cbcSMatt Macy break; 7592eda14cbcSMatt Macy default: 7593eda14cbcSMatt Macy panic("invalid cmd_type %llu", (unsigned long long)cmd_type); 7594eda14cbcSMatt Macy } 7595eda14cbcSMatt Macy mutex_exit(&vd->vdev_trim_lock); 7596eda14cbcSMatt Macy 7597eda14cbcSMatt Macy return (0); 7598eda14cbcSMatt Macy } 7599eda14cbcSMatt Macy 7600eda14cbcSMatt Macy /* 7601eda14cbcSMatt Macy * Initiates a manual TRIM for the requested vdevs. This kicks off individual 7602eda14cbcSMatt Macy * TRIM threads for each child vdev. These threads pass over all of the free 7603eda14cbcSMatt Macy * space in the vdev's metaslabs and issues TRIM commands for that space. 7604eda14cbcSMatt Macy */ 7605eda14cbcSMatt Macy int 7606eda14cbcSMatt Macy spa_vdev_trim(spa_t *spa, nvlist_t *nv, uint64_t cmd_type, uint64_t rate, 7607eda14cbcSMatt Macy boolean_t partial, boolean_t secure, nvlist_t *vdev_errlist) 7608eda14cbcSMatt Macy { 7609eda14cbcSMatt Macy int total_errors = 0; 7610eda14cbcSMatt Macy list_t vd_list; 7611eda14cbcSMatt Macy 7612eda14cbcSMatt Macy list_create(&vd_list, sizeof (vdev_t), 7613eda14cbcSMatt Macy offsetof(vdev_t, vdev_trim_node)); 7614eda14cbcSMatt Macy 7615eda14cbcSMatt Macy /* 7616eda14cbcSMatt Macy * We hold the namespace lock through the whole function 7617eda14cbcSMatt Macy * to prevent any changes to the pool while we're starting or 7618eda14cbcSMatt Macy * stopping TRIM. The config and state locks are held so that 7619eda14cbcSMatt Macy * we can properly assess the vdev state before we commit to 7620eda14cbcSMatt Macy * the TRIM operation. 7621eda14cbcSMatt Macy */ 7622eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 7623eda14cbcSMatt Macy 7624eda14cbcSMatt Macy for (nvpair_t *pair = nvlist_next_nvpair(nv, NULL); 7625eda14cbcSMatt Macy pair != NULL; pair = nvlist_next_nvpair(nv, pair)) { 7626eda14cbcSMatt Macy uint64_t vdev_guid = fnvpair_value_uint64(pair); 7627eda14cbcSMatt Macy 7628eda14cbcSMatt Macy int error = spa_vdev_trim_impl(spa, vdev_guid, cmd_type, 7629eda14cbcSMatt Macy rate, partial, secure, &vd_list); 7630eda14cbcSMatt Macy if (error != 0) { 7631eda14cbcSMatt Macy char guid_as_str[MAXNAMELEN]; 7632eda14cbcSMatt Macy 7633eda14cbcSMatt Macy (void) snprintf(guid_as_str, sizeof (guid_as_str), 7634eda14cbcSMatt Macy "%llu", (unsigned long long)vdev_guid); 7635eda14cbcSMatt Macy fnvlist_add_int64(vdev_errlist, guid_as_str, error); 7636eda14cbcSMatt Macy total_errors++; 7637eda14cbcSMatt Macy } 7638eda14cbcSMatt Macy } 7639eda14cbcSMatt Macy 7640eda14cbcSMatt Macy /* Wait for all TRIM threads to stop. */ 7641eda14cbcSMatt Macy vdev_trim_stop_wait(spa, &vd_list); 7642eda14cbcSMatt Macy 7643eda14cbcSMatt Macy /* Sync out the TRIM state */ 7644eda14cbcSMatt Macy txg_wait_synced(spa->spa_dsl_pool, 0); 7645eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 7646eda14cbcSMatt Macy 7647eda14cbcSMatt Macy list_destroy(&vd_list); 7648eda14cbcSMatt Macy 7649eda14cbcSMatt Macy return (total_errors); 7650eda14cbcSMatt Macy } 7651eda14cbcSMatt Macy 7652eda14cbcSMatt Macy /* 7653eda14cbcSMatt Macy * Split a set of devices from their mirrors, and create a new pool from them. 7654eda14cbcSMatt Macy */ 7655eda14cbcSMatt Macy int 7656a0b956f5SMartin Matuska spa_vdev_split_mirror(spa_t *spa, const char *newname, nvlist_t *config, 7657eda14cbcSMatt Macy nvlist_t *props, boolean_t exp) 7658eda14cbcSMatt Macy { 7659eda14cbcSMatt Macy int error = 0; 7660eda14cbcSMatt Macy uint64_t txg, *glist; 7661eda14cbcSMatt Macy spa_t *newspa; 7662eda14cbcSMatt Macy uint_t c, children, lastlog; 7663eda14cbcSMatt Macy nvlist_t **child, *nvl, *tmp; 7664eda14cbcSMatt Macy dmu_tx_t *tx; 76652a58b312SMartin Matuska const char *altroot = NULL; 7666eda14cbcSMatt Macy vdev_t *rvd, **vml = NULL; /* vdev modify list */ 7667eda14cbcSMatt Macy boolean_t activate_slog; 7668eda14cbcSMatt Macy 7669eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 7670eda14cbcSMatt Macy 7671eda14cbcSMatt Macy txg = spa_vdev_enter(spa); 7672eda14cbcSMatt Macy 7673eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa_namespace_lock)); 7674eda14cbcSMatt Macy if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) { 7675eda14cbcSMatt Macy error = (spa_has_checkpoint(spa)) ? 7676eda14cbcSMatt Macy ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT; 7677eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, error)); 7678eda14cbcSMatt Macy } 7679eda14cbcSMatt Macy 7680eda14cbcSMatt Macy /* clear the log and flush everything up to now */ 7681eda14cbcSMatt Macy activate_slog = spa_passivate_log(spa); 7682eda14cbcSMatt Macy (void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 7683eda14cbcSMatt Macy error = spa_reset_logs(spa); 7684eda14cbcSMatt Macy txg = spa_vdev_config_enter(spa); 7685eda14cbcSMatt Macy 7686eda14cbcSMatt Macy if (activate_slog) 7687eda14cbcSMatt Macy spa_activate_log(spa); 7688eda14cbcSMatt Macy 7689eda14cbcSMatt Macy if (error != 0) 7690eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, error)); 7691eda14cbcSMatt Macy 7692eda14cbcSMatt Macy /* check new spa name before going any further */ 7693eda14cbcSMatt Macy if (spa_lookup(newname) != NULL) 7694eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EEXIST)); 7695eda14cbcSMatt Macy 7696eda14cbcSMatt Macy /* 7697eda14cbcSMatt Macy * scan through all the children to ensure they're all mirrors 7698eda14cbcSMatt Macy */ 7699eda14cbcSMatt Macy if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 || 7700eda14cbcSMatt Macy nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child, 7701eda14cbcSMatt Macy &children) != 0) 7702eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 7703eda14cbcSMatt Macy 7704eda14cbcSMatt Macy /* first, check to ensure we've got the right child count */ 7705eda14cbcSMatt Macy rvd = spa->spa_root_vdev; 7706eda14cbcSMatt Macy lastlog = 0; 7707eda14cbcSMatt Macy for (c = 0; c < rvd->vdev_children; c++) { 7708eda14cbcSMatt Macy vdev_t *vd = rvd->vdev_child[c]; 7709eda14cbcSMatt Macy 7710eda14cbcSMatt Macy /* don't count the holes & logs as children */ 7711eda14cbcSMatt Macy if (vd->vdev_islog || (vd->vdev_ops != &vdev_indirect_ops && 7712eda14cbcSMatt Macy !vdev_is_concrete(vd))) { 7713eda14cbcSMatt Macy if (lastlog == 0) 7714eda14cbcSMatt Macy lastlog = c; 7715eda14cbcSMatt Macy continue; 7716eda14cbcSMatt Macy } 7717eda14cbcSMatt Macy 7718eda14cbcSMatt Macy lastlog = 0; 7719eda14cbcSMatt Macy } 7720eda14cbcSMatt Macy if (children != (lastlog != 0 ? lastlog : rvd->vdev_children)) 7721eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 7722eda14cbcSMatt Macy 7723eda14cbcSMatt Macy /* next, ensure no spare or cache devices are part of the split */ 7724eda14cbcSMatt Macy if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 || 7725eda14cbcSMatt Macy nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0) 7726eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, EINVAL)); 7727eda14cbcSMatt Macy 7728eda14cbcSMatt Macy vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP); 7729eda14cbcSMatt Macy glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP); 7730eda14cbcSMatt Macy 7731eda14cbcSMatt Macy /* then, loop over each vdev and validate it */ 7732eda14cbcSMatt Macy for (c = 0; c < children; c++) { 7733eda14cbcSMatt Macy uint64_t is_hole = 0; 7734eda14cbcSMatt Macy 7735eda14cbcSMatt Macy (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 7736eda14cbcSMatt Macy &is_hole); 7737eda14cbcSMatt Macy 7738eda14cbcSMatt Macy if (is_hole != 0) { 7739eda14cbcSMatt Macy if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole || 7740eda14cbcSMatt Macy spa->spa_root_vdev->vdev_child[c]->vdev_islog) { 7741eda14cbcSMatt Macy continue; 7742eda14cbcSMatt Macy } else { 7743eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 7744eda14cbcSMatt Macy break; 7745eda14cbcSMatt Macy } 7746eda14cbcSMatt Macy } 7747eda14cbcSMatt Macy 7748eda14cbcSMatt Macy /* deal with indirect vdevs */ 7749eda14cbcSMatt Macy if (spa->spa_root_vdev->vdev_child[c]->vdev_ops == 7750eda14cbcSMatt Macy &vdev_indirect_ops) 7751eda14cbcSMatt Macy continue; 7752eda14cbcSMatt Macy 7753eda14cbcSMatt Macy /* which disk is going to be split? */ 7754eda14cbcSMatt Macy if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID, 7755eda14cbcSMatt Macy &glist[c]) != 0) { 7756eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 7757eda14cbcSMatt Macy break; 7758eda14cbcSMatt Macy } 7759eda14cbcSMatt Macy 7760eda14cbcSMatt Macy /* look it up in the spa */ 7761eda14cbcSMatt Macy vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE); 7762eda14cbcSMatt Macy if (vml[c] == NULL) { 7763eda14cbcSMatt Macy error = SET_ERROR(ENODEV); 7764eda14cbcSMatt Macy break; 7765eda14cbcSMatt Macy } 7766eda14cbcSMatt Macy 7767eda14cbcSMatt Macy /* make sure there's nothing stopping the split */ 7768eda14cbcSMatt Macy if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops || 7769eda14cbcSMatt Macy vml[c]->vdev_islog || 7770eda14cbcSMatt Macy !vdev_is_concrete(vml[c]) || 7771eda14cbcSMatt Macy vml[c]->vdev_isspare || 7772eda14cbcSMatt Macy vml[c]->vdev_isl2cache || 7773eda14cbcSMatt Macy !vdev_writeable(vml[c]) || 7774eda14cbcSMatt Macy vml[c]->vdev_children != 0 || 7775eda14cbcSMatt Macy vml[c]->vdev_state != VDEV_STATE_HEALTHY || 7776eda14cbcSMatt Macy c != spa->spa_root_vdev->vdev_child[c]->vdev_id) { 7777eda14cbcSMatt Macy error = SET_ERROR(EINVAL); 7778eda14cbcSMatt Macy break; 7779eda14cbcSMatt Macy } 7780eda14cbcSMatt Macy 7781eda14cbcSMatt Macy if (vdev_dtl_required(vml[c]) || 7782eda14cbcSMatt Macy vdev_resilver_needed(vml[c], NULL, NULL)) { 7783eda14cbcSMatt Macy error = SET_ERROR(EBUSY); 7784eda14cbcSMatt Macy break; 7785eda14cbcSMatt Macy } 7786eda14cbcSMatt Macy 7787eda14cbcSMatt Macy /* we need certain info from the top level */ 778881b22a98SMartin Matuska fnvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY, 778981b22a98SMartin Matuska vml[c]->vdev_top->vdev_ms_array); 779081b22a98SMartin Matuska fnvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT, 779181b22a98SMartin Matuska vml[c]->vdev_top->vdev_ms_shift); 779281b22a98SMartin Matuska fnvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE, 779381b22a98SMartin Matuska vml[c]->vdev_top->vdev_asize); 779481b22a98SMartin Matuska fnvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT, 779581b22a98SMartin Matuska vml[c]->vdev_top->vdev_ashift); 7796eda14cbcSMatt Macy 7797eda14cbcSMatt Macy /* transfer per-vdev ZAPs */ 7798eda14cbcSMatt Macy ASSERT3U(vml[c]->vdev_leaf_zap, !=, 0); 7799eda14cbcSMatt Macy VERIFY0(nvlist_add_uint64(child[c], 7800eda14cbcSMatt Macy ZPOOL_CONFIG_VDEV_LEAF_ZAP, vml[c]->vdev_leaf_zap)); 7801eda14cbcSMatt Macy 7802eda14cbcSMatt Macy ASSERT3U(vml[c]->vdev_top->vdev_top_zap, !=, 0); 7803eda14cbcSMatt Macy VERIFY0(nvlist_add_uint64(child[c], 7804eda14cbcSMatt Macy ZPOOL_CONFIG_VDEV_TOP_ZAP, 7805eda14cbcSMatt Macy vml[c]->vdev_parent->vdev_top_zap)); 7806eda14cbcSMatt Macy } 7807eda14cbcSMatt Macy 7808eda14cbcSMatt Macy if (error != 0) { 7809eda14cbcSMatt Macy kmem_free(vml, children * sizeof (vdev_t *)); 7810eda14cbcSMatt Macy kmem_free(glist, children * sizeof (uint64_t)); 7811eda14cbcSMatt Macy return (spa_vdev_exit(spa, NULL, txg, error)); 7812eda14cbcSMatt Macy } 7813eda14cbcSMatt Macy 7814eda14cbcSMatt Macy /* stop writers from using the disks */ 7815eda14cbcSMatt Macy for (c = 0; c < children; c++) { 7816eda14cbcSMatt Macy if (vml[c] != NULL) 7817eda14cbcSMatt Macy vml[c]->vdev_offline = B_TRUE; 7818eda14cbcSMatt Macy } 7819eda14cbcSMatt Macy vdev_reopen(spa->spa_root_vdev); 7820eda14cbcSMatt Macy 7821eda14cbcSMatt Macy /* 7822eda14cbcSMatt Macy * Temporarily record the splitting vdevs in the spa config. This 7823eda14cbcSMatt Macy * will disappear once the config is regenerated. 7824eda14cbcSMatt Macy */ 782581b22a98SMartin Matuska nvl = fnvlist_alloc(); 782681b22a98SMartin Matuska fnvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST, glist, children); 7827eda14cbcSMatt Macy kmem_free(glist, children * sizeof (uint64_t)); 7828eda14cbcSMatt Macy 7829eda14cbcSMatt Macy mutex_enter(&spa->spa_props_lock); 783081b22a98SMartin Matuska fnvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT, nvl); 7831eda14cbcSMatt Macy mutex_exit(&spa->spa_props_lock); 7832eda14cbcSMatt Macy spa->spa_config_splitting = nvl; 7833eda14cbcSMatt Macy vdev_config_dirty(spa->spa_root_vdev); 7834eda14cbcSMatt Macy 7835eda14cbcSMatt Macy /* configure and create the new pool */ 783681b22a98SMartin Matuska fnvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname); 783781b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 783881b22a98SMartin Matuska exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE); 783981b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, spa_version(spa)); 784081b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG, spa->spa_config_txg); 784181b22a98SMartin Matuska fnvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID, 784281b22a98SMartin Matuska spa_generate_guid(NULL)); 7843eda14cbcSMatt Macy VERIFY0(nvlist_add_boolean(config, ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS)); 7844eda14cbcSMatt Macy (void) nvlist_lookup_string(props, 7845eda14cbcSMatt Macy zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); 7846eda14cbcSMatt Macy 7847eda14cbcSMatt Macy /* add the new pool to the namespace */ 7848eda14cbcSMatt Macy newspa = spa_add(newname, config, altroot); 7849eda14cbcSMatt Macy newspa->spa_avz_action = AVZ_ACTION_REBUILD; 7850eda14cbcSMatt Macy newspa->spa_config_txg = spa->spa_config_txg; 7851eda14cbcSMatt Macy spa_set_log_state(newspa, SPA_LOG_CLEAR); 7852eda14cbcSMatt Macy 7853eda14cbcSMatt Macy /* release the spa config lock, retaining the namespace lock */ 7854eda14cbcSMatt Macy spa_vdev_config_exit(spa, NULL, txg, 0, FTAG); 7855eda14cbcSMatt Macy 7856eda14cbcSMatt Macy if (zio_injection_enabled) 7857eda14cbcSMatt Macy zio_handle_panic_injection(spa, FTAG, 1); 7858eda14cbcSMatt Macy 7859eda14cbcSMatt Macy spa_activate(newspa, spa_mode_global); 7860eda14cbcSMatt Macy spa_async_suspend(newspa); 7861eda14cbcSMatt Macy 7862eda14cbcSMatt Macy /* 7863eda14cbcSMatt Macy * Temporarily stop the initializing and TRIM activity. We set the 7864eda14cbcSMatt Macy * state to ACTIVE so that we know to resume initializing or TRIM 7865eda14cbcSMatt Macy * once the split has completed. 7866eda14cbcSMatt Macy */ 7867eda14cbcSMatt Macy list_t vd_initialize_list; 7868eda14cbcSMatt Macy list_create(&vd_initialize_list, sizeof (vdev_t), 7869eda14cbcSMatt Macy offsetof(vdev_t, vdev_initialize_node)); 7870eda14cbcSMatt Macy 7871eda14cbcSMatt Macy list_t vd_trim_list; 7872eda14cbcSMatt Macy list_create(&vd_trim_list, sizeof (vdev_t), 7873eda14cbcSMatt Macy offsetof(vdev_t, vdev_trim_node)); 7874eda14cbcSMatt Macy 7875eda14cbcSMatt Macy for (c = 0; c < children; c++) { 7876eda14cbcSMatt Macy if (vml[c] != NULL && vml[c]->vdev_ops != &vdev_indirect_ops) { 7877eda14cbcSMatt Macy mutex_enter(&vml[c]->vdev_initialize_lock); 7878eda14cbcSMatt Macy vdev_initialize_stop(vml[c], 7879eda14cbcSMatt Macy VDEV_INITIALIZE_ACTIVE, &vd_initialize_list); 7880eda14cbcSMatt Macy mutex_exit(&vml[c]->vdev_initialize_lock); 7881eda14cbcSMatt Macy 7882eda14cbcSMatt Macy mutex_enter(&vml[c]->vdev_trim_lock); 7883eda14cbcSMatt Macy vdev_trim_stop(vml[c], VDEV_TRIM_ACTIVE, &vd_trim_list); 7884eda14cbcSMatt Macy mutex_exit(&vml[c]->vdev_trim_lock); 7885eda14cbcSMatt Macy } 7886eda14cbcSMatt Macy } 7887eda14cbcSMatt Macy 7888eda14cbcSMatt Macy vdev_initialize_stop_wait(spa, &vd_initialize_list); 7889eda14cbcSMatt Macy vdev_trim_stop_wait(spa, &vd_trim_list); 7890eda14cbcSMatt Macy 7891eda14cbcSMatt Macy list_destroy(&vd_initialize_list); 7892eda14cbcSMatt Macy list_destroy(&vd_trim_list); 7893eda14cbcSMatt Macy 7894eda14cbcSMatt Macy newspa->spa_config_source = SPA_CONFIG_SRC_SPLIT; 7895eda14cbcSMatt Macy newspa->spa_is_splitting = B_TRUE; 7896eda14cbcSMatt Macy 7897eda14cbcSMatt Macy /* create the new pool from the disks of the original pool */ 7898eda14cbcSMatt Macy error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE); 7899eda14cbcSMatt Macy if (error) 7900eda14cbcSMatt Macy goto out; 7901eda14cbcSMatt Macy 7902eda14cbcSMatt Macy /* if that worked, generate a real config for the new pool */ 7903eda14cbcSMatt Macy if (newspa->spa_root_vdev != NULL) { 790481b22a98SMartin Matuska newspa->spa_config_splitting = fnvlist_alloc(); 790581b22a98SMartin Matuska fnvlist_add_uint64(newspa->spa_config_splitting, 790681b22a98SMartin Matuska ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)); 7907eda14cbcSMatt Macy spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL, 7908eda14cbcSMatt Macy B_TRUE)); 7909eda14cbcSMatt Macy } 7910eda14cbcSMatt Macy 7911eda14cbcSMatt Macy /* set the props */ 7912eda14cbcSMatt Macy if (props != NULL) { 7913eda14cbcSMatt Macy spa_configfile_set(newspa, props, B_FALSE); 7914eda14cbcSMatt Macy error = spa_prop_set(newspa, props); 7915eda14cbcSMatt Macy if (error) 7916eda14cbcSMatt Macy goto out; 7917eda14cbcSMatt Macy } 7918eda14cbcSMatt Macy 7919eda14cbcSMatt Macy /* flush everything */ 7920eda14cbcSMatt Macy txg = spa_vdev_config_enter(newspa); 7921eda14cbcSMatt Macy vdev_config_dirty(newspa->spa_root_vdev); 7922eda14cbcSMatt Macy (void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG); 7923eda14cbcSMatt Macy 7924eda14cbcSMatt Macy if (zio_injection_enabled) 7925eda14cbcSMatt Macy zio_handle_panic_injection(spa, FTAG, 2); 7926eda14cbcSMatt Macy 7927eda14cbcSMatt Macy spa_async_resume(newspa); 7928eda14cbcSMatt Macy 7929eda14cbcSMatt Macy /* finally, update the original pool's config */ 7930eda14cbcSMatt Macy txg = spa_vdev_config_enter(spa); 7931eda14cbcSMatt Macy tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); 7932eda14cbcSMatt Macy error = dmu_tx_assign(tx, TXG_WAIT); 7933eda14cbcSMatt Macy if (error != 0) 7934eda14cbcSMatt Macy dmu_tx_abort(tx); 7935eda14cbcSMatt Macy for (c = 0; c < children; c++) { 7936eda14cbcSMatt Macy if (vml[c] != NULL && vml[c]->vdev_ops != &vdev_indirect_ops) { 7937eda14cbcSMatt Macy vdev_t *tvd = vml[c]->vdev_top; 7938eda14cbcSMatt Macy 7939eda14cbcSMatt Macy /* 7940eda14cbcSMatt Macy * Need to be sure the detachable VDEV is not 7941eda14cbcSMatt Macy * on any *other* txg's DTL list to prevent it 7942eda14cbcSMatt Macy * from being accessed after it's freed. 7943eda14cbcSMatt Macy */ 7944eda14cbcSMatt Macy for (int t = 0; t < TXG_SIZE; t++) { 7945eda14cbcSMatt Macy (void) txg_list_remove_this( 7946eda14cbcSMatt Macy &tvd->vdev_dtl_list, vml[c], t); 7947eda14cbcSMatt Macy } 7948eda14cbcSMatt Macy 7949eda14cbcSMatt Macy vdev_split(vml[c]); 7950eda14cbcSMatt Macy if (error == 0) 7951eda14cbcSMatt Macy spa_history_log_internal(spa, "detach", tx, 7952eda14cbcSMatt Macy "vdev=%s", vml[c]->vdev_path); 7953eda14cbcSMatt Macy 7954eda14cbcSMatt Macy vdev_free(vml[c]); 7955eda14cbcSMatt Macy } 7956eda14cbcSMatt Macy } 7957eda14cbcSMatt Macy spa->spa_avz_action = AVZ_ACTION_REBUILD; 7958eda14cbcSMatt Macy vdev_config_dirty(spa->spa_root_vdev); 7959eda14cbcSMatt Macy spa->spa_config_splitting = NULL; 7960eda14cbcSMatt Macy nvlist_free(nvl); 7961eda14cbcSMatt Macy if (error == 0) 7962eda14cbcSMatt Macy dmu_tx_commit(tx); 7963eda14cbcSMatt Macy (void) spa_vdev_exit(spa, NULL, txg, 0); 7964eda14cbcSMatt Macy 7965eda14cbcSMatt Macy if (zio_injection_enabled) 7966eda14cbcSMatt Macy zio_handle_panic_injection(spa, FTAG, 3); 7967eda14cbcSMatt Macy 7968eda14cbcSMatt Macy /* split is complete; log a history record */ 7969eda14cbcSMatt Macy spa_history_log_internal(newspa, "split", NULL, 7970eda14cbcSMatt Macy "from pool %s", spa_name(spa)); 7971eda14cbcSMatt Macy 7972eda14cbcSMatt Macy newspa->spa_is_splitting = B_FALSE; 7973eda14cbcSMatt Macy kmem_free(vml, children * sizeof (vdev_t *)); 7974eda14cbcSMatt Macy 7975eda14cbcSMatt Macy /* if we're not going to mount the filesystems in userland, export */ 7976eda14cbcSMatt Macy if (exp) 7977eda14cbcSMatt Macy error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL, 7978eda14cbcSMatt Macy B_FALSE, B_FALSE); 7979eda14cbcSMatt Macy 7980eda14cbcSMatt Macy return (error); 7981eda14cbcSMatt Macy 7982eda14cbcSMatt Macy out: 7983eda14cbcSMatt Macy spa_unload(newspa); 7984eda14cbcSMatt Macy spa_deactivate(newspa); 7985eda14cbcSMatt Macy spa_remove(newspa); 7986eda14cbcSMatt Macy 7987eda14cbcSMatt Macy txg = spa_vdev_config_enter(spa); 7988eda14cbcSMatt Macy 7989eda14cbcSMatt Macy /* re-online all offlined disks */ 7990eda14cbcSMatt Macy for (c = 0; c < children; c++) { 7991eda14cbcSMatt Macy if (vml[c] != NULL) 7992eda14cbcSMatt Macy vml[c]->vdev_offline = B_FALSE; 7993eda14cbcSMatt Macy } 7994eda14cbcSMatt Macy 7995eda14cbcSMatt Macy /* restart initializing or trimming disks as necessary */ 7996eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_INITIALIZE_RESTART); 7997eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_TRIM_RESTART); 7998eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_AUTOTRIM_RESTART); 7999eda14cbcSMatt Macy 8000eda14cbcSMatt Macy vdev_reopen(spa->spa_root_vdev); 8001eda14cbcSMatt Macy 8002eda14cbcSMatt Macy nvlist_free(spa->spa_config_splitting); 8003eda14cbcSMatt Macy spa->spa_config_splitting = NULL; 8004eda14cbcSMatt Macy (void) spa_vdev_exit(spa, NULL, txg, error); 8005eda14cbcSMatt Macy 8006eda14cbcSMatt Macy kmem_free(vml, children * sizeof (vdev_t *)); 8007eda14cbcSMatt Macy return (error); 8008eda14cbcSMatt Macy } 8009eda14cbcSMatt Macy 8010eda14cbcSMatt Macy /* 8011eda14cbcSMatt Macy * Find any device that's done replacing, or a vdev marked 'unspare' that's 8012eda14cbcSMatt Macy * currently spared, so we can detach it. 8013eda14cbcSMatt Macy */ 8014eda14cbcSMatt Macy static vdev_t * 8015eda14cbcSMatt Macy spa_vdev_resilver_done_hunt(vdev_t *vd) 8016eda14cbcSMatt Macy { 8017eda14cbcSMatt Macy vdev_t *newvd, *oldvd; 8018eda14cbcSMatt Macy 8019eda14cbcSMatt Macy for (int c = 0; c < vd->vdev_children; c++) { 8020eda14cbcSMatt Macy oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]); 8021eda14cbcSMatt Macy if (oldvd != NULL) 8022eda14cbcSMatt Macy return (oldvd); 8023eda14cbcSMatt Macy } 8024eda14cbcSMatt Macy 8025eda14cbcSMatt Macy /* 8026eda14cbcSMatt Macy * Check for a completed replacement. We always consider the first 8027eda14cbcSMatt Macy * vdev in the list to be the oldest vdev, and the last one to be 8028eda14cbcSMatt Macy * the newest (see spa_vdev_attach() for how that works). In 8029eda14cbcSMatt Macy * the case where the newest vdev is faulted, we will not automatically 8030eda14cbcSMatt Macy * remove it after a resilver completes. This is OK as it will require 8031eda14cbcSMatt Macy * user intervention to determine which disk the admin wishes to keep. 8032eda14cbcSMatt Macy */ 8033eda14cbcSMatt Macy if (vd->vdev_ops == &vdev_replacing_ops) { 8034eda14cbcSMatt Macy ASSERT(vd->vdev_children > 1); 8035eda14cbcSMatt Macy 8036eda14cbcSMatt Macy newvd = vd->vdev_child[vd->vdev_children - 1]; 8037eda14cbcSMatt Macy oldvd = vd->vdev_child[0]; 8038eda14cbcSMatt Macy 8039eda14cbcSMatt Macy if (vdev_dtl_empty(newvd, DTL_MISSING) && 8040eda14cbcSMatt Macy vdev_dtl_empty(newvd, DTL_OUTAGE) && 8041eda14cbcSMatt Macy !vdev_dtl_required(oldvd)) 8042eda14cbcSMatt Macy return (oldvd); 8043eda14cbcSMatt Macy } 8044eda14cbcSMatt Macy 8045eda14cbcSMatt Macy /* 8046eda14cbcSMatt Macy * Check for a completed resilver with the 'unspare' flag set. 8047eda14cbcSMatt Macy * Also potentially update faulted state. 8048eda14cbcSMatt Macy */ 8049eda14cbcSMatt Macy if (vd->vdev_ops == &vdev_spare_ops) { 8050eda14cbcSMatt Macy vdev_t *first = vd->vdev_child[0]; 8051eda14cbcSMatt Macy vdev_t *last = vd->vdev_child[vd->vdev_children - 1]; 8052eda14cbcSMatt Macy 8053eda14cbcSMatt Macy if (last->vdev_unspare) { 8054eda14cbcSMatt Macy oldvd = first; 8055eda14cbcSMatt Macy newvd = last; 8056eda14cbcSMatt Macy } else if (first->vdev_unspare) { 8057eda14cbcSMatt Macy oldvd = last; 8058eda14cbcSMatt Macy newvd = first; 8059eda14cbcSMatt Macy } else { 8060eda14cbcSMatt Macy oldvd = NULL; 8061eda14cbcSMatt Macy } 8062eda14cbcSMatt Macy 8063eda14cbcSMatt Macy if (oldvd != NULL && 8064eda14cbcSMatt Macy vdev_dtl_empty(newvd, DTL_MISSING) && 8065eda14cbcSMatt Macy vdev_dtl_empty(newvd, DTL_OUTAGE) && 8066eda14cbcSMatt Macy !vdev_dtl_required(oldvd)) 8067eda14cbcSMatt Macy return (oldvd); 8068eda14cbcSMatt Macy 8069eda14cbcSMatt Macy vdev_propagate_state(vd); 8070eda14cbcSMatt Macy 8071eda14cbcSMatt Macy /* 8072eda14cbcSMatt Macy * If there are more than two spares attached to a disk, 8073eda14cbcSMatt Macy * and those spares are not required, then we want to 8074eda14cbcSMatt Macy * attempt to free them up now so that they can be used 8075eda14cbcSMatt Macy * by other pools. Once we're back down to a single 8076eda14cbcSMatt Macy * disk+spare, we stop removing them. 8077eda14cbcSMatt Macy */ 8078eda14cbcSMatt Macy if (vd->vdev_children > 2) { 8079eda14cbcSMatt Macy newvd = vd->vdev_child[1]; 8080eda14cbcSMatt Macy 8081eda14cbcSMatt Macy if (newvd->vdev_isspare && last->vdev_isspare && 8082eda14cbcSMatt Macy vdev_dtl_empty(last, DTL_MISSING) && 8083eda14cbcSMatt Macy vdev_dtl_empty(last, DTL_OUTAGE) && 8084eda14cbcSMatt Macy !vdev_dtl_required(newvd)) 8085eda14cbcSMatt Macy return (newvd); 8086eda14cbcSMatt Macy } 8087eda14cbcSMatt Macy } 8088eda14cbcSMatt Macy 8089eda14cbcSMatt Macy return (NULL); 8090eda14cbcSMatt Macy } 8091eda14cbcSMatt Macy 8092eda14cbcSMatt Macy static void 8093eda14cbcSMatt Macy spa_vdev_resilver_done(spa_t *spa) 8094eda14cbcSMatt Macy { 8095eda14cbcSMatt Macy vdev_t *vd, *pvd, *ppvd; 8096eda14cbcSMatt Macy uint64_t guid, sguid, pguid, ppguid; 8097eda14cbcSMatt Macy 8098eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 8099eda14cbcSMatt Macy 8100eda14cbcSMatt Macy while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) { 8101eda14cbcSMatt Macy pvd = vd->vdev_parent; 8102eda14cbcSMatt Macy ppvd = pvd->vdev_parent; 8103eda14cbcSMatt Macy guid = vd->vdev_guid; 8104eda14cbcSMatt Macy pguid = pvd->vdev_guid; 8105eda14cbcSMatt Macy ppguid = ppvd->vdev_guid; 8106eda14cbcSMatt Macy sguid = 0; 8107eda14cbcSMatt Macy /* 8108eda14cbcSMatt Macy * If we have just finished replacing a hot spared device, then 8109eda14cbcSMatt Macy * we need to detach the parent's first child (the original hot 8110eda14cbcSMatt Macy * spare) as well. 8111eda14cbcSMatt Macy */ 8112eda14cbcSMatt Macy if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0 && 8113eda14cbcSMatt Macy ppvd->vdev_children == 2) { 8114eda14cbcSMatt Macy ASSERT(pvd->vdev_ops == &vdev_replacing_ops); 8115eda14cbcSMatt Macy sguid = ppvd->vdev_child[1]->vdev_guid; 8116eda14cbcSMatt Macy } 8117eda14cbcSMatt Macy ASSERT(vd->vdev_resilver_txg == 0 || !vdev_dtl_required(vd)); 8118eda14cbcSMatt Macy 8119eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 8120eda14cbcSMatt Macy if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0) 8121eda14cbcSMatt Macy return; 8122eda14cbcSMatt Macy if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0) 8123eda14cbcSMatt Macy return; 8124eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 8125eda14cbcSMatt Macy } 8126eda14cbcSMatt Macy 8127eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 8128eda14cbcSMatt Macy 8129eda14cbcSMatt Macy /* 8130eda14cbcSMatt Macy * If a detach was not performed above replace waiters will not have 8131eda14cbcSMatt Macy * been notified. In which case we must do so now. 8132eda14cbcSMatt Macy */ 8133eda14cbcSMatt Macy spa_notify_waiters(spa); 8134eda14cbcSMatt Macy } 8135eda14cbcSMatt Macy 8136eda14cbcSMatt Macy /* 8137eda14cbcSMatt Macy * Update the stored path or FRU for this vdev. 8138eda14cbcSMatt Macy */ 8139eda14cbcSMatt Macy static int 8140eda14cbcSMatt Macy spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value, 8141eda14cbcSMatt Macy boolean_t ispath) 8142eda14cbcSMatt Macy { 8143eda14cbcSMatt Macy vdev_t *vd; 8144eda14cbcSMatt Macy boolean_t sync = B_FALSE; 8145eda14cbcSMatt Macy 8146eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 8147eda14cbcSMatt Macy 8148eda14cbcSMatt Macy spa_vdev_state_enter(spa, SCL_ALL); 8149eda14cbcSMatt Macy 8150eda14cbcSMatt Macy if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) 8151eda14cbcSMatt Macy return (spa_vdev_state_exit(spa, NULL, ENOENT)); 8152eda14cbcSMatt Macy 8153eda14cbcSMatt Macy if (!vd->vdev_ops->vdev_op_leaf) 8154eda14cbcSMatt Macy return (spa_vdev_state_exit(spa, NULL, ENOTSUP)); 8155eda14cbcSMatt Macy 8156eda14cbcSMatt Macy if (ispath) { 8157eda14cbcSMatt Macy if (strcmp(value, vd->vdev_path) != 0) { 8158eda14cbcSMatt Macy spa_strfree(vd->vdev_path); 8159eda14cbcSMatt Macy vd->vdev_path = spa_strdup(value); 8160eda14cbcSMatt Macy sync = B_TRUE; 8161eda14cbcSMatt Macy } 8162eda14cbcSMatt Macy } else { 8163eda14cbcSMatt Macy if (vd->vdev_fru == NULL) { 8164eda14cbcSMatt Macy vd->vdev_fru = spa_strdup(value); 8165eda14cbcSMatt Macy sync = B_TRUE; 8166eda14cbcSMatt Macy } else if (strcmp(value, vd->vdev_fru) != 0) { 8167eda14cbcSMatt Macy spa_strfree(vd->vdev_fru); 8168eda14cbcSMatt Macy vd->vdev_fru = spa_strdup(value); 8169eda14cbcSMatt Macy sync = B_TRUE; 8170eda14cbcSMatt Macy } 8171eda14cbcSMatt Macy } 8172eda14cbcSMatt Macy 8173eda14cbcSMatt Macy return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0)); 8174eda14cbcSMatt Macy } 8175eda14cbcSMatt Macy 8176eda14cbcSMatt Macy int 8177eda14cbcSMatt Macy spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath) 8178eda14cbcSMatt Macy { 8179eda14cbcSMatt Macy return (spa_vdev_set_common(spa, guid, newpath, B_TRUE)); 8180eda14cbcSMatt Macy } 8181eda14cbcSMatt Macy 8182eda14cbcSMatt Macy int 8183eda14cbcSMatt Macy spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru) 8184eda14cbcSMatt Macy { 8185eda14cbcSMatt Macy return (spa_vdev_set_common(spa, guid, newfru, B_FALSE)); 8186eda14cbcSMatt Macy } 8187eda14cbcSMatt Macy 8188eda14cbcSMatt Macy /* 8189eda14cbcSMatt Macy * ========================================================================== 8190eda14cbcSMatt Macy * SPA Scanning 8191eda14cbcSMatt Macy * ========================================================================== 8192eda14cbcSMatt Macy */ 8193eda14cbcSMatt Macy int 8194eda14cbcSMatt Macy spa_scrub_pause_resume(spa_t *spa, pool_scrub_cmd_t cmd) 8195eda14cbcSMatt Macy { 8196eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 8197eda14cbcSMatt Macy 8198eda14cbcSMatt Macy if (dsl_scan_resilvering(spa->spa_dsl_pool)) 8199eda14cbcSMatt Macy return (SET_ERROR(EBUSY)); 8200eda14cbcSMatt Macy 8201eda14cbcSMatt Macy return (dsl_scrub_set_pause_resume(spa->spa_dsl_pool, cmd)); 8202eda14cbcSMatt Macy } 8203eda14cbcSMatt Macy 8204eda14cbcSMatt Macy int 8205eda14cbcSMatt Macy spa_scan_stop(spa_t *spa) 8206eda14cbcSMatt Macy { 8207eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 8208eda14cbcSMatt Macy if (dsl_scan_resilvering(spa->spa_dsl_pool)) 8209eda14cbcSMatt Macy return (SET_ERROR(EBUSY)); 8210c0a83fe0SMartin Matuska 8211eda14cbcSMatt Macy return (dsl_scan_cancel(spa->spa_dsl_pool)); 8212eda14cbcSMatt Macy } 8213eda14cbcSMatt Macy 8214eda14cbcSMatt Macy int 8215eda14cbcSMatt Macy spa_scan(spa_t *spa, pool_scan_func_t func) 8216eda14cbcSMatt Macy { 8217eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); 8218eda14cbcSMatt Macy 8219eda14cbcSMatt Macy if (func >= POOL_SCAN_FUNCS || func == POOL_SCAN_NONE) 8220eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 8221eda14cbcSMatt Macy 8222eda14cbcSMatt Macy if (func == POOL_SCAN_RESILVER && 8223eda14cbcSMatt Macy !spa_feature_is_enabled(spa, SPA_FEATURE_RESILVER_DEFER)) 8224eda14cbcSMatt Macy return (SET_ERROR(ENOTSUP)); 8225eda14cbcSMatt Macy 8226eda14cbcSMatt Macy /* 8227eda14cbcSMatt Macy * If a resilver was requested, but there is no DTL on a 8228eda14cbcSMatt Macy * writeable leaf device, we have nothing to do. 8229eda14cbcSMatt Macy */ 8230eda14cbcSMatt Macy if (func == POOL_SCAN_RESILVER && 8231eda14cbcSMatt Macy !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) { 8232eda14cbcSMatt Macy spa_async_request(spa, SPA_ASYNC_RESILVER_DONE); 8233eda14cbcSMatt Macy return (0); 8234eda14cbcSMatt Macy } 8235eda14cbcSMatt Macy 8236c0a83fe0SMartin Matuska if (func == POOL_SCAN_ERRORSCRUB && 8237c0a83fe0SMartin Matuska !spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) 8238c0a83fe0SMartin Matuska return (SET_ERROR(ENOTSUP)); 8239c0a83fe0SMartin Matuska 8240eda14cbcSMatt Macy return (dsl_scan(spa->spa_dsl_pool, func)); 8241eda14cbcSMatt Macy } 8242eda14cbcSMatt Macy 8243eda14cbcSMatt Macy /* 8244eda14cbcSMatt Macy * ========================================================================== 8245eda14cbcSMatt Macy * SPA async task processing 8246eda14cbcSMatt Macy * ========================================================================== 8247eda14cbcSMatt Macy */ 8248eda14cbcSMatt Macy 8249eda14cbcSMatt Macy static void 8250eda14cbcSMatt Macy spa_async_remove(spa_t *spa, vdev_t *vd) 8251eda14cbcSMatt Macy { 8252eda14cbcSMatt Macy if (vd->vdev_remove_wanted) { 8253eda14cbcSMatt Macy vd->vdev_remove_wanted = B_FALSE; 8254eda14cbcSMatt Macy vd->vdev_delayed_close = B_FALSE; 8255eda14cbcSMatt Macy vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE); 8256eda14cbcSMatt Macy 8257eda14cbcSMatt Macy /* 8258eda14cbcSMatt Macy * We want to clear the stats, but we don't want to do a full 8259eda14cbcSMatt Macy * vdev_clear() as that will cause us to throw away 8260eda14cbcSMatt Macy * degraded/faulted state as well as attempt to reopen the 8261eda14cbcSMatt Macy * device, all of which is a waste. 8262eda14cbcSMatt Macy */ 8263eda14cbcSMatt Macy vd->vdev_stat.vs_read_errors = 0; 8264eda14cbcSMatt Macy vd->vdev_stat.vs_write_errors = 0; 8265eda14cbcSMatt Macy vd->vdev_stat.vs_checksum_errors = 0; 8266eda14cbcSMatt Macy 8267eda14cbcSMatt Macy vdev_state_dirty(vd->vdev_top); 82687877fdebSMatt Macy 82697877fdebSMatt Macy /* Tell userspace that the vdev is gone. */ 82707877fdebSMatt Macy zfs_post_remove(spa, vd); 8271eda14cbcSMatt Macy } 8272eda14cbcSMatt Macy 8273eda14cbcSMatt Macy for (int c = 0; c < vd->vdev_children; c++) 8274eda14cbcSMatt Macy spa_async_remove(spa, vd->vdev_child[c]); 8275eda14cbcSMatt Macy } 8276eda14cbcSMatt Macy 8277eda14cbcSMatt Macy static void 8278eda14cbcSMatt Macy spa_async_probe(spa_t *spa, vdev_t *vd) 8279eda14cbcSMatt Macy { 8280eda14cbcSMatt Macy if (vd->vdev_probe_wanted) { 8281eda14cbcSMatt Macy vd->vdev_probe_wanted = B_FALSE; 8282eda14cbcSMatt Macy vdev_reopen(vd); /* vdev_open() does the actual probe */ 8283eda14cbcSMatt Macy } 8284eda14cbcSMatt Macy 8285eda14cbcSMatt Macy for (int c = 0; c < vd->vdev_children; c++) 8286eda14cbcSMatt Macy spa_async_probe(spa, vd->vdev_child[c]); 8287eda14cbcSMatt Macy } 8288eda14cbcSMatt Macy 8289eda14cbcSMatt Macy static void 8290eda14cbcSMatt Macy spa_async_autoexpand(spa_t *spa, vdev_t *vd) 8291eda14cbcSMatt Macy { 8292eda14cbcSMatt Macy if (!spa->spa_autoexpand) 8293eda14cbcSMatt Macy return; 8294eda14cbcSMatt Macy 8295eda14cbcSMatt Macy for (int c = 0; c < vd->vdev_children; c++) { 8296eda14cbcSMatt Macy vdev_t *cvd = vd->vdev_child[c]; 8297eda14cbcSMatt Macy spa_async_autoexpand(spa, cvd); 8298eda14cbcSMatt Macy } 8299eda14cbcSMatt Macy 8300eda14cbcSMatt Macy if (!vd->vdev_ops->vdev_op_leaf || vd->vdev_physpath == NULL) 8301eda14cbcSMatt Macy return; 8302eda14cbcSMatt Macy 8303eda14cbcSMatt Macy spa_event_notify(vd->vdev_spa, vd, NULL, ESC_ZFS_VDEV_AUTOEXPAND); 8304eda14cbcSMatt Macy } 8305eda14cbcSMatt Macy 8306da5137abSMartin Matuska static __attribute__((noreturn)) void 8307eda14cbcSMatt Macy spa_async_thread(void *arg) 8308eda14cbcSMatt Macy { 8309eda14cbcSMatt Macy spa_t *spa = (spa_t *)arg; 8310eda14cbcSMatt Macy dsl_pool_t *dp = spa->spa_dsl_pool; 8311eda14cbcSMatt Macy int tasks; 8312eda14cbcSMatt Macy 8313eda14cbcSMatt Macy ASSERT(spa->spa_sync_on); 8314eda14cbcSMatt Macy 8315eda14cbcSMatt Macy mutex_enter(&spa->spa_async_lock); 8316eda14cbcSMatt Macy tasks = spa->spa_async_tasks; 8317eda14cbcSMatt Macy spa->spa_async_tasks = 0; 8318eda14cbcSMatt Macy mutex_exit(&spa->spa_async_lock); 8319eda14cbcSMatt Macy 8320eda14cbcSMatt Macy /* 8321eda14cbcSMatt Macy * See if the config needs to be updated. 8322eda14cbcSMatt Macy */ 8323eda14cbcSMatt Macy if (tasks & SPA_ASYNC_CONFIG_UPDATE) { 8324eda14cbcSMatt Macy uint64_t old_space, new_space; 8325eda14cbcSMatt Macy 8326eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 8327eda14cbcSMatt Macy old_space = metaslab_class_get_space(spa_normal_class(spa)); 8328eda14cbcSMatt Macy old_space += metaslab_class_get_space(spa_special_class(spa)); 8329eda14cbcSMatt Macy old_space += metaslab_class_get_space(spa_dedup_class(spa)); 8330184c1b94SMartin Matuska old_space += metaslab_class_get_space( 8331184c1b94SMartin Matuska spa_embedded_log_class(spa)); 8332eda14cbcSMatt Macy 8333eda14cbcSMatt Macy spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); 8334eda14cbcSMatt Macy 8335eda14cbcSMatt Macy new_space = metaslab_class_get_space(spa_normal_class(spa)); 8336eda14cbcSMatt Macy new_space += metaslab_class_get_space(spa_special_class(spa)); 8337eda14cbcSMatt Macy new_space += metaslab_class_get_space(spa_dedup_class(spa)); 8338184c1b94SMartin Matuska new_space += metaslab_class_get_space( 8339184c1b94SMartin Matuska spa_embedded_log_class(spa)); 8340eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 8341eda14cbcSMatt Macy 8342eda14cbcSMatt Macy /* 8343eda14cbcSMatt Macy * If the pool grew as a result of the config update, 8344eda14cbcSMatt Macy * then log an internal history event. 8345eda14cbcSMatt Macy */ 8346eda14cbcSMatt Macy if (new_space != old_space) { 8347eda14cbcSMatt Macy spa_history_log_internal(spa, "vdev online", NULL, 8348eda14cbcSMatt Macy "pool '%s' size: %llu(+%llu)", 8349eda14cbcSMatt Macy spa_name(spa), (u_longlong_t)new_space, 8350eda14cbcSMatt Macy (u_longlong_t)(new_space - old_space)); 8351eda14cbcSMatt Macy } 8352eda14cbcSMatt Macy } 8353eda14cbcSMatt Macy 8354eda14cbcSMatt Macy /* 8355eda14cbcSMatt Macy * See if any devices need to be marked REMOVED. 8356eda14cbcSMatt Macy */ 8357eda14cbcSMatt Macy if (tasks & SPA_ASYNC_REMOVE) { 8358eda14cbcSMatt Macy spa_vdev_state_enter(spa, SCL_NONE); 8359eda14cbcSMatt Macy spa_async_remove(spa, spa->spa_root_vdev); 8360eda14cbcSMatt Macy for (int i = 0; i < spa->spa_l2cache.sav_count; i++) 8361eda14cbcSMatt Macy spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]); 8362eda14cbcSMatt Macy for (int i = 0; i < spa->spa_spares.sav_count; i++) 8363eda14cbcSMatt Macy spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]); 8364eda14cbcSMatt Macy (void) spa_vdev_state_exit(spa, NULL, 0); 8365eda14cbcSMatt Macy } 8366eda14cbcSMatt Macy 8367eda14cbcSMatt Macy if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) { 8368eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 8369eda14cbcSMatt Macy spa_async_autoexpand(spa, spa->spa_root_vdev); 8370eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 8371eda14cbcSMatt Macy } 8372eda14cbcSMatt Macy 8373eda14cbcSMatt Macy /* 8374eda14cbcSMatt Macy * See if any devices need to be probed. 8375eda14cbcSMatt Macy */ 8376eda14cbcSMatt Macy if (tasks & SPA_ASYNC_PROBE) { 8377eda14cbcSMatt Macy spa_vdev_state_enter(spa, SCL_NONE); 8378eda14cbcSMatt Macy spa_async_probe(spa, spa->spa_root_vdev); 8379eda14cbcSMatt Macy (void) spa_vdev_state_exit(spa, NULL, 0); 8380eda14cbcSMatt Macy } 8381eda14cbcSMatt Macy 8382eda14cbcSMatt Macy /* 8383eda14cbcSMatt Macy * If any devices are done replacing, detach them. 8384eda14cbcSMatt Macy */ 83857877fdebSMatt Macy if (tasks & SPA_ASYNC_RESILVER_DONE || 8386d411c1d6SMartin Matuska tasks & SPA_ASYNC_REBUILD_DONE || 8387d411c1d6SMartin Matuska tasks & SPA_ASYNC_DETACH_SPARE) { 8388eda14cbcSMatt Macy spa_vdev_resilver_done(spa); 8389eda14cbcSMatt Macy } 8390eda14cbcSMatt Macy 8391eda14cbcSMatt Macy /* 8392eda14cbcSMatt Macy * Kick off a resilver. 8393eda14cbcSMatt Macy */ 8394eda14cbcSMatt Macy if (tasks & SPA_ASYNC_RESILVER && 8395eda14cbcSMatt Macy !vdev_rebuild_active(spa->spa_root_vdev) && 8396eda14cbcSMatt Macy (!dsl_scan_resilvering(dp) || 8397eda14cbcSMatt Macy !spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_RESILVER_DEFER))) 8398eda14cbcSMatt Macy dsl_scan_restart_resilver(dp, 0); 8399eda14cbcSMatt Macy 8400eda14cbcSMatt Macy if (tasks & SPA_ASYNC_INITIALIZE_RESTART) { 8401eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 8402eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 8403eda14cbcSMatt Macy vdev_initialize_restart(spa->spa_root_vdev); 8404eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 8405eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 8406eda14cbcSMatt Macy } 8407eda14cbcSMatt Macy 8408eda14cbcSMatt Macy if (tasks & SPA_ASYNC_TRIM_RESTART) { 8409eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 8410eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 8411eda14cbcSMatt Macy vdev_trim_restart(spa->spa_root_vdev); 8412eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 8413eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 8414eda14cbcSMatt Macy } 8415eda14cbcSMatt Macy 8416eda14cbcSMatt Macy if (tasks & SPA_ASYNC_AUTOTRIM_RESTART) { 8417eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 8418eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 8419eda14cbcSMatt Macy vdev_autotrim_restart(spa); 8420eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 8421eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 8422eda14cbcSMatt Macy } 8423eda14cbcSMatt Macy 8424eda14cbcSMatt Macy /* 8425eda14cbcSMatt Macy * Kick off L2 cache whole device TRIM. 8426eda14cbcSMatt Macy */ 8427eda14cbcSMatt Macy if (tasks & SPA_ASYNC_L2CACHE_TRIM) { 8428eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 8429eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 8430eda14cbcSMatt Macy vdev_trim_l2arc(spa); 8431eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 8432eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 8433eda14cbcSMatt Macy } 8434eda14cbcSMatt Macy 8435eda14cbcSMatt Macy /* 8436eda14cbcSMatt Macy * Kick off L2 cache rebuilding. 8437eda14cbcSMatt Macy */ 8438eda14cbcSMatt Macy if (tasks & SPA_ASYNC_L2CACHE_REBUILD) { 8439eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 8440eda14cbcSMatt Macy spa_config_enter(spa, SCL_L2ARC, FTAG, RW_READER); 8441eda14cbcSMatt Macy l2arc_spa_rebuild_start(spa); 8442eda14cbcSMatt Macy spa_config_exit(spa, SCL_L2ARC, FTAG); 8443eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 8444eda14cbcSMatt Macy } 8445eda14cbcSMatt Macy 8446eda14cbcSMatt Macy /* 8447eda14cbcSMatt Macy * Let the world know that we're done. 8448eda14cbcSMatt Macy */ 8449eda14cbcSMatt Macy mutex_enter(&spa->spa_async_lock); 8450eda14cbcSMatt Macy spa->spa_async_thread = NULL; 8451eda14cbcSMatt Macy cv_broadcast(&spa->spa_async_cv); 8452eda14cbcSMatt Macy mutex_exit(&spa->spa_async_lock); 8453eda14cbcSMatt Macy thread_exit(); 8454eda14cbcSMatt Macy } 8455eda14cbcSMatt Macy 8456eda14cbcSMatt Macy void 8457eda14cbcSMatt Macy spa_async_suspend(spa_t *spa) 8458eda14cbcSMatt Macy { 8459eda14cbcSMatt Macy mutex_enter(&spa->spa_async_lock); 8460eda14cbcSMatt Macy spa->spa_async_suspended++; 8461eda14cbcSMatt Macy while (spa->spa_async_thread != NULL) 8462eda14cbcSMatt Macy cv_wait(&spa->spa_async_cv, &spa->spa_async_lock); 8463eda14cbcSMatt Macy mutex_exit(&spa->spa_async_lock); 8464eda14cbcSMatt Macy 8465eda14cbcSMatt Macy spa_vdev_remove_suspend(spa); 8466eda14cbcSMatt Macy 8467eda14cbcSMatt Macy zthr_t *condense_thread = spa->spa_condense_zthr; 8468eda14cbcSMatt Macy if (condense_thread != NULL) 8469eda14cbcSMatt Macy zthr_cancel(condense_thread); 8470eda14cbcSMatt Macy 8471eda14cbcSMatt Macy zthr_t *discard_thread = spa->spa_checkpoint_discard_zthr; 8472eda14cbcSMatt Macy if (discard_thread != NULL) 8473eda14cbcSMatt Macy zthr_cancel(discard_thread); 8474eda14cbcSMatt Macy 8475eda14cbcSMatt Macy zthr_t *ll_delete_thread = spa->spa_livelist_delete_zthr; 8476eda14cbcSMatt Macy if (ll_delete_thread != NULL) 8477eda14cbcSMatt Macy zthr_cancel(ll_delete_thread); 8478eda14cbcSMatt Macy 8479eda14cbcSMatt Macy zthr_t *ll_condense_thread = spa->spa_livelist_condense_zthr; 8480eda14cbcSMatt Macy if (ll_condense_thread != NULL) 8481eda14cbcSMatt Macy zthr_cancel(ll_condense_thread); 8482eda14cbcSMatt Macy } 8483eda14cbcSMatt Macy 8484eda14cbcSMatt Macy void 8485eda14cbcSMatt Macy spa_async_resume(spa_t *spa) 8486eda14cbcSMatt Macy { 8487eda14cbcSMatt Macy mutex_enter(&spa->spa_async_lock); 8488eda14cbcSMatt Macy ASSERT(spa->spa_async_suspended != 0); 8489eda14cbcSMatt Macy spa->spa_async_suspended--; 8490eda14cbcSMatt Macy mutex_exit(&spa->spa_async_lock); 8491eda14cbcSMatt Macy spa_restart_removal(spa); 8492eda14cbcSMatt Macy 8493eda14cbcSMatt Macy zthr_t *condense_thread = spa->spa_condense_zthr; 8494eda14cbcSMatt Macy if (condense_thread != NULL) 8495eda14cbcSMatt Macy zthr_resume(condense_thread); 8496eda14cbcSMatt Macy 8497eda14cbcSMatt Macy zthr_t *discard_thread = spa->spa_checkpoint_discard_zthr; 8498eda14cbcSMatt Macy if (discard_thread != NULL) 8499eda14cbcSMatt Macy zthr_resume(discard_thread); 8500eda14cbcSMatt Macy 8501eda14cbcSMatt Macy zthr_t *ll_delete_thread = spa->spa_livelist_delete_zthr; 8502eda14cbcSMatt Macy if (ll_delete_thread != NULL) 8503eda14cbcSMatt Macy zthr_resume(ll_delete_thread); 8504eda14cbcSMatt Macy 8505eda14cbcSMatt Macy zthr_t *ll_condense_thread = spa->spa_livelist_condense_zthr; 8506eda14cbcSMatt Macy if (ll_condense_thread != NULL) 8507eda14cbcSMatt Macy zthr_resume(ll_condense_thread); 8508eda14cbcSMatt Macy } 8509eda14cbcSMatt Macy 8510eda14cbcSMatt Macy static boolean_t 8511eda14cbcSMatt Macy spa_async_tasks_pending(spa_t *spa) 8512eda14cbcSMatt Macy { 8513eda14cbcSMatt Macy uint_t non_config_tasks; 8514eda14cbcSMatt Macy uint_t config_task; 8515eda14cbcSMatt Macy boolean_t config_task_suspended; 8516eda14cbcSMatt Macy 8517eda14cbcSMatt Macy non_config_tasks = spa->spa_async_tasks & ~SPA_ASYNC_CONFIG_UPDATE; 8518eda14cbcSMatt Macy config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE; 8519eda14cbcSMatt Macy if (spa->spa_ccw_fail_time == 0) { 8520eda14cbcSMatt Macy config_task_suspended = B_FALSE; 8521eda14cbcSMatt Macy } else { 8522eda14cbcSMatt Macy config_task_suspended = 8523eda14cbcSMatt Macy (gethrtime() - spa->spa_ccw_fail_time) < 8524eda14cbcSMatt Macy ((hrtime_t)zfs_ccw_retry_interval * NANOSEC); 8525eda14cbcSMatt Macy } 8526eda14cbcSMatt Macy 8527eda14cbcSMatt Macy return (non_config_tasks || (config_task && !config_task_suspended)); 8528eda14cbcSMatt Macy } 8529eda14cbcSMatt Macy 8530eda14cbcSMatt Macy static void 8531eda14cbcSMatt Macy spa_async_dispatch(spa_t *spa) 8532eda14cbcSMatt Macy { 8533eda14cbcSMatt Macy mutex_enter(&spa->spa_async_lock); 8534eda14cbcSMatt Macy if (spa_async_tasks_pending(spa) && 8535eda14cbcSMatt Macy !spa->spa_async_suspended && 8536eda14cbcSMatt Macy spa->spa_async_thread == NULL) 8537eda14cbcSMatt Macy spa->spa_async_thread = thread_create(NULL, 0, 8538eda14cbcSMatt Macy spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri); 8539eda14cbcSMatt Macy mutex_exit(&spa->spa_async_lock); 8540eda14cbcSMatt Macy } 8541eda14cbcSMatt Macy 8542eda14cbcSMatt Macy void 8543eda14cbcSMatt Macy spa_async_request(spa_t *spa, int task) 8544eda14cbcSMatt Macy { 8545eda14cbcSMatt Macy zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task); 8546eda14cbcSMatt Macy mutex_enter(&spa->spa_async_lock); 8547eda14cbcSMatt Macy spa->spa_async_tasks |= task; 8548eda14cbcSMatt Macy mutex_exit(&spa->spa_async_lock); 8549eda14cbcSMatt Macy } 8550eda14cbcSMatt Macy 8551eda14cbcSMatt Macy int 8552eda14cbcSMatt Macy spa_async_tasks(spa_t *spa) 8553eda14cbcSMatt Macy { 8554eda14cbcSMatt Macy return (spa->spa_async_tasks); 8555eda14cbcSMatt Macy } 8556eda14cbcSMatt Macy 8557eda14cbcSMatt Macy /* 8558eda14cbcSMatt Macy * ========================================================================== 8559eda14cbcSMatt Macy * SPA syncing routines 8560eda14cbcSMatt Macy * ========================================================================== 8561eda14cbcSMatt Macy */ 8562eda14cbcSMatt Macy 8563eda14cbcSMatt Macy 8564eda14cbcSMatt Macy static int 8565eda14cbcSMatt Macy bpobj_enqueue_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed, 8566eda14cbcSMatt Macy dmu_tx_t *tx) 8567eda14cbcSMatt Macy { 8568eda14cbcSMatt Macy bpobj_t *bpo = arg; 8569eda14cbcSMatt Macy bpobj_enqueue(bpo, bp, bp_freed, tx); 8570eda14cbcSMatt Macy return (0); 8571eda14cbcSMatt Macy } 8572eda14cbcSMatt Macy 8573eda14cbcSMatt Macy int 8574eda14cbcSMatt Macy bpobj_enqueue_alloc_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 8575eda14cbcSMatt Macy { 8576eda14cbcSMatt Macy return (bpobj_enqueue_cb(arg, bp, B_FALSE, tx)); 8577eda14cbcSMatt Macy } 8578eda14cbcSMatt Macy 8579eda14cbcSMatt Macy int 8580eda14cbcSMatt Macy bpobj_enqueue_free_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 8581eda14cbcSMatt Macy { 8582eda14cbcSMatt Macy return (bpobj_enqueue_cb(arg, bp, B_TRUE, tx)); 8583eda14cbcSMatt Macy } 8584eda14cbcSMatt Macy 8585eda14cbcSMatt Macy static int 8586eda14cbcSMatt Macy spa_free_sync_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 8587eda14cbcSMatt Macy { 8588eda14cbcSMatt Macy zio_t *pio = arg; 8589eda14cbcSMatt Macy 8590eda14cbcSMatt Macy zio_nowait(zio_free_sync(pio, pio->io_spa, dmu_tx_get_txg(tx), bp, 8591eda14cbcSMatt Macy pio->io_flags)); 8592eda14cbcSMatt Macy return (0); 8593eda14cbcSMatt Macy } 8594eda14cbcSMatt Macy 8595eda14cbcSMatt Macy static int 8596eda14cbcSMatt Macy bpobj_spa_free_sync_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed, 8597eda14cbcSMatt Macy dmu_tx_t *tx) 8598eda14cbcSMatt Macy { 8599eda14cbcSMatt Macy ASSERT(!bp_freed); 8600eda14cbcSMatt Macy return (spa_free_sync_cb(arg, bp, tx)); 8601eda14cbcSMatt Macy } 8602eda14cbcSMatt Macy 8603eda14cbcSMatt Macy /* 8604eda14cbcSMatt Macy * Note: this simple function is not inlined to make it easier to dtrace the 8605eda14cbcSMatt Macy * amount of time spent syncing frees. 8606eda14cbcSMatt Macy */ 8607eda14cbcSMatt Macy static void 8608eda14cbcSMatt Macy spa_sync_frees(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx) 8609eda14cbcSMatt Macy { 8610eda14cbcSMatt Macy zio_t *zio = zio_root(spa, NULL, NULL, 0); 8611eda14cbcSMatt Macy bplist_iterate(bpl, spa_free_sync_cb, zio, tx); 8612eda14cbcSMatt Macy VERIFY(zio_wait(zio) == 0); 8613eda14cbcSMatt Macy } 8614eda14cbcSMatt Macy 8615eda14cbcSMatt Macy /* 8616eda14cbcSMatt Macy * Note: this simple function is not inlined to make it easier to dtrace the 8617eda14cbcSMatt Macy * amount of time spent syncing deferred frees. 8618eda14cbcSMatt Macy */ 8619eda14cbcSMatt Macy static void 8620eda14cbcSMatt Macy spa_sync_deferred_frees(spa_t *spa, dmu_tx_t *tx) 8621eda14cbcSMatt Macy { 8622eda14cbcSMatt Macy if (spa_sync_pass(spa) != 1) 8623eda14cbcSMatt Macy return; 8624eda14cbcSMatt Macy 8625eda14cbcSMatt Macy /* 8626eda14cbcSMatt Macy * Note: 8627eda14cbcSMatt Macy * If the log space map feature is active, we stop deferring 8628eda14cbcSMatt Macy * frees to the next TXG and therefore running this function 8629eda14cbcSMatt Macy * would be considered a no-op as spa_deferred_bpobj should 8630eda14cbcSMatt Macy * not have any entries. 8631eda14cbcSMatt Macy * 8632eda14cbcSMatt Macy * That said we run this function anyway (instead of returning 8633eda14cbcSMatt Macy * immediately) for the edge-case scenario where we just 8634eda14cbcSMatt Macy * activated the log space map feature in this TXG but we have 8635eda14cbcSMatt Macy * deferred frees from the previous TXG. 8636eda14cbcSMatt Macy */ 8637eda14cbcSMatt Macy zio_t *zio = zio_root(spa, NULL, NULL, 0); 8638eda14cbcSMatt Macy VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj, 8639eda14cbcSMatt Macy bpobj_spa_free_sync_cb, zio, tx), ==, 0); 8640eda14cbcSMatt Macy VERIFY0(zio_wait(zio)); 8641eda14cbcSMatt Macy } 8642eda14cbcSMatt Macy 8643eda14cbcSMatt Macy static void 8644eda14cbcSMatt Macy spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx) 8645eda14cbcSMatt Macy { 8646eda14cbcSMatt Macy char *packed = NULL; 8647eda14cbcSMatt Macy size_t bufsize; 8648eda14cbcSMatt Macy size_t nvsize = 0; 8649eda14cbcSMatt Macy dmu_buf_t *db; 8650eda14cbcSMatt Macy 8651eda14cbcSMatt Macy VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0); 8652eda14cbcSMatt Macy 8653eda14cbcSMatt Macy /* 8654eda14cbcSMatt Macy * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration 8655eda14cbcSMatt Macy * information. This avoids the dmu_buf_will_dirty() path and 8656eda14cbcSMatt Macy * saves us a pre-read to get data we don't actually care about. 8657eda14cbcSMatt Macy */ 8658eda14cbcSMatt Macy bufsize = P2ROUNDUP((uint64_t)nvsize, SPA_CONFIG_BLOCKSIZE); 8659eda14cbcSMatt Macy packed = vmem_alloc(bufsize, KM_SLEEP); 8660eda14cbcSMatt Macy 8661eda14cbcSMatt Macy VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR, 8662eda14cbcSMatt Macy KM_SLEEP) == 0); 8663da5137abSMartin Matuska memset(packed + nvsize, 0, bufsize - nvsize); 8664eda14cbcSMatt Macy 8665eda14cbcSMatt Macy dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx); 8666eda14cbcSMatt Macy 8667eda14cbcSMatt Macy vmem_free(packed, bufsize); 8668eda14cbcSMatt Macy 8669eda14cbcSMatt Macy VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); 8670eda14cbcSMatt Macy dmu_buf_will_dirty(db, tx); 8671eda14cbcSMatt Macy *(uint64_t *)db->db_data = nvsize; 8672eda14cbcSMatt Macy dmu_buf_rele(db, FTAG); 8673eda14cbcSMatt Macy } 8674eda14cbcSMatt Macy 8675eda14cbcSMatt Macy static void 8676eda14cbcSMatt Macy spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx, 8677eda14cbcSMatt Macy const char *config, const char *entry) 8678eda14cbcSMatt Macy { 8679eda14cbcSMatt Macy nvlist_t *nvroot; 8680eda14cbcSMatt Macy nvlist_t **list; 8681eda14cbcSMatt Macy int i; 8682eda14cbcSMatt Macy 8683eda14cbcSMatt Macy if (!sav->sav_sync) 8684eda14cbcSMatt Macy return; 8685eda14cbcSMatt Macy 8686eda14cbcSMatt Macy /* 8687eda14cbcSMatt Macy * Update the MOS nvlist describing the list of available devices. 8688eda14cbcSMatt Macy * spa_validate_aux() will have already made sure this nvlist is 8689eda14cbcSMatt Macy * valid and the vdevs are labeled appropriately. 8690eda14cbcSMatt Macy */ 8691eda14cbcSMatt Macy if (sav->sav_object == 0) { 8692eda14cbcSMatt Macy sav->sav_object = dmu_object_alloc(spa->spa_meta_objset, 8693eda14cbcSMatt Macy DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE, 8694eda14cbcSMatt Macy sizeof (uint64_t), tx); 8695eda14cbcSMatt Macy VERIFY(zap_update(spa->spa_meta_objset, 8696eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1, 8697eda14cbcSMatt Macy &sav->sav_object, tx) == 0); 8698eda14cbcSMatt Macy } 8699eda14cbcSMatt Macy 870081b22a98SMartin Matuska nvroot = fnvlist_alloc(); 8701eda14cbcSMatt Macy if (sav->sav_count == 0) { 8702681ce946SMartin Matuska fnvlist_add_nvlist_array(nvroot, config, 8703681ce946SMartin Matuska (const nvlist_t * const *)NULL, 0); 8704eda14cbcSMatt Macy } else { 8705eda14cbcSMatt Macy list = kmem_alloc(sav->sav_count*sizeof (void *), KM_SLEEP); 8706eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) 8707eda14cbcSMatt Macy list[i] = vdev_config_generate(spa, sav->sav_vdevs[i], 8708eda14cbcSMatt Macy B_FALSE, VDEV_CONFIG_L2CACHE); 8709681ce946SMartin Matuska fnvlist_add_nvlist_array(nvroot, config, 8710681ce946SMartin Matuska (const nvlist_t * const *)list, sav->sav_count); 8711eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) 8712eda14cbcSMatt Macy nvlist_free(list[i]); 8713eda14cbcSMatt Macy kmem_free(list, sav->sav_count * sizeof (void *)); 8714eda14cbcSMatt Macy } 8715eda14cbcSMatt Macy 8716eda14cbcSMatt Macy spa_sync_nvlist(spa, sav->sav_object, nvroot, tx); 8717eda14cbcSMatt Macy nvlist_free(nvroot); 8718eda14cbcSMatt Macy 8719eda14cbcSMatt Macy sav->sav_sync = B_FALSE; 8720eda14cbcSMatt Macy } 8721eda14cbcSMatt Macy 8722eda14cbcSMatt Macy /* 8723eda14cbcSMatt Macy * Rebuild spa's all-vdev ZAP from the vdev ZAPs indicated in each vdev_t. 8724eda14cbcSMatt Macy * The all-vdev ZAP must be empty. 8725eda14cbcSMatt Macy */ 8726eda14cbcSMatt Macy static void 8727eda14cbcSMatt Macy spa_avz_build(vdev_t *vd, uint64_t avz, dmu_tx_t *tx) 8728eda14cbcSMatt Macy { 8729eda14cbcSMatt Macy spa_t *spa = vd->vdev_spa; 8730eda14cbcSMatt Macy 8731d411c1d6SMartin Matuska if (vd->vdev_root_zap != 0 && 8732d411c1d6SMartin Matuska spa_feature_is_active(spa, SPA_FEATURE_AVZ_V2)) { 8733d411c1d6SMartin Matuska VERIFY0(zap_add_int(spa->spa_meta_objset, avz, 8734d411c1d6SMartin Matuska vd->vdev_root_zap, tx)); 8735d411c1d6SMartin Matuska } 8736eda14cbcSMatt Macy if (vd->vdev_top_zap != 0) { 8737eda14cbcSMatt Macy VERIFY0(zap_add_int(spa->spa_meta_objset, avz, 8738eda14cbcSMatt Macy vd->vdev_top_zap, tx)); 8739eda14cbcSMatt Macy } 8740eda14cbcSMatt Macy if (vd->vdev_leaf_zap != 0) { 8741eda14cbcSMatt Macy VERIFY0(zap_add_int(spa->spa_meta_objset, avz, 8742eda14cbcSMatt Macy vd->vdev_leaf_zap, tx)); 8743eda14cbcSMatt Macy } 8744eda14cbcSMatt Macy for (uint64_t i = 0; i < vd->vdev_children; i++) { 8745eda14cbcSMatt Macy spa_avz_build(vd->vdev_child[i], avz, tx); 8746eda14cbcSMatt Macy } 8747eda14cbcSMatt Macy } 8748eda14cbcSMatt Macy 8749eda14cbcSMatt Macy static void 8750eda14cbcSMatt Macy spa_sync_config_object(spa_t *spa, dmu_tx_t *tx) 8751eda14cbcSMatt Macy { 8752eda14cbcSMatt Macy nvlist_t *config; 8753eda14cbcSMatt Macy 8754eda14cbcSMatt Macy /* 8755eda14cbcSMatt Macy * If the pool is being imported from a pre-per-vdev-ZAP version of ZFS, 8756eda14cbcSMatt Macy * its config may not be dirty but we still need to build per-vdev ZAPs. 8757eda14cbcSMatt Macy * Similarly, if the pool is being assembled (e.g. after a split), we 8758eda14cbcSMatt Macy * need to rebuild the AVZ although the config may not be dirty. 8759eda14cbcSMatt Macy */ 8760eda14cbcSMatt Macy if (list_is_empty(&spa->spa_config_dirty_list) && 8761eda14cbcSMatt Macy spa->spa_avz_action == AVZ_ACTION_NONE) 8762eda14cbcSMatt Macy return; 8763eda14cbcSMatt Macy 8764eda14cbcSMatt Macy spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 8765eda14cbcSMatt Macy 8766eda14cbcSMatt Macy ASSERT(spa->spa_avz_action == AVZ_ACTION_NONE || 8767eda14cbcSMatt Macy spa->spa_avz_action == AVZ_ACTION_INITIALIZE || 8768eda14cbcSMatt Macy spa->spa_all_vdev_zaps != 0); 8769eda14cbcSMatt Macy 8770eda14cbcSMatt Macy if (spa->spa_avz_action == AVZ_ACTION_REBUILD) { 8771eda14cbcSMatt Macy /* Make and build the new AVZ */ 8772eda14cbcSMatt Macy uint64_t new_avz = zap_create(spa->spa_meta_objset, 8773eda14cbcSMatt Macy DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx); 8774eda14cbcSMatt Macy spa_avz_build(spa->spa_root_vdev, new_avz, tx); 8775eda14cbcSMatt Macy 8776eda14cbcSMatt Macy /* Diff old AVZ with new one */ 8777eda14cbcSMatt Macy zap_cursor_t zc; 8778eda14cbcSMatt Macy zap_attribute_t za; 8779eda14cbcSMatt Macy 8780eda14cbcSMatt Macy for (zap_cursor_init(&zc, spa->spa_meta_objset, 8781eda14cbcSMatt Macy spa->spa_all_vdev_zaps); 8782eda14cbcSMatt Macy zap_cursor_retrieve(&zc, &za) == 0; 8783eda14cbcSMatt Macy zap_cursor_advance(&zc)) { 8784eda14cbcSMatt Macy uint64_t vdzap = za.za_first_integer; 8785eda14cbcSMatt Macy if (zap_lookup_int(spa->spa_meta_objset, new_avz, 8786eda14cbcSMatt Macy vdzap) == ENOENT) { 8787eda14cbcSMatt Macy /* 8788eda14cbcSMatt Macy * ZAP is listed in old AVZ but not in new one; 8789eda14cbcSMatt Macy * destroy it 8790eda14cbcSMatt Macy */ 8791eda14cbcSMatt Macy VERIFY0(zap_destroy(spa->spa_meta_objset, vdzap, 8792eda14cbcSMatt Macy tx)); 8793eda14cbcSMatt Macy } 8794eda14cbcSMatt Macy } 8795eda14cbcSMatt Macy 8796eda14cbcSMatt Macy zap_cursor_fini(&zc); 8797eda14cbcSMatt Macy 8798eda14cbcSMatt Macy /* Destroy the old AVZ */ 8799eda14cbcSMatt Macy VERIFY0(zap_destroy(spa->spa_meta_objset, 8800eda14cbcSMatt Macy spa->spa_all_vdev_zaps, tx)); 8801eda14cbcSMatt Macy 8802eda14cbcSMatt Macy /* Replace the old AVZ in the dir obj with the new one */ 8803eda14cbcSMatt Macy VERIFY0(zap_update(spa->spa_meta_objset, 8804eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_VDEV_ZAP_MAP, 8805eda14cbcSMatt Macy sizeof (new_avz), 1, &new_avz, tx)); 8806eda14cbcSMatt Macy 8807eda14cbcSMatt Macy spa->spa_all_vdev_zaps = new_avz; 8808eda14cbcSMatt Macy } else if (spa->spa_avz_action == AVZ_ACTION_DESTROY) { 8809eda14cbcSMatt Macy zap_cursor_t zc; 8810eda14cbcSMatt Macy zap_attribute_t za; 8811eda14cbcSMatt Macy 8812eda14cbcSMatt Macy /* Walk through the AVZ and destroy all listed ZAPs */ 8813eda14cbcSMatt Macy for (zap_cursor_init(&zc, spa->spa_meta_objset, 8814eda14cbcSMatt Macy spa->spa_all_vdev_zaps); 8815eda14cbcSMatt Macy zap_cursor_retrieve(&zc, &za) == 0; 8816eda14cbcSMatt Macy zap_cursor_advance(&zc)) { 8817eda14cbcSMatt Macy uint64_t zap = za.za_first_integer; 8818eda14cbcSMatt Macy VERIFY0(zap_destroy(spa->spa_meta_objset, zap, tx)); 8819eda14cbcSMatt Macy } 8820eda14cbcSMatt Macy 8821eda14cbcSMatt Macy zap_cursor_fini(&zc); 8822eda14cbcSMatt Macy 8823eda14cbcSMatt Macy /* Destroy and unlink the AVZ itself */ 8824eda14cbcSMatt Macy VERIFY0(zap_destroy(spa->spa_meta_objset, 8825eda14cbcSMatt Macy spa->spa_all_vdev_zaps, tx)); 8826eda14cbcSMatt Macy VERIFY0(zap_remove(spa->spa_meta_objset, 8827eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_VDEV_ZAP_MAP, tx)); 8828eda14cbcSMatt Macy spa->spa_all_vdev_zaps = 0; 8829eda14cbcSMatt Macy } 8830eda14cbcSMatt Macy 8831eda14cbcSMatt Macy if (spa->spa_all_vdev_zaps == 0) { 8832eda14cbcSMatt Macy spa->spa_all_vdev_zaps = zap_create_link(spa->spa_meta_objset, 8833eda14cbcSMatt Macy DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT, 8834eda14cbcSMatt Macy DMU_POOL_VDEV_ZAP_MAP, tx); 8835eda14cbcSMatt Macy } 8836eda14cbcSMatt Macy spa->spa_avz_action = AVZ_ACTION_NONE; 8837eda14cbcSMatt Macy 8838eda14cbcSMatt Macy /* Create ZAPs for vdevs that don't have them. */ 8839eda14cbcSMatt Macy vdev_construct_zaps(spa->spa_root_vdev, tx); 8840eda14cbcSMatt Macy 8841eda14cbcSMatt Macy config = spa_config_generate(spa, spa->spa_root_vdev, 8842eda14cbcSMatt Macy dmu_tx_get_txg(tx), B_FALSE); 8843eda14cbcSMatt Macy 8844eda14cbcSMatt Macy /* 8845eda14cbcSMatt Macy * If we're upgrading the spa version then make sure that 8846eda14cbcSMatt Macy * the config object gets updated with the correct version. 8847eda14cbcSMatt Macy */ 8848eda14cbcSMatt Macy if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version) 8849eda14cbcSMatt Macy fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, 8850eda14cbcSMatt Macy spa->spa_uberblock.ub_version); 8851eda14cbcSMatt Macy 8852eda14cbcSMatt Macy spa_config_exit(spa, SCL_STATE, FTAG); 8853eda14cbcSMatt Macy 8854eda14cbcSMatt Macy nvlist_free(spa->spa_config_syncing); 8855eda14cbcSMatt Macy spa->spa_config_syncing = config; 8856eda14cbcSMatt Macy 8857eda14cbcSMatt Macy spa_sync_nvlist(spa, spa->spa_config_object, config, tx); 8858eda14cbcSMatt Macy } 8859eda14cbcSMatt Macy 8860eda14cbcSMatt Macy static void 8861eda14cbcSMatt Macy spa_sync_version(void *arg, dmu_tx_t *tx) 8862eda14cbcSMatt Macy { 8863eda14cbcSMatt Macy uint64_t *versionp = arg; 8864eda14cbcSMatt Macy uint64_t version = *versionp; 8865eda14cbcSMatt Macy spa_t *spa = dmu_tx_pool(tx)->dp_spa; 8866eda14cbcSMatt Macy 8867eda14cbcSMatt Macy /* 8868eda14cbcSMatt Macy * Setting the version is special cased when first creating the pool. 8869eda14cbcSMatt Macy */ 8870eda14cbcSMatt Macy ASSERT(tx->tx_txg != TXG_INITIAL); 8871eda14cbcSMatt Macy 8872eda14cbcSMatt Macy ASSERT(SPA_VERSION_IS_SUPPORTED(version)); 8873eda14cbcSMatt Macy ASSERT(version >= spa_version(spa)); 8874eda14cbcSMatt Macy 8875eda14cbcSMatt Macy spa->spa_uberblock.ub_version = version; 8876eda14cbcSMatt Macy vdev_config_dirty(spa->spa_root_vdev); 8877eda14cbcSMatt Macy spa_history_log_internal(spa, "set", tx, "version=%lld", 8878eda14cbcSMatt Macy (longlong_t)version); 8879eda14cbcSMatt Macy } 8880eda14cbcSMatt Macy 8881eda14cbcSMatt Macy /* 8882eda14cbcSMatt Macy * Set zpool properties. 8883eda14cbcSMatt Macy */ 8884eda14cbcSMatt Macy static void 8885eda14cbcSMatt Macy spa_sync_props(void *arg, dmu_tx_t *tx) 8886eda14cbcSMatt Macy { 8887eda14cbcSMatt Macy nvlist_t *nvp = arg; 8888eda14cbcSMatt Macy spa_t *spa = dmu_tx_pool(tx)->dp_spa; 8889eda14cbcSMatt Macy objset_t *mos = spa->spa_meta_objset; 8890eda14cbcSMatt Macy nvpair_t *elem = NULL; 8891eda14cbcSMatt Macy 8892eda14cbcSMatt Macy mutex_enter(&spa->spa_props_lock); 8893eda14cbcSMatt Macy 8894eda14cbcSMatt Macy while ((elem = nvlist_next_nvpair(nvp, elem))) { 8895eda14cbcSMatt Macy uint64_t intval; 88962a58b312SMartin Matuska const char *strval, *fname; 8897eda14cbcSMatt Macy zpool_prop_t prop; 8898eda14cbcSMatt Macy const char *propname; 8899c98ecfceSAllan Jude const char *elemname = nvpair_name(elem); 8900eda14cbcSMatt Macy zprop_type_t proptype; 8901eda14cbcSMatt Macy spa_feature_t fid; 8902eda14cbcSMatt Macy 8903c98ecfceSAllan Jude switch (prop = zpool_name_to_prop(elemname)) { 8904eda14cbcSMatt Macy case ZPOOL_PROP_VERSION: 8905eda14cbcSMatt Macy intval = fnvpair_value_uint64(elem); 8906eda14cbcSMatt Macy /* 8907eda14cbcSMatt Macy * The version is synced separately before other 8908eda14cbcSMatt Macy * properties and should be correct by now. 8909eda14cbcSMatt Macy */ 8910eda14cbcSMatt Macy ASSERT3U(spa_version(spa), >=, intval); 8911eda14cbcSMatt Macy break; 8912eda14cbcSMatt Macy 8913eda14cbcSMatt Macy case ZPOOL_PROP_ALTROOT: 8914eda14cbcSMatt Macy /* 8915eda14cbcSMatt Macy * 'altroot' is a non-persistent property. It should 8916eda14cbcSMatt Macy * have been set temporarily at creation or import time. 8917eda14cbcSMatt Macy */ 8918eda14cbcSMatt Macy ASSERT(spa->spa_root != NULL); 8919eda14cbcSMatt Macy break; 8920eda14cbcSMatt Macy 8921eda14cbcSMatt Macy case ZPOOL_PROP_READONLY: 8922eda14cbcSMatt Macy case ZPOOL_PROP_CACHEFILE: 8923eda14cbcSMatt Macy /* 8924eda14cbcSMatt Macy * 'readonly' and 'cachefile' are also non-persistent 8925eda14cbcSMatt Macy * properties. 8926eda14cbcSMatt Macy */ 8927eda14cbcSMatt Macy break; 8928eda14cbcSMatt Macy case ZPOOL_PROP_COMMENT: 8929eda14cbcSMatt Macy strval = fnvpair_value_string(elem); 8930eda14cbcSMatt Macy if (spa->spa_comment != NULL) 8931eda14cbcSMatt Macy spa_strfree(spa->spa_comment); 8932eda14cbcSMatt Macy spa->spa_comment = spa_strdup(strval); 8933eda14cbcSMatt Macy /* 8934eda14cbcSMatt Macy * We need to dirty the configuration on all the vdevs 893533b8c039SMartin Matuska * so that their labels get updated. We also need to 893633b8c039SMartin Matuska * update the cache file to keep it in sync with the 893733b8c039SMartin Matuska * MOS version. It's unnecessary to do this for pool 893833b8c039SMartin Matuska * creation since the vdev's configuration has already 893933b8c039SMartin Matuska * been dirtied. 8940eda14cbcSMatt Macy */ 894133b8c039SMartin Matuska if (tx->tx_txg != TXG_INITIAL) { 8942eda14cbcSMatt Macy vdev_config_dirty(spa->spa_root_vdev); 894333b8c039SMartin Matuska spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 894433b8c039SMartin Matuska } 8945eda14cbcSMatt Macy spa_history_log_internal(spa, "set", tx, 8946c98ecfceSAllan Jude "%s=%s", elemname, strval); 8947eda14cbcSMatt Macy break; 8948ee36e25aSMartin Matuska case ZPOOL_PROP_COMPATIBILITY: 8949ee36e25aSMartin Matuska strval = fnvpair_value_string(elem); 8950ee36e25aSMartin Matuska if (spa->spa_compatibility != NULL) 8951ee36e25aSMartin Matuska spa_strfree(spa->spa_compatibility); 8952ee36e25aSMartin Matuska spa->spa_compatibility = spa_strdup(strval); 8953ee36e25aSMartin Matuska /* 8954ee36e25aSMartin Matuska * Dirty the configuration on vdevs as above. 8955ee36e25aSMartin Matuska */ 895633b8c039SMartin Matuska if (tx->tx_txg != TXG_INITIAL) { 8957ee36e25aSMartin Matuska vdev_config_dirty(spa->spa_root_vdev); 895833b8c039SMartin Matuska spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); 895933b8c039SMartin Matuska } 896033b8c039SMartin Matuska 8961ee36e25aSMartin Matuska spa_history_log_internal(spa, "set", tx, 8962ee36e25aSMartin Matuska "%s=%s", nvpair_name(elem), strval); 8963ee36e25aSMartin Matuska break; 8964ee36e25aSMartin Matuska 8965c98ecfceSAllan Jude case ZPOOL_PROP_INVAL: 8966c98ecfceSAllan Jude if (zpool_prop_feature(elemname)) { 8967c98ecfceSAllan Jude fname = strchr(elemname, '@') + 1; 8968c98ecfceSAllan Jude VERIFY0(zfeature_lookup_name(fname, &fid)); 8969c98ecfceSAllan Jude 8970c98ecfceSAllan Jude spa_feature_enable(spa, fid, tx); 8971c98ecfceSAllan Jude spa_history_log_internal(spa, "set", tx, 8972c98ecfceSAllan Jude "%s=enabled", elemname); 8973c98ecfceSAllan Jude break; 8974c98ecfceSAllan Jude } else if (!zfs_prop_user(elemname)) { 8975c98ecfceSAllan Jude ASSERT(zpool_prop_feature(elemname)); 8976c98ecfceSAllan Jude break; 8977c98ecfceSAllan Jude } 8978c98ecfceSAllan Jude zfs_fallthrough; 8979eda14cbcSMatt Macy default: 8980eda14cbcSMatt Macy /* 8981eda14cbcSMatt Macy * Set pool property values in the poolprops mos object. 8982eda14cbcSMatt Macy */ 8983eda14cbcSMatt Macy if (spa->spa_pool_props_object == 0) { 8984eda14cbcSMatt Macy spa->spa_pool_props_object = 8985eda14cbcSMatt Macy zap_create_link(mos, DMU_OT_POOL_PROPS, 8986eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS, 8987eda14cbcSMatt Macy tx); 8988eda14cbcSMatt Macy } 8989eda14cbcSMatt Macy 8990eda14cbcSMatt Macy /* normalize the property name */ 8991c0a83fe0SMartin Matuska if (prop == ZPOOL_PROP_INVAL) { 8992c98ecfceSAllan Jude propname = elemname; 8993c98ecfceSAllan Jude proptype = PROP_TYPE_STRING; 8994c0a83fe0SMartin Matuska } else { 8995c0a83fe0SMartin Matuska propname = zpool_prop_to_name(prop); 8996c0a83fe0SMartin Matuska proptype = zpool_prop_get_type(prop); 8997c98ecfceSAllan Jude } 8998eda14cbcSMatt Macy 8999eda14cbcSMatt Macy if (nvpair_type(elem) == DATA_TYPE_STRING) { 9000eda14cbcSMatt Macy ASSERT(proptype == PROP_TYPE_STRING); 9001eda14cbcSMatt Macy strval = fnvpair_value_string(elem); 9002eda14cbcSMatt Macy VERIFY0(zap_update(mos, 9003eda14cbcSMatt Macy spa->spa_pool_props_object, propname, 9004eda14cbcSMatt Macy 1, strlen(strval) + 1, strval, tx)); 9005eda14cbcSMatt Macy spa_history_log_internal(spa, "set", tx, 9006c98ecfceSAllan Jude "%s=%s", elemname, strval); 9007eda14cbcSMatt Macy } else if (nvpair_type(elem) == DATA_TYPE_UINT64) { 9008eda14cbcSMatt Macy intval = fnvpair_value_uint64(elem); 9009eda14cbcSMatt Macy 9010eda14cbcSMatt Macy if (proptype == PROP_TYPE_INDEX) { 9011eda14cbcSMatt Macy const char *unused; 9012eda14cbcSMatt Macy VERIFY0(zpool_prop_index_to_string( 9013eda14cbcSMatt Macy prop, intval, &unused)); 9014eda14cbcSMatt Macy } 9015eda14cbcSMatt Macy VERIFY0(zap_update(mos, 9016eda14cbcSMatt Macy spa->spa_pool_props_object, propname, 9017eda14cbcSMatt Macy 8, 1, &intval, tx)); 9018eda14cbcSMatt Macy spa_history_log_internal(spa, "set", tx, 9019c98ecfceSAllan Jude "%s=%lld", elemname, 9020eda14cbcSMatt Macy (longlong_t)intval); 9021eda14cbcSMatt Macy 9022eda14cbcSMatt Macy switch (prop) { 9023eda14cbcSMatt Macy case ZPOOL_PROP_DELEGATION: 9024eda14cbcSMatt Macy spa->spa_delegation = intval; 9025eda14cbcSMatt Macy break; 9026eda14cbcSMatt Macy case ZPOOL_PROP_BOOTFS: 9027eda14cbcSMatt Macy spa->spa_bootfs = intval; 9028eda14cbcSMatt Macy break; 9029eda14cbcSMatt Macy case ZPOOL_PROP_FAILUREMODE: 9030eda14cbcSMatt Macy spa->spa_failmode = intval; 9031eda14cbcSMatt Macy break; 9032eda14cbcSMatt Macy case ZPOOL_PROP_AUTOTRIM: 9033eda14cbcSMatt Macy spa->spa_autotrim = intval; 9034eda14cbcSMatt Macy spa_async_request(spa, 9035eda14cbcSMatt Macy SPA_ASYNC_AUTOTRIM_RESTART); 9036eda14cbcSMatt Macy break; 9037eda14cbcSMatt Macy case ZPOOL_PROP_AUTOEXPAND: 9038eda14cbcSMatt Macy spa->spa_autoexpand = intval; 9039eda14cbcSMatt Macy if (tx->tx_txg != TXG_INITIAL) 9040eda14cbcSMatt Macy spa_async_request(spa, 9041eda14cbcSMatt Macy SPA_ASYNC_AUTOEXPAND); 9042eda14cbcSMatt Macy break; 9043eda14cbcSMatt Macy case ZPOOL_PROP_MULTIHOST: 9044eda14cbcSMatt Macy spa->spa_multihost = intval; 9045eda14cbcSMatt Macy break; 9046eda14cbcSMatt Macy default: 9047eda14cbcSMatt Macy break; 9048eda14cbcSMatt Macy } 9049dbd5678dSMartin Matuska } else { 9050dbd5678dSMartin Matuska ASSERT(0); /* not allowed */ 9051dbd5678dSMartin Matuska } 9052eda14cbcSMatt Macy } 9053eda14cbcSMatt Macy 9054eda14cbcSMatt Macy } 9055eda14cbcSMatt Macy 9056eda14cbcSMatt Macy mutex_exit(&spa->spa_props_lock); 9057eda14cbcSMatt Macy } 9058eda14cbcSMatt Macy 9059eda14cbcSMatt Macy /* 9060eda14cbcSMatt Macy * Perform one-time upgrade on-disk changes. spa_version() does not 9061eda14cbcSMatt Macy * reflect the new version this txg, so there must be no changes this 9062eda14cbcSMatt Macy * txg to anything that the upgrade code depends on after it executes. 9063eda14cbcSMatt Macy * Therefore this must be called after dsl_pool_sync() does the sync 9064eda14cbcSMatt Macy * tasks. 9065eda14cbcSMatt Macy */ 9066eda14cbcSMatt Macy static void 9067eda14cbcSMatt Macy spa_sync_upgrades(spa_t *spa, dmu_tx_t *tx) 9068eda14cbcSMatt Macy { 9069eda14cbcSMatt Macy if (spa_sync_pass(spa) != 1) 9070eda14cbcSMatt Macy return; 9071eda14cbcSMatt Macy 9072eda14cbcSMatt Macy dsl_pool_t *dp = spa->spa_dsl_pool; 9073eda14cbcSMatt Macy rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG); 9074eda14cbcSMatt Macy 9075eda14cbcSMatt Macy if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN && 9076eda14cbcSMatt Macy spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) { 9077eda14cbcSMatt Macy dsl_pool_create_origin(dp, tx); 9078eda14cbcSMatt Macy 9079eda14cbcSMatt Macy /* Keeping the origin open increases spa_minref */ 9080eda14cbcSMatt Macy spa->spa_minref += 3; 9081eda14cbcSMatt Macy } 9082eda14cbcSMatt Macy 9083eda14cbcSMatt Macy if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES && 9084eda14cbcSMatt Macy spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) { 9085eda14cbcSMatt Macy dsl_pool_upgrade_clones(dp, tx); 9086eda14cbcSMatt Macy } 9087eda14cbcSMatt Macy 9088eda14cbcSMatt Macy if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES && 9089eda14cbcSMatt Macy spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) { 9090eda14cbcSMatt Macy dsl_pool_upgrade_dir_clones(dp, tx); 9091eda14cbcSMatt Macy 9092eda14cbcSMatt Macy /* Keeping the freedir open increases spa_minref */ 9093eda14cbcSMatt Macy spa->spa_minref += 3; 9094eda14cbcSMatt Macy } 9095eda14cbcSMatt Macy 9096eda14cbcSMatt Macy if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES && 9097eda14cbcSMatt Macy spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) { 9098eda14cbcSMatt Macy spa_feature_create_zap_objects(spa, tx); 9099eda14cbcSMatt Macy } 9100eda14cbcSMatt Macy 9101eda14cbcSMatt Macy /* 9102eda14cbcSMatt Macy * LZ4_COMPRESS feature's behaviour was changed to activate_on_enable 9103eda14cbcSMatt Macy * when possibility to use lz4 compression for metadata was added 9104eda14cbcSMatt Macy * Old pools that have this feature enabled must be upgraded to have 9105eda14cbcSMatt Macy * this feature active 9106eda14cbcSMatt Macy */ 9107eda14cbcSMatt Macy if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) { 9108eda14cbcSMatt Macy boolean_t lz4_en = spa_feature_is_enabled(spa, 9109eda14cbcSMatt Macy SPA_FEATURE_LZ4_COMPRESS); 9110eda14cbcSMatt Macy boolean_t lz4_ac = spa_feature_is_active(spa, 9111eda14cbcSMatt Macy SPA_FEATURE_LZ4_COMPRESS); 9112eda14cbcSMatt Macy 9113eda14cbcSMatt Macy if (lz4_en && !lz4_ac) 9114eda14cbcSMatt Macy spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx); 9115eda14cbcSMatt Macy } 9116eda14cbcSMatt Macy 9117eda14cbcSMatt Macy /* 9118eda14cbcSMatt Macy * If we haven't written the salt, do so now. Note that the 9119eda14cbcSMatt Macy * feature may not be activated yet, but that's fine since 9120eda14cbcSMatt Macy * the presence of this ZAP entry is backwards compatible. 9121eda14cbcSMatt Macy */ 9122eda14cbcSMatt Macy if (zap_contains(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 9123eda14cbcSMatt Macy DMU_POOL_CHECKSUM_SALT) == ENOENT) { 9124eda14cbcSMatt Macy VERIFY0(zap_add(spa->spa_meta_objset, 9125eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CHECKSUM_SALT, 1, 9126eda14cbcSMatt Macy sizeof (spa->spa_cksum_salt.zcs_bytes), 9127eda14cbcSMatt Macy spa->spa_cksum_salt.zcs_bytes, tx)); 9128eda14cbcSMatt Macy } 9129eda14cbcSMatt Macy 9130eda14cbcSMatt Macy rrw_exit(&dp->dp_config_rwlock, FTAG); 9131eda14cbcSMatt Macy } 9132eda14cbcSMatt Macy 9133eda14cbcSMatt Macy static void 9134eda14cbcSMatt Macy vdev_indirect_state_sync_verify(vdev_t *vd) 9135eda14cbcSMatt Macy { 9136eda14cbcSMatt Macy vdev_indirect_mapping_t *vim __maybe_unused = vd->vdev_indirect_mapping; 9137eda14cbcSMatt Macy vdev_indirect_births_t *vib __maybe_unused = vd->vdev_indirect_births; 9138eda14cbcSMatt Macy 9139eda14cbcSMatt Macy if (vd->vdev_ops == &vdev_indirect_ops) { 9140eda14cbcSMatt Macy ASSERT(vim != NULL); 9141eda14cbcSMatt Macy ASSERT(vib != NULL); 9142eda14cbcSMatt Macy } 9143eda14cbcSMatt Macy 9144eda14cbcSMatt Macy uint64_t obsolete_sm_object = 0; 9145eda14cbcSMatt Macy ASSERT0(vdev_obsolete_sm_object(vd, &obsolete_sm_object)); 9146eda14cbcSMatt Macy if (obsolete_sm_object != 0) { 9147eda14cbcSMatt Macy ASSERT(vd->vdev_obsolete_sm != NULL); 9148eda14cbcSMatt Macy ASSERT(vd->vdev_removing || 9149eda14cbcSMatt Macy vd->vdev_ops == &vdev_indirect_ops); 9150eda14cbcSMatt Macy ASSERT(vdev_indirect_mapping_num_entries(vim) > 0); 9151eda14cbcSMatt Macy ASSERT(vdev_indirect_mapping_bytes_mapped(vim) > 0); 9152eda14cbcSMatt Macy ASSERT3U(obsolete_sm_object, ==, 9153eda14cbcSMatt Macy space_map_object(vd->vdev_obsolete_sm)); 9154eda14cbcSMatt Macy ASSERT3U(vdev_indirect_mapping_bytes_mapped(vim), >=, 9155eda14cbcSMatt Macy space_map_allocated(vd->vdev_obsolete_sm)); 9156eda14cbcSMatt Macy } 9157eda14cbcSMatt Macy ASSERT(vd->vdev_obsolete_segments != NULL); 9158eda14cbcSMatt Macy 9159eda14cbcSMatt Macy /* 9160eda14cbcSMatt Macy * Since frees / remaps to an indirect vdev can only 9161eda14cbcSMatt Macy * happen in syncing context, the obsolete segments 9162eda14cbcSMatt Macy * tree must be empty when we start syncing. 9163eda14cbcSMatt Macy */ 9164eda14cbcSMatt Macy ASSERT0(range_tree_space(vd->vdev_obsolete_segments)); 9165eda14cbcSMatt Macy } 9166eda14cbcSMatt Macy 9167eda14cbcSMatt Macy /* 9168eda14cbcSMatt Macy * Set the top-level vdev's max queue depth. Evaluate each top-level's 9169eda14cbcSMatt Macy * async write queue depth in case it changed. The max queue depth will 9170eda14cbcSMatt Macy * not change in the middle of syncing out this txg. 9171eda14cbcSMatt Macy */ 9172eda14cbcSMatt Macy static void 9173eda14cbcSMatt Macy spa_sync_adjust_vdev_max_queue_depth(spa_t *spa) 9174eda14cbcSMatt Macy { 9175eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 9176eda14cbcSMatt Macy 9177eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 9178eda14cbcSMatt Macy uint32_t max_queue_depth = zfs_vdev_async_write_max_active * 9179eda14cbcSMatt Macy zfs_vdev_queue_depth_pct / 100; 9180eda14cbcSMatt Macy metaslab_class_t *normal = spa_normal_class(spa); 9181eda14cbcSMatt Macy metaslab_class_t *special = spa_special_class(spa); 9182eda14cbcSMatt Macy metaslab_class_t *dedup = spa_dedup_class(spa); 9183eda14cbcSMatt Macy 9184eda14cbcSMatt Macy uint64_t slots_per_allocator = 0; 9185eda14cbcSMatt Macy for (int c = 0; c < rvd->vdev_children; c++) { 9186eda14cbcSMatt Macy vdev_t *tvd = rvd->vdev_child[c]; 9187eda14cbcSMatt Macy 9188eda14cbcSMatt Macy metaslab_group_t *mg = tvd->vdev_mg; 9189eda14cbcSMatt Macy if (mg == NULL || !metaslab_group_initialized(mg)) 9190eda14cbcSMatt Macy continue; 9191eda14cbcSMatt Macy 9192eda14cbcSMatt Macy metaslab_class_t *mc = mg->mg_class; 9193eda14cbcSMatt Macy if (mc != normal && mc != special && mc != dedup) 9194eda14cbcSMatt Macy continue; 9195eda14cbcSMatt Macy 9196eda14cbcSMatt Macy /* 9197eda14cbcSMatt Macy * It is safe to do a lock-free check here because only async 9198eda14cbcSMatt Macy * allocations look at mg_max_alloc_queue_depth, and async 9199eda14cbcSMatt Macy * allocations all happen from spa_sync(). 9200eda14cbcSMatt Macy */ 9201eda14cbcSMatt Macy for (int i = 0; i < mg->mg_allocators; i++) { 9202eda14cbcSMatt Macy ASSERT0(zfs_refcount_count( 9203eda14cbcSMatt Macy &(mg->mg_allocator[i].mga_alloc_queue_depth))); 9204eda14cbcSMatt Macy } 9205eda14cbcSMatt Macy mg->mg_max_alloc_queue_depth = max_queue_depth; 9206eda14cbcSMatt Macy 9207eda14cbcSMatt Macy for (int i = 0; i < mg->mg_allocators; i++) { 9208eda14cbcSMatt Macy mg->mg_allocator[i].mga_cur_max_alloc_queue_depth = 9209eda14cbcSMatt Macy zfs_vdev_def_queue_depth; 9210eda14cbcSMatt Macy } 9211eda14cbcSMatt Macy slots_per_allocator += zfs_vdev_def_queue_depth; 9212eda14cbcSMatt Macy } 9213eda14cbcSMatt Macy 9214eda14cbcSMatt Macy for (int i = 0; i < spa->spa_alloc_count; i++) { 92157877fdebSMatt Macy ASSERT0(zfs_refcount_count(&normal->mc_allocator[i]. 92167877fdebSMatt Macy mca_alloc_slots)); 92177877fdebSMatt Macy ASSERT0(zfs_refcount_count(&special->mc_allocator[i]. 92187877fdebSMatt Macy mca_alloc_slots)); 92197877fdebSMatt Macy ASSERT0(zfs_refcount_count(&dedup->mc_allocator[i]. 92207877fdebSMatt Macy mca_alloc_slots)); 92217877fdebSMatt Macy normal->mc_allocator[i].mca_alloc_max_slots = 92227877fdebSMatt Macy slots_per_allocator; 92237877fdebSMatt Macy special->mc_allocator[i].mca_alloc_max_slots = 92247877fdebSMatt Macy slots_per_allocator; 92257877fdebSMatt Macy dedup->mc_allocator[i].mca_alloc_max_slots = 92267877fdebSMatt Macy slots_per_allocator; 9227eda14cbcSMatt Macy } 9228eda14cbcSMatt Macy normal->mc_alloc_throttle_enabled = zio_dva_throttle_enabled; 9229eda14cbcSMatt Macy special->mc_alloc_throttle_enabled = zio_dva_throttle_enabled; 9230eda14cbcSMatt Macy dedup->mc_alloc_throttle_enabled = zio_dva_throttle_enabled; 9231eda14cbcSMatt Macy } 9232eda14cbcSMatt Macy 9233eda14cbcSMatt Macy static void 9234eda14cbcSMatt Macy spa_sync_condense_indirect(spa_t *spa, dmu_tx_t *tx) 9235eda14cbcSMatt Macy { 9236eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 9237eda14cbcSMatt Macy 9238eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 9239eda14cbcSMatt Macy for (int c = 0; c < rvd->vdev_children; c++) { 9240eda14cbcSMatt Macy vdev_t *vd = rvd->vdev_child[c]; 9241eda14cbcSMatt Macy vdev_indirect_state_sync_verify(vd); 9242eda14cbcSMatt Macy 9243eda14cbcSMatt Macy if (vdev_indirect_should_condense(vd)) { 9244eda14cbcSMatt Macy spa_condense_indirect_start_sync(vd, tx); 9245eda14cbcSMatt Macy break; 9246eda14cbcSMatt Macy } 9247eda14cbcSMatt Macy } 9248eda14cbcSMatt Macy } 9249eda14cbcSMatt Macy 9250eda14cbcSMatt Macy static void 9251eda14cbcSMatt Macy spa_sync_iterate_to_convergence(spa_t *spa, dmu_tx_t *tx) 9252eda14cbcSMatt Macy { 9253eda14cbcSMatt Macy objset_t *mos = spa->spa_meta_objset; 9254eda14cbcSMatt Macy dsl_pool_t *dp = spa->spa_dsl_pool; 9255eda14cbcSMatt Macy uint64_t txg = tx->tx_txg; 9256eda14cbcSMatt Macy bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK]; 9257eda14cbcSMatt Macy 9258eda14cbcSMatt Macy do { 9259eda14cbcSMatt Macy int pass = ++spa->spa_sync_pass; 9260eda14cbcSMatt Macy 9261eda14cbcSMatt Macy spa_sync_config_object(spa, tx); 9262eda14cbcSMatt Macy spa_sync_aux_dev(spa, &spa->spa_spares, tx, 9263eda14cbcSMatt Macy ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES); 9264eda14cbcSMatt Macy spa_sync_aux_dev(spa, &spa->spa_l2cache, tx, 9265eda14cbcSMatt Macy ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE); 9266eda14cbcSMatt Macy spa_errlog_sync(spa, txg); 9267eda14cbcSMatt Macy dsl_pool_sync(dp, txg); 9268eda14cbcSMatt Macy 9269eda14cbcSMatt Macy if (pass < zfs_sync_pass_deferred_free || 9270eda14cbcSMatt Macy spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) { 9271eda14cbcSMatt Macy /* 9272eda14cbcSMatt Macy * If the log space map feature is active we don't 9273eda14cbcSMatt Macy * care about deferred frees and the deferred bpobj 9274eda14cbcSMatt Macy * as the log space map should effectively have the 9275eda14cbcSMatt Macy * same results (i.e. appending only to one object). 9276eda14cbcSMatt Macy */ 9277eda14cbcSMatt Macy spa_sync_frees(spa, free_bpl, tx); 9278eda14cbcSMatt Macy } else { 9279eda14cbcSMatt Macy /* 9280eda14cbcSMatt Macy * We can not defer frees in pass 1, because 9281eda14cbcSMatt Macy * we sync the deferred frees later in pass 1. 9282eda14cbcSMatt Macy */ 9283eda14cbcSMatt Macy ASSERT3U(pass, >, 1); 9284eda14cbcSMatt Macy bplist_iterate(free_bpl, bpobj_enqueue_alloc_cb, 9285eda14cbcSMatt Macy &spa->spa_deferred_bpobj, tx); 9286eda14cbcSMatt Macy } 9287eda14cbcSMatt Macy 92882a58b312SMartin Matuska brt_sync(spa, txg); 9289eda14cbcSMatt Macy ddt_sync(spa, txg); 9290eda14cbcSMatt Macy dsl_scan_sync(dp, tx); 9291c0a83fe0SMartin Matuska dsl_errorscrub_sync(dp, tx); 9292eda14cbcSMatt Macy svr_sync(spa, tx); 9293eda14cbcSMatt Macy spa_sync_upgrades(spa, tx); 9294eda14cbcSMatt Macy 9295eda14cbcSMatt Macy spa_flush_metaslabs(spa, tx); 9296eda14cbcSMatt Macy 9297eda14cbcSMatt Macy vdev_t *vd = NULL; 9298eda14cbcSMatt Macy while ((vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) 9299eda14cbcSMatt Macy != NULL) 9300eda14cbcSMatt Macy vdev_sync(vd, txg); 9301eda14cbcSMatt Macy 9302eda14cbcSMatt Macy /* 9303eda14cbcSMatt Macy * Note: We need to check if the MOS is dirty because we could 9304eda14cbcSMatt Macy * have marked the MOS dirty without updating the uberblock 9305eda14cbcSMatt Macy * (e.g. if we have sync tasks but no dirty user data). We need 9306eda14cbcSMatt Macy * to check the uberblock's rootbp because it is updated if we 9307eda14cbcSMatt Macy * have synced out dirty data (though in this case the MOS will 9308eda14cbcSMatt Macy * most likely also be dirty due to second order effects, we 9309eda14cbcSMatt Macy * don't want to rely on that here). 9310eda14cbcSMatt Macy */ 9311eda14cbcSMatt Macy if (pass == 1 && 9312eda14cbcSMatt Macy spa->spa_uberblock.ub_rootbp.blk_birth < txg && 9313eda14cbcSMatt Macy !dmu_objset_is_dirty(mos, txg)) { 9314eda14cbcSMatt Macy /* 9315eda14cbcSMatt Macy * Nothing changed on the first pass, therefore this 9316eda14cbcSMatt Macy * TXG is a no-op. Avoid syncing deferred frees, so 9317eda14cbcSMatt Macy * that we can keep this TXG as a no-op. 9318eda14cbcSMatt Macy */ 9319eda14cbcSMatt Macy ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); 9320eda14cbcSMatt Macy ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 9321eda14cbcSMatt Macy ASSERT(txg_list_empty(&dp->dp_sync_tasks, txg)); 9322eda14cbcSMatt Macy ASSERT(txg_list_empty(&dp->dp_early_sync_tasks, txg)); 9323eda14cbcSMatt Macy break; 9324eda14cbcSMatt Macy } 9325eda14cbcSMatt Macy 9326eda14cbcSMatt Macy spa_sync_deferred_frees(spa, tx); 9327eda14cbcSMatt Macy } while (dmu_objset_is_dirty(mos, txg)); 9328eda14cbcSMatt Macy } 9329eda14cbcSMatt Macy 9330eda14cbcSMatt Macy /* 9331eda14cbcSMatt Macy * Rewrite the vdev configuration (which includes the uberblock) to 9332eda14cbcSMatt Macy * commit the transaction group. 9333eda14cbcSMatt Macy * 9334eda14cbcSMatt Macy * If there are no dirty vdevs, we sync the uberblock to a few random 9335eda14cbcSMatt Macy * top-level vdevs that are known to be visible in the config cache 9336eda14cbcSMatt Macy * (see spa_vdev_add() for a complete description). If there *are* dirty 9337eda14cbcSMatt Macy * vdevs, sync the uberblock to all vdevs. 9338eda14cbcSMatt Macy */ 9339eda14cbcSMatt Macy static void 9340eda14cbcSMatt Macy spa_sync_rewrite_vdev_config(spa_t *spa, dmu_tx_t *tx) 9341eda14cbcSMatt Macy { 9342eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 9343eda14cbcSMatt Macy uint64_t txg = tx->tx_txg; 9344eda14cbcSMatt Macy 9345eda14cbcSMatt Macy for (;;) { 9346eda14cbcSMatt Macy int error = 0; 9347eda14cbcSMatt Macy 9348eda14cbcSMatt Macy /* 9349eda14cbcSMatt Macy * We hold SCL_STATE to prevent vdev open/close/etc. 9350eda14cbcSMatt Macy * while we're attempting to write the vdev labels. 9351eda14cbcSMatt Macy */ 9352eda14cbcSMatt Macy spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 9353eda14cbcSMatt Macy 9354eda14cbcSMatt Macy if (list_is_empty(&spa->spa_config_dirty_list)) { 9355eda14cbcSMatt Macy vdev_t *svd[SPA_SYNC_MIN_VDEVS] = { NULL }; 9356eda14cbcSMatt Macy int svdcount = 0; 9357eda14cbcSMatt Macy int children = rvd->vdev_children; 935833b8c039SMartin Matuska int c0 = random_in_range(children); 9359eda14cbcSMatt Macy 9360eda14cbcSMatt Macy for (int c = 0; c < children; c++) { 9361eda14cbcSMatt Macy vdev_t *vd = 9362eda14cbcSMatt Macy rvd->vdev_child[(c0 + c) % children]; 9363eda14cbcSMatt Macy 9364eda14cbcSMatt Macy /* Stop when revisiting the first vdev */ 9365eda14cbcSMatt Macy if (c > 0 && svd[0] == vd) 9366eda14cbcSMatt Macy break; 9367eda14cbcSMatt Macy 9368eda14cbcSMatt Macy if (vd->vdev_ms_array == 0 || 9369eda14cbcSMatt Macy vd->vdev_islog || 9370eda14cbcSMatt Macy !vdev_is_concrete(vd)) 9371eda14cbcSMatt Macy continue; 9372eda14cbcSMatt Macy 9373eda14cbcSMatt Macy svd[svdcount++] = vd; 9374eda14cbcSMatt Macy if (svdcount == SPA_SYNC_MIN_VDEVS) 9375eda14cbcSMatt Macy break; 9376eda14cbcSMatt Macy } 9377eda14cbcSMatt Macy error = vdev_config_sync(svd, svdcount, txg); 9378eda14cbcSMatt Macy } else { 9379eda14cbcSMatt Macy error = vdev_config_sync(rvd->vdev_child, 9380eda14cbcSMatt Macy rvd->vdev_children, txg); 9381eda14cbcSMatt Macy } 9382eda14cbcSMatt Macy 9383eda14cbcSMatt Macy if (error == 0) 9384eda14cbcSMatt Macy spa->spa_last_synced_guid = rvd->vdev_guid; 9385eda14cbcSMatt Macy 9386eda14cbcSMatt Macy spa_config_exit(spa, SCL_STATE, FTAG); 9387eda14cbcSMatt Macy 9388eda14cbcSMatt Macy if (error == 0) 9389eda14cbcSMatt Macy break; 9390eda14cbcSMatt Macy zio_suspend(spa, NULL, ZIO_SUSPEND_IOERR); 9391eda14cbcSMatt Macy zio_resume_wait(spa); 9392eda14cbcSMatt Macy } 9393eda14cbcSMatt Macy } 9394eda14cbcSMatt Macy 9395eda14cbcSMatt Macy /* 9396eda14cbcSMatt Macy * Sync the specified transaction group. New blocks may be dirtied as 9397eda14cbcSMatt Macy * part of the process, so we iterate until it converges. 9398eda14cbcSMatt Macy */ 9399eda14cbcSMatt Macy void 9400eda14cbcSMatt Macy spa_sync(spa_t *spa, uint64_t txg) 9401eda14cbcSMatt Macy { 9402eda14cbcSMatt Macy vdev_t *vd = NULL; 9403eda14cbcSMatt Macy 9404eda14cbcSMatt Macy VERIFY(spa_writeable(spa)); 9405eda14cbcSMatt Macy 9406eda14cbcSMatt Macy /* 9407eda14cbcSMatt Macy * Wait for i/os issued in open context that need to complete 9408eda14cbcSMatt Macy * before this txg syncs. 9409eda14cbcSMatt Macy */ 9410eda14cbcSMatt Macy (void) zio_wait(spa->spa_txg_zio[txg & TXG_MASK]); 9411eda14cbcSMatt Macy spa->spa_txg_zio[txg & TXG_MASK] = zio_root(spa, NULL, NULL, 9412eda14cbcSMatt Macy ZIO_FLAG_CANFAIL); 9413eda14cbcSMatt Macy 9414eda14cbcSMatt Macy /* 94152a58b312SMartin Matuska * Now that there can be no more cloning in this transaction group, 94162a58b312SMartin Matuska * but we are still before issuing frees, we can process pending BRT 94172a58b312SMartin Matuska * updates. 94182a58b312SMartin Matuska */ 94192a58b312SMartin Matuska brt_pending_apply(spa, txg); 94202a58b312SMartin Matuska 94212a58b312SMartin Matuska /* 9422eda14cbcSMatt Macy * Lock out configuration changes. 9423eda14cbcSMatt Macy */ 9424eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); 9425eda14cbcSMatt Macy 9426eda14cbcSMatt Macy spa->spa_syncing_txg = txg; 9427eda14cbcSMatt Macy spa->spa_sync_pass = 0; 9428eda14cbcSMatt Macy 9429eda14cbcSMatt Macy for (int i = 0; i < spa->spa_alloc_count; i++) { 94303f9d360cSMartin Matuska mutex_enter(&spa->spa_allocs[i].spaa_lock); 94313f9d360cSMartin Matuska VERIFY0(avl_numnodes(&spa->spa_allocs[i].spaa_tree)); 94323f9d360cSMartin Matuska mutex_exit(&spa->spa_allocs[i].spaa_lock); 9433eda14cbcSMatt Macy } 9434eda14cbcSMatt Macy 9435eda14cbcSMatt Macy /* 9436eda14cbcSMatt Macy * If there are any pending vdev state changes, convert them 9437eda14cbcSMatt Macy * into config changes that go out with this transaction group. 9438eda14cbcSMatt Macy */ 9439eda14cbcSMatt Macy spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); 94402a58b312SMartin Matuska while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) { 94412a58b312SMartin Matuska /* Avoid holding the write lock unless actually necessary */ 94422a58b312SMartin Matuska if (vd->vdev_aux == NULL) { 94432a58b312SMartin Matuska vdev_state_clean(vd); 94442a58b312SMartin Matuska vdev_config_dirty(vd); 94452a58b312SMartin Matuska continue; 94462a58b312SMartin Matuska } 9447eda14cbcSMatt Macy /* 9448eda14cbcSMatt Macy * We need the write lock here because, for aux vdevs, 9449eda14cbcSMatt Macy * calling vdev_config_dirty() modifies sav_config. 9450eda14cbcSMatt Macy * This is ugly and will become unnecessary when we 9451eda14cbcSMatt Macy * eliminate the aux vdev wart by integrating all vdevs 9452eda14cbcSMatt Macy * into the root vdev tree. 9453eda14cbcSMatt Macy */ 9454eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 9455eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER); 9456eda14cbcSMatt Macy while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) { 9457eda14cbcSMatt Macy vdev_state_clean(vd); 9458eda14cbcSMatt Macy vdev_config_dirty(vd); 9459eda14cbcSMatt Macy } 9460eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 9461eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 9462eda14cbcSMatt Macy } 9463eda14cbcSMatt Macy spa_config_exit(spa, SCL_STATE, FTAG); 9464eda14cbcSMatt Macy 9465eda14cbcSMatt Macy dsl_pool_t *dp = spa->spa_dsl_pool; 9466eda14cbcSMatt Macy dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg); 9467eda14cbcSMatt Macy 9468eda14cbcSMatt Macy spa->spa_sync_starttime = gethrtime(); 9469eda14cbcSMatt Macy taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid); 9470eda14cbcSMatt Macy spa->spa_deadman_tqid = taskq_dispatch_delay(system_delay_taskq, 9471eda14cbcSMatt Macy spa_deadman, spa, TQ_SLEEP, ddi_get_lbolt() + 9472eda14cbcSMatt Macy NSEC_TO_TICK(spa->spa_deadman_synctime)); 9473eda14cbcSMatt Macy 9474eda14cbcSMatt Macy /* 9475eda14cbcSMatt Macy * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg, 9476eda14cbcSMatt Macy * set spa_deflate if we have no raid-z vdevs. 9477eda14cbcSMatt Macy */ 9478eda14cbcSMatt Macy if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE && 9479eda14cbcSMatt Macy spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) { 9480eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 9481eda14cbcSMatt Macy 9482eda14cbcSMatt Macy int i; 9483eda14cbcSMatt Macy for (i = 0; i < rvd->vdev_children; i++) { 9484eda14cbcSMatt Macy vd = rvd->vdev_child[i]; 9485eda14cbcSMatt Macy if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE) 9486eda14cbcSMatt Macy break; 9487eda14cbcSMatt Macy } 9488eda14cbcSMatt Macy if (i == rvd->vdev_children) { 9489eda14cbcSMatt Macy spa->spa_deflate = TRUE; 9490eda14cbcSMatt Macy VERIFY0(zap_add(spa->spa_meta_objset, 9491eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, 9492eda14cbcSMatt Macy sizeof (uint64_t), 1, &spa->spa_deflate, tx)); 9493eda14cbcSMatt Macy } 9494eda14cbcSMatt Macy } 9495eda14cbcSMatt Macy 9496eda14cbcSMatt Macy spa_sync_adjust_vdev_max_queue_depth(spa); 9497eda14cbcSMatt Macy 9498eda14cbcSMatt Macy spa_sync_condense_indirect(spa, tx); 9499eda14cbcSMatt Macy 9500eda14cbcSMatt Macy spa_sync_iterate_to_convergence(spa, tx); 9501eda14cbcSMatt Macy 9502eda14cbcSMatt Macy #ifdef ZFS_DEBUG 9503eda14cbcSMatt Macy if (!list_is_empty(&spa->spa_config_dirty_list)) { 9504eda14cbcSMatt Macy /* 9505eda14cbcSMatt Macy * Make sure that the number of ZAPs for all the vdevs matches 9506eda14cbcSMatt Macy * the number of ZAPs in the per-vdev ZAP list. This only gets 9507eda14cbcSMatt Macy * called if the config is dirty; otherwise there may be 9508eda14cbcSMatt Macy * outstanding AVZ operations that weren't completed in 9509eda14cbcSMatt Macy * spa_sync_config_object. 9510eda14cbcSMatt Macy */ 9511eda14cbcSMatt Macy uint64_t all_vdev_zap_entry_count; 9512eda14cbcSMatt Macy ASSERT0(zap_count(spa->spa_meta_objset, 9513eda14cbcSMatt Macy spa->spa_all_vdev_zaps, &all_vdev_zap_entry_count)); 9514eda14cbcSMatt Macy ASSERT3U(vdev_count_verify_zaps(spa->spa_root_vdev), ==, 9515eda14cbcSMatt Macy all_vdev_zap_entry_count); 9516eda14cbcSMatt Macy } 9517eda14cbcSMatt Macy #endif 9518eda14cbcSMatt Macy 9519eda14cbcSMatt Macy if (spa->spa_vdev_removal != NULL) { 9520eda14cbcSMatt Macy ASSERT0(spa->spa_vdev_removal->svr_bytes_done[txg & TXG_MASK]); 9521eda14cbcSMatt Macy } 9522eda14cbcSMatt Macy 9523eda14cbcSMatt Macy spa_sync_rewrite_vdev_config(spa, tx); 9524eda14cbcSMatt Macy dmu_tx_commit(tx); 9525eda14cbcSMatt Macy 9526eda14cbcSMatt Macy taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid); 9527eda14cbcSMatt Macy spa->spa_deadman_tqid = 0; 9528eda14cbcSMatt Macy 9529eda14cbcSMatt Macy /* 9530eda14cbcSMatt Macy * Clear the dirty config list. 9531eda14cbcSMatt Macy */ 9532eda14cbcSMatt Macy while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL) 9533eda14cbcSMatt Macy vdev_config_clean(vd); 9534eda14cbcSMatt Macy 9535eda14cbcSMatt Macy /* 9536eda14cbcSMatt Macy * Now that the new config has synced transactionally, 9537eda14cbcSMatt Macy * let it become visible to the config cache. 9538eda14cbcSMatt Macy */ 9539eda14cbcSMatt Macy if (spa->spa_config_syncing != NULL) { 9540eda14cbcSMatt Macy spa_config_set(spa, spa->spa_config_syncing); 9541eda14cbcSMatt Macy spa->spa_config_txg = txg; 9542eda14cbcSMatt Macy spa->spa_config_syncing = NULL; 9543eda14cbcSMatt Macy } 9544eda14cbcSMatt Macy 9545eda14cbcSMatt Macy dsl_pool_sync_done(dp, txg); 9546eda14cbcSMatt Macy 9547eda14cbcSMatt Macy for (int i = 0; i < spa->spa_alloc_count; i++) { 95483f9d360cSMartin Matuska mutex_enter(&spa->spa_allocs[i].spaa_lock); 95493f9d360cSMartin Matuska VERIFY0(avl_numnodes(&spa->spa_allocs[i].spaa_tree)); 95503f9d360cSMartin Matuska mutex_exit(&spa->spa_allocs[i].spaa_lock); 9551eda14cbcSMatt Macy } 9552eda14cbcSMatt Macy 9553eda14cbcSMatt Macy /* 9554eda14cbcSMatt Macy * Update usable space statistics. 9555eda14cbcSMatt Macy */ 9556eda14cbcSMatt Macy while ((vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg))) 9557eda14cbcSMatt Macy != NULL) 9558eda14cbcSMatt Macy vdev_sync_done(vd, txg); 9559eda14cbcSMatt Macy 9560eda14cbcSMatt Macy metaslab_class_evict_old(spa->spa_normal_class, txg); 9561eda14cbcSMatt Macy metaslab_class_evict_old(spa->spa_log_class, txg); 9562eda14cbcSMatt Macy 9563eda14cbcSMatt Macy spa_sync_close_syncing_log_sm(spa); 9564eda14cbcSMatt Macy 9565eda14cbcSMatt Macy spa_update_dspace(spa); 9566eda14cbcSMatt Macy 95672a58b312SMartin Matuska if (spa_get_autotrim(spa) == SPA_AUTOTRIM_ON) 95682a58b312SMartin Matuska vdev_autotrim_kick(spa); 95692a58b312SMartin Matuska 9570eda14cbcSMatt Macy /* 9571eda14cbcSMatt Macy * It had better be the case that we didn't dirty anything 9572eda14cbcSMatt Macy * since vdev_config_sync(). 9573eda14cbcSMatt Macy */ 9574eda14cbcSMatt Macy ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); 9575eda14cbcSMatt Macy ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); 9576eda14cbcSMatt Macy ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg)); 9577eda14cbcSMatt Macy 9578eda14cbcSMatt Macy while (zfs_pause_spa_sync) 9579eda14cbcSMatt Macy delay(1); 9580eda14cbcSMatt Macy 9581eda14cbcSMatt Macy spa->spa_sync_pass = 0; 9582eda14cbcSMatt Macy 9583eda14cbcSMatt Macy /* 9584eda14cbcSMatt Macy * Update the last synced uberblock here. We want to do this at 9585eda14cbcSMatt Macy * the end of spa_sync() so that consumers of spa_last_synced_txg() 9586eda14cbcSMatt Macy * will be guaranteed that all the processing associated with 9587eda14cbcSMatt Macy * that txg has been completed. 9588eda14cbcSMatt Macy */ 9589eda14cbcSMatt Macy spa->spa_ubsync = spa->spa_uberblock; 9590eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG, FTAG); 9591eda14cbcSMatt Macy 9592eda14cbcSMatt Macy spa_handle_ignored_writes(spa); 9593eda14cbcSMatt Macy 9594eda14cbcSMatt Macy /* 9595eda14cbcSMatt Macy * If any async tasks have been requested, kick them off. 9596eda14cbcSMatt Macy */ 9597eda14cbcSMatt Macy spa_async_dispatch(spa); 9598eda14cbcSMatt Macy } 9599eda14cbcSMatt Macy 9600eda14cbcSMatt Macy /* 9601eda14cbcSMatt Macy * Sync all pools. We don't want to hold the namespace lock across these 9602eda14cbcSMatt Macy * operations, so we take a reference on the spa_t and drop the lock during the 9603eda14cbcSMatt Macy * sync. 9604eda14cbcSMatt Macy */ 9605eda14cbcSMatt Macy void 9606eda14cbcSMatt Macy spa_sync_allpools(void) 9607eda14cbcSMatt Macy { 9608eda14cbcSMatt Macy spa_t *spa = NULL; 9609eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 9610eda14cbcSMatt Macy while ((spa = spa_next(spa)) != NULL) { 9611eda14cbcSMatt Macy if (spa_state(spa) != POOL_STATE_ACTIVE || 9612eda14cbcSMatt Macy !spa_writeable(spa) || spa_suspended(spa)) 9613eda14cbcSMatt Macy continue; 9614eda14cbcSMatt Macy spa_open_ref(spa, FTAG); 9615eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 9616eda14cbcSMatt Macy txg_wait_synced(spa_get_dsl(spa), 0); 9617eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 9618eda14cbcSMatt Macy spa_close(spa, FTAG); 9619eda14cbcSMatt Macy } 9620eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 9621eda14cbcSMatt Macy } 9622eda14cbcSMatt Macy 9623eda14cbcSMatt Macy /* 9624eda14cbcSMatt Macy * ========================================================================== 9625eda14cbcSMatt Macy * Miscellaneous routines 9626eda14cbcSMatt Macy * ========================================================================== 9627eda14cbcSMatt Macy */ 9628eda14cbcSMatt Macy 9629eda14cbcSMatt Macy /* 9630eda14cbcSMatt Macy * Remove all pools in the system. 9631eda14cbcSMatt Macy */ 9632eda14cbcSMatt Macy void 9633eda14cbcSMatt Macy spa_evict_all(void) 9634eda14cbcSMatt Macy { 9635eda14cbcSMatt Macy spa_t *spa; 9636eda14cbcSMatt Macy 9637eda14cbcSMatt Macy /* 9638eda14cbcSMatt Macy * Remove all cached state. All pools should be closed now, 9639eda14cbcSMatt Macy * so every spa in the AVL tree should be unreferenced. 9640eda14cbcSMatt Macy */ 9641eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 9642eda14cbcSMatt Macy while ((spa = spa_next(NULL)) != NULL) { 9643eda14cbcSMatt Macy /* 9644eda14cbcSMatt Macy * Stop async tasks. The async thread may need to detach 9645eda14cbcSMatt Macy * a device that's been replaced, which requires grabbing 9646eda14cbcSMatt Macy * spa_namespace_lock, so we must drop it here. 9647eda14cbcSMatt Macy */ 9648eda14cbcSMatt Macy spa_open_ref(spa, FTAG); 9649eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 9650eda14cbcSMatt Macy spa_async_suspend(spa); 9651eda14cbcSMatt Macy mutex_enter(&spa_namespace_lock); 9652eda14cbcSMatt Macy spa_close(spa, FTAG); 9653eda14cbcSMatt Macy 9654eda14cbcSMatt Macy if (spa->spa_state != POOL_STATE_UNINITIALIZED) { 9655eda14cbcSMatt Macy spa_unload(spa); 9656eda14cbcSMatt Macy spa_deactivate(spa); 9657eda14cbcSMatt Macy } 9658eda14cbcSMatt Macy spa_remove(spa); 9659eda14cbcSMatt Macy } 9660eda14cbcSMatt Macy mutex_exit(&spa_namespace_lock); 9661eda14cbcSMatt Macy } 9662eda14cbcSMatt Macy 9663eda14cbcSMatt Macy vdev_t * 9664eda14cbcSMatt Macy spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux) 9665eda14cbcSMatt Macy { 9666eda14cbcSMatt Macy vdev_t *vd; 9667eda14cbcSMatt Macy int i; 9668eda14cbcSMatt Macy 9669eda14cbcSMatt Macy if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL) 9670eda14cbcSMatt Macy return (vd); 9671eda14cbcSMatt Macy 9672eda14cbcSMatt Macy if (aux) { 9673eda14cbcSMatt Macy for (i = 0; i < spa->spa_l2cache.sav_count; i++) { 9674eda14cbcSMatt Macy vd = spa->spa_l2cache.sav_vdevs[i]; 9675eda14cbcSMatt Macy if (vd->vdev_guid == guid) 9676eda14cbcSMatt Macy return (vd); 9677eda14cbcSMatt Macy } 9678eda14cbcSMatt Macy 9679eda14cbcSMatt Macy for (i = 0; i < spa->spa_spares.sav_count; i++) { 9680eda14cbcSMatt Macy vd = spa->spa_spares.sav_vdevs[i]; 9681eda14cbcSMatt Macy if (vd->vdev_guid == guid) 9682eda14cbcSMatt Macy return (vd); 9683eda14cbcSMatt Macy } 9684eda14cbcSMatt Macy } 9685eda14cbcSMatt Macy 9686eda14cbcSMatt Macy return (NULL); 9687eda14cbcSMatt Macy } 9688eda14cbcSMatt Macy 9689eda14cbcSMatt Macy void 9690eda14cbcSMatt Macy spa_upgrade(spa_t *spa, uint64_t version) 9691eda14cbcSMatt Macy { 9692eda14cbcSMatt Macy ASSERT(spa_writeable(spa)); 9693eda14cbcSMatt Macy 9694eda14cbcSMatt Macy spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 9695eda14cbcSMatt Macy 9696eda14cbcSMatt Macy /* 9697eda14cbcSMatt Macy * This should only be called for a non-faulted pool, and since a 9698eda14cbcSMatt Macy * future version would result in an unopenable pool, this shouldn't be 9699eda14cbcSMatt Macy * possible. 9700eda14cbcSMatt Macy */ 9701eda14cbcSMatt Macy ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version)); 9702eda14cbcSMatt Macy ASSERT3U(version, >=, spa->spa_uberblock.ub_version); 9703eda14cbcSMatt Macy 9704eda14cbcSMatt Macy spa->spa_uberblock.ub_version = version; 9705eda14cbcSMatt Macy vdev_config_dirty(spa->spa_root_vdev); 9706eda14cbcSMatt Macy 9707eda14cbcSMatt Macy spa_config_exit(spa, SCL_ALL, FTAG); 9708eda14cbcSMatt Macy 9709eda14cbcSMatt Macy txg_wait_synced(spa_get_dsl(spa), 0); 9710eda14cbcSMatt Macy } 9711eda14cbcSMatt Macy 9712dae17134SMartin Matuska static boolean_t 9713dae17134SMartin Matuska spa_has_aux_vdev(spa_t *spa, uint64_t guid, spa_aux_vdev_t *sav) 9714eda14cbcSMatt Macy { 9715e92ffd9bSMartin Matuska (void) spa; 9716eda14cbcSMatt Macy int i; 9717dae17134SMartin Matuska uint64_t vdev_guid; 9718eda14cbcSMatt Macy 9719eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) 9720eda14cbcSMatt Macy if (sav->sav_vdevs[i]->vdev_guid == guid) 9721eda14cbcSMatt Macy return (B_TRUE); 9722eda14cbcSMatt Macy 9723eda14cbcSMatt Macy for (i = 0; i < sav->sav_npending; i++) { 9724eda14cbcSMatt Macy if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID, 9725dae17134SMartin Matuska &vdev_guid) == 0 && vdev_guid == guid) 9726eda14cbcSMatt Macy return (B_TRUE); 9727eda14cbcSMatt Macy } 9728eda14cbcSMatt Macy 9729eda14cbcSMatt Macy return (B_FALSE); 9730eda14cbcSMatt Macy } 9731eda14cbcSMatt Macy 9732dae17134SMartin Matuska boolean_t 9733dae17134SMartin Matuska spa_has_l2cache(spa_t *spa, uint64_t guid) 9734dae17134SMartin Matuska { 9735dae17134SMartin Matuska return (spa_has_aux_vdev(spa, guid, &spa->spa_l2cache)); 9736dae17134SMartin Matuska } 9737dae17134SMartin Matuska 9738dae17134SMartin Matuska boolean_t 9739dae17134SMartin Matuska spa_has_spare(spa_t *spa, uint64_t guid) 9740dae17134SMartin Matuska { 9741dae17134SMartin Matuska return (spa_has_aux_vdev(spa, guid, &spa->spa_spares)); 9742dae17134SMartin Matuska } 9743dae17134SMartin Matuska 9744eda14cbcSMatt Macy /* 9745eda14cbcSMatt Macy * Check if a pool has an active shared spare device. 9746eda14cbcSMatt Macy * Note: reference count of an active spare is 2, as a spare and as a replace 9747eda14cbcSMatt Macy */ 9748eda14cbcSMatt Macy static boolean_t 9749eda14cbcSMatt Macy spa_has_active_shared_spare(spa_t *spa) 9750eda14cbcSMatt Macy { 9751eda14cbcSMatt Macy int i, refcnt; 9752eda14cbcSMatt Macy uint64_t pool; 9753eda14cbcSMatt Macy spa_aux_vdev_t *sav = &spa->spa_spares; 9754eda14cbcSMatt Macy 9755eda14cbcSMatt Macy for (i = 0; i < sav->sav_count; i++) { 9756eda14cbcSMatt Macy if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool, 9757eda14cbcSMatt Macy &refcnt) && pool != 0ULL && pool == spa_guid(spa) && 9758eda14cbcSMatt Macy refcnt > 2) 9759eda14cbcSMatt Macy return (B_TRUE); 9760eda14cbcSMatt Macy } 9761eda14cbcSMatt Macy 9762eda14cbcSMatt Macy return (B_FALSE); 9763eda14cbcSMatt Macy } 9764eda14cbcSMatt Macy 9765eda14cbcSMatt Macy uint64_t 9766eda14cbcSMatt Macy spa_total_metaslabs(spa_t *spa) 9767eda14cbcSMatt Macy { 9768eda14cbcSMatt Macy vdev_t *rvd = spa->spa_root_vdev; 9769eda14cbcSMatt Macy 9770eda14cbcSMatt Macy uint64_t m = 0; 9771eda14cbcSMatt Macy for (uint64_t c = 0; c < rvd->vdev_children; c++) { 9772eda14cbcSMatt Macy vdev_t *vd = rvd->vdev_child[c]; 9773eda14cbcSMatt Macy if (!vdev_is_concrete(vd)) 9774eda14cbcSMatt Macy continue; 9775eda14cbcSMatt Macy m += vd->vdev_ms_count; 9776eda14cbcSMatt Macy } 9777eda14cbcSMatt Macy return (m); 9778eda14cbcSMatt Macy } 9779eda14cbcSMatt Macy 9780eda14cbcSMatt Macy /* 9781eda14cbcSMatt Macy * Notify any waiting threads that some activity has switched from being in- 9782eda14cbcSMatt Macy * progress to not-in-progress so that the thread can wake up and determine 9783eda14cbcSMatt Macy * whether it is finished waiting. 9784eda14cbcSMatt Macy */ 9785eda14cbcSMatt Macy void 9786eda14cbcSMatt Macy spa_notify_waiters(spa_t *spa) 9787eda14cbcSMatt Macy { 9788eda14cbcSMatt Macy /* 9789eda14cbcSMatt Macy * Acquiring spa_activities_lock here prevents the cv_broadcast from 9790eda14cbcSMatt Macy * happening between the waiting thread's check and cv_wait. 9791eda14cbcSMatt Macy */ 9792eda14cbcSMatt Macy mutex_enter(&spa->spa_activities_lock); 9793eda14cbcSMatt Macy cv_broadcast(&spa->spa_activities_cv); 9794eda14cbcSMatt Macy mutex_exit(&spa->spa_activities_lock); 9795eda14cbcSMatt Macy } 9796eda14cbcSMatt Macy 9797eda14cbcSMatt Macy /* 9798eda14cbcSMatt Macy * Notify any waiting threads that the pool is exporting, and then block until 9799eda14cbcSMatt Macy * they are finished using the spa_t. 9800eda14cbcSMatt Macy */ 9801eda14cbcSMatt Macy void 9802eda14cbcSMatt Macy spa_wake_waiters(spa_t *spa) 9803eda14cbcSMatt Macy { 9804eda14cbcSMatt Macy mutex_enter(&spa->spa_activities_lock); 9805eda14cbcSMatt Macy spa->spa_waiters_cancel = B_TRUE; 9806eda14cbcSMatt Macy cv_broadcast(&spa->spa_activities_cv); 9807eda14cbcSMatt Macy while (spa->spa_waiters != 0) 9808eda14cbcSMatt Macy cv_wait(&spa->spa_waiters_cv, &spa->spa_activities_lock); 9809eda14cbcSMatt Macy spa->spa_waiters_cancel = B_FALSE; 9810eda14cbcSMatt Macy mutex_exit(&spa->spa_activities_lock); 9811eda14cbcSMatt Macy } 9812eda14cbcSMatt Macy 9813eda14cbcSMatt Macy /* Whether the vdev or any of its descendants are being initialized/trimmed. */ 9814eda14cbcSMatt Macy static boolean_t 9815eda14cbcSMatt Macy spa_vdev_activity_in_progress_impl(vdev_t *vd, zpool_wait_activity_t activity) 9816eda14cbcSMatt Macy { 9817eda14cbcSMatt Macy spa_t *spa = vd->vdev_spa; 9818eda14cbcSMatt Macy 9819eda14cbcSMatt Macy ASSERT(spa_config_held(spa, SCL_CONFIG | SCL_STATE, RW_READER)); 9820eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa->spa_activities_lock)); 9821eda14cbcSMatt Macy ASSERT(activity == ZPOOL_WAIT_INITIALIZE || 9822eda14cbcSMatt Macy activity == ZPOOL_WAIT_TRIM); 9823eda14cbcSMatt Macy 9824eda14cbcSMatt Macy kmutex_t *lock = activity == ZPOOL_WAIT_INITIALIZE ? 9825eda14cbcSMatt Macy &vd->vdev_initialize_lock : &vd->vdev_trim_lock; 9826eda14cbcSMatt Macy 9827eda14cbcSMatt Macy mutex_exit(&spa->spa_activities_lock); 9828eda14cbcSMatt Macy mutex_enter(lock); 9829eda14cbcSMatt Macy mutex_enter(&spa->spa_activities_lock); 9830eda14cbcSMatt Macy 9831eda14cbcSMatt Macy boolean_t in_progress = (activity == ZPOOL_WAIT_INITIALIZE) ? 9832eda14cbcSMatt Macy (vd->vdev_initialize_state == VDEV_INITIALIZE_ACTIVE) : 9833eda14cbcSMatt Macy (vd->vdev_trim_state == VDEV_TRIM_ACTIVE); 9834eda14cbcSMatt Macy mutex_exit(lock); 9835eda14cbcSMatt Macy 9836eda14cbcSMatt Macy if (in_progress) 9837eda14cbcSMatt Macy return (B_TRUE); 9838eda14cbcSMatt Macy 9839eda14cbcSMatt Macy for (int i = 0; i < vd->vdev_children; i++) { 9840eda14cbcSMatt Macy if (spa_vdev_activity_in_progress_impl(vd->vdev_child[i], 9841eda14cbcSMatt Macy activity)) 9842eda14cbcSMatt Macy return (B_TRUE); 9843eda14cbcSMatt Macy } 9844eda14cbcSMatt Macy 9845eda14cbcSMatt Macy return (B_FALSE); 9846eda14cbcSMatt Macy } 9847eda14cbcSMatt Macy 9848eda14cbcSMatt Macy /* 9849eda14cbcSMatt Macy * If use_guid is true, this checks whether the vdev specified by guid is 9850eda14cbcSMatt Macy * being initialized/trimmed. Otherwise, it checks whether any vdev in the pool 9851eda14cbcSMatt Macy * is being initialized/trimmed. The caller must hold the config lock and 9852eda14cbcSMatt Macy * spa_activities_lock. 9853eda14cbcSMatt Macy */ 9854eda14cbcSMatt Macy static int 9855eda14cbcSMatt Macy spa_vdev_activity_in_progress(spa_t *spa, boolean_t use_guid, uint64_t guid, 9856eda14cbcSMatt Macy zpool_wait_activity_t activity, boolean_t *in_progress) 9857eda14cbcSMatt Macy { 9858eda14cbcSMatt Macy mutex_exit(&spa->spa_activities_lock); 9859eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 9860eda14cbcSMatt Macy mutex_enter(&spa->spa_activities_lock); 9861eda14cbcSMatt Macy 9862eda14cbcSMatt Macy vdev_t *vd; 9863eda14cbcSMatt Macy if (use_guid) { 9864eda14cbcSMatt Macy vd = spa_lookup_by_guid(spa, guid, B_FALSE); 9865eda14cbcSMatt Macy if (vd == NULL || !vd->vdev_ops->vdev_op_leaf) { 9866eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 9867eda14cbcSMatt Macy return (EINVAL); 9868eda14cbcSMatt Macy } 9869eda14cbcSMatt Macy } else { 9870eda14cbcSMatt Macy vd = spa->spa_root_vdev; 9871eda14cbcSMatt Macy } 9872eda14cbcSMatt Macy 9873eda14cbcSMatt Macy *in_progress = spa_vdev_activity_in_progress_impl(vd, activity); 9874eda14cbcSMatt Macy 9875eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 9876eda14cbcSMatt Macy return (0); 9877eda14cbcSMatt Macy } 9878eda14cbcSMatt Macy 9879eda14cbcSMatt Macy /* 9880eda14cbcSMatt Macy * Locking for waiting threads 9881eda14cbcSMatt Macy * --------------------------- 9882eda14cbcSMatt Macy * 9883eda14cbcSMatt Macy * Waiting threads need a way to check whether a given activity is in progress, 9884eda14cbcSMatt Macy * and then, if it is, wait for it to complete. Each activity will have some 9885eda14cbcSMatt Macy * in-memory representation of the relevant on-disk state which can be used to 9886eda14cbcSMatt Macy * determine whether or not the activity is in progress. The in-memory state and 9887eda14cbcSMatt Macy * the locking used to protect it will be different for each activity, and may 9888eda14cbcSMatt Macy * not be suitable for use with a cvar (e.g., some state is protected by the 9889eda14cbcSMatt Macy * config lock). To allow waiting threads to wait without any races, another 9890eda14cbcSMatt Macy * lock, spa_activities_lock, is used. 9891eda14cbcSMatt Macy * 9892eda14cbcSMatt Macy * When the state is checked, both the activity-specific lock (if there is one) 9893eda14cbcSMatt Macy * and spa_activities_lock are held. In some cases, the activity-specific lock 9894eda14cbcSMatt Macy * is acquired explicitly (e.g. the config lock). In others, the locking is 9895eda14cbcSMatt Macy * internal to some check (e.g. bpobj_is_empty). After checking, the waiting 9896eda14cbcSMatt Macy * thread releases the activity-specific lock and, if the activity is in 9897eda14cbcSMatt Macy * progress, then cv_waits using spa_activities_lock. 9898eda14cbcSMatt Macy * 9899eda14cbcSMatt Macy * The waiting thread is woken when another thread, one completing some 9900eda14cbcSMatt Macy * activity, updates the state of the activity and then calls 9901eda14cbcSMatt Macy * spa_notify_waiters, which will cv_broadcast. This 'completing' thread only 9902eda14cbcSMatt Macy * needs to hold its activity-specific lock when updating the state, and this 9903eda14cbcSMatt Macy * lock can (but doesn't have to) be dropped before calling spa_notify_waiters. 9904eda14cbcSMatt Macy * 9905eda14cbcSMatt Macy * Because spa_notify_waiters acquires spa_activities_lock before broadcasting, 9906eda14cbcSMatt Macy * and because it is held when the waiting thread checks the state of the 9907eda14cbcSMatt Macy * activity, it can never be the case that the completing thread both updates 9908eda14cbcSMatt Macy * the activity state and cv_broadcasts in between the waiting thread's check 9909eda14cbcSMatt Macy * and cv_wait. Thus, a waiting thread can never miss a wakeup. 9910eda14cbcSMatt Macy * 9911eda14cbcSMatt Macy * In order to prevent deadlock, when the waiting thread does its check, in some 9912eda14cbcSMatt Macy * cases it will temporarily drop spa_activities_lock in order to acquire the 9913eda14cbcSMatt Macy * activity-specific lock. The order in which spa_activities_lock and the 9914eda14cbcSMatt Macy * activity specific lock are acquired in the waiting thread is determined by 9915eda14cbcSMatt Macy * the order in which they are acquired in the completing thread; if the 9916eda14cbcSMatt Macy * completing thread calls spa_notify_waiters with the activity-specific lock 9917eda14cbcSMatt Macy * held, then the waiting thread must also acquire the activity-specific lock 9918eda14cbcSMatt Macy * first. 9919eda14cbcSMatt Macy */ 9920eda14cbcSMatt Macy 9921eda14cbcSMatt Macy static int 9922eda14cbcSMatt Macy spa_activity_in_progress(spa_t *spa, zpool_wait_activity_t activity, 9923eda14cbcSMatt Macy boolean_t use_tag, uint64_t tag, boolean_t *in_progress) 9924eda14cbcSMatt Macy { 9925eda14cbcSMatt Macy int error = 0; 9926eda14cbcSMatt Macy 9927eda14cbcSMatt Macy ASSERT(MUTEX_HELD(&spa->spa_activities_lock)); 9928eda14cbcSMatt Macy 9929eda14cbcSMatt Macy switch (activity) { 9930eda14cbcSMatt Macy case ZPOOL_WAIT_CKPT_DISCARD: 9931eda14cbcSMatt Macy *in_progress = 9932eda14cbcSMatt Macy (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT) && 9933eda14cbcSMatt Macy zap_contains(spa_meta_objset(spa), 9934eda14cbcSMatt Macy DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ZPOOL_CHECKPOINT) == 9935eda14cbcSMatt Macy ENOENT); 9936eda14cbcSMatt Macy break; 9937eda14cbcSMatt Macy case ZPOOL_WAIT_FREE: 9938eda14cbcSMatt Macy *in_progress = ((spa_version(spa) >= SPA_VERSION_DEADLISTS && 9939eda14cbcSMatt Macy !bpobj_is_empty(&spa->spa_dsl_pool->dp_free_bpobj)) || 9940eda14cbcSMatt Macy spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY) || 9941eda14cbcSMatt Macy spa_livelist_delete_check(spa)); 9942eda14cbcSMatt Macy break; 9943eda14cbcSMatt Macy case ZPOOL_WAIT_INITIALIZE: 9944eda14cbcSMatt Macy case ZPOOL_WAIT_TRIM: 9945eda14cbcSMatt Macy error = spa_vdev_activity_in_progress(spa, use_tag, tag, 9946eda14cbcSMatt Macy activity, in_progress); 9947eda14cbcSMatt Macy break; 9948eda14cbcSMatt Macy case ZPOOL_WAIT_REPLACE: 9949eda14cbcSMatt Macy mutex_exit(&spa->spa_activities_lock); 9950eda14cbcSMatt Macy spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 9951eda14cbcSMatt Macy mutex_enter(&spa->spa_activities_lock); 9952eda14cbcSMatt Macy 9953eda14cbcSMatt Macy *in_progress = vdev_replace_in_progress(spa->spa_root_vdev); 9954eda14cbcSMatt Macy spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 9955eda14cbcSMatt Macy break; 9956eda14cbcSMatt Macy case ZPOOL_WAIT_REMOVE: 9957eda14cbcSMatt Macy *in_progress = (spa->spa_removing_phys.sr_state == 9958eda14cbcSMatt Macy DSS_SCANNING); 9959eda14cbcSMatt Macy break; 9960eda14cbcSMatt Macy case ZPOOL_WAIT_RESILVER: 9961eda14cbcSMatt Macy if ((*in_progress = vdev_rebuild_active(spa->spa_root_vdev))) 9962eda14cbcSMatt Macy break; 9963c03c5b1cSMartin Matuska zfs_fallthrough; 9964eda14cbcSMatt Macy case ZPOOL_WAIT_SCRUB: 9965eda14cbcSMatt Macy { 9966eda14cbcSMatt Macy boolean_t scanning, paused, is_scrub; 9967eda14cbcSMatt Macy dsl_scan_t *scn = spa->spa_dsl_pool->dp_scan; 9968eda14cbcSMatt Macy 9969eda14cbcSMatt Macy is_scrub = (scn->scn_phys.scn_func == POOL_SCAN_SCRUB); 9970eda14cbcSMatt Macy scanning = (scn->scn_phys.scn_state == DSS_SCANNING); 9971eda14cbcSMatt Macy paused = dsl_scan_is_paused_scrub(scn); 9972eda14cbcSMatt Macy *in_progress = (scanning && !paused && 9973eda14cbcSMatt Macy is_scrub == (activity == ZPOOL_WAIT_SCRUB)); 9974eda14cbcSMatt Macy break; 9975eda14cbcSMatt Macy } 9976eda14cbcSMatt Macy default: 9977eda14cbcSMatt Macy panic("unrecognized value for activity %d", activity); 9978eda14cbcSMatt Macy } 9979eda14cbcSMatt Macy 9980eda14cbcSMatt Macy return (error); 9981eda14cbcSMatt Macy } 9982eda14cbcSMatt Macy 9983eda14cbcSMatt Macy static int 9984eda14cbcSMatt Macy spa_wait_common(const char *pool, zpool_wait_activity_t activity, 9985eda14cbcSMatt Macy boolean_t use_tag, uint64_t tag, boolean_t *waited) 9986eda14cbcSMatt Macy { 9987eda14cbcSMatt Macy /* 9988eda14cbcSMatt Macy * The tag is used to distinguish between instances of an activity. 9989eda14cbcSMatt Macy * 'initialize' and 'trim' are the only activities that we use this for. 9990eda14cbcSMatt Macy * The other activities can only have a single instance in progress in a 9991eda14cbcSMatt Macy * pool at one time, making the tag unnecessary. 9992eda14cbcSMatt Macy * 9993eda14cbcSMatt Macy * There can be multiple devices being replaced at once, but since they 9994eda14cbcSMatt Macy * all finish once resilvering finishes, we don't bother keeping track 9995eda14cbcSMatt Macy * of them individually, we just wait for them all to finish. 9996eda14cbcSMatt Macy */ 9997eda14cbcSMatt Macy if (use_tag && activity != ZPOOL_WAIT_INITIALIZE && 9998eda14cbcSMatt Macy activity != ZPOOL_WAIT_TRIM) 9999eda14cbcSMatt Macy return (EINVAL); 10000eda14cbcSMatt Macy 10001eda14cbcSMatt Macy if (activity < 0 || activity >= ZPOOL_WAIT_NUM_ACTIVITIES) 10002eda14cbcSMatt Macy return (EINVAL); 10003eda14cbcSMatt Macy 10004eda14cbcSMatt Macy spa_t *spa; 10005eda14cbcSMatt Macy int error = spa_open(pool, &spa, FTAG); 10006eda14cbcSMatt Macy if (error != 0) 10007eda14cbcSMatt Macy return (error); 10008eda14cbcSMatt Macy 10009eda14cbcSMatt Macy /* 10010eda14cbcSMatt Macy * Increment the spa's waiter count so that we can call spa_close and 10011eda14cbcSMatt Macy * still ensure that the spa_t doesn't get freed before this thread is 10012eda14cbcSMatt Macy * finished with it when the pool is exported. We want to call spa_close 10013eda14cbcSMatt Macy * before we start waiting because otherwise the additional ref would 10014eda14cbcSMatt Macy * prevent the pool from being exported or destroyed throughout the 10015eda14cbcSMatt Macy * potentially long wait. 10016eda14cbcSMatt Macy */ 10017eda14cbcSMatt Macy mutex_enter(&spa->spa_activities_lock); 10018eda14cbcSMatt Macy spa->spa_waiters++; 10019eda14cbcSMatt Macy spa_close(spa, FTAG); 10020eda14cbcSMatt Macy 10021eda14cbcSMatt Macy *waited = B_FALSE; 10022eda14cbcSMatt Macy for (;;) { 10023eda14cbcSMatt Macy boolean_t in_progress; 10024eda14cbcSMatt Macy error = spa_activity_in_progress(spa, activity, use_tag, tag, 10025eda14cbcSMatt Macy &in_progress); 10026eda14cbcSMatt Macy 10027eda14cbcSMatt Macy if (error || !in_progress || spa->spa_waiters_cancel) 10028eda14cbcSMatt Macy break; 10029eda14cbcSMatt Macy 10030eda14cbcSMatt Macy *waited = B_TRUE; 10031eda14cbcSMatt Macy 10032eda14cbcSMatt Macy if (cv_wait_sig(&spa->spa_activities_cv, 10033eda14cbcSMatt Macy &spa->spa_activities_lock) == 0) { 10034eda14cbcSMatt Macy error = EINTR; 10035eda14cbcSMatt Macy break; 10036eda14cbcSMatt Macy } 10037eda14cbcSMatt Macy } 10038eda14cbcSMatt Macy 10039eda14cbcSMatt Macy spa->spa_waiters--; 10040eda14cbcSMatt Macy cv_signal(&spa->spa_waiters_cv); 10041eda14cbcSMatt Macy mutex_exit(&spa->spa_activities_lock); 10042eda14cbcSMatt Macy 10043eda14cbcSMatt Macy return (error); 10044eda14cbcSMatt Macy } 10045eda14cbcSMatt Macy 10046eda14cbcSMatt Macy /* 10047eda14cbcSMatt Macy * Wait for a particular instance of the specified activity to complete, where 10048eda14cbcSMatt Macy * the instance is identified by 'tag' 10049eda14cbcSMatt Macy */ 10050eda14cbcSMatt Macy int 10051eda14cbcSMatt Macy spa_wait_tag(const char *pool, zpool_wait_activity_t activity, uint64_t tag, 10052eda14cbcSMatt Macy boolean_t *waited) 10053eda14cbcSMatt Macy { 10054eda14cbcSMatt Macy return (spa_wait_common(pool, activity, B_TRUE, tag, waited)); 10055eda14cbcSMatt Macy } 10056eda14cbcSMatt Macy 10057eda14cbcSMatt Macy /* 10058eda14cbcSMatt Macy * Wait for all instances of the specified activity complete 10059eda14cbcSMatt Macy */ 10060eda14cbcSMatt Macy int 10061eda14cbcSMatt Macy spa_wait(const char *pool, zpool_wait_activity_t activity, boolean_t *waited) 10062eda14cbcSMatt Macy { 10063eda14cbcSMatt Macy 10064eda14cbcSMatt Macy return (spa_wait_common(pool, activity, B_FALSE, 0, waited)); 10065eda14cbcSMatt Macy } 10066eda14cbcSMatt Macy 10067eda14cbcSMatt Macy sysevent_t * 10068eda14cbcSMatt Macy spa_event_create(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl, const char *name) 10069eda14cbcSMatt Macy { 10070eda14cbcSMatt Macy sysevent_t *ev = NULL; 10071eda14cbcSMatt Macy #ifdef _KERNEL 10072eda14cbcSMatt Macy nvlist_t *resource; 10073eda14cbcSMatt Macy 10074eda14cbcSMatt Macy resource = zfs_event_create(spa, vd, FM_SYSEVENT_CLASS, name, hist_nvl); 10075eda14cbcSMatt Macy if (resource) { 10076eda14cbcSMatt Macy ev = kmem_alloc(sizeof (sysevent_t), KM_SLEEP); 10077eda14cbcSMatt Macy ev->resource = resource; 10078eda14cbcSMatt Macy } 10079e92ffd9bSMartin Matuska #else 10080e92ffd9bSMartin Matuska (void) spa, (void) vd, (void) hist_nvl, (void) name; 10081eda14cbcSMatt Macy #endif 10082eda14cbcSMatt Macy return (ev); 10083eda14cbcSMatt Macy } 10084eda14cbcSMatt Macy 10085eda14cbcSMatt Macy void 10086eda14cbcSMatt Macy spa_event_post(sysevent_t *ev) 10087eda14cbcSMatt Macy { 10088eda14cbcSMatt Macy #ifdef _KERNEL 10089eda14cbcSMatt Macy if (ev) { 10090eda14cbcSMatt Macy zfs_zevent_post(ev->resource, NULL, zfs_zevent_post_cb); 10091eda14cbcSMatt Macy kmem_free(ev, sizeof (*ev)); 10092eda14cbcSMatt Macy } 10093e92ffd9bSMartin Matuska #else 10094e92ffd9bSMartin Matuska (void) ev; 10095eda14cbcSMatt Macy #endif 10096eda14cbcSMatt Macy } 10097eda14cbcSMatt Macy 10098eda14cbcSMatt Macy /* 10099eda14cbcSMatt Macy * Post a zevent corresponding to the given sysevent. The 'name' must be one 10100eda14cbcSMatt Macy * of the event definitions in sys/sysevent/eventdefs.h. The payload will be 10101eda14cbcSMatt Macy * filled in from the spa and (optionally) the vdev. This doesn't do anything 10102eda14cbcSMatt Macy * in the userland libzpool, as we don't want consumers to misinterpret ztest 10103eda14cbcSMatt Macy * or zdb as real changes. 10104eda14cbcSMatt Macy */ 10105eda14cbcSMatt Macy void 10106eda14cbcSMatt Macy spa_event_notify(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl, const char *name) 10107eda14cbcSMatt Macy { 10108eda14cbcSMatt Macy spa_event_post(spa_event_create(spa, vd, hist_nvl, name)); 10109eda14cbcSMatt Macy } 10110eda14cbcSMatt Macy 10111eda14cbcSMatt Macy /* state manipulation functions */ 10112eda14cbcSMatt Macy EXPORT_SYMBOL(spa_open); 10113eda14cbcSMatt Macy EXPORT_SYMBOL(spa_open_rewind); 10114eda14cbcSMatt Macy EXPORT_SYMBOL(spa_get_stats); 10115eda14cbcSMatt Macy EXPORT_SYMBOL(spa_create); 10116eda14cbcSMatt Macy EXPORT_SYMBOL(spa_import); 10117eda14cbcSMatt Macy EXPORT_SYMBOL(spa_tryimport); 10118eda14cbcSMatt Macy EXPORT_SYMBOL(spa_destroy); 10119eda14cbcSMatt Macy EXPORT_SYMBOL(spa_export); 10120eda14cbcSMatt Macy EXPORT_SYMBOL(spa_reset); 10121eda14cbcSMatt Macy EXPORT_SYMBOL(spa_async_request); 10122eda14cbcSMatt Macy EXPORT_SYMBOL(spa_async_suspend); 10123eda14cbcSMatt Macy EXPORT_SYMBOL(spa_async_resume); 10124eda14cbcSMatt Macy EXPORT_SYMBOL(spa_inject_addref); 10125eda14cbcSMatt Macy EXPORT_SYMBOL(spa_inject_delref); 10126eda14cbcSMatt Macy EXPORT_SYMBOL(spa_scan_stat_init); 10127eda14cbcSMatt Macy EXPORT_SYMBOL(spa_scan_get_stats); 10128eda14cbcSMatt Macy 10129eda14cbcSMatt Macy /* device manipulation */ 10130eda14cbcSMatt Macy EXPORT_SYMBOL(spa_vdev_add); 10131eda14cbcSMatt Macy EXPORT_SYMBOL(spa_vdev_attach); 10132eda14cbcSMatt Macy EXPORT_SYMBOL(spa_vdev_detach); 10133eda14cbcSMatt Macy EXPORT_SYMBOL(spa_vdev_setpath); 10134eda14cbcSMatt Macy EXPORT_SYMBOL(spa_vdev_setfru); 10135eda14cbcSMatt Macy EXPORT_SYMBOL(spa_vdev_split_mirror); 10136eda14cbcSMatt Macy 10137eda14cbcSMatt Macy /* spare statech is global across all pools) */ 10138eda14cbcSMatt Macy EXPORT_SYMBOL(spa_spare_add); 10139eda14cbcSMatt Macy EXPORT_SYMBOL(spa_spare_remove); 10140eda14cbcSMatt Macy EXPORT_SYMBOL(spa_spare_exists); 10141eda14cbcSMatt Macy EXPORT_SYMBOL(spa_spare_activate); 10142eda14cbcSMatt Macy 10143eda14cbcSMatt Macy /* L2ARC statech is global across all pools) */ 10144eda14cbcSMatt Macy EXPORT_SYMBOL(spa_l2cache_add); 10145eda14cbcSMatt Macy EXPORT_SYMBOL(spa_l2cache_remove); 10146eda14cbcSMatt Macy EXPORT_SYMBOL(spa_l2cache_exists); 10147eda14cbcSMatt Macy EXPORT_SYMBOL(spa_l2cache_activate); 10148eda14cbcSMatt Macy EXPORT_SYMBOL(spa_l2cache_drop); 10149eda14cbcSMatt Macy 10150eda14cbcSMatt Macy /* scanning */ 10151eda14cbcSMatt Macy EXPORT_SYMBOL(spa_scan); 10152eda14cbcSMatt Macy EXPORT_SYMBOL(spa_scan_stop); 10153eda14cbcSMatt Macy 10154eda14cbcSMatt Macy /* spa syncing */ 10155eda14cbcSMatt Macy EXPORT_SYMBOL(spa_sync); /* only for DMU use */ 10156eda14cbcSMatt Macy EXPORT_SYMBOL(spa_sync_allpools); 10157eda14cbcSMatt Macy 10158eda14cbcSMatt Macy /* properties */ 10159eda14cbcSMatt Macy EXPORT_SYMBOL(spa_prop_set); 10160eda14cbcSMatt Macy EXPORT_SYMBOL(spa_prop_get); 10161eda14cbcSMatt Macy EXPORT_SYMBOL(spa_prop_clear_bootfs); 10162eda14cbcSMatt Macy 10163eda14cbcSMatt Macy /* asynchronous event notification */ 10164eda14cbcSMatt Macy EXPORT_SYMBOL(spa_event_notify); 10165eda14cbcSMatt Macy 10166b2526e8bSMartin Matuska ZFS_MODULE_PARAM(zfs_metaslab, metaslab_, preload_pct, UINT, ZMOD_RW, 10167b2526e8bSMartin Matuska "Percentage of CPUs to run a metaslab preload taskq"); 10168b2526e8bSMartin Matuska 10169eda14cbcSMatt Macy /* BEGIN CSTYLED */ 10170be181ee2SMartin Matuska ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_shift, UINT, ZMOD_RW, 1017116038816SMartin Matuska "log2 fraction of arc that can be used by inflight I/Os when " 10172eda14cbcSMatt Macy "verifying pool during import"); 10173c03c5b1cSMartin Matuska /* END CSTYLED */ 10174eda14cbcSMatt Macy 10175eda14cbcSMatt Macy ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_metadata, INT, ZMOD_RW, 10176eda14cbcSMatt Macy "Set to traverse metadata on pool import"); 10177eda14cbcSMatt Macy 10178eda14cbcSMatt Macy ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_data, INT, ZMOD_RW, 10179eda14cbcSMatt Macy "Set to traverse data on pool import"); 10180eda14cbcSMatt Macy 10181eda14cbcSMatt Macy ZFS_MODULE_PARAM(zfs_spa, spa_, load_print_vdev_tree, INT, ZMOD_RW, 10182eda14cbcSMatt Macy "Print vdev tree to zfs_dbgmsg during pool import"); 10183eda14cbcSMatt Macy 10184eda14cbcSMatt Macy ZFS_MODULE_PARAM(zfs_zio, zio_, taskq_batch_pct, UINT, ZMOD_RD, 10185eda14cbcSMatt Macy "Percentage of CPUs to run an IO worker thread"); 10186eda14cbcSMatt Macy 1018716038816SMartin Matuska ZFS_MODULE_PARAM(zfs_zio, zio_, taskq_batch_tpq, UINT, ZMOD_RD, 1018816038816SMartin Matuska "Number of threads per IO worker taskqueue"); 1018916038816SMartin Matuska 10190c03c5b1cSMartin Matuska /* BEGIN CSTYLED */ 10191dbd5678dSMartin Matuska ZFS_MODULE_PARAM(zfs, zfs_, max_missing_tvds, U64, ZMOD_RW, 10192eda14cbcSMatt Macy "Allow importing pool with up to this number of missing top-level " 10193eda14cbcSMatt Macy "vdevs (in read-only mode)"); 10194c03c5b1cSMartin Matuska /* END CSTYLED */ 10195eda14cbcSMatt Macy 10196c03c5b1cSMartin Matuska ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_pause, INT, 10197c03c5b1cSMartin Matuska ZMOD_RW, "Set the livelist condense zthr to pause"); 10198eda14cbcSMatt Macy 10199c03c5b1cSMartin Matuska ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_pause, INT, 10200c03c5b1cSMartin Matuska ZMOD_RW, "Set the livelist condense synctask to pause"); 10201eda14cbcSMatt Macy 10202c03c5b1cSMartin Matuska /* BEGIN CSTYLED */ 10203c03c5b1cSMartin Matuska ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_cancel, 10204c03c5b1cSMartin Matuska INT, ZMOD_RW, 10205eda14cbcSMatt Macy "Whether livelist condensing was canceled in the synctask"); 10206eda14cbcSMatt Macy 10207c03c5b1cSMartin Matuska ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_cancel, 10208c03c5b1cSMartin Matuska INT, ZMOD_RW, 10209eda14cbcSMatt Macy "Whether livelist condensing was canceled in the zthr function"); 10210eda14cbcSMatt Macy 10211c03c5b1cSMartin Matuska ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, new_alloc, INT, 10212c03c5b1cSMartin Matuska ZMOD_RW, 10213eda14cbcSMatt Macy "Whether extra ALLOC blkptrs were added to a livelist entry while it " 10214eda14cbcSMatt Macy "was being condensed"); 10215eda14cbcSMatt Macy /* END CSTYLED */ 10216