Mercurial > illumos > illumos-gate
annotate usr/src/uts/common/fs/zfs/spa.c @ 9425:e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
6826466 want to post sysevents on hot spare activation
6826468 spa 'allowfaulted' needs some work
6826469 kernel support for storing vdev FRU information
6826470 skip posting checksum errors from DTL regions of leaf vdevs
6826471 I/O errors after device remove probe can confuse FMA
6826472 spares should enjoy some of the benefits of cache devices
| author | Eric Schrock <Eric.Schrock@Sun.COM> |
|---|---|
| date | Wed, 22 Apr 2009 14:55:27 -0700 |
| parents | a8a7fc849933 |
| children | fcff33da767f |
| rev | line source |
|---|---|
| 789 | 1 /* |
| 2 * CDDL HEADER START | |
| 3 * | |
| 4 * The contents of this file are subject to the terms of the | |
| 1544 | 5 * Common Development and Distribution License (the "License"). |
| 6 * You may not use this file except in compliance with the License. | |
| 789 | 7 * |
| 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
| 9 * or http://www.opensolaris.org/os/licensing. | |
| 10 * See the License for the specific language governing permissions | |
| 11 * and limitations under the License. | |
| 12 * | |
| 13 * When distributing Covered Code, include this CDDL HEADER in each | |
| 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
| 15 * If applicable, add the following below this CDDL HEADER, with the | |
| 16 * fields enclosed by brackets "[]" replaced with your own identifying | |
| 17 * information: Portions Copyright [yyyy] [name of copyright owner] | |
| 18 * | |
| 19 * CDDL HEADER END | |
| 20 */ | |
| 2082 | 21 |
| 789 | 22 /* |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. |
| 789 | 24 * Use is subject to license terms. |
| 25 */ | |
| 26 | |
| 27 /* | |
| 28 * This file contains all the routines used when modifying on-disk SPA state. | |
| 29 * This includes opening, importing, destroying, exporting a pool, and syncing a | |
| 30 * pool. | |
| 31 */ | |
| 32 | |
| 33 #include <sys/zfs_context.h> | |
| 1544 | 34 #include <sys/fm/fs/zfs.h> |
| 789 | 35 #include <sys/spa_impl.h> |
| 36 #include <sys/zio.h> | |
| 37 #include <sys/zio_checksum.h> | |
| 38 #include <sys/zio_compress.h> | |
| 39 #include <sys/dmu.h> | |
| 40 #include <sys/dmu_tx.h> | |
| 41 #include <sys/zap.h> | |
| 42 #include <sys/zil.h> | |
| 43 #include <sys/vdev_impl.h> | |
| 44 #include <sys/metaslab.h> | |
| 45 #include <sys/uberblock_impl.h> | |
| 46 #include <sys/txg.h> | |
| 47 #include <sys/avl.h> | |
| 48 #include <sys/dmu_traverse.h> | |
| 3912 | 49 #include <sys/dmu_objset.h> |
| 789 | 50 #include <sys/unique.h> |
| 51 #include <sys/dsl_pool.h> | |
| 3912 | 52 #include <sys/dsl_dataset.h> |
| 789 | 53 #include <sys/dsl_dir.h> |
| 54 #include <sys/dsl_prop.h> | |
| 3912 | 55 #include <sys/dsl_synctask.h> |
| 789 | 56 #include <sys/fs/zfs.h> |
| 5450 | 57 #include <sys/arc.h> |
| 789 | 58 #include <sys/callb.h> |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
59 #include <sys/systeminfo.h> |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
60 #include <sys/sunddi.h> |
| 6423 | 61 #include <sys/spa_boot.h> |
| 789 | 62 |
|
8662
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
63 #ifdef _KERNEL |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
64 #include <sys/zone.h> |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
65 #endif /* _KERNEL */ |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
66 |
| 5094 | 67 #include "zfs_prop.h" |
|
5913
a77f8ad2ce63
6575965 panic/thread=2a1016b5ca0: BAD TRAP: type=9 rp=1858500 addr=0 mmu_fsr=0, really, truly out of space
perrin
parents:
5886
diff
changeset
|
68 #include "zfs_comutil.h" |
| 5094 | 69 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
70 int zio_taskq_threads[ZIO_TYPES][ZIO_TASKQ_TYPES] = { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
71 /* ISSUE INTR */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
72 { 1, 1 }, /* ZIO_TYPE_NULL */ |
|
9230
e4561e3eb1ef
6821169 offlining a device results in checksum errors
George Wilson <George.Wilson@Sun.COM>
parents:
8680
diff
changeset
|
73 { 8, 8 }, /* ZIO_TYPE_READ */ |
|
e4561e3eb1ef
6821169 offlining a device results in checksum errors
George Wilson <George.Wilson@Sun.COM>
parents:
8680
diff
changeset
|
74 { 8, 8 }, /* ZIO_TYPE_WRITE */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
75 { 1, 1 }, /* ZIO_TYPE_FREE */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
76 { 1, 1 }, /* ZIO_TYPE_CLAIM */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
77 { 1, 1 }, /* ZIO_TYPE_IOCTL */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
78 }; |
| 2986 | 79 |
| 5094 | 80 static void spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx); |
|
7214
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
81 static boolean_t spa_has_active_shared_spare(spa_t *spa); |
| 5094 | 82 |
| 83 /* | |
| 84 * ========================================================================== | |
| 85 * SPA properties routines | |
| 86 * ========================================================================== | |
| 87 */ | |
| 88 | |
| 89 /* | |
| 90 * Add a (source=src, propname=propval) list to an nvlist. | |
| 91 */ | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
92 static void |
| 5094 | 93 spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval, |
| 94 uint64_t intval, zprop_source_t src) | |
| 95 { | |
| 96 const char *propname = zpool_prop_to_name(prop); | |
| 97 nvlist_t *propval; | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
98 |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
99 VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0); |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
100 VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0); |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
101 |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
102 if (strval != NULL) |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
103 VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0); |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
104 else |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
105 VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0); |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
106 |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
107 VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0); |
| 5094 | 108 nvlist_free(propval); |
| 109 } | |
| 110 | |
| 111 /* | |
| 112 * Get property values from the spa configuration. | |
| 113 */ | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
114 static void |
| 5094 | 115 spa_prop_get_config(spa_t *spa, nvlist_t **nvp) |
| 116 { | |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
117 uint64_t size; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
118 uint64_t used; |
| 5094 | 119 uint64_t cap, version; |
| 120 zprop_source_t src = ZPROP_SRC_NONE; | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
121 spa_config_dirent_t *dp; |
| 5094 | 122 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
123 ASSERT(MUTEX_HELD(&spa->spa_props_lock)); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
124 |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
125 if (spa->spa_root_vdev != NULL) { |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
126 size = spa_get_space(spa); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
127 used = spa_get_alloc(spa); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
128 spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
129 spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
130 spa_prop_add_list(*nvp, ZPOOL_PROP_USED, NULL, used, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
131 spa_prop_add_list(*nvp, ZPOOL_PROP_AVAILABLE, NULL, |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
132 size - used, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
133 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
134 cap = (size == 0) ? 0 : (used * 100 / size); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
135 spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
136 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
137 spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL, |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
138 spa->spa_root_vdev->vdev_state, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
139 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
140 version = spa_version(spa); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
141 if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION)) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
142 src = ZPROP_SRC_DEFAULT; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
143 else |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
144 src = ZPROP_SRC_LOCAL; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
145 spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
146 } |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
147 |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
148 spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src); |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
149 |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
150 if (spa->spa_root != NULL) |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
151 spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root, |
|
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
152 0, ZPROP_SRC_LOCAL); |
| 5094 | 153 |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
154 if ((dp = list_head(&spa->spa_config_list)) != NULL) { |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
155 if (dp->scd_path == NULL) { |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
156 spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
157 "none", 0, ZPROP_SRC_LOCAL); |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
158 } else if (strcmp(dp->scd_path, spa_config_path) != 0) { |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
159 spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE, |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
160 dp->scd_path, 0, ZPROP_SRC_LOCAL); |
| 5363 | 161 } |
| 162 } | |
| 5094 | 163 } |
| 164 | |
| 165 /* | |
| 166 * Get zpool property values. | |
| 167 */ | |
| 168 int | |
| 169 spa_prop_get(spa_t *spa, nvlist_t **nvp) | |
| 170 { | |
| 171 zap_cursor_t zc; | |
| 172 zap_attribute_t za; | |
| 173 objset_t *mos = spa->spa_meta_objset; | |
| 174 int err; | |
| 175 | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
176 VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); |
| 5094 | 177 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
178 mutex_enter(&spa->spa_props_lock); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
179 |
| 5094 | 180 /* |
| 181 * Get properties from the spa config. | |
| 182 */ | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
183 spa_prop_get_config(spa, nvp); |
| 5094 | 184 |
| 185 /* If no pool property object, no more prop to get. */ | |
| 186 if (spa->spa_pool_props_object == 0) { | |
| 187 mutex_exit(&spa->spa_props_lock); | |
| 188 return (0); | |
| 189 } | |
| 190 | |
| 191 /* | |
| 192 * Get properties from the MOS pool property object. | |
| 193 */ | |
| 194 for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object); | |
| 195 (err = zap_cursor_retrieve(&zc, &za)) == 0; | |
| 196 zap_cursor_advance(&zc)) { | |
| 197 uint64_t intval = 0; | |
| 198 char *strval = NULL; | |
| 199 zprop_source_t src = ZPROP_SRC_DEFAULT; | |
| 200 zpool_prop_t prop; | |
| 201 | |
| 202 if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL) | |
| 203 continue; | |
| 204 | |
| 205 switch (za.za_integer_length) { | |
| 206 case 8: | |
| 207 /* integer property */ | |
| 208 if (za.za_first_integer != | |
| 209 zpool_prop_default_numeric(prop)) | |
| 210 src = ZPROP_SRC_LOCAL; | |
| 211 | |
| 212 if (prop == ZPOOL_PROP_BOOTFS) { | |
| 213 dsl_pool_t *dp; | |
| 214 dsl_dataset_t *ds = NULL; | |
| 215 | |
| 216 dp = spa_get_dsl(spa); | |
| 217 rw_enter(&dp->dp_config_rwlock, RW_READER); | |
|
6689
47572a2f5e73
6610506 Eliminate or improve retry logic from callers of dmu_objset_open()
maybee
parents:
6673
diff
changeset
|
218 if (err = dsl_dataset_hold_obj(dp, |
|
47572a2f5e73
6610506 Eliminate or improve retry logic from callers of dmu_objset_open()
maybee
parents:
6673
diff
changeset
|
219 za.za_first_integer, FTAG, &ds)) { |
| 5094 | 220 rw_exit(&dp->dp_config_rwlock); |
| 221 break; | |
| 222 } | |
| 223 | |
| 224 strval = kmem_alloc( | |
| 225 MAXNAMELEN + strlen(MOS_DIR_NAME) + 1, | |
| 226 KM_SLEEP); | |
| 227 dsl_dataset_name(ds, strval); | |
|
6689
47572a2f5e73
6610506 Eliminate or improve retry logic from callers of dmu_objset_open()
maybee
parents:
6673
diff
changeset
|
228 dsl_dataset_rele(ds, FTAG); |
| 5094 | 229 rw_exit(&dp->dp_config_rwlock); |
| 230 } else { | |
| 231 strval = NULL; | |
| 232 intval = za.za_first_integer; | |
| 233 } | |
| 234 | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
235 spa_prop_add_list(*nvp, prop, strval, intval, src); |
| 5094 | 236 |
| 237 if (strval != NULL) | |
| 238 kmem_free(strval, | |
| 239 MAXNAMELEN + strlen(MOS_DIR_NAME) + 1); | |
| 240 | |
| 241 break; | |
| 242 | |
| 243 case 1: | |
| 244 /* string property */ | |
| 245 strval = kmem_alloc(za.za_num_integers, KM_SLEEP); | |
| 246 err = zap_lookup(mos, spa->spa_pool_props_object, | |
| 247 za.za_name, 1, za.za_num_integers, strval); | |
| 248 if (err) { | |
| 249 kmem_free(strval, za.za_num_integers); | |
| 250 break; | |
| 251 } | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
252 spa_prop_add_list(*nvp, prop, strval, 0, src); |
| 5094 | 253 kmem_free(strval, za.za_num_integers); |
| 254 break; | |
| 255 | |
| 256 default: | |
| 257 break; | |
| 258 } | |
| 259 } | |
| 260 zap_cursor_fini(&zc); | |
| 261 mutex_exit(&spa->spa_props_lock); | |
| 262 out: | |
| 263 if (err && err != ENOENT) { | |
| 264 nvlist_free(*nvp); | |
|
5949
02e692d1cb28
6654224 zfs_ioc_pool_get_props() double-frees nvlist on error
lling
parents:
5913
diff
changeset
|
265 *nvp = NULL; |
| 5094 | 266 return (err); |
| 267 } | |
| 268 | |
| 269 return (0); | |
| 270 } | |
| 271 | |
| 272 /* | |
| 273 * Validate the given pool properties nvlist and modify the list | |
| 274 * for the property values to be set. | |
| 275 */ | |
| 276 static int | |
| 277 spa_prop_validate(spa_t *spa, nvlist_t *props) | |
| 278 { | |
| 279 nvpair_t *elem; | |
| 280 int error = 0, reset_bootfs = 0; | |
| 281 uint64_t objnum; | |
| 282 | |
| 283 elem = NULL; | |
| 284 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { | |
| 285 zpool_prop_t prop; | |
| 286 char *propname, *strval; | |
| 287 uint64_t intval; | |
| 288 objset_t *os; | |
| 5363 | 289 char *slash; |
| 5094 | 290 |
| 291 propname = nvpair_name(elem); | |
| 292 | |
| 293 if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL) | |
| 294 return (EINVAL); | |
| 295 | |
| 296 switch (prop) { | |
| 297 case ZPOOL_PROP_VERSION: | |
| 298 error = nvpair_value_uint64(elem, &intval); | |
| 299 if (!error && | |
| 300 (intval < spa_version(spa) || intval > SPA_VERSION)) | |
| 301 error = EINVAL; | |
| 302 break; | |
| 303 | |
| 304 case ZPOOL_PROP_DELEGATION: | |
| 305 case ZPOOL_PROP_AUTOREPLACE: | |
|
7538
18c2451107fd
PSARC 2008/469 Excluding snapshot info from 'zfs list'
Rich Morris <Richard.Morris@Sun.COM>
parents:
7497
diff
changeset
|
306 case ZPOOL_PROP_LISTSNAPS: |
| 5094 | 307 error = nvpair_value_uint64(elem, &intval); |
| 308 if (!error && intval > 1) | |
| 309 error = EINVAL; | |
| 310 break; | |
| 311 | |
| 312 case ZPOOL_PROP_BOOTFS: | |
| 313 if (spa_version(spa) < SPA_VERSION_BOOTFS) { | |
| 314 error = ENOTSUP; | |
| 315 break; | |
| 316 } | |
| 317 | |
| 318 /* | |
|
7042
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
319 * Make sure the vdev config is bootable |
| 5094 | 320 */ |
|
7042
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
321 if (!vdev_is_bootable(spa->spa_root_vdev)) { |
| 5094 | 322 error = ENOTSUP; |
| 323 break; | |
| 324 } | |
| 325 | |
| 326 reset_bootfs = 1; | |
| 327 | |
| 328 error = nvpair_value_string(elem, &strval); | |
| 329 | |
| 330 if (!error) { | |
|
7042
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
331 uint64_t compress; |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
332 |
| 5094 | 333 if (strval == NULL || strval[0] == '\0') { |
| 334 objnum = zpool_prop_default_numeric( | |
| 335 ZPOOL_PROP_BOOTFS); | |
| 336 break; | |
| 337 } | |
| 338 | |
| 339 if (error = dmu_objset_open(strval, DMU_OST_ZFS, | |
|
6689
47572a2f5e73
6610506 Eliminate or improve retry logic from callers of dmu_objset_open()
maybee
parents:
6673
diff
changeset
|
340 DS_MODE_USER | DS_MODE_READONLY, &os)) |
| 5094 | 341 break; |
|
7042
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
342 |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
343 /* We don't support gzip bootable datasets */ |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
344 if ((error = dsl_prop_get_integer(strval, |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
345 zfs_prop_to_name(ZFS_PROP_COMPRESSION), |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
346 &compress, NULL)) == 0 && |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
347 !BOOTFS_COMPRESS_VALID(compress)) { |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
348 error = ENOTSUP; |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
349 } else { |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
350 objnum = dmu_objset_id(os); |
|
46fc4b6db23e
6721094 Setting certain properties on root pools should not be allowed
gw25295
parents:
6995
diff
changeset
|
351 } |
| 5094 | 352 dmu_objset_close(os); |
| 353 } | |
| 354 break; | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
355 |
| 5329 | 356 case ZPOOL_PROP_FAILUREMODE: |
| 357 error = nvpair_value_uint64(elem, &intval); | |
| 358 if (!error && (intval < ZIO_FAILURE_MODE_WAIT || | |
| 359 intval > ZIO_FAILURE_MODE_PANIC)) | |
| 360 error = EINVAL; | |
| 361 | |
| 362 /* | |
| 363 * This is a special case which only occurs when | |
| 364 * the pool has completely failed. This allows | |
| 365 * the user to change the in-core failmode property | |
| 366 * without syncing it out to disk (I/Os might | |
| 367 * currently be blocked). We do this by returning | |
| 368 * EIO to the caller (spa_prop_set) to trick it | |
| 369 * into thinking we encountered a property validation | |
| 370 * error. | |
| 371 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
372 if (!error && spa_suspended(spa)) { |
| 5329 | 373 spa->spa_failmode = intval; |
| 374 error = EIO; | |
| 375 } | |
| 376 break; | |
| 5363 | 377 |
| 378 case ZPOOL_PROP_CACHEFILE: | |
| 379 if ((error = nvpair_value_string(elem, &strval)) != 0) | |
| 380 break; | |
| 381 | |
| 382 if (strval[0] == '\0') | |
| 383 break; | |
| 384 | |
| 385 if (strcmp(strval, "none") == 0) | |
| 386 break; | |
| 387 | |
| 388 if (strval[0] != '/') { | |
| 389 error = EINVAL; | |
| 390 break; | |
| 391 } | |
| 392 | |
| 393 slash = strrchr(strval, '/'); | |
| 394 ASSERT(slash != NULL); | |
| 395 | |
| 396 if (slash[1] == '\0' || strcmp(slash, "/.") == 0 || | |
| 397 strcmp(slash, "/..") == 0) | |
| 398 error = EINVAL; | |
| 399 break; | |
| 5094 | 400 } |
| 401 | |
| 402 if (error) | |
| 403 break; | |
| 404 } | |
| 405 | |
| 406 if (!error && reset_bootfs) { | |
| 407 error = nvlist_remove(props, | |
| 408 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING); | |
| 409 | |
| 410 if (!error) { | |
| 411 error = nvlist_add_uint64(props, | |
| 412 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum); | |
| 413 } | |
| 414 } | |
| 415 | |
| 416 return (error); | |
| 417 } | |
| 418 | |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
419 void |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
420 spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
421 { |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
422 char *cachefile; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
423 spa_config_dirent_t *dp; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
424 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
425 if (nvlist_lookup_string(nvp, zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
426 &cachefile) != 0) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
427 return; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
428 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
429 dp = kmem_alloc(sizeof (spa_config_dirent_t), |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
430 KM_SLEEP); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
431 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
432 if (cachefile[0] == '\0') |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
433 dp->scd_path = spa_strdup(spa_config_path); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
434 else if (strcmp(cachefile, "none") == 0) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
435 dp->scd_path = NULL; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
436 else |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
437 dp->scd_path = spa_strdup(cachefile); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
438 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
439 list_insert_head(&spa->spa_config_list, dp); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
440 if (need_sync) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
441 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
442 } |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
443 |
| 5094 | 444 int |
| 445 spa_prop_set(spa_t *spa, nvlist_t *nvp) | |
| 446 { | |
| 447 int error; | |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
448 nvpair_t *elem; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
449 boolean_t need_sync = B_FALSE; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
450 zpool_prop_t prop; |
| 5094 | 451 |
| 452 if ((error = spa_prop_validate(spa, nvp)) != 0) | |
| 453 return (error); | |
| 454 | |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
455 elem = NULL; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
456 while ((elem = nvlist_next_nvpair(nvp, elem)) != NULL) { |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
457 if ((prop = zpool_name_to_prop( |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
458 nvpair_name(elem))) == ZPROP_INVAL) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
459 return (EINVAL); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
460 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
461 if (prop == ZPOOL_PROP_CACHEFILE || prop == ZPOOL_PROP_ALTROOT) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
462 continue; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
463 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
464 need_sync = B_TRUE; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
465 break; |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
466 } |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
467 |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
468 if (need_sync) |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
469 return (dsl_sync_task_do(spa_get_dsl(spa), NULL, spa_sync_props, |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
470 spa, nvp, 3)); |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
471 else |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
472 return (0); |
| 5094 | 473 } |
| 474 | |
| 475 /* | |
| 476 * If the bootfs property value is dsobj, clear it. | |
| 477 */ | |
| 478 void | |
| 479 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx) | |
| 480 { | |
| 481 if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) { | |
| 482 VERIFY(zap_remove(spa->spa_meta_objset, | |
| 483 spa->spa_pool_props_object, | |
| 484 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0); | |
| 485 spa->spa_bootfs = 0; | |
| 486 } | |
| 487 } | |
| 488 | |
| 789 | 489 /* |
| 490 * ========================================================================== | |
| 491 * SPA state manipulation (open/create/destroy/import/export) | |
| 492 * ========================================================================== | |
| 493 */ | |
| 494 | |
| 1544 | 495 static int |
| 496 spa_error_entry_compare(const void *a, const void *b) | |
| 497 { | |
| 498 spa_error_entry_t *sa = (spa_error_entry_t *)a; | |
| 499 spa_error_entry_t *sb = (spa_error_entry_t *)b; | |
| 500 int ret; | |
| 501 | |
| 502 ret = bcmp(&sa->se_bookmark, &sb->se_bookmark, | |
| 503 sizeof (zbookmark_t)); | |
| 504 | |
| 505 if (ret < 0) | |
| 506 return (-1); | |
| 507 else if (ret > 0) | |
| 508 return (1); | |
| 509 else | |
| 510 return (0); | |
| 511 } | |
| 512 | |
| 513 /* | |
| 514 * Utility function which retrieves copies of the current logs and | |
| 515 * re-initializes them in the process. | |
| 516 */ | |
| 517 void | |
| 518 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub) | |
| 519 { | |
| 520 ASSERT(MUTEX_HELD(&spa->spa_errlist_lock)); | |
| 521 | |
| 522 bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t)); | |
| 523 bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t)); | |
| 524 | |
| 525 avl_create(&spa->spa_errlist_scrub, | |
| 526 spa_error_entry_compare, sizeof (spa_error_entry_t), | |
| 527 offsetof(spa_error_entry_t, se_avl)); | |
| 528 avl_create(&spa->spa_errlist_last, | |
| 529 spa_error_entry_compare, sizeof (spa_error_entry_t), | |
| 530 offsetof(spa_error_entry_t, se_avl)); | |
| 531 } | |
| 532 | |
| 789 | 533 /* |
| 534 * Activate an uninitialized pool. | |
| 535 */ | |
| 536 static void | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
537 spa_activate(spa_t *spa, int mode) |
| 789 | 538 { |
| 539 ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED); | |
| 540 | |
| 541 spa->spa_state = POOL_STATE_ACTIVE; | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
542 spa->spa_mode = mode; |
| 789 | 543 |
| 544 spa->spa_normal_class = metaslab_class_create(); | |
| 4527 | 545 spa->spa_log_class = metaslab_class_create(); |
| 789 | 546 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
547 for (int t = 0; t < ZIO_TYPES; t++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
548 for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
549 spa->spa_zio_taskq[t][q] = taskq_create("spa_zio", |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
550 zio_taskq_threads[t][q], maxclsyspri, 50, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
551 INT_MAX, TASKQ_PREPOPULATE); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
552 } |
| 789 | 553 } |
| 554 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
555 list_create(&spa->spa_config_dirty_list, sizeof (vdev_t), |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
556 offsetof(vdev_t, vdev_config_dirty_node)); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
557 list_create(&spa->spa_state_dirty_list, sizeof (vdev_t), |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
558 offsetof(vdev_t, vdev_state_dirty_node)); |
| 789 | 559 |
| 560 txg_list_create(&spa->spa_vdev_txg_list, | |
| 561 offsetof(struct vdev, vdev_txg_node)); | |
| 1544 | 562 |
| 563 avl_create(&spa->spa_errlist_scrub, | |
| 564 spa_error_entry_compare, sizeof (spa_error_entry_t), | |
| 565 offsetof(spa_error_entry_t, se_avl)); | |
| 566 avl_create(&spa->spa_errlist_last, | |
| 567 spa_error_entry_compare, sizeof (spa_error_entry_t), | |
| 568 offsetof(spa_error_entry_t, se_avl)); | |
| 789 | 569 } |
| 570 | |
| 571 /* | |
| 572 * Opposite of spa_activate(). | |
| 573 */ | |
| 574 static void | |
| 575 spa_deactivate(spa_t *spa) | |
| 576 { | |
| 577 ASSERT(spa->spa_sync_on == B_FALSE); | |
| 578 ASSERT(spa->spa_dsl_pool == NULL); | |
| 579 ASSERT(spa->spa_root_vdev == NULL); | |
| 580 | |
| 581 ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED); | |
| 582 | |
| 583 txg_list_destroy(&spa->spa_vdev_txg_list); | |
| 584 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
585 list_destroy(&spa->spa_config_dirty_list); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
586 list_destroy(&spa->spa_state_dirty_list); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
587 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
588 for (int t = 0; t < ZIO_TYPES; t++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
589 for (int q = 0; q < ZIO_TASKQ_TYPES; q++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
590 taskq_destroy(spa->spa_zio_taskq[t][q]); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
591 spa->spa_zio_taskq[t][q] = NULL; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
592 } |
| 789 | 593 } |
| 594 | |
| 595 metaslab_class_destroy(spa->spa_normal_class); | |
| 596 spa->spa_normal_class = NULL; | |
| 597 | |
| 4527 | 598 metaslab_class_destroy(spa->spa_log_class); |
| 599 spa->spa_log_class = NULL; | |
| 600 | |
| 1544 | 601 /* |
| 602 * If this was part of an import or the open otherwise failed, we may | |
| 603 * still have errors left in the queues. Empty them just in case. | |
| 604 */ | |
| 605 spa_errlog_drain(spa); | |
| 606 | |
| 607 avl_destroy(&spa->spa_errlist_scrub); | |
| 608 avl_destroy(&spa->spa_errlist_last); | |
| 609 | |
| 789 | 610 spa->spa_state = POOL_STATE_UNINITIALIZED; |
| 611 } | |
| 612 | |
| 613 /* | |
| 614 * Verify a pool configuration, and construct the vdev tree appropriately. This | |
| 615 * will create all the necessary vdevs in the appropriate layout, with each vdev | |
| 616 * in the CLOSED state. This will prep the pool before open/creation/import. | |
| 617 * All vdev validation is done by the vdev_alloc() routine. | |
| 618 */ | |
| 2082 | 619 static int |
| 620 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, | |
| 621 uint_t id, int atype) | |
| 789 | 622 { |
| 623 nvlist_t **child; | |
| 624 uint_t c, children; | |
| 2082 | 625 int error; |
| 626 | |
| 627 if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0) | |
| 628 return (error); | |
| 629 | |
| 630 if ((*vdp)->vdev_ops->vdev_op_leaf) | |
| 631 return (0); | |
| 789 | 632 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
633 error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
634 &child, &children); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
635 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
636 if (error == ENOENT) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
637 return (0); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
638 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
639 if (error) { |
| 2082 | 640 vdev_free(*vdp); |
| 641 *vdp = NULL; | |
| 642 return (EINVAL); | |
| 789 | 643 } |
| 644 | |
| 645 for (c = 0; c < children; c++) { | |
| 2082 | 646 vdev_t *vd; |
| 647 if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c, | |
| 648 atype)) != 0) { | |
| 649 vdev_free(*vdp); | |
| 650 *vdp = NULL; | |
| 651 return (error); | |
| 789 | 652 } |
| 653 } | |
| 654 | |
| 2082 | 655 ASSERT(*vdp != NULL); |
| 656 | |
| 657 return (0); | |
| 789 | 658 } |
| 659 | |
| 660 /* | |
| 661 * Opposite of spa_load(). | |
| 662 */ | |
| 663 static void | |
| 664 spa_unload(spa_t *spa) | |
| 665 { | |
| 2082 | 666 int i; |
| 667 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
668 ASSERT(MUTEX_HELD(&spa_namespace_lock)); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
669 |
| 789 | 670 /* |
| 1544 | 671 * Stop async tasks. |
| 672 */ | |
| 673 spa_async_suspend(spa); | |
| 674 | |
| 675 /* | |
| 789 | 676 * Stop syncing. |
| 677 */ | |
| 678 if (spa->spa_sync_on) { | |
| 679 txg_sync_stop(spa->spa_dsl_pool); | |
| 680 spa->spa_sync_on = B_FALSE; | |
| 681 } | |
| 682 | |
| 683 /* | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
684 * Wait for any outstanding async I/O to complete. |
| 789 | 685 */ |
|
9234
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
686 if (spa->spa_async_zio_root != NULL) { |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
687 (void) zio_wait(spa->spa_async_zio_root); |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
688 spa->spa_async_zio_root = NULL; |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
689 } |
| 789 | 690 |
| 691 /* | |
| 692 * Close the dsl pool. | |
| 693 */ | |
| 694 if (spa->spa_dsl_pool) { | |
| 695 dsl_pool_close(spa->spa_dsl_pool); | |
| 696 spa->spa_dsl_pool = NULL; | |
| 697 } | |
| 698 | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
699 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
700 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
701 /* |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
702 * Drop and purge level 2 cache |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
703 */ |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
704 spa_l2cache_drop(spa); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
705 |
| 789 | 706 /* |
| 707 * Close all vdevs. | |
| 708 */ | |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
709 if (spa->spa_root_vdev) |
| 789 | 710 vdev_free(spa->spa_root_vdev); |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
711 ASSERT(spa->spa_root_vdev == NULL); |
| 1544 | 712 |
| 5450 | 713 for (i = 0; i < spa->spa_spares.sav_count; i++) |
| 714 vdev_free(spa->spa_spares.sav_vdevs[i]); | |
| 715 if (spa->spa_spares.sav_vdevs) { | |
| 716 kmem_free(spa->spa_spares.sav_vdevs, | |
| 717 spa->spa_spares.sav_count * sizeof (void *)); | |
| 718 spa->spa_spares.sav_vdevs = NULL; | |
| 719 } | |
| 720 if (spa->spa_spares.sav_config) { | |
| 721 nvlist_free(spa->spa_spares.sav_config); | |
| 722 spa->spa_spares.sav_config = NULL; | |
| 2082 | 723 } |
|
7377
2afc6772d754
6739314 failed log devices in a pool with spares causes panic on load
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
7361
diff
changeset
|
724 spa->spa_spares.sav_count = 0; |
| 5450 | 725 |
| 726 for (i = 0; i < spa->spa_l2cache.sav_count; i++) | |
| 727 vdev_free(spa->spa_l2cache.sav_vdevs[i]); | |
| 728 if (spa->spa_l2cache.sav_vdevs) { | |
| 729 kmem_free(spa->spa_l2cache.sav_vdevs, | |
| 730 spa->spa_l2cache.sav_count * sizeof (void *)); | |
| 731 spa->spa_l2cache.sav_vdevs = NULL; | |
| 732 } | |
| 733 if (spa->spa_l2cache.sav_config) { | |
| 734 nvlist_free(spa->spa_l2cache.sav_config); | |
| 735 spa->spa_l2cache.sav_config = NULL; | |
| 2082 | 736 } |
|
7377
2afc6772d754
6739314 failed log devices in a pool with spares causes panic on load
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
7361
diff
changeset
|
737 spa->spa_l2cache.sav_count = 0; |
| 2082 | 738 |
| 1544 | 739 spa->spa_async_suspended = 0; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
740 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
741 spa_config_exit(spa, SCL_ALL, FTAG); |
| 789 | 742 } |
| 743 | |
| 744 /* | |
| 2082 | 745 * Load (or re-load) the current list of vdevs describing the active spares for |
| 746 * this pool. When this is called, we have some form of basic information in | |
| 5450 | 747 * 'spa_spares.sav_config'. We parse this into vdevs, try to open them, and |
| 748 * then re-generate a more complete list including status information. | |
| 2082 | 749 */ |
| 750 static void | |
| 751 spa_load_spares(spa_t *spa) | |
| 752 { | |
| 753 nvlist_t **spares; | |
| 754 uint_t nspares; | |
| 755 int i; | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
756 vdev_t *vd, *tvd; |
| 2082 | 757 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
758 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
759 |
| 2082 | 760 /* |
| 761 * First, close and free any existing spare vdevs. | |
| 762 */ | |
| 5450 | 763 for (i = 0; i < spa->spa_spares.sav_count; i++) { |
| 764 vd = spa->spa_spares.sav_vdevs[i]; | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
765 |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
766 /* Undo the call to spa_activate() below */ |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
767 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
768 B_FALSE)) != NULL && tvd->vdev_isspare) |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
769 spa_spare_remove(tvd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
770 vdev_close(vd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
771 vdev_free(vd); |
| 2082 | 772 } |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
773 |
| 5450 | 774 if (spa->spa_spares.sav_vdevs) |
| 775 kmem_free(spa->spa_spares.sav_vdevs, | |
| 776 spa->spa_spares.sav_count * sizeof (void *)); | |
| 777 | |
| 778 if (spa->spa_spares.sav_config == NULL) | |
| 2082 | 779 nspares = 0; |
| 780 else | |
| 5450 | 781 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, |
| 2082 | 782 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); |
| 783 | |
| 5450 | 784 spa->spa_spares.sav_count = (int)nspares; |
| 785 spa->spa_spares.sav_vdevs = NULL; | |
| 2082 | 786 |
| 787 if (nspares == 0) | |
| 788 return; | |
| 789 | |
| 790 /* | |
| 791 * Construct the array of vdevs, opening them to get status in the | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
792 * process. For each spare, there is potentially two different vdev_t |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
793 * structures associated with it: one in the list of spares (used only |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
794 * for basic validation purposes) and one in the active vdev |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
795 * configuration (if it's spared in). During this phase we open and |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
796 * validate each vdev on the spare list. If the vdev also exists in the |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
797 * active configuration, then we also mark this vdev as an active spare. |
| 2082 | 798 */ |
| 5450 | 799 spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *), |
| 800 KM_SLEEP); | |
| 801 for (i = 0; i < spa->spa_spares.sav_count; i++) { | |
| 2082 | 802 VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0, |
| 803 VDEV_ALLOC_SPARE) == 0); | |
| 804 ASSERT(vd != NULL); | |
| 805 | |
| 5450 | 806 spa->spa_spares.sav_vdevs[i] = vd; |
| 2082 | 807 |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
808 if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid, |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
809 B_FALSE)) != NULL) { |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
810 if (!tvd->vdev_isspare) |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
811 spa_spare_add(tvd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
812 |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
813 /* |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
814 * We only mark the spare active if we were successfully |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
815 * able to load the vdev. Otherwise, importing a pool |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
816 * with a bad active spare would result in strange |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
817 * behavior, because multiple pool would think the spare |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
818 * is actively in use. |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
819 * |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
820 * There is a vulnerability here to an equally bizarre |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
821 * circumstance, where a dead active spare is later |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
822 * brought back to life (onlined or otherwise). Given |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
823 * the rarity of this scenario, and the extra complexity |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
824 * it adds, we ignore the possibility. |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
825 */ |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
826 if (!vdev_is_dead(tvd)) |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
827 spa_spare_activate(tvd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
828 } |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
829 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
830 vd->vdev_top = vd; |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
831 vd->vdev_aux = &spa->spa_spares; |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
832 |
| 2082 | 833 if (vdev_open(vd) != 0) |
| 834 continue; | |
| 835 | |
| 5450 | 836 if (vdev_validate_aux(vd) == 0) |
| 837 spa_spare_add(vd); | |
| 2082 | 838 } |
| 839 | |
| 840 /* | |
| 841 * Recompute the stashed list of spares, with status information | |
| 842 * this time. | |
| 843 */ | |
| 5450 | 844 VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES, |
| 2082 | 845 DATA_TYPE_NVLIST_ARRAY) == 0); |
| 846 | |
| 5450 | 847 spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *), |
| 848 KM_SLEEP); | |
| 849 for (i = 0; i < spa->spa_spares.sav_count; i++) | |
| 850 spares[i] = vdev_config_generate(spa, | |
| 851 spa->spa_spares.sav_vdevs[i], B_TRUE, B_TRUE, B_FALSE); | |
| 852 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, | |
| 853 ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0); | |
| 854 for (i = 0; i < spa->spa_spares.sav_count; i++) | |
| 2082 | 855 nvlist_free(spares[i]); |
| 5450 | 856 kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *)); |
| 857 } | |
| 858 | |
| 859 /* | |
| 860 * Load (or re-load) the current list of vdevs describing the active l2cache for | |
| 861 * this pool. When this is called, we have some form of basic information in | |
| 862 * 'spa_l2cache.sav_config'. We parse this into vdevs, try to open them, and | |
| 863 * then re-generate a more complete list including status information. | |
| 864 * Devices which are already active have their details maintained, and are | |
| 865 * not re-opened. | |
| 866 */ | |
| 867 static void | |
| 868 spa_load_l2cache(spa_t *spa) | |
| 869 { | |
| 870 nvlist_t **l2cache; | |
| 871 uint_t nl2cache; | |
| 872 int i, j, oldnvdevs; | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
873 uint64_t guid, size; |
| 5450 | 874 vdev_t *vd, **oldvdevs, **newvdevs; |
| 875 spa_aux_vdev_t *sav = &spa->spa_l2cache; | |
| 876 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
877 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
878 |
| 5450 | 879 if (sav->sav_config != NULL) { |
| 880 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, | |
| 881 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); | |
| 882 newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP); | |
| 883 } else { | |
| 884 nl2cache = 0; | |
| 885 } | |
| 886 | |
| 887 oldvdevs = sav->sav_vdevs; | |
| 888 oldnvdevs = sav->sav_count; | |
| 889 sav->sav_vdevs = NULL; | |
| 890 sav->sav_count = 0; | |
| 891 | |
| 892 /* | |
| 893 * Process new nvlist of vdevs. | |
| 894 */ | |
| 895 for (i = 0; i < nl2cache; i++) { | |
| 896 VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID, | |
| 897 &guid) == 0); | |
| 898 | |
| 899 newvdevs[i] = NULL; | |
| 900 for (j = 0; j < oldnvdevs; j++) { | |
| 901 vd = oldvdevs[j]; | |
| 902 if (vd != NULL && guid == vd->vdev_guid) { | |
| 903 /* | |
| 904 * Retain previous vdev for add/remove ops. | |
| 905 */ | |
| 906 newvdevs[i] = vd; | |
| 907 oldvdevs[j] = NULL; | |
| 908 break; | |
| 909 } | |
| 910 } | |
| 911 | |
| 912 if (newvdevs[i] == NULL) { | |
| 913 /* | |
| 914 * Create new vdev | |
| 915 */ | |
| 916 VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0, | |
| 917 VDEV_ALLOC_L2CACHE) == 0); | |
| 918 ASSERT(vd != NULL); | |
| 919 newvdevs[i] = vd; | |
| 920 | |
| 921 /* | |
| 922 * Commit this vdev as an l2cache device, | |
| 923 * even if it fails to open. | |
| 924 */ | |
| 925 spa_l2cache_add(vd); | |
| 926 | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
927 vd->vdev_top = vd; |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
928 vd->vdev_aux = sav; |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
929 |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
930 spa_l2cache_activate(vd); |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
931 |
| 5450 | 932 if (vdev_open(vd) != 0) |
| 933 continue; | |
| 934 | |
| 935 (void) vdev_validate_aux(vd); | |
| 936 | |
| 937 if (!vdev_is_dead(vd)) { | |
| 938 size = vdev_get_rsize(vd); | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
939 l2arc_add_vdev(spa, vd, |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
940 VDEV_LABEL_START_SIZE, |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
941 size - VDEV_LABEL_START_SIZE); |
| 5450 | 942 } |
| 943 } | |
| 944 } | |
| 945 | |
| 946 /* | |
| 947 * Purge vdevs that were dropped | |
| 948 */ | |
| 949 for (i = 0; i < oldnvdevs; i++) { | |
| 950 uint64_t pool; | |
| 951 | |
| 952 vd = oldvdevs[i]; | |
| 953 if (vd != NULL) { | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
954 if (spa_l2cache_exists(vd->vdev_guid, &pool) && |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
955 pool != 0ULL && l2arc_vdev_present(vd)) |
| 5450 | 956 l2arc_remove_vdev(vd); |
| 957 (void) vdev_close(vd); | |
| 958 spa_l2cache_remove(vd); | |
| 959 } | |
| 960 } | |
| 961 | |
| 962 if (oldvdevs) | |
| 963 kmem_free(oldvdevs, oldnvdevs * sizeof (void *)); | |
| 964 | |
| 965 if (sav->sav_config == NULL) | |
| 966 goto out; | |
| 967 | |
| 968 sav->sav_vdevs = newvdevs; | |
| 969 sav->sav_count = (int)nl2cache; | |
| 970 | |
| 971 /* | |
| 972 * Recompute the stashed list of l2cache devices, with status | |
| 973 * information this time. | |
| 974 */ | |
| 975 VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE, | |
| 976 DATA_TYPE_NVLIST_ARRAY) == 0); | |
| 977 | |
| 978 l2cache = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); | |
| 979 for (i = 0; i < sav->sav_count; i++) | |
| 980 l2cache[i] = vdev_config_generate(spa, | |
| 981 sav->sav_vdevs[i], B_TRUE, B_FALSE, B_TRUE); | |
| 982 VERIFY(nvlist_add_nvlist_array(sav->sav_config, | |
| 983 ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0); | |
| 984 out: | |
| 985 for (i = 0; i < sav->sav_count; i++) | |
| 986 nvlist_free(l2cache[i]); | |
| 987 if (sav->sav_count) | |
| 988 kmem_free(l2cache, sav->sav_count * sizeof (void *)); | |
| 2082 | 989 } |
| 990 | |
| 991 static int | |
| 992 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value) | |
| 993 { | |
| 994 dmu_buf_t *db; | |
| 995 char *packed = NULL; | |
| 996 size_t nvsize = 0; | |
| 997 int error; | |
| 998 *value = NULL; | |
| 999 | |
| 1000 VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); | |
| 1001 nvsize = *(uint64_t *)db->db_data; | |
| 1002 dmu_buf_rele(db, FTAG); | |
| 1003 | |
| 1004 packed = kmem_alloc(nvsize, KM_SLEEP); | |
| 1005 error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed); | |
| 1006 if (error == 0) | |
| 1007 error = nvlist_unpack(packed, nvsize, value, 0); | |
| 1008 kmem_free(packed, nvsize); | |
| 1009 | |
| 1010 return (error); | |
| 1011 } | |
| 1012 | |
| 1013 /* | |
| 4451 | 1014 * Checks to see if the given vdev could not be opened, in which case we post a |
| 1015 * sysevent to notify the autoreplace code that the device has been removed. | |
| 1016 */ | |
| 1017 static void | |
| 1018 spa_check_removed(vdev_t *vd) | |
| 1019 { | |
| 1020 int c; | |
| 1021 | |
| 1022 for (c = 0; c < vd->vdev_children; c++) | |
| 1023 spa_check_removed(vd->vdev_child[c]); | |
| 1024 | |
| 1025 if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd)) { | |
| 1026 zfs_post_autoreplace(vd->vdev_spa, vd); | |
| 1027 spa_event_notify(vd->vdev_spa, vd, ESC_ZFS_VDEV_CHECK); | |
| 1028 } | |
| 1029 } | |
| 1030 | |
| 1031 /* | |
| 7294 | 1032 * Check for missing log devices |
| 1033 */ | |
| 1034 int | |
| 1035 spa_check_logs(spa_t *spa) | |
| 1036 { | |
| 1037 switch (spa->spa_log_state) { | |
| 1038 case SPA_LOG_MISSING: | |
| 1039 /* need to recheck in case slog has been restored */ | |
| 1040 case SPA_LOG_UNKNOWN: | |
| 1041 if (dmu_objset_find(spa->spa_name, zil_check_log_chain, NULL, | |
| 1042 DS_FIND_CHILDREN)) { | |
| 1043 spa->spa_log_state = SPA_LOG_MISSING; | |
| 1044 return (1); | |
| 1045 } | |
| 1046 break; | |
| 1047 | |
| 1048 case SPA_LOG_CLEAR: | |
| 1049 (void) dmu_objset_find(spa->spa_name, zil_clear_log_chain, NULL, | |
| 1050 DS_FIND_CHILDREN); | |
| 1051 break; | |
| 1052 } | |
| 1053 spa->spa_log_state = SPA_LOG_GOOD; | |
| 1054 return (0); | |
| 1055 } | |
| 1056 | |
| 1057 /* | |
| 789 | 1058 * Load an existing storage pool, using the pool's builtin spa_config as a |
| 1544 | 1059 * source of configuration information. |
| 789 | 1060 */ |
| 1061 static int | |
| 1544 | 1062 spa_load(spa_t *spa, nvlist_t *config, spa_load_state_t state, int mosconfig) |
| 789 | 1063 { |
| 1064 int error = 0; | |
| 1065 nvlist_t *nvroot = NULL; | |
| 1066 vdev_t *rvd; | |
| 1067 uberblock_t *ub = &spa->spa_uberblock; | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1068 uint64_t config_cache_txg = spa->spa_config_txg; |
| 789 | 1069 uint64_t pool_guid; |
| 2082 | 1070 uint64_t version; |
| 4451 | 1071 uint64_t autoreplace = 0; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1072 int orig_mode = spa->spa_mode; |
| 7294 | 1073 char *ereport = FM_EREPORT_ZFS_POOL; |
| 789 | 1074 |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1075 /* |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1076 * If this is an untrusted config, access the pool in read-only mode. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1077 * This prevents things like resilvering recently removed devices. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1078 */ |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1079 if (!mosconfig) |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1080 spa->spa_mode = FREAD; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1081 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1082 ASSERT(MUTEX_HELD(&spa_namespace_lock)); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1083 |
| 1544 | 1084 spa->spa_load_state = state; |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1085 |
| 789 | 1086 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot) || |
| 1733 | 1087 nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) { |
| 1544 | 1088 error = EINVAL; |
| 1089 goto out; | |
| 1090 } | |
| 789 | 1091 |
| 2082 | 1092 /* |
| 1093 * Versioning wasn't explicitly added to the label until later, so if | |
| 1094 * it's not present treat it as the initial version. | |
| 1095 */ | |
| 1096 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &version) != 0) | |
| 4577 | 1097 version = SPA_VERSION_INITIAL; |
| 2082 | 1098 |
| 1733 | 1099 (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, |
| 1100 &spa->spa_config_txg); | |
| 1101 | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1102 if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) && |
| 1544 | 1103 spa_guid_exists(pool_guid, 0)) { |
| 1104 error = EEXIST; | |
| 1105 goto out; | |
| 1106 } | |
| 789 | 1107 |
|
2174
73de7a781492
6433717 offline devices should not be marked persistently unavailble
eschrock
parents:
2082
diff
changeset
|
1108 spa->spa_load_guid = pool_guid; |
|
73de7a781492
6433717 offline devices should not be marked persistently unavailble
eschrock
parents:
2082
diff
changeset
|
1109 |
| 789 | 1110 /* |
|
9234
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1111 * Create "The Godfather" zio to hold all async IOs |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1112 */ |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1113 if (spa->spa_async_zio_root == NULL) |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1114 spa->spa_async_zio_root = zio_root(spa, NULL, NULL, |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1115 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1116 ZIO_FLAG_GODFATHER); |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1117 |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
1118 /* |
| 2082 | 1119 * Parse the configuration into a vdev tree. We explicitly set the |
| 1120 * value that will be returned by spa_version() since parsing the | |
| 1121 * configuration requires knowing the version number. | |
| 789 | 1122 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1123 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 2082 | 1124 spa->spa_ubsync.ub_version = version; |
| 1125 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_LOAD); | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1126 spa_config_exit(spa, SCL_ALL, FTAG); |
| 789 | 1127 |
| 2082 | 1128 if (error != 0) |
| 1544 | 1129 goto out; |
| 789 | 1130 |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1131 ASSERT(spa->spa_root_vdev == rvd); |
| 789 | 1132 ASSERT(spa_guid(spa) == pool_guid); |
| 1133 | |
| 1134 /* | |
| 1135 * Try to open all vdevs, loading each label in the process. | |
| 1136 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1137 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
4070
4390ea390a1e
6386594 zdb message should be clearer when failing for lack of permissions
mc142369
parents:
3975
diff
changeset
|
1138 error = vdev_open(rvd); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1139 spa_config_exit(spa, SCL_ALL, FTAG); |
|
4070
4390ea390a1e
6386594 zdb message should be clearer when failing for lack of permissions
mc142369
parents:
3975
diff
changeset
|
1140 if (error != 0) |
| 1544 | 1141 goto out; |
| 789 | 1142 |
| 1143 /* | |
|
9276
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1144 * We need to validate the vdev labels against the configuration that |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1145 * we have in hand, which is dependent on the setting of mosconfig. If |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1146 * mosconfig is true then we're validating the vdev labels based on |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1147 * that config. Otherwise, we're validating against the cached config |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1148 * (zpool.cache) that was read when we loaded the zfs module, and then |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1149 * later we will recursively call spa_load() and validate against |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1150 * the vdev config. |
|
1986
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1151 */ |
|
9276
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1152 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1153 error = vdev_validate(rvd); |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1154 spa_config_exit(spa, SCL_ALL, FTAG); |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1155 if (error != 0) |
|
a8a7fc849933
6816124 System crash running zpool destroy on broken zpool
Mark J Musante <Mark.Musante@Sun.COM>
parents:
9234
diff
changeset
|
1156 goto out; |
|
1986
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1157 |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1158 if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) { |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1159 error = ENXIO; |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1160 goto out; |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1161 } |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1162 |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1163 /* |
| 789 | 1164 * Find the best uberblock. |
| 1165 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1166 vdev_uberblock_load(NULL, rvd, ub); |
| 789 | 1167 |
| 1168 /* | |
| 1169 * If we weren't able to find a single valid uberblock, return failure. | |
| 1170 */ | |
| 1171 if (ub->ub_txg == 0) { | |
| 1760 | 1172 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, |
| 1173 VDEV_AUX_CORRUPT_DATA); | |
| 1544 | 1174 error = ENXIO; |
| 1175 goto out; | |
| 1176 } | |
| 1177 | |
| 1178 /* | |
| 1179 * If the pool is newer than the code, we can't open it. | |
| 1180 */ | |
| 4577 | 1181 if (ub->ub_version > SPA_VERSION) { |
| 1760 | 1182 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, |
| 1183 VDEV_AUX_VERSION_NEWER); | |
| 1544 | 1184 error = ENOTSUP; |
| 1185 goto out; | |
| 789 | 1186 } |
| 1187 | |
| 1188 /* | |
| 1189 * If the vdev guid sum doesn't match the uberblock, we have an | |
| 1190 * incomplete configuration. | |
| 1191 */ | |
| 1732 | 1192 if (rvd->vdev_guid_sum != ub->ub_guid_sum && mosconfig) { |
| 1544 | 1193 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, |
| 1194 VDEV_AUX_BAD_GUID_SUM); | |
| 1195 error = ENXIO; | |
| 1196 goto out; | |
| 789 | 1197 } |
| 1198 | |
| 1199 /* | |
| 1200 * Initialize internal SPA structures. | |
| 1201 */ | |
| 1202 spa->spa_state = POOL_STATE_ACTIVE; | |
| 1203 spa->spa_ubsync = spa->spa_uberblock; | |
| 1204 spa->spa_first_txg = spa_last_synced_txg(spa) + 1; | |
| 1544 | 1205 error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool); |
| 1206 if (error) { | |
| 1207 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1208 VDEV_AUX_CORRUPT_DATA); | |
| 1209 goto out; | |
| 1210 } | |
| 789 | 1211 spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset; |
| 1212 | |
| 1544 | 1213 if (zap_lookup(spa->spa_meta_objset, |
| 789 | 1214 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, |
| 1544 | 1215 sizeof (uint64_t), 1, &spa->spa_config_object) != 0) { |
| 1216 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1217 VDEV_AUX_CORRUPT_DATA); | |
| 1218 error = EIO; | |
| 1219 goto out; | |
| 1220 } | |
| 789 | 1221 |
| 1222 if (!mosconfig) { | |
| 2082 | 1223 nvlist_t *newconfig; |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1224 uint64_t hostid; |
| 2082 | 1225 |
| 1226 if (load_nvlist(spa, spa->spa_config_object, &newconfig) != 0) { | |
| 1544 | 1227 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, |
| 1228 VDEV_AUX_CORRUPT_DATA); | |
| 1229 error = EIO; | |
| 1230 goto out; | |
| 1231 } | |
| 789 | 1232 |
|
7706
75cbbfb9ce50
6716241 Changing hostid, by moving in a new sysinit file, panics a zfs root file system
Lin Ling <Lin.Ling@Sun.COM>
parents:
7687
diff
changeset
|
1233 if (!spa_is_root(spa) && nvlist_lookup_uint64(newconfig, |
|
75cbbfb9ce50
6716241 Changing hostid, by moving in a new sysinit file, panics a zfs root file system
Lin Ling <Lin.Ling@Sun.COM>
parents:
7687
diff
changeset
|
1234 ZPOOL_CONFIG_HOSTID, &hostid) == 0) { |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1235 char *hostname; |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1236 unsigned long myhostid = 0; |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1237 |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1238 VERIFY(nvlist_lookup_string(newconfig, |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1239 ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1240 |
|
8662
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1241 #ifdef _KERNEL |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1242 myhostid = zone_get_hostid(NULL); |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1243 #else /* _KERNEL */ |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1244 /* |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1245 * We're emulating the system's hostid in userland, so |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1246 * we can't use zone_get_hostid(). |
|
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1247 */ |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1248 (void) ddi_strtoul(hw_serial, NULL, 10, &myhostid); |
|
8662
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1249 #endif /* _KERNEL */ |
|
4178
ad95fd86760b
6553537 zfs root fails to boot from a snv_63+zfsboot-pfinstall netinstall image
lling
parents:
4070
diff
changeset
|
1250 if (hostid != 0 && myhostid != 0 && |
|
8662
18153249ee93
PSARC/2008/647 Configurable Hostids for Non-Global Zones
jv227347 <Jordan.Vaughan@Sun.com>
parents:
8525
diff
changeset
|
1251 hostid != myhostid) { |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1252 cmn_err(CE_WARN, "pool '%s' could not be " |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1253 "loaded as it was last accessed by " |
|
7706
75cbbfb9ce50
6716241 Changing hostid, by moving in a new sysinit file, panics a zfs root file system
Lin Ling <Lin.Ling@Sun.COM>
parents:
7687
diff
changeset
|
1254 "another system (host: %s hostid: 0x%lx). " |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1255 "See: http://www.sun.com/msg/ZFS-8000-EY", |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1256 spa_name(spa), hostname, |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1257 (unsigned long)hostid); |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1258 error = EBADF; |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1259 goto out; |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1260 } |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1261 } |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
1262 |
| 789 | 1263 spa_config_set(spa, newconfig); |
| 1264 spa_unload(spa); | |
| 1265 spa_deactivate(spa); | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1266 spa_activate(spa, orig_mode); |
| 789 | 1267 |
| 1544 | 1268 return (spa_load(spa, newconfig, state, B_TRUE)); |
| 1269 } | |
| 1270 | |
| 1271 if (zap_lookup(spa->spa_meta_objset, | |
| 1272 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST, | |
| 1273 sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj) != 0) { | |
| 1274 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1275 VDEV_AUX_CORRUPT_DATA); | |
| 1276 error = EIO; | |
| 1277 goto out; | |
| 789 | 1278 } |
| 1279 | |
| 1544 | 1280 /* |
| 2082 | 1281 * Load the bit that tells us to use the new accounting function |
| 1282 * (raid-z deflation). If we have an older pool, this will not | |
| 1283 * be present. | |
| 1284 */ | |
| 1285 error = zap_lookup(spa->spa_meta_objset, | |
| 1286 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, | |
| 1287 sizeof (uint64_t), 1, &spa->spa_deflate); | |
| 1288 if (error != 0 && error != ENOENT) { | |
| 1289 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1290 VDEV_AUX_CORRUPT_DATA); | |
| 1291 error = EIO; | |
| 1292 goto out; | |
| 1293 } | |
| 1294 | |
| 1295 /* | |
| 1544 | 1296 * Load the persistent error log. If we have an older pool, this will |
| 1297 * not be present. | |
| 1298 */ | |
| 1299 error = zap_lookup(spa->spa_meta_objset, | |
| 1300 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_LAST, | |
| 1301 sizeof (uint64_t), 1, &spa->spa_errlog_last); | |
|
1807
35c8b566d7af
6410711 intent log blocks don't get invited to pool parties
bonwick
parents:
1775
diff
changeset
|
1302 if (error != 0 && error != ENOENT) { |
| 1544 | 1303 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, |
| 1304 VDEV_AUX_CORRUPT_DATA); | |
| 1305 error = EIO; | |
| 1306 goto out; | |
| 1307 } | |
| 1308 | |
| 1309 error = zap_lookup(spa->spa_meta_objset, | |
| 1310 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_SCRUB, | |
| 1311 sizeof (uint64_t), 1, &spa->spa_errlog_scrub); | |
| 1312 if (error != 0 && error != ENOENT) { | |
| 1313 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1314 VDEV_AUX_CORRUPT_DATA); | |
| 1315 error = EIO; | |
| 1316 goto out; | |
| 1317 } | |
| 789 | 1318 |
| 1319 /* | |
| 2926 | 1320 * Load the history object. If we have an older pool, this |
| 1321 * will not be present. | |
| 1322 */ | |
| 1323 error = zap_lookup(spa->spa_meta_objset, | |
| 1324 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_HISTORY, | |
| 1325 sizeof (uint64_t), 1, &spa->spa_history); | |
| 1326 if (error != 0 && error != ENOENT) { | |
| 1327 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1328 VDEV_AUX_CORRUPT_DATA); | |
| 1329 error = EIO; | |
| 1330 goto out; | |
| 1331 } | |
| 1332 | |
| 1333 /* | |
| 2082 | 1334 * Load any hot spares for this pool. |
| 1335 */ | |
| 1336 error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, | |
| 5450 | 1337 DMU_POOL_SPARES, sizeof (uint64_t), 1, &spa->spa_spares.sav_object); |
| 2082 | 1338 if (error != 0 && error != ENOENT) { |
| 1339 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1340 VDEV_AUX_CORRUPT_DATA); | |
| 1341 error = EIO; | |
| 1342 goto out; | |
| 1343 } | |
| 1344 if (error == 0) { | |
| 4577 | 1345 ASSERT(spa_version(spa) >= SPA_VERSION_SPARES); |
| 5450 | 1346 if (load_nvlist(spa, spa->spa_spares.sav_object, |
| 1347 &spa->spa_spares.sav_config) != 0) { | |
| 2082 | 1348 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, |
| 1349 VDEV_AUX_CORRUPT_DATA); | |
| 1350 error = EIO; | |
| 1351 goto out; | |
| 1352 } | |
| 1353 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1354 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 2082 | 1355 spa_load_spares(spa); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1356 spa_config_exit(spa, SCL_ALL, FTAG); |
| 2082 | 1357 } |
| 1358 | |
| 5450 | 1359 /* |
| 1360 * Load any level 2 ARC devices for this pool. | |
| 1361 */ | |
| 1362 error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, | |
| 1363 DMU_POOL_L2CACHE, sizeof (uint64_t), 1, | |
| 1364 &spa->spa_l2cache.sav_object); | |
| 1365 if (error != 0 && error != ENOENT) { | |
| 1366 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1367 VDEV_AUX_CORRUPT_DATA); | |
| 1368 error = EIO; | |
| 1369 goto out; | |
| 1370 } | |
| 1371 if (error == 0) { | |
| 1372 ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE); | |
| 1373 if (load_nvlist(spa, spa->spa_l2cache.sav_object, | |
| 1374 &spa->spa_l2cache.sav_config) != 0) { | |
| 1375 vdev_set_state(rvd, B_TRUE, | |
| 1376 VDEV_STATE_CANT_OPEN, | |
| 1377 VDEV_AUX_CORRUPT_DATA); | |
| 1378 error = EIO; | |
| 1379 goto out; | |
| 1380 } | |
| 1381 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1382 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 5450 | 1383 spa_load_l2cache(spa); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1384 spa_config_exit(spa, SCL_ALL, FTAG); |
| 5450 | 1385 } |
| 1386 | |
| 7294 | 1387 if (spa_check_logs(spa)) { |
| 1388 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1389 VDEV_AUX_BAD_LOG); | |
| 1390 error = ENXIO; | |
| 1391 ereport = FM_EREPORT_ZFS_LOG_REPLAY; | |
| 1392 goto out; | |
| 1393 } | |
| 1394 | |
| 1395 | |
| 5094 | 1396 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); |
| 4543 | 1397 |
| 3912 | 1398 error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT, |
| 1399 DMU_POOL_PROPS, sizeof (uint64_t), 1, &spa->spa_pool_props_object); | |
| 1400 | |
| 1401 if (error && error != ENOENT) { | |
| 1402 vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN, | |
| 1403 VDEV_AUX_CORRUPT_DATA); | |
| 1404 error = EIO; | |
| 1405 goto out; | |
| 1406 } | |
| 1407 | |
| 1408 if (error == 0) { | |
| 1409 (void) zap_lookup(spa->spa_meta_objset, | |
| 1410 spa->spa_pool_props_object, | |
| 4451 | 1411 zpool_prop_to_name(ZPOOL_PROP_BOOTFS), |
| 3912 | 1412 sizeof (uint64_t), 1, &spa->spa_bootfs); |
| 4451 | 1413 (void) zap_lookup(spa->spa_meta_objset, |
| 1414 spa->spa_pool_props_object, | |
| 1415 zpool_prop_to_name(ZPOOL_PROP_AUTOREPLACE), | |
| 1416 sizeof (uint64_t), 1, &autoreplace); | |
| 4543 | 1417 (void) zap_lookup(spa->spa_meta_objset, |
| 1418 spa->spa_pool_props_object, | |
| 1419 zpool_prop_to_name(ZPOOL_PROP_DELEGATION), | |
| 1420 sizeof (uint64_t), 1, &spa->spa_delegation); | |
| 5329 | 1421 (void) zap_lookup(spa->spa_meta_objset, |
| 1422 spa->spa_pool_props_object, | |
| 1423 zpool_prop_to_name(ZPOOL_PROP_FAILUREMODE), | |
| 1424 sizeof (uint64_t), 1, &spa->spa_failmode); | |
| 3912 | 1425 } |
| 1426 | |
| 2082 | 1427 /* |
| 4451 | 1428 * If the 'autoreplace' property is set, then post a resource notifying |
| 1429 * the ZFS DE that it should not issue any faults for unopenable | |
| 1430 * devices. We also iterate over the vdevs, and post a sysevent for any | |
| 1431 * unopenable vdevs so that the normal autoreplace handler can take | |
| 1432 * over. | |
| 1433 */ | |
|
5756
05eb4c1ff492
6585441 spa_event_notify() doesn't pass its attributes
eschrock
parents:
5688
diff
changeset
|
1434 if (autoreplace && state != SPA_LOAD_TRYIMPORT) |
| 4451 | 1435 spa_check_removed(spa->spa_root_vdev); |
| 1436 | |
| 1437 /* | |
|
1986
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1438 * Load the vdev state for all toplevel vdevs. |
| 789 | 1439 */ |
|
1986
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1440 vdev_load(rvd); |
| 789 | 1441 |
| 1442 /* | |
| 1443 * Propagate the leaf DTLs we just loaded all the way up the tree. | |
| 1444 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1445 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 789 | 1446 vdev_dtl_reassess(rvd, 0, 0, B_FALSE); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1447 spa_config_exit(spa, SCL_ALL, FTAG); |
| 789 | 1448 |
| 1449 /* | |
| 1450 * Check the state of the root vdev. If it can't be opened, it | |
| 1451 * indicates one or more toplevel vdevs are faulted. | |
| 1452 */ | |
| 1544 | 1453 if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) { |
| 1454 error = ENXIO; | |
| 1455 goto out; | |
| 1456 } | |
| 789 | 1457 |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1458 if (spa_writeable(spa)) { |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1459 dmu_tx_t *tx; |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1460 int need_update = B_FALSE; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1461 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1462 ASSERT(state != SPA_LOAD_TRYIMPORT); |
|
1601
438b928f80c7
6397197 ADVANCE_ZIL should only visit claimed-but-not-yet-replayed logs
bonwick
parents:
1585
diff
changeset
|
1463 |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1464 /* |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1465 * Claim log blocks that haven't been committed yet. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1466 * This must all happen in a single txg. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1467 */ |
|
1601
438b928f80c7
6397197 ADVANCE_ZIL should only visit claimed-but-not-yet-replayed logs
bonwick
parents:
1585
diff
changeset
|
1468 tx = dmu_tx_create_assigned(spa_get_dsl(spa), |
| 789 | 1469 spa_first_txg(spa)); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1470 (void) dmu_objset_find(spa_name(spa), |
| 2417 | 1471 zil_claim, tx, DS_FIND_CHILDREN); |
| 789 | 1472 dmu_tx_commit(tx); |
| 1473 | |
| 1474 spa->spa_sync_on = B_TRUE; | |
| 1475 txg_sync_start(spa->spa_dsl_pool); | |
| 1476 | |
| 1477 /* | |
| 1478 * Wait for all claims to sync. | |
| 1479 */ | |
| 1480 txg_wait_synced(spa->spa_dsl_pool, 0); | |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1481 |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1482 /* |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1483 * If the config cache is stale, or we have uninitialized |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1484 * metaslabs (see spa_vdev_add()), then update the config. |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1485 */ |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1486 if (config_cache_txg != spa->spa_config_txg || |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1487 state == SPA_LOAD_IMPORT) |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1488 need_update = B_TRUE; |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1489 |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1490 for (int c = 0; c < rvd->vdev_children; c++) |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1491 if (rvd->vdev_child[c]->vdev_ms_array == 0) |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1492 need_update = B_TRUE; |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1493 |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1494 /* |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1495 * Update the config cache asychronously in case we're the |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1496 * root pool, in which case the config cache isn't writable yet. |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
1497 */ |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1498 if (need_update) |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1499 spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE); |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1500 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1501 /* |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1502 * Check all DTLs to see if anything needs resilvering. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1503 */ |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1504 if (vdev_resilver_needed(rvd, NULL, NULL)) |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1505 spa_async_request(spa, SPA_ASYNC_RESILVER); |
| 789 | 1506 } |
| 1507 | |
| 1544 | 1508 error = 0; |
| 1509 out: | |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
1510 spa->spa_minref = refcount_count(&spa->spa_refcount); |
| 2082 | 1511 if (error && error != EBADF) |
| 7294 | 1512 zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0); |
| 1544 | 1513 spa->spa_load_state = SPA_LOAD_NONE; |
| 1514 spa->spa_ena = 0; | |
| 1515 | |
| 1516 return (error); | |
| 789 | 1517 } |
| 1518 | |
| 1519 /* | |
| 1520 * Pool Open/Import | |
| 1521 * | |
| 1522 * The import case is identical to an open except that the configuration is sent | |
| 1523 * down from userland, instead of grabbed from the configuration cache. For the | |
| 1524 * case of an open, the pool configuration will exist in the | |
| 4451 | 1525 * POOL_STATE_UNINITIALIZED state. |
| 789 | 1526 * |
| 1527 * The stats information (gen/count/ustats) is used to gather vdev statistics at | |
| 1528 * the same time open the pool, without having to keep around the spa_t in some | |
| 1529 * ambiguous state. | |
| 1530 */ | |
| 1531 static int | |
| 1532 spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t **config) | |
| 1533 { | |
| 1534 spa_t *spa; | |
| 1535 int error; | |
| 1536 int locked = B_FALSE; | |
| 1537 | |
| 1538 *spapp = NULL; | |
| 1539 | |
| 1540 /* | |
| 1541 * As disgusting as this is, we need to support recursive calls to this | |
| 1542 * function because dsl_dir_open() is called during spa_load(), and ends | |
| 1543 * up calling spa_open() again. The real fix is to figure out how to | |
| 1544 * avoid dsl_dir_open() calling this in the first place. | |
| 1545 */ | |
| 1546 if (mutex_owner(&spa_namespace_lock) != curthread) { | |
| 1547 mutex_enter(&spa_namespace_lock); | |
| 1548 locked = B_TRUE; | |
| 1549 } | |
| 1550 | |
| 1551 if ((spa = spa_lookup(pool)) == NULL) { | |
| 1552 if (locked) | |
| 1553 mutex_exit(&spa_namespace_lock); | |
| 1554 return (ENOENT); | |
| 1555 } | |
| 1556 if (spa->spa_state == POOL_STATE_UNINITIALIZED) { | |
| 1557 | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1558 spa_activate(spa, spa_mode_global); |
| 789 | 1559 |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1560 error = spa_load(spa, spa->spa_config, SPA_LOAD_OPEN, B_FALSE); |
| 789 | 1561 |
| 1562 if (error == EBADF) { | |
| 1563 /* | |
|
1986
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1564 * If vdev_validate() returns failure (indicated by |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1565 * EBADF), it indicates that one of the vdevs indicates |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1566 * that the pool has been exported or destroyed. If |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1567 * this is the case, the config cache is out of sync and |
|
628267397204
6424405 zpool import destroyed_pool can damage existing pool using same devices
eschrock
parents:
1807
diff
changeset
|
1568 * we should remove the pool from the namespace. |
| 789 | 1569 */ |
| 1570 spa_unload(spa); | |
| 1571 spa_deactivate(spa); | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
1572 spa_config_sync(spa, B_TRUE, B_TRUE); |
| 789 | 1573 spa_remove(spa); |
| 1574 if (locked) | |
| 1575 mutex_exit(&spa_namespace_lock); | |
| 1576 return (ENOENT); | |
| 1544 | 1577 } |
| 1578 | |
| 1579 if (error) { | |
| 789 | 1580 /* |
| 1581 * We can't open the pool, but we still have useful | |
| 1582 * information: the state of each vdev after the | |
| 1583 * attempted vdev_open(). Return this to the user. | |
| 1584 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1585 if (config != NULL && spa->spa_root_vdev != NULL) |
| 789 | 1586 *config = spa_config_generate(spa, NULL, -1ULL, |
| 1587 B_TRUE); | |
| 1588 spa_unload(spa); | |
| 1589 spa_deactivate(spa); | |
| 1544 | 1590 spa->spa_last_open_failed = B_TRUE; |
| 789 | 1591 if (locked) |
| 1592 mutex_exit(&spa_namespace_lock); | |
| 1593 *spapp = NULL; | |
| 1594 return (error); | |
| 1544 | 1595 } else { |
| 1596 spa->spa_last_open_failed = B_FALSE; | |
| 789 | 1597 } |
| 1598 } | |
| 1599 | |
| 1600 spa_open_ref(spa, tag); | |
| 4451 | 1601 |
| 789 | 1602 if (locked) |
| 1603 mutex_exit(&spa_namespace_lock); | |
| 1604 | |
| 1605 *spapp = spa; | |
| 1606 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1607 if (config != NULL) |
| 789 | 1608 *config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); |
| 1609 | |
| 1610 return (0); | |
| 1611 } | |
| 1612 | |
| 1613 int | |
| 1614 spa_open(const char *name, spa_t **spapp, void *tag) | |
| 1615 { | |
| 1616 return (spa_open_common(name, spapp, tag, NULL)); | |
| 1617 } | |
| 1618 | |
| 1544 | 1619 /* |
| 1620 * Lookup the given spa_t, incrementing the inject count in the process, | |
| 1621 * preventing it from being exported or destroyed. | |
| 1622 */ | |
| 1623 spa_t * | |
| 1624 spa_inject_addref(char *name) | |
| 1625 { | |
| 1626 spa_t *spa; | |
| 1627 | |
| 1628 mutex_enter(&spa_namespace_lock); | |
| 1629 if ((spa = spa_lookup(name)) == NULL) { | |
| 1630 mutex_exit(&spa_namespace_lock); | |
| 1631 return (NULL); | |
| 1632 } | |
| 1633 spa->spa_inject_ref++; | |
| 1634 mutex_exit(&spa_namespace_lock); | |
| 1635 | |
| 1636 return (spa); | |
| 1637 } | |
| 1638 | |
| 1639 void | |
| 1640 spa_inject_delref(spa_t *spa) | |
| 1641 { | |
| 1642 mutex_enter(&spa_namespace_lock); | |
| 1643 spa->spa_inject_ref--; | |
| 1644 mutex_exit(&spa_namespace_lock); | |
| 1645 } | |
| 1646 | |
| 5450 | 1647 /* |
| 1648 * Add spares device information to the nvlist. | |
| 1649 */ | |
| 2082 | 1650 static void |
| 1651 spa_add_spares(spa_t *spa, nvlist_t *config) | |
| 1652 { | |
| 1653 nvlist_t **spares; | |
| 1654 uint_t i, nspares; | |
| 1655 nvlist_t *nvroot; | |
| 1656 uint64_t guid; | |
| 1657 vdev_stat_t *vs; | |
| 1658 uint_t vsc; | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1659 uint64_t pool; |
| 2082 | 1660 |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1661 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1662 |
| 5450 | 1663 if (spa->spa_spares.sav_count == 0) |
| 2082 | 1664 return; |
| 1665 | |
| 1666 VERIFY(nvlist_lookup_nvlist(config, | |
| 1667 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); | |
| 5450 | 1668 VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, |
| 2082 | 1669 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); |
| 1670 if (nspares != 0) { | |
| 1671 VERIFY(nvlist_add_nvlist_array(nvroot, | |
| 1672 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); | |
| 1673 VERIFY(nvlist_lookup_nvlist_array(nvroot, | |
| 1674 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0); | |
| 1675 | |
| 1676 /* | |
| 1677 * Go through and find any spares which have since been | |
| 1678 * repurposed as an active spare. If this is the case, update | |
| 1679 * their status appropriately. | |
| 1680 */ | |
| 1681 for (i = 0; i < nspares; i++) { | |
| 1682 VERIFY(nvlist_lookup_uint64(spares[i], | |
| 1683 ZPOOL_CONFIG_GUID, &guid) == 0); | |
|
7214
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
1684 if (spa_spare_exists(guid, &pool, NULL) && |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
1685 pool != 0ULL) { |
| 2082 | 1686 VERIFY(nvlist_lookup_uint64_array( |
| 1687 spares[i], ZPOOL_CONFIG_STATS, | |
| 1688 (uint64_t **)&vs, &vsc) == 0); | |
| 1689 vs->vs_state = VDEV_STATE_CANT_OPEN; | |
| 1690 vs->vs_aux = VDEV_AUX_SPARED; | |
| 1691 } | |
| 1692 } | |
| 1693 } | |
| 1694 } | |
| 1695 | |
| 5450 | 1696 /* |
| 1697 * Add l2cache device information to the nvlist, including vdev stats. | |
| 1698 */ | |
| 1699 static void | |
| 1700 spa_add_l2cache(spa_t *spa, nvlist_t *config) | |
| 1701 { | |
| 1702 nvlist_t **l2cache; | |
| 1703 uint_t i, j, nl2cache; | |
| 1704 nvlist_t *nvroot; | |
| 1705 uint64_t guid; | |
| 1706 vdev_t *vd; | |
| 1707 vdev_stat_t *vs; | |
| 1708 uint_t vsc; | |
| 1709 | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1710 ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER)); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1711 |
| 5450 | 1712 if (spa->spa_l2cache.sav_count == 0) |
| 1713 return; | |
| 1714 | |
| 1715 VERIFY(nvlist_lookup_nvlist(config, | |
| 1716 ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); | |
| 1717 VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, | |
| 1718 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); | |
| 1719 if (nl2cache != 0) { | |
| 1720 VERIFY(nvlist_add_nvlist_array(nvroot, | |
| 1721 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); | |
| 1722 VERIFY(nvlist_lookup_nvlist_array(nvroot, | |
| 1723 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0); | |
| 1724 | |
| 1725 /* | |
| 1726 * Update level 2 cache device stats. | |
| 1727 */ | |
| 1728 | |
| 1729 for (i = 0; i < nl2cache; i++) { | |
| 1730 VERIFY(nvlist_lookup_uint64(l2cache[i], | |
| 1731 ZPOOL_CONFIG_GUID, &guid) == 0); | |
| 1732 | |
| 1733 vd = NULL; | |
| 1734 for (j = 0; j < spa->spa_l2cache.sav_count; j++) { | |
| 1735 if (guid == | |
| 1736 spa->spa_l2cache.sav_vdevs[j]->vdev_guid) { | |
| 1737 vd = spa->spa_l2cache.sav_vdevs[j]; | |
| 1738 break; | |
| 1739 } | |
| 1740 } | |
| 1741 ASSERT(vd != NULL); | |
| 1742 | |
| 1743 VERIFY(nvlist_lookup_uint64_array(l2cache[i], | |
| 1744 ZPOOL_CONFIG_STATS, (uint64_t **)&vs, &vsc) == 0); | |
| 1745 vdev_get_stats(vd, vs); | |
| 1746 } | |
| 1747 } | |
| 1748 } | |
| 1749 | |
| 789 | 1750 int |
| 1544 | 1751 spa_get_stats(const char *name, nvlist_t **config, char *altroot, size_t buflen) |
| 789 | 1752 { |
| 1753 int error; | |
| 1754 spa_t *spa; | |
| 1755 | |
| 1756 *config = NULL; | |
| 1757 error = spa_open_common(name, &spa, FTAG, config); | |
| 1758 | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1759 if (spa != NULL) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1760 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1761 * This still leaves a window of inconsistency where the spares |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1762 * or l2cache devices could change and the config would be |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1763 * self-inconsistent. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1764 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1765 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1766 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1767 if (*config != NULL) { |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1768 VERIFY(nvlist_add_uint64(*config, |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1769 ZPOOL_CONFIG_ERRCOUNT, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1770 spa_get_errlog_size(spa)) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1771 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1772 if (spa_suspended(spa)) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1773 VERIFY(nvlist_add_uint64(*config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1774 ZPOOL_CONFIG_SUSPENDED, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1775 spa->spa_failmode) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1776 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1777 spa_add_spares(spa, *config); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1778 spa_add_l2cache(spa, *config); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1779 } |
| 2082 | 1780 } |
| 1781 | |
| 1544 | 1782 /* |
| 1783 * We want to get the alternate root even for faulted pools, so we cheat | |
| 1784 * and call spa_lookup() directly. | |
| 1785 */ | |
| 1786 if (altroot) { | |
| 1787 if (spa == NULL) { | |
| 1788 mutex_enter(&spa_namespace_lock); | |
| 1789 spa = spa_lookup(name); | |
| 1790 if (spa) | |
| 1791 spa_altroot(spa, altroot, buflen); | |
| 1792 else | |
| 1793 altroot[0] = '\0'; | |
| 1794 spa = NULL; | |
| 1795 mutex_exit(&spa_namespace_lock); | |
| 1796 } else { | |
| 1797 spa_altroot(spa, altroot, buflen); | |
| 1798 } | |
| 1799 } | |
| 1800 | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1801 if (spa != NULL) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1802 spa_config_exit(spa, SCL_CONFIG, FTAG); |
| 789 | 1803 spa_close(spa, FTAG); |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
1804 } |
| 789 | 1805 |
| 1806 return (error); | |
| 1807 } | |
| 1808 | |
| 1809 /* | |
| 5450 | 1810 * Validate that the auxiliary device array is well formed. We must have an |
| 1811 * array of nvlists, each which describes a valid leaf vdev. If this is an | |
| 1812 * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be | |
| 1813 * specified, as long as they are well-formed. | |
| 2082 | 1814 */ |
| 1815 static int | |
| 5450 | 1816 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode, |
| 1817 spa_aux_vdev_t *sav, const char *config, uint64_t version, | |
| 1818 vdev_labeltype_t label) | |
| 2082 | 1819 { |
| 5450 | 1820 nvlist_t **dev; |
| 1821 uint_t i, ndev; | |
| 2082 | 1822 vdev_t *vd; |
| 1823 int error; | |
| 1824 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1825 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1826 |
| 2082 | 1827 /* |
| 5450 | 1828 * It's acceptable to have no devs specified. |
| 2082 | 1829 */ |
| 5450 | 1830 if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0) |
| 2082 | 1831 return (0); |
| 1832 | |
| 5450 | 1833 if (ndev == 0) |
| 2082 | 1834 return (EINVAL); |
| 1835 | |
| 1836 /* | |
| 5450 | 1837 * Make sure the pool is formatted with a version that supports this |
| 1838 * device type. | |
| 2082 | 1839 */ |
| 5450 | 1840 if (spa_version(spa) < version) |
| 2082 | 1841 return (ENOTSUP); |
| 1842 | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1843 /* |
| 5450 | 1844 * Set the pending device list so we correctly handle device in-use |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1845 * checking. |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1846 */ |
| 5450 | 1847 sav->sav_pending = dev; |
| 1848 sav->sav_npending = ndev; | |
| 1849 | |
| 1850 for (i = 0; i < ndev; i++) { | |
| 1851 if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0, | |
| 2082 | 1852 mode)) != 0) |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1853 goto out; |
| 2082 | 1854 |
| 1855 if (!vd->vdev_ops->vdev_op_leaf) { | |
| 1856 vdev_free(vd); | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1857 error = EINVAL; |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1858 goto out; |
| 2082 | 1859 } |
| 1860 | |
| 5450 | 1861 /* |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1862 * The L2ARC currently only supports disk devices in |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1863 * kernel context. For user-level testing, we allow it. |
| 5450 | 1864 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1865 #ifdef _KERNEL |
| 5450 | 1866 if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) && |
| 1867 strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) { | |
| 1868 error = ENOTBLK; | |
| 1869 goto out; | |
| 1870 } | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1871 #endif |
| 2082 | 1872 vd->vdev_top = vd; |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1873 |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1874 if ((error = vdev_open(vd)) == 0 && |
| 5450 | 1875 (error = vdev_label_init(vd, crtxg, label)) == 0) { |
| 1876 VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID, | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1877 vd->vdev_guid) == 0); |
| 2082 | 1878 } |
| 1879 | |
| 1880 vdev_free(vd); | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1881 |
| 5450 | 1882 if (error && |
| 1883 (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE)) | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1884 goto out; |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1885 else |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1886 error = 0; |
| 2082 | 1887 } |
| 1888 | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1889 out: |
| 5450 | 1890 sav->sav_pending = NULL; |
| 1891 sav->sav_npending = 0; | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
1892 return (error); |
| 2082 | 1893 } |
| 1894 | |
| 5450 | 1895 static int |
| 1896 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode) | |
| 1897 { | |
| 1898 int error; | |
| 1899 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1900 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
1901 |
| 5450 | 1902 if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode, |
| 1903 &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES, | |
| 1904 VDEV_LABEL_SPARE)) != 0) { | |
| 1905 return (error); | |
| 1906 } | |
| 1907 | |
| 1908 return (spa_validate_aux_devs(spa, nvroot, crtxg, mode, | |
| 1909 &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE, | |
| 1910 VDEV_LABEL_L2CACHE)); | |
| 1911 } | |
| 1912 | |
| 1913 static void | |
| 1914 spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs, | |
| 1915 const char *config) | |
| 1916 { | |
| 1917 int i; | |
| 1918 | |
| 1919 if (sav->sav_config != NULL) { | |
| 1920 nvlist_t **olddevs; | |
| 1921 uint_t oldndevs; | |
| 1922 nvlist_t **newdevs; | |
| 1923 | |
| 1924 /* | |
| 1925 * Generate new dev list by concatentating with the | |
| 1926 * current dev list. | |
| 1927 */ | |
| 1928 VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config, | |
| 1929 &olddevs, &oldndevs) == 0); | |
| 1930 | |
| 1931 newdevs = kmem_alloc(sizeof (void *) * | |
| 1932 (ndevs + oldndevs), KM_SLEEP); | |
| 1933 for (i = 0; i < oldndevs; i++) | |
| 1934 VERIFY(nvlist_dup(olddevs[i], &newdevs[i], | |
| 1935 KM_SLEEP) == 0); | |
| 1936 for (i = 0; i < ndevs; i++) | |
| 1937 VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs], | |
| 1938 KM_SLEEP) == 0); | |
| 1939 | |
| 1940 VERIFY(nvlist_remove(sav->sav_config, config, | |
| 1941 DATA_TYPE_NVLIST_ARRAY) == 0); | |
| 1942 | |
| 1943 VERIFY(nvlist_add_nvlist_array(sav->sav_config, | |
| 1944 config, newdevs, ndevs + oldndevs) == 0); | |
| 1945 for (i = 0; i < oldndevs + ndevs; i++) | |
| 1946 nvlist_free(newdevs[i]); | |
| 1947 kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *)); | |
| 1948 } else { | |
| 1949 /* | |
| 1950 * Generate a new dev list. | |
| 1951 */ | |
| 1952 VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME, | |
| 1953 KM_SLEEP) == 0); | |
| 1954 VERIFY(nvlist_add_nvlist_array(sav->sav_config, config, | |
| 1955 devs, ndevs) == 0); | |
| 1956 } | |
| 1957 } | |
| 1958 | |
| 1959 /* | |
| 1960 * Stop and drop level 2 ARC devices | |
| 1961 */ | |
| 1962 void | |
| 1963 spa_l2cache_drop(spa_t *spa) | |
| 1964 { | |
| 1965 vdev_t *vd; | |
| 1966 int i; | |
| 1967 spa_aux_vdev_t *sav = &spa->spa_l2cache; | |
| 1968 | |
| 1969 for (i = 0; i < sav->sav_count; i++) { | |
| 1970 uint64_t pool; | |
| 1971 | |
| 1972 vd = sav->sav_vdevs[i]; | |
| 1973 ASSERT(vd != NULL); | |
| 1974 | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1975 if (spa_l2cache_exists(vd->vdev_guid, &pool) && |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
1976 pool != 0ULL && l2arc_vdev_present(vd)) |
| 5450 | 1977 l2arc_remove_vdev(vd); |
| 1978 if (vd->vdev_isl2cache) | |
| 1979 spa_l2cache_remove(vd); | |
| 1980 vdev_clear_stats(vd); | |
| 1981 (void) vdev_close(vd); | |
| 1982 } | |
| 1983 } | |
| 1984 | |
| 2082 | 1985 /* |
| 789 | 1986 * Pool Creation |
| 1987 */ | |
| 1988 int | |
| 5094 | 1989 spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props, |
|
7184
9508660f9c27
PSARC 2008/223 Pool root file system properties via zpool(1M)
timh
parents:
7147
diff
changeset
|
1990 const char *history_str, nvlist_t *zplprops) |
| 789 | 1991 { |
| 1992 spa_t *spa; | |
| 5094 | 1993 char *altroot = NULL; |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
1994 vdev_t *rvd; |
| 789 | 1995 dsl_pool_t *dp; |
| 1996 dmu_tx_t *tx; | |
| 2082 | 1997 int c, error = 0; |
| 789 | 1998 uint64_t txg = TXG_INITIAL; |
| 5450 | 1999 nvlist_t **spares, **l2cache; |
| 2000 uint_t nspares, nl2cache; | |
| 5094 | 2001 uint64_t version; |
| 789 | 2002 |
| 2003 /* | |
| 2004 * If this pool already exists, return failure. | |
| 2005 */ | |
| 2006 mutex_enter(&spa_namespace_lock); | |
| 2007 if (spa_lookup(pool) != NULL) { | |
| 2008 mutex_exit(&spa_namespace_lock); | |
| 2009 return (EEXIST); | |
| 2010 } | |
| 2011 | |
| 2012 /* | |
| 2013 * Allocate a new spa_t structure. | |
| 2014 */ | |
| 5094 | 2015 (void) nvlist_lookup_string(props, |
| 2016 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2017 spa = spa_add(pool, altroot); |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
2018 spa_activate(spa, spa_mode_global); |
| 789 | 2019 |
| 2020 spa->spa_uberblock.ub_txg = txg - 1; | |
| 5094 | 2021 |
| 2022 if (props && (error = spa_prop_validate(spa, props))) { | |
| 2023 spa_unload(spa); | |
| 2024 spa_deactivate(spa); | |
| 2025 spa_remove(spa); | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
2026 mutex_exit(&spa_namespace_lock); |
| 5094 | 2027 return (error); |
| 2028 } | |
| 2029 | |
| 2030 if (nvlist_lookup_uint64(props, zpool_prop_to_name(ZPOOL_PROP_VERSION), | |
| 2031 &version) != 0) | |
| 2032 version = SPA_VERSION; | |
| 2033 ASSERT(version <= SPA_VERSION); | |
| 2034 spa->spa_uberblock.ub_version = version; | |
| 789 | 2035 spa->spa_ubsync = spa->spa_uberblock; |
| 2036 | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2037 /* |
|
9234
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2038 * Create "The Godfather" zio to hold all async IOs |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2039 */ |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2040 if (spa->spa_async_zio_root == NULL) |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2041 spa->spa_async_zio_root = zio_root(spa, NULL, NULL, |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2042 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE | |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2043 ZIO_FLAG_GODFATHER); |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2044 |
|
bffdc4fc05c4
6792139 recovering from a suspended pool needs some work
George Wilson <George.Wilson@Sun.COM>
parents:
9230
diff
changeset
|
2045 /* |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2046 * Create the root vdev. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2047 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2048 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2049 |
| 2082 | 2050 error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD); |
| 2051 | |
| 2052 ASSERT(error != 0 || rvd != NULL); | |
| 2053 ASSERT(error != 0 || spa->spa_root_vdev == rvd); | |
| 2054 | |
|
5913
a77f8ad2ce63
6575965 panic/thread=2a1016b5ca0: BAD TRAP: type=9 rp=1858500 addr=0 mmu_fsr=0, really, truly out of space
perrin
parents:
5886
diff
changeset
|
2055 if (error == 0 && !zfs_allocatable_devs(nvroot)) |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2056 error = EINVAL; |
| 2082 | 2057 |
| 2058 if (error == 0 && | |
| 2059 (error = vdev_create(rvd, txg, B_FALSE)) == 0 && | |
| 5450 | 2060 (error = spa_validate_aux(spa, nvroot, txg, |
| 2082 | 2061 VDEV_ALLOC_ADD)) == 0) { |
| 2062 for (c = 0; c < rvd->vdev_children; c++) | |
| 2063 vdev_init(rvd->vdev_child[c], txg); | |
| 2064 vdev_config_dirty(rvd); | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2065 } |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2066 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2067 spa_config_exit(spa, SCL_ALL, FTAG); |
| 789 | 2068 |
| 2082 | 2069 if (error != 0) { |
| 789 | 2070 spa_unload(spa); |
| 2071 spa_deactivate(spa); | |
| 2072 spa_remove(spa); | |
| 2073 mutex_exit(&spa_namespace_lock); | |
| 2074 return (error); | |
| 2075 } | |
| 2076 | |
| 2082 | 2077 /* |
| 2078 * Get the list of spares, if specified. | |
| 2079 */ | |
| 2080 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, | |
| 2081 &spares, &nspares) == 0) { | |
| 5450 | 2082 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME, |
| 2082 | 2083 KM_SLEEP) == 0); |
| 5450 | 2084 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, |
| 2082 | 2085 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2086 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 2082 | 2087 spa_load_spares(spa); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2088 spa_config_exit(spa, SCL_ALL, FTAG); |
| 5450 | 2089 spa->spa_spares.sav_sync = B_TRUE; |
| 2090 } | |
| 2091 | |
| 2092 /* | |
| 2093 * Get the list of level 2 cache devices, if specified. | |
| 2094 */ | |
| 2095 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, | |
| 2096 &l2cache, &nl2cache) == 0) { | |
| 2097 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, | |
| 2098 NV_UNIQUE_NAME, KM_SLEEP) == 0); | |
| 2099 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, | |
| 2100 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2101 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 5450 | 2102 spa_load_l2cache(spa); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2103 spa_config_exit(spa, SCL_ALL, FTAG); |
| 5450 | 2104 spa->spa_l2cache.sav_sync = B_TRUE; |
| 2082 | 2105 } |
| 2106 | |
|
7184
9508660f9c27
PSARC 2008/223 Pool root file system properties via zpool(1M)
timh
parents:
7147
diff
changeset
|
2107 spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg); |
| 789 | 2108 spa->spa_meta_objset = dp->dp_meta_objset; |
| 2109 | |
| 2110 tx = dmu_tx_create_assigned(dp, txg); | |
| 2111 | |
| 2112 /* | |
| 2113 * Create the pool config object. | |
| 2114 */ | |
| 2115 spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset, | |
|
7497
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
2116 DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE, |
| 789 | 2117 DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx); |
| 2118 | |
| 1544 | 2119 if (zap_add(spa->spa_meta_objset, |
| 789 | 2120 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG, |
| 1544 | 2121 sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) { |
| 2122 cmn_err(CE_PANIC, "failed to add pool config"); | |
| 2123 } | |
| 789 | 2124 |
| 5094 | 2125 /* Newly created pools with the right version are always deflated. */ |
| 2126 if (version >= SPA_VERSION_RAIDZ_DEFLATE) { | |
| 2127 spa->spa_deflate = TRUE; | |
| 2128 if (zap_add(spa->spa_meta_objset, | |
| 2129 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, | |
| 2130 sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) { | |
| 2131 cmn_err(CE_PANIC, "failed to add deflate"); | |
| 2132 } | |
| 2082 | 2133 } |
| 2134 | |
| 789 | 2135 /* |
| 2136 * Create the deferred-free bplist object. Turn off compression | |
| 2137 * because sync-to-convergence takes longer if the blocksize | |
| 2138 * keeps changing. | |
| 2139 */ | |
| 2140 spa->spa_sync_bplist_obj = bplist_create(spa->spa_meta_objset, | |
| 2141 1 << 14, tx); | |
| 2142 dmu_object_set_compress(spa->spa_meta_objset, spa->spa_sync_bplist_obj, | |
| 2143 ZIO_COMPRESS_OFF, tx); | |
| 2144 | |
| 1544 | 2145 if (zap_add(spa->spa_meta_objset, |
| 789 | 2146 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST, |
| 1544 | 2147 sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj, tx) != 0) { |
| 2148 cmn_err(CE_PANIC, "failed to add bplist"); | |
| 2149 } | |
| 789 | 2150 |
| 2926 | 2151 /* |
| 2152 * Create the pool's history object. | |
| 2153 */ | |
| 5094 | 2154 if (version >= SPA_VERSION_ZPOOL_HISTORY) |
| 2155 spa_history_create_obj(spa, tx); | |
| 2156 | |
| 2157 /* | |
| 2158 * Set pool properties. | |
| 2159 */ | |
| 2160 spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS); | |
| 2161 spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION); | |
| 5329 | 2162 spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE); |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
2163 if (props != NULL) { |
|
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
2164 spa_configfile_set(spa, props, B_FALSE); |
| 5094 | 2165 spa_sync_props(spa, props, CRED(), tx); |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
2166 } |
| 2926 | 2167 |
| 789 | 2168 dmu_tx_commit(tx); |
| 2169 | |
| 2170 spa->spa_sync_on = B_TRUE; | |
| 2171 txg_sync_start(spa->spa_dsl_pool); | |
| 2172 | |
| 2173 /* | |
| 2174 * We explicitly wait for the first transaction to complete so that our | |
| 2175 * bean counters are appropriately updated. | |
| 2176 */ | |
| 2177 txg_wait_synced(spa->spa_dsl_pool, txg); | |
| 2178 | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
2179 spa_config_sync(spa, B_FALSE, B_TRUE); |
| 789 | 2180 |
| 5094 | 2181 if (version >= SPA_VERSION_ZPOOL_HISTORY && history_str != NULL) |
|
4715
e8d212dda064
6535695 Panic: shpp->sh_eof == shpp->sh_pool_create_len, file: ../../common/fs/zfs/spa_history.c, line: 235
ek110237
parents:
4627
diff
changeset
|
2182 (void) spa_history_log(spa, history_str, LOG_CMD_POOL_CREATE); |
|
e8d212dda064
6535695 Panic: shpp->sh_eof == shpp->sh_pool_create_len, file: ../../common/fs/zfs/spa_history.c, line: 235
ek110237
parents:
4627
diff
changeset
|
2183 |
|
8667
5c308a17eb7c
6795440 Assertion failure in spa_close()
George Wilson <George.Wilson@Sun.COM>
parents:
8662
diff
changeset
|
2184 spa->spa_minref = refcount_count(&spa->spa_refcount); |
|
5c308a17eb7c
6795440 Assertion failure in spa_close()
George Wilson <George.Wilson@Sun.COM>
parents:
8662
diff
changeset
|
2185 |
| 789 | 2186 mutex_exit(&spa_namespace_lock); |
| 2187 | |
| 2188 return (0); | |
| 2189 } | |
| 2190 | |
| 6423 | 2191 #ifdef _KERNEL |
| 2192 /* | |
| 2193 * Build a "root" vdev for a top level vdev read in from a rootpool | |
| 2194 * device label. | |
| 2195 */ | |
| 2196 static void | |
| 2197 spa_build_rootpool_config(nvlist_t *config) | |
| 2198 { | |
| 2199 nvlist_t *nvtop, *nvroot; | |
| 2200 uint64_t pgid; | |
| 2201 | |
| 2202 /* | |
| 2203 * Add this top-level vdev to the child array. | |
| 2204 */ | |
| 2205 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvtop) | |
| 2206 == 0); | |
| 2207 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pgid) | |
| 2208 == 0); | |
| 2209 | |
| 2210 /* | |
| 2211 * Put this pool's top-level vdevs into a root vdev. | |
| 2212 */ | |
| 2213 VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); | |
| 2214 VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) | |
| 2215 == 0); | |
| 2216 VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0); | |
| 2217 VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0); | |
| 2218 VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, | |
| 2219 &nvtop, 1) == 0); | |
| 2220 | |
| 2221 /* | |
| 2222 * Replace the existing vdev_tree with the new root vdev in | |
| 2223 * this pool's configuration (remove the old, add the new). | |
| 2224 */ | |
| 2225 VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0); | |
| 2226 nvlist_free(nvroot); | |
| 2227 } | |
| 2228 | |
| 2229 /* | |
| 2230 * Get the root pool information from the root disk, then import the root pool | |
| 2231 * during the system boot up time. | |
| 2232 */ | |
|
7539
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2233 extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **); |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2234 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2235 int |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2236 spa_check_rootconf(char *devpath, char *devid, nvlist_t **bestconf, |
| 6423 | 2237 uint64_t *besttxg) |
| 2238 { | |
| 2239 nvlist_t *config; | |
| 2240 uint64_t txg; | |
|
7539
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2241 int error; |
|
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2242 |
|
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2243 if (error = vdev_disk_read_rootlabel(devpath, devid, &config)) |
|
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2244 return (error); |
| 6423 | 2245 |
| 2246 VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0); | |
| 2247 | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2248 if (bestconf != NULL) |
| 6423 | 2249 *bestconf = config; |
|
7539
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2250 else |
|
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2251 nvlist_free(config); |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2252 *besttxg = txg; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2253 return (0); |
| 6423 | 2254 } |
| 2255 | |
| 2256 boolean_t | |
| 2257 spa_rootdev_validate(nvlist_t *nv) | |
| 2258 { | |
| 2259 uint64_t ival; | |
| 2260 | |
| 2261 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, &ival) == 0 || | |
| 2262 nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, &ival) == 0 || | |
| 2263 nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, &ival) == 0) | |
| 2264 return (B_FALSE); | |
| 2265 | |
| 2266 return (B_TRUE); | |
| 2267 } | |
| 2268 | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2269 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2270 /* |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2271 * Given the boot device's physical path or devid, check if the device |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2272 * is in a valid state. If so, return the configuration from the vdev |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2273 * label. |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2274 */ |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2275 int |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2276 spa_get_rootconf(char *devpath, char *devid, nvlist_t **bestconf) |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2277 { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2278 nvlist_t *conf = NULL; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2279 uint64_t txg = 0; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2280 nvlist_t *nvtop, **child; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2281 char *type; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2282 char *bootpath = NULL; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2283 uint_t children, c; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2284 char *tmp; |
|
7539
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2285 int error; |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2286 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2287 if (devpath && ((tmp = strchr(devpath, ' ')) != NULL)) |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2288 *tmp = '\0'; |
|
7539
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2289 if (error = spa_check_rootconf(devpath, devid, &conf, &txg)) { |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2290 cmn_err(CE_NOTE, "error reading device label"); |
|
7539
e3f4b4b9f982
6724326 better "can't mountroot" message
Lin Ling <Lin.Ling@Sun.COM>
parents:
7538
diff
changeset
|
2291 return (error); |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2292 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2293 if (txg == 0) { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2294 cmn_err(CE_NOTE, "this device is detached"); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2295 nvlist_free(conf); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2296 return (EINVAL); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2297 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2298 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2299 VERIFY(nvlist_lookup_nvlist(conf, ZPOOL_CONFIG_VDEV_TREE, |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2300 &nvtop) == 0); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2301 VERIFY(nvlist_lookup_string(nvtop, ZPOOL_CONFIG_TYPE, &type) == 0); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2302 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2303 if (strcmp(type, VDEV_TYPE_DISK) == 0) { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2304 if (spa_rootdev_validate(nvtop)) { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2305 goto out; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2306 } else { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2307 nvlist_free(conf); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2308 return (EINVAL); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2309 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2310 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2311 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2312 ASSERT(strcmp(type, VDEV_TYPE_MIRROR) == 0); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2313 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2314 VERIFY(nvlist_lookup_nvlist_array(nvtop, ZPOOL_CONFIG_CHILDREN, |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2315 &child, &children) == 0); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2316 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2317 /* |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2318 * Go thru vdevs in the mirror to see if the given device |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2319 * has the most recent txg. Only the device with the most |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2320 * recent txg has valid information and should be booted. |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2321 */ |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2322 for (c = 0; c < children; c++) { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2323 char *cdevid, *cpath; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2324 uint64_t tmptxg; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2325 |
|
8242
e46e4b2f0a03
6770866 GRUB/ZFS should require physical path or devid, but not both
Lin Ling <Lin.Ling@Sun.COM>
parents:
8241
diff
changeset
|
2326 cpath = NULL; |
|
e46e4b2f0a03
6770866 GRUB/ZFS should require physical path or devid, but not both
Lin Ling <Lin.Ling@Sun.COM>
parents:
8241
diff
changeset
|
2327 cdevid = NULL; |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2328 if (nvlist_lookup_string(child[c], ZPOOL_CONFIG_PHYS_PATH, |
|
8242
e46e4b2f0a03
6770866 GRUB/ZFS should require physical path or devid, but not both
Lin Ling <Lin.Ling@Sun.COM>
parents:
8241
diff
changeset
|
2329 &cpath) != 0 && nvlist_lookup_string(child[c], |
|
e46e4b2f0a03
6770866 GRUB/ZFS should require physical path or devid, but not both
Lin Ling <Lin.Ling@Sun.COM>
parents:
8241
diff
changeset
|
2330 ZPOOL_CONFIG_DEVID, &cdevid) != 0) |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2331 return (EINVAL); |
|
7687
1132fbaf0c27
6750475 can't boot off a mirrored root with a failed disk
Lin Ling <Lin.Ling@Sun.COM>
parents:
7539
diff
changeset
|
2332 if ((spa_check_rootconf(cpath, cdevid, NULL, |
|
1132fbaf0c27
6750475 can't boot off a mirrored root with a failed disk
Lin Ling <Lin.Ling@Sun.COM>
parents:
7539
diff
changeset
|
2333 &tmptxg) == 0) && (tmptxg > txg)) { |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2334 txg = tmptxg; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2335 VERIFY(nvlist_lookup_string(child[c], |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2336 ZPOOL_CONFIG_PATH, &bootpath) == 0); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2337 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2338 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2339 |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2340 /* Does the best device match the one we've booted from? */ |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2341 if (bootpath) { |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2342 cmn_err(CE_NOTE, "try booting from '%s'", bootpath); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2343 return (EINVAL); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2344 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2345 out: |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2346 *bestconf = conf; |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2347 return (0); |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2348 } |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2349 |
| 6423 | 2350 /* |
| 2351 * Import a root pool. | |
| 2352 * | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2353 * For x86. devpath_list will consist of devid and/or physpath name of |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2354 * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a"). |
|
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2355 * The GRUB "findroot" command will return the vdev we should boot. |
| 6423 | 2356 * |
| 2357 * For Sparc, devpath_list consists the physpath name of the booting device | |
| 2358 * no matter the rootpool is a single device pool or a mirrored pool. | |
| 2359 * e.g. | |
| 2360 * "/pci@1f,0/ide@d/disk@0,0:a" | |
| 2361 */ | |
| 2362 int | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2363 spa_import_rootpool(char *devpath, char *devid) |
| 6423 | 2364 { |
| 2365 nvlist_t *conf = NULL; | |
| 2366 char *pname; | |
| 2367 int error; | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2368 spa_t *spa; |
| 6423 | 2369 |
| 2370 /* | |
| 2371 * Get the vdev pathname and configuation from the most | |
| 2372 * recently updated vdev (highest txg). | |
| 2373 */ | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2374 if (error = spa_get_rootconf(devpath, devid, &conf)) |
| 6423 | 2375 goto msg_out; |
| 2376 | |
| 2377 /* | |
| 2378 * Add type "root" vdev to the config. | |
| 2379 */ | |
| 2380 spa_build_rootpool_config(conf); | |
| 2381 | |
| 2382 VERIFY(nvlist_lookup_string(conf, ZPOOL_CONFIG_POOL_NAME, &pname) == 0); | |
| 2383 | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2384 mutex_enter(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2385 if ((spa = spa_lookup(pname)) != NULL) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2386 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2387 * Remove the existing root pool from the namespace so that we |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2388 * can replace it with the correct config we just read in. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2389 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2390 spa_remove(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2391 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2392 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2393 spa = spa_add(pname, NULL); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2394 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2395 spa->spa_is_root = B_TRUE; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2396 VERIFY(nvlist_dup(conf, &spa->spa_config, 0) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2397 mutex_exit(&spa_namespace_lock); |
| 6423 | 2398 |
| 2399 nvlist_free(conf); | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2400 return (0); |
| 6423 | 2401 |
| 2402 msg_out: | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2403 cmn_err(CE_NOTE, "\n" |
| 6423 | 2404 " *************************************************** \n" |
| 2405 " * This device is not bootable! * \n" | |
| 2406 " * It is either offlined or detached or faulted. * \n" | |
| 2407 " * Please try to boot from a different device. * \n" | |
|
7147
1e1d75c88283
6704717 ZFS mirrored root doesn't live up to expectations
taylor
parents:
7046
diff
changeset
|
2408 " *************************************************** "); |
| 6423 | 2409 |
| 2410 return (error); | |
| 2411 } | |
| 2412 #endif | |
| 2413 | |
| 2414 /* | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2415 * Take a pool and insert it into the namespace as if it had been loaded at |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2416 * boot. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2417 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2418 int |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2419 spa_import_verbatim(const char *pool, nvlist_t *config, nvlist_t *props) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2420 { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2421 spa_t *spa; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2422 char *altroot = NULL; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2423 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2424 mutex_enter(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2425 if (spa_lookup(pool) != NULL) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2426 mutex_exit(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2427 return (EEXIST); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2428 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2429 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2430 (void) nvlist_lookup_string(props, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2431 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2432 spa = spa_add(pool, altroot); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2433 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2434 VERIFY(nvlist_dup(config, &spa->spa_config, 0) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2435 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2436 if (props != NULL) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2437 spa_configfile_set(spa, props, B_FALSE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2438 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2439 spa_config_sync(spa, B_FALSE, B_TRUE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2440 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2441 mutex_exit(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2442 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2443 return (0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2444 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2445 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2446 /* |
| 6423 | 2447 * Import a non-root pool into the system. |
| 2448 */ | |
| 2449 int | |
| 2450 spa_import(const char *pool, nvlist_t *config, nvlist_t *props) | |
| 2451 { | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2452 spa_t *spa; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2453 char *altroot = NULL; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2454 int error; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2455 nvlist_t *nvroot; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2456 nvlist_t **spares, **l2cache; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2457 uint_t nspares, nl2cache; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2458 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2459 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2460 * If a pool with this name exists, return failure. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2461 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2462 mutex_enter(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2463 if ((spa = spa_lookup(pool)) != NULL) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2464 mutex_exit(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2465 return (EEXIST); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2466 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2467 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2468 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2469 * Create and initialize the spa structure. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2470 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2471 (void) nvlist_lookup_string(props, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2472 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2473 spa = spa_add(pool, altroot); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2474 spa_activate(spa, spa_mode_global); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2475 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2476 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2477 * Pass off the heavy lifting to spa_load(). Pass TRUE for mosconfig |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2478 * because the user-supplied config is actually the one to trust when |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2479 * doing an import. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2480 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2481 error = spa_load(spa, config, SPA_LOAD_IMPORT, B_TRUE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2482 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2483 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2484 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2485 * Toss any existing sparelist, as it doesn't have any validity |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2486 * anymore, and conflicts with spa_has_spare(). |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2487 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2488 if (spa->spa_spares.sav_config) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2489 nvlist_free(spa->spa_spares.sav_config); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2490 spa->spa_spares.sav_config = NULL; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2491 spa_load_spares(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2492 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2493 if (spa->spa_l2cache.sav_config) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2494 nvlist_free(spa->spa_l2cache.sav_config); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2495 spa->spa_l2cache.sav_config = NULL; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2496 spa_load_l2cache(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2497 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2498 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2499 VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2500 &nvroot) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2501 if (error == 0) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2502 error = spa_validate_aux(spa, nvroot, -1ULL, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2503 VDEV_ALLOC_SPARE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2504 if (error == 0) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2505 error = spa_validate_aux(spa, nvroot, -1ULL, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2506 VDEV_ALLOC_L2CACHE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2507 spa_config_exit(spa, SCL_ALL, FTAG); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2508 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2509 if (props != NULL) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2510 spa_configfile_set(spa, props, B_FALSE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2511 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2512 if (error != 0 || (props && spa_writeable(spa) && |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2513 (error = spa_prop_set(spa, props)))) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2514 spa_unload(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2515 spa_deactivate(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2516 spa_remove(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2517 mutex_exit(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2518 return (error); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2519 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2520 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2521 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2522 * Override any spares and level 2 cache devices as specified by |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2523 * the user, as these may have correct device names/devids, etc. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2524 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2525 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2526 &spares, &nspares) == 0) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2527 if (spa->spa_spares.sav_config) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2528 VERIFY(nvlist_remove(spa->spa_spares.sav_config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2529 ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2530 else |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2531 VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2532 NV_UNIQUE_NAME, KM_SLEEP) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2533 VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2534 ZPOOL_CONFIG_SPARES, spares, nspares) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2535 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2536 spa_load_spares(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2537 spa_config_exit(spa, SCL_ALL, FTAG); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2538 spa->spa_spares.sav_sync = B_TRUE; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2539 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2540 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2541 &l2cache, &nl2cache) == 0) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2542 if (spa->spa_l2cache.sav_config) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2543 VERIFY(nvlist_remove(spa->spa_l2cache.sav_config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2544 ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2545 else |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2546 VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2547 NV_UNIQUE_NAME, KM_SLEEP) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2548 VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2549 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2550 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2551 spa_load_l2cache(spa); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2552 spa_config_exit(spa, SCL_ALL, FTAG); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2553 spa->spa_l2cache.sav_sync = B_TRUE; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2554 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2555 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2556 if (spa_writeable(spa)) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2557 /* |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2558 * Update the config cache to include the newly-imported pool. |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2559 */ |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2560 spa_config_update_common(spa, SPA_CONFIG_UPDATE_POOL, B_FALSE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2561 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2562 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2563 mutex_exit(&spa_namespace_lock); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2564 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2565 return (0); |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
2566 } |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
2567 |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
2568 |
| 789 | 2569 /* |
| 2570 * This (illegal) pool name is used when temporarily importing a spa_t in order | |
| 2571 * to get the vdev stats associated with the imported devices. | |
| 2572 */ | |
| 2573 #define TRYIMPORT_NAME "$import" | |
| 2574 | |
| 2575 nvlist_t * | |
| 2576 spa_tryimport(nvlist_t *tryconfig) | |
| 2577 { | |
| 2578 nvlist_t *config = NULL; | |
| 2579 char *poolname; | |
| 2580 spa_t *spa; | |
| 2581 uint64_t state; | |
|
8680
005fe27123ba
6786321 panic on spa_tryimport() a corrupted pool
Lin Ling <Lin.Ling@Sun.COM>
parents:
8667
diff
changeset
|
2582 int error; |
| 789 | 2583 |
| 2584 if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname)) | |
| 2585 return (NULL); | |
| 2586 | |
| 2587 if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state)) | |
| 2588 return (NULL); | |
| 2589 | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2590 /* |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2591 * Create and initialize the spa structure. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2592 */ |
| 789 | 2593 mutex_enter(&spa_namespace_lock); |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2594 spa = spa_add(TRYIMPORT_NAME, NULL); |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
2595 spa_activate(spa, FREAD); |
| 789 | 2596 |
| 2597 /* | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2598 * Pass off the heavy lifting to spa_load(). |
| 1732 | 2599 * Pass TRUE for mosconfig because the user-supplied config |
| 2600 * is actually the one to trust when doing an import. | |
| 789 | 2601 */ |
|
8680
005fe27123ba
6786321 panic on spa_tryimport() a corrupted pool
Lin Ling <Lin.Ling@Sun.COM>
parents:
8667
diff
changeset
|
2602 error = spa_load(spa, tryconfig, SPA_LOAD_TRYIMPORT, B_TRUE); |
| 789 | 2603 |
| 2604 /* | |
| 2605 * If 'tryconfig' was at least parsable, return the current config. | |
| 2606 */ | |
| 2607 if (spa->spa_root_vdev != NULL) { | |
| 2608 config = spa_config_generate(spa, NULL, -1ULL, B_TRUE); | |
| 2609 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, | |
| 2610 poolname) == 0); | |
| 2611 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, | |
| 2612 state) == 0); | |
|
3975
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
2613 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP, |
|
6674f5d79069
6282725 hostname/hostid should be stored in the label
ek110237
parents:
3912
diff
changeset
|
2614 spa->spa_uberblock.ub_timestamp) == 0); |
| 2082 | 2615 |
| 2616 /* | |
| 6423 | 2617 * If the bootfs property exists on this pool then we |
| 2618 * copy it out so that external consumers can tell which | |
| 2619 * pools are bootable. | |
| 2620 */ | |
|
8680
005fe27123ba
6786321 panic on spa_tryimport() a corrupted pool
Lin Ling <Lin.Ling@Sun.COM>
parents:
8667
diff
changeset
|
2621 if ((!error || error == EEXIST) && spa->spa_bootfs) { |
| 6423 | 2622 char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP); |
| 2623 | |
| 2624 /* | |
| 2625 * We have to play games with the name since the | |
| 2626 * pool was opened as TRYIMPORT_NAME. | |
| 2627 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2628 if (dsl_dsobj_to_dsname(spa_name(spa), |
| 6423 | 2629 spa->spa_bootfs, tmpname) == 0) { |
| 2630 char *cp; | |
| 2631 char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP); | |
| 2632 | |
| 2633 cp = strchr(tmpname, '/'); | |
| 2634 if (cp == NULL) { | |
| 2635 (void) strlcpy(dsname, tmpname, | |
| 2636 MAXPATHLEN); | |
| 2637 } else { | |
| 2638 (void) snprintf(dsname, MAXPATHLEN, | |
| 2639 "%s/%s", poolname, ++cp); | |
| 2640 } | |
| 2641 VERIFY(nvlist_add_string(config, | |
| 2642 ZPOOL_CONFIG_BOOTFS, dsname) == 0); | |
| 2643 kmem_free(dsname, MAXPATHLEN); | |
| 2644 } | |
| 2645 kmem_free(tmpname, MAXPATHLEN); | |
| 2646 } | |
| 2647 | |
| 2648 /* | |
| 5450 | 2649 * Add the list of hot spares and level 2 cache devices. |
| 2082 | 2650 */ |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2651 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); |
| 2082 | 2652 spa_add_spares(spa, config); |
| 5450 | 2653 spa_add_l2cache(spa, config); |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
2654 spa_config_exit(spa, SCL_CONFIG, FTAG); |
| 789 | 2655 } |
| 2656 | |
| 2657 spa_unload(spa); | |
| 2658 spa_deactivate(spa); | |
| 2659 spa_remove(spa); | |
| 2660 mutex_exit(&spa_namespace_lock); | |
| 2661 | |
| 2662 return (config); | |
| 2663 } | |
| 2664 | |
| 2665 /* | |
| 2666 * Pool export/destroy | |
| 2667 * | |
| 2668 * The act of destroying or exporting a pool is very simple. We make sure there | |
| 2669 * is no more pending I/O and any references to the pool are gone. Then, we | |
| 2670 * update the pool state and sync all the labels to disk, removing the | |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2671 * configuration from the cache afterwards. If the 'hardforce' flag is set, then |
|
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2672 * we don't sync the labels or remove the configuration cache. |
| 789 | 2673 */ |
| 2674 static int | |
|
7214
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2675 spa_export_common(char *pool, int new_state, nvlist_t **oldconfig, |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2676 boolean_t force, boolean_t hardforce) |
| 789 | 2677 { |
| 2678 spa_t *spa; | |
| 2679 | |
|
1775
e51e26b432c0
6410698 ZFS metadata needs to be more highly replicated (ditto blocks)
billm
parents:
1760
diff
changeset
|
2680 if (oldconfig) |
|
e51e26b432c0
6410698 ZFS metadata needs to be more highly replicated (ditto blocks)
billm
parents:
1760
diff
changeset
|
2681 *oldconfig = NULL; |
|
e51e26b432c0
6410698 ZFS metadata needs to be more highly replicated (ditto blocks)
billm
parents:
1760
diff
changeset
|
2682 |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
2683 if (!(spa_mode_global & FWRITE)) |
| 789 | 2684 return (EROFS); |
| 2685 | |
| 2686 mutex_enter(&spa_namespace_lock); | |
| 2687 if ((spa = spa_lookup(pool)) == NULL) { | |
| 2688 mutex_exit(&spa_namespace_lock); | |
| 2689 return (ENOENT); | |
| 2690 } | |
| 2691 | |
| 2692 /* | |
| 1544 | 2693 * Put a hold on the pool, drop the namespace lock, stop async tasks, |
| 2694 * reacquire the namespace lock, and see if we can export. | |
| 2695 */ | |
| 2696 spa_open_ref(spa, FTAG); | |
| 2697 mutex_exit(&spa_namespace_lock); | |
| 2698 spa_async_suspend(spa); | |
| 2699 mutex_enter(&spa_namespace_lock); | |
| 2700 spa_close(spa, FTAG); | |
| 2701 | |
| 2702 /* | |
| 789 | 2703 * The pool will be in core if it's openable, |
| 2704 * in which case we can modify its state. | |
| 2705 */ | |
| 2706 if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) { | |
| 2707 /* | |
| 2708 * Objsets may be open only because they're dirty, so we | |
| 2709 * have to force it to sync before checking spa_refcnt. | |
| 2710 */ | |
| 2711 txg_wait_synced(spa->spa_dsl_pool, 0); | |
| 2712 | |
| 1544 | 2713 /* |
| 2714 * A pool cannot be exported or destroyed if there are active | |
| 2715 * references. If we are resetting a pool, allow references by | |
| 2716 * fault injection handlers. | |
| 2717 */ | |
| 2718 if (!spa_refcount_zero(spa) || | |
| 2719 (spa->spa_inject_ref != 0 && | |
| 2720 new_state != POOL_STATE_UNINITIALIZED)) { | |
| 2721 spa_async_resume(spa); | |
| 789 | 2722 mutex_exit(&spa_namespace_lock); |
| 2723 return (EBUSY); | |
| 2724 } | |
| 2725 | |
| 2726 /* | |
|
7214
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2727 * A pool cannot be exported if it has an active shared spare. |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2728 * This is to prevent other pools stealing the active spare |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2729 * from an exported pool. At user's own will, such pool can |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2730 * be forcedly exported. |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2731 */ |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2732 if (!force && new_state == POOL_STATE_EXPORTED && |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2733 spa_has_active_shared_spare(spa)) { |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2734 spa_async_resume(spa); |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2735 mutex_exit(&spa_namespace_lock); |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2736 return (EXDEV); |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2737 } |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2738 |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2739 /* |
| 789 | 2740 * We want this to be reflected on every label, |
| 2741 * so mark them all dirty. spa_unload() will do the | |
| 2742 * final sync that pushes these changes out. | |
| 2743 */ | |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2744 if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) { |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2745 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 1544 | 2746 spa->spa_state = new_state; |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2747 spa->spa_final_txg = spa_last_synced_txg(spa) + 1; |
| 1544 | 2748 vdev_config_dirty(spa->spa_root_vdev); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2749 spa_config_exit(spa, SCL_ALL, FTAG); |
| 1544 | 2750 } |
| 789 | 2751 } |
| 2752 | |
| 4451 | 2753 spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY); |
| 2754 | |
| 789 | 2755 if (spa->spa_state != POOL_STATE_UNINITIALIZED) { |
| 2756 spa_unload(spa); | |
| 2757 spa_deactivate(spa); | |
| 2758 } | |
| 2759 | |
|
1775
e51e26b432c0
6410698 ZFS metadata needs to be more highly replicated (ditto blocks)
billm
parents:
1760
diff
changeset
|
2760 if (oldconfig && spa->spa_config) |
|
e51e26b432c0
6410698 ZFS metadata needs to be more highly replicated (ditto blocks)
billm
parents:
1760
diff
changeset
|
2761 VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0); |
|
e51e26b432c0
6410698 ZFS metadata needs to be more highly replicated (ditto blocks)
billm
parents:
1760
diff
changeset
|
2762 |
| 1544 | 2763 if (new_state != POOL_STATE_UNINITIALIZED) { |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2764 if (!hardforce) |
|
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2765 spa_config_sync(spa, B_TRUE, B_TRUE); |
| 1544 | 2766 spa_remove(spa); |
| 2767 } | |
| 789 | 2768 mutex_exit(&spa_namespace_lock); |
| 2769 | |
| 2770 return (0); | |
| 2771 } | |
| 2772 | |
| 2773 /* | |
| 2774 * Destroy a storage pool. | |
| 2775 */ | |
| 2776 int | |
| 2777 spa_destroy(char *pool) | |
| 2778 { | |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2779 return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL, |
|
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2780 B_FALSE, B_FALSE)); |
| 789 | 2781 } |
| 2782 | |
| 2783 /* | |
| 2784 * Export a storage pool. | |
| 2785 */ | |
| 2786 int | |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2787 spa_export(char *pool, nvlist_t **oldconfig, boolean_t force, |
|
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2788 boolean_t hardforce) |
| 789 | 2789 { |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2790 return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig, |
|
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2791 force, hardforce)); |
| 789 | 2792 } |
| 2793 | |
| 2794 /* | |
| 1544 | 2795 * Similar to spa_export(), this unloads the spa_t without actually removing it |
| 2796 * from the namespace in any way. | |
| 2797 */ | |
| 2798 int | |
| 2799 spa_reset(char *pool) | |
| 2800 { | |
|
7214
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
2801 return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL, |
|
8211
32722be6ad3b
6775357 ZFS should have a way to export a pool without touching anything
George Wilson <George.Wilson@Sun.COM>
parents:
7897
diff
changeset
|
2802 B_FALSE, B_FALSE)); |
| 1544 | 2803 } |
| 2804 | |
| 2805 /* | |
| 789 | 2806 * ========================================================================== |
| 2807 * Device manipulation | |
| 2808 * ========================================================================== | |
| 2809 */ | |
| 2810 | |
| 2811 /* | |
| 4527 | 2812 * Add a device to a storage pool. |
| 789 | 2813 */ |
| 2814 int | |
| 2815 spa_vdev_add(spa_t *spa, nvlist_t *nvroot) | |
| 2816 { | |
| 2817 uint64_t txg; | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
2818 int error; |
| 789 | 2819 vdev_t *rvd = spa->spa_root_vdev; |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2820 vdev_t *vd, *tvd; |
| 5450 | 2821 nvlist_t **spares, **l2cache; |
| 2822 uint_t nspares, nl2cache; | |
| 789 | 2823 |
| 2824 txg = spa_vdev_enter(spa); | |
| 2825 | |
| 2082 | 2826 if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0, |
| 2827 VDEV_ALLOC_ADD)) != 0) | |
| 2828 return (spa_vdev_exit(spa, NULL, txg, error)); | |
| 2829 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2830 spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */ |
| 789 | 2831 |
| 5450 | 2832 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares, |
| 2833 &nspares) != 0) | |
| 2082 | 2834 nspares = 0; |
| 2835 | |
| 5450 | 2836 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache, |
| 2837 &nl2cache) != 0) | |
| 2838 nl2cache = 0; | |
| 2839 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2840 if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) |
| 2082 | 2841 return (spa_vdev_exit(spa, vd, txg, EINVAL)); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2842 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2843 if (vd->vdev_children != 0 && |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2844 (error = vdev_create(vd, txg, B_FALSE)) != 0) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2845 return (spa_vdev_exit(spa, vd, txg, error)); |
| 2082 | 2846 |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2847 /* |
| 5450 | 2848 * We must validate the spares and l2cache devices after checking the |
| 2849 * children. Otherwise, vdev_inuse() will blindly overwrite the spare. | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2850 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
2851 if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2852 return (spa_vdev_exit(spa, vd, txg, error)); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2853 |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2854 /* |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2855 * Transfer each new top-level vdev from vd to rvd. |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2856 */ |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
2857 for (int c = 0; c < vd->vdev_children; c++) { |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2858 tvd = vd->vdev_child[c]; |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2859 vdev_remove_child(vd, tvd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2860 tvd->vdev_id = rvd->vdev_children; |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2861 vdev_add_child(rvd, tvd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2862 vdev_config_dirty(tvd); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2863 } |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2864 |
| 2082 | 2865 if (nspares != 0) { |
| 5450 | 2866 spa_set_aux_vdevs(&spa->spa_spares, spares, nspares, |
| 2867 ZPOOL_CONFIG_SPARES); | |
| 2082 | 2868 spa_load_spares(spa); |
| 5450 | 2869 spa->spa_spares.sav_sync = B_TRUE; |
| 2870 } | |
| 2871 | |
| 2872 if (nl2cache != 0) { | |
| 2873 spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache, | |
| 2874 ZPOOL_CONFIG_L2CACHE); | |
| 2875 spa_load_l2cache(spa); | |
| 2876 spa->spa_l2cache.sav_sync = B_TRUE; | |
| 789 | 2877 } |
| 2878 | |
| 2879 /* | |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2880 * We have to be careful when adding new vdevs to an existing pool. |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2881 * If other threads start allocating from these vdevs before we |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2882 * sync the config cache, and we lose power, then upon reboot we may |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2883 * fail to open the pool because there are DVAs that the config cache |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2884 * can't translate. Therefore, we first add the vdevs without |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2885 * initializing metaslabs; sync the config cache (via spa_vdev_exit()); |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2886 * and then let spa_config_update() initialize the new metaslabs. |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2887 * |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2888 * spa_load() checks for added-but-not-initialized vdevs, so that |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2889 * if we lose power at any point in this sequence, the remaining |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2890 * steps will be completed the next time we load the pool. |
| 789 | 2891 */ |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2892 (void) spa_vdev_exit(spa, vd, txg, 0); |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2893 |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2894 mutex_enter(&spa_namespace_lock); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2895 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2896 mutex_exit(&spa_namespace_lock); |
| 789 | 2897 |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
2898 return (0); |
| 789 | 2899 } |
| 2900 | |
| 2901 /* | |
| 2902 * Attach a device to a mirror. The arguments are the path to any device | |
| 2903 * in the mirror, and the nvroot for the new device. If the path specifies | |
| 2904 * a device that is not mirrored, we automatically insert the mirror vdev. | |
| 2905 * | |
| 2906 * If 'replacing' is specified, the new device is intended to replace the | |
| 2907 * existing device; in this case the two devices are made into their own | |
| 4451 | 2908 * mirror using the 'replacing' vdev, which is functionally identical to |
| 789 | 2909 * the mirror vdev (it actually reuses all the same ops) but has a few |
| 2910 * extra rules: you can't attach to it after it's been created, and upon | |
| 2911 * completion of resilvering, the first disk (the one being replaced) | |
| 2912 * is automatically detached. | |
| 2913 */ | |
| 2914 int | |
| 1544 | 2915 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing) |
| 789 | 2916 { |
| 2917 uint64_t txg, open_txg; | |
| 2918 vdev_t *rvd = spa->spa_root_vdev; | |
| 2919 vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd; | |
| 2082 | 2920 vdev_ops_t *pvops; |
|
7313
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
2921 dmu_tx_t *tx; |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
2922 char *oldvdpath, *newvdpath; |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
2923 int newvd_isspare; |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
2924 int error; |
| 789 | 2925 |
| 2926 txg = spa_vdev_enter(spa); | |
| 2927 | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
2928 oldvd = spa_lookup_by_guid(spa, guid, B_FALSE); |
| 789 | 2929 |
| 2930 if (oldvd == NULL) | |
| 2931 return (spa_vdev_exit(spa, NULL, txg, ENODEV)); | |
| 2932 | |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2933 if (!oldvd->vdev_ops->vdev_op_leaf) |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2934 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
2935 |
| 789 | 2936 pvd = oldvd->vdev_parent; |
| 2937 | |
| 2082 | 2938 if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0, |
| 4451 | 2939 VDEV_ALLOC_ADD)) != 0) |
| 2940 return (spa_vdev_exit(spa, NULL, txg, EINVAL)); | |
| 2941 | |
| 2942 if (newrootvd->vdev_children != 1) | |
| 789 | 2943 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); |
| 2944 | |
| 2945 newvd = newrootvd->vdev_child[0]; | |
| 2946 | |
| 2947 if (!newvd->vdev_ops->vdev_op_leaf) | |
| 2948 return (spa_vdev_exit(spa, newrootvd, txg, EINVAL)); | |
| 2949 | |
| 2082 | 2950 if ((error = vdev_create(newrootvd, txg, replacing)) != 0) |
| 789 | 2951 return (spa_vdev_exit(spa, newrootvd, txg, error)); |
| 2952 | |
| 4527 | 2953 /* |
| 2954 * Spares can't replace logs | |
| 2955 */ | |
|
7326
a3c803100a09
6713886 hot spares of mirrored log devices should not be allowed
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
7313
diff
changeset
|
2956 if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare) |
| 4527 | 2957 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); |
| 2958 | |
| 2082 | 2959 if (!replacing) { |
| 2960 /* | |
| 2961 * For attach, the only allowable parent is a mirror or the root | |
| 2962 * vdev. | |
| 2963 */ | |
| 2964 if (pvd->vdev_ops != &vdev_mirror_ops && | |
| 2965 pvd->vdev_ops != &vdev_root_ops) | |
| 2966 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); | |
| 2967 | |
| 2968 pvops = &vdev_mirror_ops; | |
| 2969 } else { | |
| 2970 /* | |
| 2971 * Active hot spares can only be replaced by inactive hot | |
| 2972 * spares. | |
| 2973 */ | |
| 2974 if (pvd->vdev_ops == &vdev_spare_ops && | |
| 2975 pvd->vdev_child[1] == oldvd && | |
| 2976 !spa_has_spare(spa, newvd->vdev_guid)) | |
| 2977 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); | |
| 2978 | |
| 2979 /* | |
| 2980 * If the source is a hot spare, and the parent isn't already a | |
| 2981 * spare, then we want to create a new hot spare. Otherwise, we | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2982 * want to create a replacing vdev. The user is not allowed to |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2983 * attach to a spared vdev child unless the 'isspare' state is |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2984 * the same (spare replaces spare, non-spare replaces |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2985 * non-spare). |
| 2082 | 2986 */ |
| 2987 if (pvd->vdev_ops == &vdev_replacing_ops) | |
| 2988 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2989 else if (pvd->vdev_ops == &vdev_spare_ops && |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2990 newvd->vdev_isspare != oldvd->vdev_isspare) |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
2991 return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP)); |
| 2082 | 2992 else if (pvd->vdev_ops != &vdev_spare_ops && |
| 2993 newvd->vdev_isspare) | |
| 2994 pvops = &vdev_spare_ops; | |
| 2995 else | |
| 2996 pvops = &vdev_replacing_ops; | |
| 2997 } | |
| 2998 | |
|
1175
759d20c7e57b
6366265 attach/replace should allow a new device size at least the min of all devs in a mirror/raidz
lling
parents:
797
diff
changeset
|
2999 /* |
|
759d20c7e57b
6366265 attach/replace should allow a new device size at least the min of all devs in a mirror/raidz
lling
parents:
797
diff
changeset
|
3000 * Compare the new device size with the replaceable/attachable |
|
759d20c7e57b
6366265 attach/replace should allow a new device size at least the min of all devs in a mirror/raidz
lling
parents:
797
diff
changeset
|
3001 * device size. |
|
759d20c7e57b
6366265 attach/replace should allow a new device size at least the min of all devs in a mirror/raidz
lling
parents:
797
diff
changeset
|
3002 */ |
|
759d20c7e57b
6366265 attach/replace should allow a new device size at least the min of all devs in a mirror/raidz
lling
parents:
797
diff
changeset
|
3003 if (newvd->vdev_psize < vdev_get_rsize(oldvd)) |
| 789 | 3004 return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW)); |
| 3005 | |
| 1732 | 3006 /* |
| 3007 * The new device cannot have a higher alignment requirement | |
| 3008 * than the top-level vdev. | |
| 3009 */ | |
| 3010 if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift) | |
| 789 | 3011 return (spa_vdev_exit(spa, newrootvd, txg, EDOM)); |
| 3012 | |
| 3013 /* | |
| 3014 * If this is an in-place replacement, update oldvd's path and devid | |
| 3015 * to make it distinguishable from newvd, and unopenable from now on. | |
| 3016 */ | |
| 3017 if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) { | |
| 3018 spa_strfree(oldvd->vdev_path); | |
| 3019 oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5, | |
| 3020 KM_SLEEP); | |
| 3021 (void) sprintf(oldvd->vdev_path, "%s/%s", | |
| 3022 newvd->vdev_path, "old"); | |
| 3023 if (oldvd->vdev_devid != NULL) { | |
| 3024 spa_strfree(oldvd->vdev_devid); | |
| 3025 oldvd->vdev_devid = NULL; | |
| 3026 } | |
| 3027 } | |
| 3028 | |
| 3029 /* | |
| 2082 | 3030 * If the parent is not a mirror, or if we're replacing, insert the new |
| 3031 * mirror/replacing/spare vdev above oldvd. | |
| 789 | 3032 */ |
| 3033 if (pvd->vdev_ops != pvops) | |
| 3034 pvd = vdev_add_parent(oldvd, pvops); | |
| 3035 | |
| 3036 ASSERT(pvd->vdev_top->vdev_parent == rvd); | |
| 3037 ASSERT(pvd->vdev_ops == pvops); | |
| 3038 ASSERT(oldvd->vdev_parent == pvd); | |
| 3039 | |
| 3040 /* | |
| 3041 * Extract the new device from its root and add it to pvd. | |
| 3042 */ | |
| 3043 vdev_remove_child(newrootvd, newvd); | |
| 3044 newvd->vdev_id = pvd->vdev_children; | |
| 3045 vdev_add_child(pvd, newvd); | |
| 3046 | |
| 1544 | 3047 /* |
| 3048 * If newvd is smaller than oldvd, but larger than its rsize, | |
| 3049 * the addition of newvd may have decreased our parent's asize. | |
| 3050 */ | |
| 3051 pvd->vdev_asize = MIN(pvd->vdev_asize, newvd->vdev_asize); | |
| 3052 | |
| 789 | 3053 tvd = newvd->vdev_top; |
| 3054 ASSERT(pvd->vdev_top == tvd); | |
| 3055 ASSERT(tvd->vdev_parent == rvd); | |
| 3056 | |
| 3057 vdev_config_dirty(tvd); | |
| 3058 | |
| 3059 /* | |
| 3060 * Set newvd's DTL to [TXG_INITIAL, open_txg]. It will propagate | |
| 3061 * upward when spa_vdev_exit() calls vdev_dtl_reassess(). | |
| 3062 */ | |
| 3063 open_txg = txg + TXG_CONCURRENT_STATES - 1; | |
| 3064 | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3065 vdev_dtl_dirty(newvd, DTL_MISSING, |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3066 TXG_INITIAL, open_txg - TXG_INITIAL + 1); |
| 789 | 3067 |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3068 if (newvd->vdev_isspare) { |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3069 spa_spare_activate(newvd); |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3070 spa_event_notify(spa, newvd, ESC_ZFS_VDEV_SPARE); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3071 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3072 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3073 oldvdpath = spa_strdup(oldvd->vdev_path); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3074 newvdpath = spa_strdup(newvd->vdev_path); |
|
7313
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3075 newvd_isspare = newvd->vdev_isspare; |
| 1544 | 3076 |
| 789 | 3077 /* |
| 3078 * Mark newvd's DTL dirty in this txg. | |
| 3079 */ | |
| 1732 | 3080 vdev_dirty(tvd, VDD_DTL, newvd, txg); |
| 789 | 3081 |
| 3082 (void) spa_vdev_exit(spa, newrootvd, open_txg, 0); | |
| 3083 | |
|
7313
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3084 tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir); |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3085 if (dmu_tx_assign(tx, TXG_WAIT) == 0) { |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3086 spa_history_internal_log(LOG_POOL_VDEV_ATTACH, spa, tx, |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3087 CRED(), "%s vdev=%s %s vdev=%s", |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3088 replacing && newvd_isspare ? "spare in" : |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3089 replacing ? "replace" : "attach", newvdpath, |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3090 replacing ? "for" : "to", oldvdpath); |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3091 dmu_tx_commit(tx); |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3092 } else { |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3093 dmu_tx_abort(tx); |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3094 } |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3095 |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3096 spa_strfree(oldvdpath); |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3097 spa_strfree(newvdpath); |
|
99e2110471bb
6734585 zpool history should log when a spare device becomes active
Eric Kustarz <Eric.Kustarz@Sun.COM>
parents:
7294
diff
changeset
|
3098 |
| 789 | 3099 /* |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3100 * Kick off a resilver to update newvd. |
| 789 | 3101 */ |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3102 VERIFY3U(spa_scrub(spa, POOL_SCRUB_RESILVER), ==, 0); |
| 789 | 3103 |
| 3104 return (0); | |
| 3105 } | |
| 3106 | |
| 3107 /* | |
| 3108 * Detach a device from a mirror or replacing vdev. | |
| 3109 * If 'replace_done' is specified, only detach if the parent | |
| 3110 * is a replacing vdev. | |
| 3111 */ | |
| 3112 int | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3113 spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done) |
| 789 | 3114 { |
| 3115 uint64_t txg; | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3116 int error; |
| 789 | 3117 vdev_t *rvd = spa->spa_root_vdev; |
| 3118 vdev_t *vd, *pvd, *cvd, *tvd; | |
| 2082 | 3119 boolean_t unspare = B_FALSE; |
| 3120 uint64_t unspare_guid; | |
|
6673
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3121 size_t len; |
| 789 | 3122 |
| 3123 txg = spa_vdev_enter(spa); | |
| 3124 | |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
3125 vd = spa_lookup_by_guid(spa, guid, B_FALSE); |
| 789 | 3126 |
| 3127 if (vd == NULL) | |
| 3128 return (spa_vdev_exit(spa, NULL, txg, ENODEV)); | |
| 3129 | |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
3130 if (!vd->vdev_ops->vdev_op_leaf) |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
3131 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
3132 |
| 789 | 3133 pvd = vd->vdev_parent; |
| 3134 | |
| 3135 /* | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3136 * If the parent/child relationship is not as expected, don't do it. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3137 * Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3138 * vdev that's replacing B with C. The user's intent in replacing |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3139 * is to go from M(A,B) to M(A,C). If the user decides to cancel |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3140 * the replace by detaching C, the expected behavior is to end up |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3141 * M(A,B). But suppose that right after deciding to detach C, |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3142 * the replacement of B completes. We would have M(A,C), and then |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3143 * ask to detach C, which would leave us with just A -- not what |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3144 * the user wanted. To prevent this, we make sure that the |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3145 * parent/child relationship hasn't changed -- in this example, |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3146 * that C's parent is still the replacing vdev R. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3147 */ |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3148 if (pvd->vdev_guid != pguid && pguid != 0) |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3149 return (spa_vdev_exit(spa, NULL, txg, EBUSY)); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3150 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3151 /* |
| 789 | 3152 * If replace_done is specified, only remove this device if it's |
| 2082 | 3153 * the first child of a replacing vdev. For the 'spare' vdev, either |
| 3154 * disk can be removed. | |
| 789 | 3155 */ |
| 2082 | 3156 if (replace_done) { |
| 3157 if (pvd->vdev_ops == &vdev_replacing_ops) { | |
| 3158 if (vd->vdev_id != 0) | |
| 3159 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); | |
| 3160 } else if (pvd->vdev_ops != &vdev_spare_ops) { | |
| 3161 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); | |
| 3162 } | |
| 3163 } | |
| 3164 | |
| 3165 ASSERT(pvd->vdev_ops != &vdev_spare_ops || | |
| 4577 | 3166 spa_version(spa) >= SPA_VERSION_SPARES); |
| 789 | 3167 |
| 3168 /* | |
| 2082 | 3169 * Only mirror, replacing, and spare vdevs support detach. |
| 789 | 3170 */ |
| 3171 if (pvd->vdev_ops != &vdev_replacing_ops && | |
| 2082 | 3172 pvd->vdev_ops != &vdev_mirror_ops && |
| 3173 pvd->vdev_ops != &vdev_spare_ops) | |
| 789 | 3174 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); |
| 3175 | |
| 3176 /* | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3177 * If this device has the only valid copy of some data, |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3178 * we cannot safely detach it. |
| 789 | 3179 */ |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3180 if (vdev_dtl_required(vd)) |
| 789 | 3181 return (spa_vdev_exit(spa, NULL, txg, EBUSY)); |
| 3182 | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3183 ASSERT(pvd->vdev_children >= 2); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3184 |
| 789 | 3185 /* |
|
6673
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3186 * If we are detaching the second disk from a replacing vdev, then |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3187 * check to see if we changed the original vdev's path to have "/old" |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3188 * at the end in spa_vdev_attach(). If so, undo that change now. |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3189 */ |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3190 if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id == 1 && |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3191 pvd->vdev_child[0]->vdev_path != NULL && |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3192 pvd->vdev_child[1]->vdev_path != NULL) { |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3193 ASSERT(pvd->vdev_child[1] == vd); |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3194 cvd = pvd->vdev_child[0]; |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3195 len = strlen(vd->vdev_path); |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3196 if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 && |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3197 strcmp(cvd->vdev_path + len, "/old") == 0) { |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3198 spa_strfree(cvd->vdev_path); |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3199 cvd->vdev_path = spa_strdup(vd->vdev_path); |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3200 } |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3201 } |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3202 |
|
be079d6124af
6697301 deadlock between ZFS and devfs can hang system
eschrock
parents:
6643
diff
changeset
|
3203 /* |
| 2082 | 3204 * If we are detaching the original disk from a spare, then it implies |
| 3205 * that the spare should become a real disk, and be removed from the | |
| 3206 * active spare list for the pool. | |
| 3207 */ | |
| 3208 if (pvd->vdev_ops == &vdev_spare_ops && | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3209 vd->vdev_id == 0 && pvd->vdev_child[1]->vdev_isspare) |
| 2082 | 3210 unspare = B_TRUE; |
| 3211 | |
| 3212 /* | |
| 789 | 3213 * Erase the disk labels so the disk can be used for other things. |
| 3214 * This must be done after all other error cases are handled, | |
| 3215 * but before we disembowel vd (so we can still do I/O to it). | |
| 3216 * But if we can't do it, don't treat the error as fatal -- | |
| 3217 * it may be that the unwritability of the disk is the reason | |
| 3218 * it's being detached! | |
| 3219 */ | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3220 error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE); |
| 789 | 3221 |
| 3222 /* | |
| 3223 * Remove vd from its parent and compact the parent's children. | |
| 3224 */ | |
| 3225 vdev_remove_child(pvd, vd); | |
| 3226 vdev_compact_children(pvd); | |
| 3227 | |
| 3228 /* | |
| 3229 * Remember one of the remaining children so we can get tvd below. | |
| 3230 */ | |
| 3231 cvd = pvd->vdev_child[0]; | |
| 3232 | |
| 3233 /* | |
| 2082 | 3234 * If we need to remove the remaining child from the list of hot spares, |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3235 * do it now, marking the vdev as no longer a spare in the process. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3236 * We must do this before vdev_remove_parent(), because that can |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3237 * change the GUID if it creates a new toplevel GUID. For a similar |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3238 * reason, we must remove the spare now, in the same txg as the detach; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3239 * otherwise someone could attach a new sibling, change the GUID, and |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3240 * the subsequent attempt to spa_vdev_remove(unspare_guid) would fail. |
| 2082 | 3241 */ |
| 3242 if (unspare) { | |
| 3243 ASSERT(cvd->vdev_isspare); | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3244 spa_spare_remove(cvd); |
| 2082 | 3245 unspare_guid = cvd->vdev_guid; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3246 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); |
| 2082 | 3247 } |
| 3248 | |
| 3249 /* | |
| 789 | 3250 * If the parent mirror/replacing vdev only has one child, |
| 3251 * the parent is no longer needed. Remove it from the tree. | |
| 3252 */ | |
| 3253 if (pvd->vdev_children == 1) | |
| 3254 vdev_remove_parent(cvd); | |
| 3255 | |
| 3256 /* | |
| 3257 * We don't set tvd until now because the parent we just removed | |
| 3258 * may have been the previous top-level vdev. | |
| 3259 */ | |
| 3260 tvd = cvd->vdev_top; | |
| 3261 ASSERT(tvd->vdev_parent == rvd); | |
| 3262 | |
| 3263 /* | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3264 * Reevaluate the parent vdev state. |
| 789 | 3265 */ |
| 4451 | 3266 vdev_propagate_state(cvd); |
| 789 | 3267 |
| 3268 /* | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3269 * If the device we just detached was smaller than the others, it may be |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3270 * possible to add metaslabs (i.e. grow the pool). vdev_metaslab_init() |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3271 * can't fail because the existing metaslabs are already in core, so |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3272 * there's nothing to read from disk. |
| 789 | 3273 */ |
| 1732 | 3274 VERIFY(vdev_metaslab_init(tvd, txg) == 0); |
| 789 | 3275 |
| 3276 vdev_config_dirty(tvd); | |
| 3277 | |
| 3278 /* | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3279 * Mark vd's DTL as dirty in this txg. vdev_dtl_sync() will see that |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3280 * vd->vdev_detached is set and free vd's DTL object in syncing context. |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3281 * But first make sure we're not on any *other* txg's DTL list, to |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3282 * prevent vd from being accessed after it's freed. |
| 789 | 3283 */ |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3284 for (int t = 0; t < TXG_SIZE; t++) |
| 789 | 3285 (void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t); |
| 1732 | 3286 vd->vdev_detached = B_TRUE; |
| 3287 vdev_dirty(tvd, VDD_DTL, vd, txg); | |
| 789 | 3288 |
| 4451 | 3289 spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE); |
| 3290 | |
| 2082 | 3291 error = spa_vdev_exit(spa, vd, txg, 0); |
| 3292 | |
| 3293 /* | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3294 * If this was the removal of the original device in a hot spare vdev, |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3295 * then we want to go through and remove the device from the hot spare |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
3296 * list of every other pool. |
| 2082 | 3297 */ |
| 3298 if (unspare) { | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3299 spa_t *myspa = spa; |
| 2082 | 3300 spa = NULL; |
| 3301 mutex_enter(&spa_namespace_lock); | |
| 3302 while ((spa = spa_next(spa)) != NULL) { | |
| 3303 if (spa->spa_state != POOL_STATE_ACTIVE) | |
| 3304 continue; | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3305 if (spa == myspa) |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3306 continue; |
|
7793
4dbbc0a3f135
6755897 recursive mutex enter in spa_vdev_enter when running test suite
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7754
diff
changeset
|
3307 spa_open_ref(spa, FTAG); |
|
4dbbc0a3f135
6755897 recursive mutex enter in spa_vdev_enter when running test suite
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7754
diff
changeset
|
3308 mutex_exit(&spa_namespace_lock); |
| 2082 | 3309 (void) spa_vdev_remove(spa, unspare_guid, B_TRUE); |
|
7793
4dbbc0a3f135
6755897 recursive mutex enter in spa_vdev_enter when running test suite
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7754
diff
changeset
|
3310 mutex_enter(&spa_namespace_lock); |
|
4dbbc0a3f135
6755897 recursive mutex enter in spa_vdev_enter when running test suite
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7754
diff
changeset
|
3311 spa_close(spa, FTAG); |
| 2082 | 3312 } |
| 3313 mutex_exit(&spa_namespace_lock); | |
| 3314 } | |
| 3315 | |
| 3316 return (error); | |
| 3317 } | |
| 3318 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3319 static nvlist_t * |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3320 spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid) |
| 2082 | 3321 { |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3322 for (int i = 0; i < count; i++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3323 uint64_t guid; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3324 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3325 VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3326 &guid) == 0); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3327 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3328 if (guid == target_guid) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3329 return (nvpp[i]); |
| 2082 | 3330 } |
| 3331 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3332 return (NULL); |
| 5450 | 3333 } |
| 3334 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3335 static void |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3336 spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3337 nvlist_t *dev_to_remove) |
| 5450 | 3338 { |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3339 nvlist_t **newdev = NULL; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3340 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3341 if (count > 1) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3342 newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3343 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3344 for (int i = 0, j = 0; i < count; i++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3345 if (dev[i] == dev_to_remove) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3346 continue; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3347 VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0); |
| 5450 | 3348 } |
| 3349 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3350 VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3351 VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3352 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3353 for (int i = 0; i < count - 1; i++) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3354 nvlist_free(newdev[i]); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3355 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3356 if (count > 1) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3357 kmem_free(newdev, (count - 1) * sizeof (void *)); |
| 5450 | 3358 } |
| 3359 | |
| 3360 /* | |
| 3361 * Remove a device from the pool. Currently, this supports removing only hot | |
| 3362 * spares and level 2 ARC devices. | |
| 3363 */ | |
| 3364 int | |
| 3365 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare) | |
| 3366 { | |
| 3367 vdev_t *vd; | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3368 nvlist_t **spares, **l2cache, *nv; |
| 5450 | 3369 uint_t nspares, nl2cache; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3370 uint64_t txg = 0; |
| 5450 | 3371 int error = 0; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3372 boolean_t locked = MUTEX_HELD(&spa_namespace_lock); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3373 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3374 if (!locked) |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3375 txg = spa_vdev_enter(spa); |
| 5450 | 3376 |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
3377 vd = spa_lookup_by_guid(spa, guid, B_FALSE); |
| 5450 | 3378 |
| 3379 if (spa->spa_spares.sav_vdevs != NULL && | |
| 3380 nvlist_lookup_nvlist_array(spa->spa_spares.sav_config, | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3381 ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 && |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3382 (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3383 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3384 * Only remove the hot spare if it's not currently in use |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3385 * in this pool. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3386 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3387 if (vd == NULL || unspare) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3388 spa_vdev_remove_aux(spa->spa_spares.sav_config, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3389 ZPOOL_CONFIG_SPARES, spares, nspares, nv); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3390 spa_load_spares(spa); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3391 spa->spa_spares.sav_sync = B_TRUE; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3392 } else { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3393 error = EBUSY; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3394 } |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3395 } else if (spa->spa_l2cache.sav_vdevs != NULL && |
| 5450 | 3396 nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config, |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3397 ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 && |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3398 (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3399 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3400 * Cache devices can always be removed. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3401 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3402 spa_vdev_remove_aux(spa->spa_l2cache.sav_config, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3403 ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv); |
| 5450 | 3404 spa_load_l2cache(spa); |
| 3405 spa->spa_l2cache.sav_sync = B_TRUE; | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3406 } else if (vd != NULL) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3407 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3408 * Normal vdevs cannot be removed (yet). |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3409 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3410 error = ENOTSUP; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3411 } else { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3412 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3413 * There is no vdev of any kind with the specified guid. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3414 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3415 error = ENOENT; |
| 5450 | 3416 } |
| 2082 | 3417 |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3418 if (!locked) |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3419 return (spa_vdev_exit(spa, NULL, txg, error)); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3420 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3421 return (error); |
| 789 | 3422 } |
| 3423 | |
| 3424 /* | |
| 4451 | 3425 * Find any device that's done replacing, or a vdev marked 'unspare' that's |
| 3426 * current spared, so we can detach it. | |
| 789 | 3427 */ |
| 1544 | 3428 static vdev_t * |
| 4451 | 3429 spa_vdev_resilver_done_hunt(vdev_t *vd) |
| 789 | 3430 { |
| 1544 | 3431 vdev_t *newvd, *oldvd; |
| 789 | 3432 int c; |
| 3433 | |
| 1544 | 3434 for (c = 0; c < vd->vdev_children; c++) { |
| 4451 | 3435 oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]); |
| 1544 | 3436 if (oldvd != NULL) |
| 3437 return (oldvd); | |
| 3438 } | |
| 789 | 3439 |
| 4451 | 3440 /* |
| 3441 * Check for a completed replacement. | |
| 3442 */ | |
| 789 | 3443 if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) { |
| 1544 | 3444 oldvd = vd->vdev_child[0]; |
| 3445 newvd = vd->vdev_child[1]; | |
| 789 | 3446 |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3447 if (vdev_dtl_empty(newvd, DTL_MISSING) && |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3448 !vdev_dtl_required(oldvd)) |
| 1544 | 3449 return (oldvd); |
| 3450 } | |
| 789 | 3451 |
| 4451 | 3452 /* |
| 3453 * Check for a completed resilver with the 'unspare' flag set. | |
| 3454 */ | |
| 3455 if (vd->vdev_ops == &vdev_spare_ops && vd->vdev_children == 2) { | |
| 3456 newvd = vd->vdev_child[0]; | |
| 3457 oldvd = vd->vdev_child[1]; | |
| 3458 | |
| 3459 if (newvd->vdev_unspare && | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3460 vdev_dtl_empty(newvd, DTL_MISSING) && |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3461 !vdev_dtl_required(oldvd)) { |
| 4451 | 3462 newvd->vdev_unspare = 0; |
| 3463 return (oldvd); | |
| 3464 } | |
| 3465 } | |
| 3466 | |
| 1544 | 3467 return (NULL); |
| 789 | 3468 } |
| 3469 | |
| 1544 | 3470 static void |
| 4451 | 3471 spa_vdev_resilver_done(spa_t *spa) |
| 789 | 3472 { |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3473 vdev_t *vd, *pvd, *ppvd; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3474 uint64_t guid, sguid, pguid, ppguid; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3475 |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3476 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 789 | 3477 |
| 4451 | 3478 while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) { |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3479 pvd = vd->vdev_parent; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3480 ppvd = pvd->vdev_parent; |
| 1544 | 3481 guid = vd->vdev_guid; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3482 pguid = pvd->vdev_guid; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3483 ppguid = ppvd->vdev_guid; |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3484 sguid = 0; |
| 2082 | 3485 /* |
| 3486 * If we have just finished replacing a hot spared device, then | |
| 3487 * we need to detach the parent's first child (the original hot | |
| 3488 * spare) as well. | |
| 3489 */ | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3490 if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0) { |
| 2082 | 3491 ASSERT(pvd->vdev_ops == &vdev_replacing_ops); |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3492 ASSERT(ppvd->vdev_children == 2); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3493 sguid = ppvd->vdev_child[1]->vdev_guid; |
| 2082 | 3494 } |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3495 spa_config_exit(spa, SCL_ALL, FTAG); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3496 if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0) |
| 1544 | 3497 return; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3498 if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0) |
| 2082 | 3499 return; |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3500 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 789 | 3501 } |
| 3502 | |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
3503 spa_config_exit(spa, SCL_ALL, FTAG); |
| 789 | 3504 } |
| 3505 | |
| 3506 /* | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3507 * Update the stored path or FRU for this vdev. Dirty the vdev configuration, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3508 * relying on spa_vdev_enter/exit() to synchronize the labels and cache. |
|
1354
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3509 */ |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3510 int |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3511 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value, |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3512 boolean_t ispath) |
|
1354
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3513 { |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
3514 vdev_t *vd; |
|
1354
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3515 uint64_t txg; |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3516 |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3517 txg = spa_vdev_enter(spa); |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3518 |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3519 if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) |
| 5450 | 3520 return (spa_vdev_exit(spa, NULL, txg, ENOENT)); |
|
1354
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3521 |
|
1585
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
3522 if (!vd->vdev_ops->vdev_op_leaf) |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
3523 return (spa_vdev_exit(spa, NULL, txg, ENOTSUP)); |
|
4ad213e858a9
6395480 ztest ASSERT: rbt.bt_objset == wbt.bt_objset, line 2041
bonwick
parents:
1544
diff
changeset
|
3524 |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3525 if (ispath) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3526 spa_strfree(vd->vdev_path); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3527 vd->vdev_path = spa_strdup(value); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3528 } else { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3529 if (vd->vdev_fru != NULL) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3530 spa_strfree(vd->vdev_fru); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3531 vd->vdev_fru = spa_strdup(value); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3532 } |
|
1354
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3533 |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3534 vdev_config_dirty(vd->vdev_top); |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3535 |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3536 return (spa_vdev_exit(spa, NULL, txg, 0)); |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3537 } |
|
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3538 |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3539 int |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3540 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3541 { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3542 return (spa_vdev_set_common(spa, guid, newpath, B_TRUE)); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3543 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3544 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3545 int |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3546 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3547 { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3548 return (spa_vdev_set_common(spa, guid, newfru, B_FALSE)); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3549 } |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
3550 |
|
1354
81359ee1ee63
6362672 import gets confused about overlapping slices
eschrock
parents:
1175
diff
changeset
|
3551 /* |
| 789 | 3552 * ========================================================================== |
| 3553 * SPA Scrubbing | |
| 3554 * ========================================================================== | |
| 3555 */ | |
| 3556 | |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3557 int |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3558 spa_scrub(spa_t *spa, pool_scrub_type_t type) |
| 789 | 3559 { |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3560 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0); |
| 4808 | 3561 |
| 789 | 3562 if ((uint_t)type >= POOL_SCRUB_TYPES) |
| 3563 return (ENOTSUP); | |
| 3564 | |
| 3565 /* | |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3566 * If a resilver was requested, but there is no DTL on a |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3567 * writeable leaf device, we have nothing to do. |
| 789 | 3568 */ |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3569 if (type == POOL_SCRUB_RESILVER && |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3570 !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) { |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3571 spa_async_request(spa, SPA_ASYNC_RESILVER_DONE); |
| 1544 | 3572 return (0); |
| 3573 } | |
| 789 | 3574 |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3575 if (type == POOL_SCRUB_EVERYTHING && |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3576 spa->spa_dsl_pool->dp_scrub_func != SCRUB_FUNC_NONE && |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3577 spa->spa_dsl_pool->dp_scrub_isresilver) |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3578 return (EBUSY); |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3579 |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3580 if (type == POOL_SCRUB_EVERYTHING || type == POOL_SCRUB_RESILVER) { |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3581 return (dsl_pool_scrub_clean(spa->spa_dsl_pool)); |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3582 } else if (type == POOL_SCRUB_NONE) { |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3583 return (dsl_pool_scrub_cancel(spa->spa_dsl_pool)); |
| 1544 | 3584 } else { |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3585 return (EINVAL); |
| 1544 | 3586 } |
| 789 | 3587 } |
| 3588 | |
| 1544 | 3589 /* |
| 3590 * ========================================================================== | |
| 3591 * SPA async task processing | |
| 3592 * ========================================================================== | |
| 3593 */ | |
| 3594 | |
| 3595 static void | |
| 4451 | 3596 spa_async_remove(spa_t *spa, vdev_t *vd) |
| 789 | 3597 { |
|
7361
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3598 if (vd->vdev_remove_wanted) { |
|
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3599 vd->vdev_remove_wanted = 0; |
|
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3600 vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3601 vdev_clear(spa, vd); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3602 vdev_state_dirty(vd->vdev_top); |
| 1544 | 3603 } |
|
7361
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3604 |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3605 for (int c = 0; c < vd->vdev_children; c++) |
|
7361
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3606 spa_async_remove(spa, vd->vdev_child[c]); |
| 1544 | 3607 } |
| 3608 | |
| 3609 static void | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3610 spa_async_probe(spa_t *spa, vdev_t *vd) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3611 { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3612 if (vd->vdev_probe_wanted) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3613 vd->vdev_probe_wanted = 0; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3614 vdev_reopen(vd); /* vdev_open() does the actual probe */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3615 } |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3616 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3617 for (int c = 0; c < vd->vdev_children; c++) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3618 spa_async_probe(spa, vd->vdev_child[c]); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3619 } |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3620 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3621 static void |
| 1544 | 3622 spa_async_thread(spa_t *spa) |
| 3623 { | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3624 int tasks; |
| 1544 | 3625 |
| 3626 ASSERT(spa->spa_sync_on); | |
| 789 | 3627 |
| 1544 | 3628 mutex_enter(&spa->spa_async_lock); |
| 3629 tasks = spa->spa_async_tasks; | |
| 3630 spa->spa_async_tasks = 0; | |
| 3631 mutex_exit(&spa->spa_async_lock); | |
| 3632 | |
| 3633 /* | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3634 * See if the config needs to be updated. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3635 */ |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3636 if (tasks & SPA_ASYNC_CONFIG_UPDATE) { |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3637 mutex_enter(&spa_namespace_lock); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3638 spa_config_update(spa, SPA_CONFIG_UPDATE_POOL); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3639 mutex_exit(&spa_namespace_lock); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3640 } |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3641 |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3642 /* |
| 4451 | 3643 * See if any devices need to be marked REMOVED. |
| 1544 | 3644 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3645 if (tasks & SPA_ASYNC_REMOVE) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3646 spa_vdev_state_enter(spa); |
| 4451 | 3647 spa_async_remove(spa, spa->spa_root_vdev); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3648 for (int i = 0; i < spa->spa_l2cache.sav_count; i++) |
|
7361
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3649 spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3650 for (int i = 0; i < spa->spa_spares.sav_count; i++) |
|
7361
e7d1b928b483
6715111 A removed L2ARC device should show status REMOVED
Brendan Gregg - Sun Microsystems <Brendan.Gregg@Sun.COM>
parents:
7326
diff
changeset
|
3651 spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3652 (void) spa_vdev_state_exit(spa, NULL, 0); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3653 } |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3654 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3655 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3656 * See if any devices need to be probed. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3657 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3658 if (tasks & SPA_ASYNC_PROBE) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3659 spa_vdev_state_enter(spa); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3660 spa_async_probe(spa, spa->spa_root_vdev); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3661 (void) spa_vdev_state_exit(spa, NULL, 0); |
| 4451 | 3662 } |
| 1544 | 3663 |
| 3664 /* | |
| 3665 * If any devices are done replacing, detach them. | |
| 3666 */ | |
| 4451 | 3667 if (tasks & SPA_ASYNC_RESILVER_DONE) |
| 3668 spa_vdev_resilver_done(spa); | |
| 789 | 3669 |
| 1544 | 3670 /* |
| 3671 * Kick off a resilver. | |
| 3672 */ | |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3673 if (tasks & SPA_ASYNC_RESILVER) |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
3674 VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER) == 0); |
| 1544 | 3675 |
| 3676 /* | |
| 3677 * Let the world know that we're done. | |
| 3678 */ | |
| 3679 mutex_enter(&spa->spa_async_lock); | |
| 3680 spa->spa_async_thread = NULL; | |
| 3681 cv_broadcast(&spa->spa_async_cv); | |
| 3682 mutex_exit(&spa->spa_async_lock); | |
| 3683 thread_exit(); | |
| 3684 } | |
| 3685 | |
| 3686 void | |
| 3687 spa_async_suspend(spa_t *spa) | |
| 3688 { | |
| 3689 mutex_enter(&spa->spa_async_lock); | |
| 3690 spa->spa_async_suspended++; | |
| 3691 while (spa->spa_async_thread != NULL) | |
| 3692 cv_wait(&spa->spa_async_cv, &spa->spa_async_lock); | |
| 3693 mutex_exit(&spa->spa_async_lock); | |
| 3694 } | |
| 3695 | |
| 3696 void | |
| 3697 spa_async_resume(spa_t *spa) | |
| 3698 { | |
| 3699 mutex_enter(&spa->spa_async_lock); | |
| 3700 ASSERT(spa->spa_async_suspended != 0); | |
| 3701 spa->spa_async_suspended--; | |
| 3702 mutex_exit(&spa->spa_async_lock); | |
| 3703 } | |
| 3704 | |
| 3705 static void | |
| 3706 spa_async_dispatch(spa_t *spa) | |
| 3707 { | |
| 3708 mutex_enter(&spa->spa_async_lock); | |
| 3709 if (spa->spa_async_tasks && !spa->spa_async_suspended && | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3710 spa->spa_async_thread == NULL && |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3711 rootdir != NULL && !vn_is_readonly(rootdir)) |
| 1544 | 3712 spa->spa_async_thread = thread_create(NULL, 0, |
| 3713 spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri); | |
| 3714 mutex_exit(&spa->spa_async_lock); | |
| 3715 } | |
| 3716 | |
| 3717 void | |
| 3718 spa_async_request(spa_t *spa, int task) | |
| 3719 { | |
| 3720 mutex_enter(&spa->spa_async_lock); | |
| 3721 spa->spa_async_tasks |= task; | |
| 3722 mutex_exit(&spa->spa_async_lock); | |
| 789 | 3723 } |
| 3724 | |
| 3725 /* | |
| 3726 * ========================================================================== | |
| 3727 * SPA syncing routines | |
| 3728 * ========================================================================== | |
| 3729 */ | |
| 3730 | |
| 3731 static void | |
| 3732 spa_sync_deferred_frees(spa_t *spa, uint64_t txg) | |
| 3733 { | |
| 3734 bplist_t *bpl = &spa->spa_sync_bplist; | |
| 3735 dmu_tx_t *tx; | |
| 3736 blkptr_t blk; | |
| 3737 uint64_t itor = 0; | |
| 3738 zio_t *zio; | |
| 3739 int error; | |
| 3740 uint8_t c = 1; | |
| 3741 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3742 zio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3743 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3744 while (bplist_iterate(bpl, &itor, &blk) == 0) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3745 ASSERT(blk.blk_birth < txg); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3746 zio_nowait(zio_free(zio, spa, txg, &blk, NULL, NULL, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3747 ZIO_FLAG_MUSTSUCCEED)); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3748 } |
| 789 | 3749 |
| 3750 error = zio_wait(zio); | |
| 3751 ASSERT3U(error, ==, 0); | |
| 3752 | |
| 3753 tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg); | |
| 3754 bplist_vacate(bpl, tx); | |
| 3755 | |
| 3756 /* | |
| 3757 * Pre-dirty the first block so we sync to convergence faster. | |
| 3758 * (Usually only the first block is needed.) | |
| 3759 */ | |
| 3760 dmu_write(spa->spa_meta_objset, spa->spa_sync_bplist_obj, 0, 1, &c, tx); | |
| 3761 dmu_tx_commit(tx); | |
| 3762 } | |
| 3763 | |
| 3764 static void | |
| 2082 | 3765 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx) |
| 3766 { | |
| 3767 char *packed = NULL; | |
|
7497
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3768 size_t bufsize; |
| 2082 | 3769 size_t nvsize = 0; |
| 3770 dmu_buf_t *db; | |
| 3771 | |
| 3772 VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0); | |
| 3773 | |
|
7497
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3774 /* |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3775 * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3776 * information. This avoids the dbuf_will_dirty() path and |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3777 * saves us a pre-read to get data we don't actually care about. |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3778 */ |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3779 bufsize = P2ROUNDUP(nvsize, SPA_CONFIG_BLOCKSIZE); |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3780 packed = kmem_alloc(bufsize, KM_SLEEP); |
| 2082 | 3781 |
| 3782 VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR, | |
| 3783 KM_SLEEP) == 0); | |
|
7497
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3784 bzero(packed + nvsize, bufsize - nvsize); |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3785 |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3786 dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx); |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3787 |
|
f6c6be3b6154
6733970 assertion failure in dbuf_dirty() via spa_sync_nvlist()
Tim Haley <Tim.Haley@Sun.COM>
parents:
7377
diff
changeset
|
3788 kmem_free(packed, bufsize); |
| 2082 | 3789 |
| 3790 VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db)); | |
| 3791 dmu_buf_will_dirty(db, tx); | |
| 3792 *(uint64_t *)db->db_data = nvsize; | |
| 3793 dmu_buf_rele(db, FTAG); | |
| 3794 } | |
| 3795 | |
| 3796 static void | |
| 5450 | 3797 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx, |
| 3798 const char *config, const char *entry) | |
| 2082 | 3799 { |
| 3800 nvlist_t *nvroot; | |
| 5450 | 3801 nvlist_t **list; |
| 2082 | 3802 int i; |
| 3803 | |
| 5450 | 3804 if (!sav->sav_sync) |
| 2082 | 3805 return; |
| 3806 | |
| 3807 /* | |
| 5450 | 3808 * Update the MOS nvlist describing the list of available devices. |
| 3809 * spa_validate_aux() will have already made sure this nvlist is | |
| 4451 | 3810 * valid and the vdevs are labeled appropriately. |
| 2082 | 3811 */ |
| 5450 | 3812 if (sav->sav_object == 0) { |
| 3813 sav->sav_object = dmu_object_alloc(spa->spa_meta_objset, | |
| 3814 DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE, | |
| 3815 sizeof (uint64_t), tx); | |
| 2082 | 3816 VERIFY(zap_update(spa->spa_meta_objset, |
| 5450 | 3817 DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1, |
| 3818 &sav->sav_object, tx) == 0); | |
| 2082 | 3819 } |
| 3820 | |
| 3821 VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0); | |
| 5450 | 3822 if (sav->sav_count == 0) { |
| 3823 VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0); | |
| 2082 | 3824 } else { |
| 5450 | 3825 list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP); |
| 3826 for (i = 0; i < sav->sav_count; i++) | |
| 3827 list[i] = vdev_config_generate(spa, sav->sav_vdevs[i], | |
| 3828 B_FALSE, B_FALSE, B_TRUE); | |
| 3829 VERIFY(nvlist_add_nvlist_array(nvroot, config, list, | |
| 3830 sav->sav_count) == 0); | |
| 3831 for (i = 0; i < sav->sav_count; i++) | |
| 3832 nvlist_free(list[i]); | |
| 3833 kmem_free(list, sav->sav_count * sizeof (void *)); | |
| 2082 | 3834 } |
| 3835 | |
| 5450 | 3836 spa_sync_nvlist(spa, sav->sav_object, nvroot, tx); |
| 2926 | 3837 nvlist_free(nvroot); |
| 2082 | 3838 |
| 5450 | 3839 sav->sav_sync = B_FALSE; |
| 2082 | 3840 } |
| 3841 | |
| 3842 static void | |
| 789 | 3843 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx) |
| 3844 { | |
| 3845 nvlist_t *config; | |
| 3846 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3847 if (list_is_empty(&spa->spa_config_dirty_list)) |
| 789 | 3848 return; |
| 3849 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3850 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3851 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3852 config = spa_config_generate(spa, spa->spa_root_vdev, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3853 dmu_tx_get_txg(tx), B_FALSE); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3854 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3855 spa_config_exit(spa, SCL_STATE, FTAG); |
| 789 | 3856 |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3857 if (spa->spa_config_syncing) |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3858 nvlist_free(spa->spa_config_syncing); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3859 spa->spa_config_syncing = config; |
| 789 | 3860 |
| 2082 | 3861 spa_sync_nvlist(spa, spa->spa_config_object, config, tx); |
| 789 | 3862 } |
| 3863 | |
| 5094 | 3864 /* |
| 3865 * Set zpool properties. | |
| 3866 */ | |
| 3912 | 3867 static void |
| 4543 | 3868 spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx) |
| 3912 | 3869 { |
| 3870 spa_t *spa = arg1; | |
| 5094 | 3871 objset_t *mos = spa->spa_meta_objset; |
| 3912 | 3872 nvlist_t *nvp = arg2; |
| 5094 | 3873 nvpair_t *elem; |
| 4451 | 3874 uint64_t intval; |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
3875 char *strval; |
| 5094 | 3876 zpool_prop_t prop; |
| 3877 const char *propname; | |
| 3878 zprop_type_t proptype; | |
| 3879 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3880 mutex_enter(&spa->spa_props_lock); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3881 |
| 5094 | 3882 elem = NULL; |
| 3883 while ((elem = nvlist_next_nvpair(nvp, elem))) { | |
| 3884 switch (prop = zpool_name_to_prop(nvpair_name(elem))) { | |
| 3885 case ZPOOL_PROP_VERSION: | |
| 3886 /* | |
| 3887 * Only set version for non-zpool-creation cases | |
| 3888 * (set/import). spa_create() needs special care | |
| 3889 * for version setting. | |
| 3890 */ | |
| 3891 if (tx->tx_txg != TXG_INITIAL) { | |
| 3892 VERIFY(nvpair_value_uint64(elem, | |
| 3893 &intval) == 0); | |
| 3894 ASSERT(intval <= SPA_VERSION); | |
| 3895 ASSERT(intval >= spa_version(spa)); | |
| 3896 spa->spa_uberblock.ub_version = intval; | |
| 3897 vdev_config_dirty(spa->spa_root_vdev); | |
| 3898 } | |
| 3899 break; | |
| 3900 | |
| 3901 case ZPOOL_PROP_ALTROOT: | |
| 3902 /* | |
| 3903 * 'altroot' is a non-persistent property. It should | |
| 3904 * have been set temporarily at creation or import time. | |
| 3905 */ | |
| 3906 ASSERT(spa->spa_root != NULL); | |
| 3907 break; | |
| 3908 | |
| 5363 | 3909 case ZPOOL_PROP_CACHEFILE: |
| 5094 | 3910 /* |
|
8525
e0e0e525d0f8
6788830 set large value to reservation cause core dump
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
8242
diff
changeset
|
3911 * 'cachefile' is also a non-persisitent property. |
| 5094 | 3912 */ |
| 4543 | 3913 break; |
| 5094 | 3914 default: |
| 3915 /* | |
| 3916 * Set pool property values in the poolprops mos object. | |
| 3917 */ | |
| 3918 if (spa->spa_pool_props_object == 0) { | |
| 3919 objset_t *mos = spa->spa_meta_objset; | |
| 3920 | |
| 3921 VERIFY((spa->spa_pool_props_object = | |
| 3922 zap_create(mos, DMU_OT_POOL_PROPS, | |
| 3923 DMU_OT_NONE, 0, tx)) > 0); | |
| 3924 | |
| 3925 VERIFY(zap_update(mos, | |
| 3926 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS, | |
| 3927 8, 1, &spa->spa_pool_props_object, tx) | |
| 3928 == 0); | |
| 3929 } | |
| 3930 | |
| 3931 /* normalize the property name */ | |
| 3932 propname = zpool_prop_to_name(prop); | |
| 3933 proptype = zpool_prop_get_type(prop); | |
| 3934 | |
| 3935 if (nvpair_type(elem) == DATA_TYPE_STRING) { | |
| 3936 ASSERT(proptype == PROP_TYPE_STRING); | |
| 3937 VERIFY(nvpair_value_string(elem, &strval) == 0); | |
| 3938 VERIFY(zap_update(mos, | |
| 3939 spa->spa_pool_props_object, propname, | |
| 3940 1, strlen(strval) + 1, strval, tx) == 0); | |
| 3941 | |
| 3942 } else if (nvpair_type(elem) == DATA_TYPE_UINT64) { | |
| 3943 VERIFY(nvpair_value_uint64(elem, &intval) == 0); | |
| 3944 | |
| 3945 if (proptype == PROP_TYPE_INDEX) { | |
| 3946 const char *unused; | |
| 3947 VERIFY(zpool_prop_index_to_string( | |
| 3948 prop, intval, &unused) == 0); | |
| 3949 } | |
| 3950 VERIFY(zap_update(mos, | |
| 3951 spa->spa_pool_props_object, propname, | |
| 3952 8, 1, &intval, tx) == 0); | |
| 3953 } else { | |
| 3954 ASSERT(0); /* not allowed */ | |
| 3955 } | |
| 3956 | |
| 5329 | 3957 switch (prop) { |
| 3958 case ZPOOL_PROP_DELEGATION: | |
| 5094 | 3959 spa->spa_delegation = intval; |
| 5329 | 3960 break; |
| 3961 case ZPOOL_PROP_BOOTFS: | |
| 5094 | 3962 spa->spa_bootfs = intval; |
| 5329 | 3963 break; |
| 3964 case ZPOOL_PROP_FAILUREMODE: | |
| 3965 spa->spa_failmode = intval; | |
| 3966 break; | |
| 3967 default: | |
| 3968 break; | |
| 3969 } | |
| 3912 | 3970 } |
| 5094 | 3971 |
| 3972 /* log internal history if this is not a zpool create */ | |
| 3973 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY && | |
| 3974 tx->tx_txg != TXG_INITIAL) { | |
| 3975 spa_history_internal_log(LOG_POOL_PROPSET, | |
| 3976 spa, tx, cr, "%s %lld %s", | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3977 nvpair_name(elem), intval, spa_name(spa)); |
| 5094 | 3978 } |
| 3912 | 3979 } |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3980 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3981 mutex_exit(&spa->spa_props_lock); |
| 3912 | 3982 } |
| 3983 | |
| 789 | 3984 /* |
| 3985 * Sync the specified transaction group. New blocks may be dirtied as | |
| 3986 * part of the process, so we iterate until it converges. | |
| 3987 */ | |
| 3988 void | |
| 3989 spa_sync(spa_t *spa, uint64_t txg) | |
| 3990 { | |
| 3991 dsl_pool_t *dp = spa->spa_dsl_pool; | |
| 3992 objset_t *mos = spa->spa_meta_objset; | |
| 3993 bplist_t *bpl = &spa->spa_sync_bplist; | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
3994 vdev_t *rvd = spa->spa_root_vdev; |
| 789 | 3995 vdev_t *vd; |
| 3996 dmu_tx_t *tx; | |
| 3997 int dirty_vdevs; | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
3998 int error; |
| 789 | 3999 |
| 4000 /* | |
| 4001 * Lock out configuration changes. | |
| 4002 */ | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4003 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER); |
| 789 | 4004 |
| 4005 spa->spa_syncing_txg = txg; | |
| 4006 spa->spa_sync_pass = 0; | |
| 4007 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4008 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4009 * If there are any pending vdev state changes, convert them |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4010 * into config changes that go out with this transaction group. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4011 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4012 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); |
|
8241
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4013 while (list_head(&spa->spa_state_dirty_list) != NULL) { |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4014 /* |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4015 * We need the write lock here because, for aux vdevs, |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4016 * calling vdev_config_dirty() modifies sav_config. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4017 * This is ugly and will become unnecessary when we |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4018 * eliminate the aux vdev wart by integrating all vdevs |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4019 * into the root vdev tree. |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4020 */ |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4021 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4022 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4023 while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) { |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4024 vdev_state_clean(vd); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4025 vdev_config_dirty(vd); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4026 } |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4027 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); |
|
5a60f16123ba
6328632 zpool offline is a bit too conservative
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
8211
diff
changeset
|
4028 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4029 } |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4030 spa_config_exit(spa, SCL_STATE, FTAG); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4031 |
| 1544 | 4032 VERIFY(0 == bplist_open(bpl, mos, spa->spa_sync_bplist_obj)); |
| 789 | 4033 |
| 2082 | 4034 tx = dmu_tx_create_assigned(dp, txg); |
| 4035 | |
| 4036 /* | |
| 4577 | 4037 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg, |
| 2082 | 4038 * set spa_deflate if we have no raid-z vdevs. |
| 4039 */ | |
| 4577 | 4040 if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE && |
| 4041 spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) { | |
| 2082 | 4042 int i; |
| 4043 | |
| 4044 for (i = 0; i < rvd->vdev_children; i++) { | |
| 4045 vd = rvd->vdev_child[i]; | |
| 4046 if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE) | |
| 4047 break; | |
| 4048 } | |
| 4049 if (i == rvd->vdev_children) { | |
| 4050 spa->spa_deflate = TRUE; | |
| 4051 VERIFY(0 == zap_add(spa->spa_meta_objset, | |
| 4052 DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE, | |
| 4053 sizeof (uint64_t), 1, &spa->spa_deflate, tx)); | |
| 4054 } | |
| 4055 } | |
| 4056 | |
|
7046
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4057 if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN && |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4058 spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) { |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4059 dsl_pool_create_origin(dp, tx); |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4060 |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4061 /* Keeping the origin open increases spa_minref */ |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4062 spa->spa_minref += 3; |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4063 } |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4064 |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4065 if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES && |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4066 spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) { |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4067 dsl_pool_upgrade_clones(dp, tx); |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4068 } |
|
361307ae060d
6343667 scrub/resilver has to start over when a snapshot is taken
ahrens
parents:
7042
diff
changeset
|
4069 |
| 789 | 4070 /* |
| 4071 * If anything has changed in this txg, push the deferred frees | |
| 4072 * from the previous txg. If not, leave them alone so that we | |
| 4073 * don't generate work on an otherwise idle system. | |
| 4074 */ | |
| 4075 if (!txg_list_empty(&dp->dp_dirty_datasets, txg) || | |
|
2329
e640bebc73b3
6446569 deferred list is hooked on flintstone vitamins
ek110237
parents:
2199
diff
changeset
|
4076 !txg_list_empty(&dp->dp_dirty_dirs, txg) || |
|
e640bebc73b3
6446569 deferred list is hooked on flintstone vitamins
ek110237
parents:
2199
diff
changeset
|
4077 !txg_list_empty(&dp->dp_sync_tasks, txg)) |
| 789 | 4078 spa_sync_deferred_frees(spa, txg); |
| 4079 | |
| 4080 /* | |
| 4081 * Iterate to convergence. | |
| 4082 */ | |
| 4083 do { | |
| 4084 spa->spa_sync_pass++; | |
| 4085 | |
| 4086 spa_sync_config_object(spa, tx); | |
| 5450 | 4087 spa_sync_aux_dev(spa, &spa->spa_spares, tx, |
| 4088 ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES); | |
| 4089 spa_sync_aux_dev(spa, &spa->spa_l2cache, tx, | |
| 4090 ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE); | |
| 1544 | 4091 spa_errlog_sync(spa, txg); |
| 789 | 4092 dsl_pool_sync(dp, txg); |
| 4093 | |
| 4094 dirty_vdevs = 0; | |
| 4095 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) { | |
| 4096 vdev_sync(vd, txg); | |
| 4097 dirty_vdevs++; | |
| 4098 } | |
| 4099 | |
| 4100 bplist_sync(bpl, tx); | |
| 4101 } while (dirty_vdevs); | |
| 4102 | |
| 4103 bplist_close(bpl); | |
| 4104 | |
| 4105 dprintf("txg %llu passes %d\n", txg, spa->spa_sync_pass); | |
| 4106 | |
| 4107 /* | |
| 4108 * Rewrite the vdev configuration (which includes the uberblock) | |
| 4109 * to commit the transaction group. | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4110 * |
|
5688
c0b02c8fd2c0
6640580 spa_get_random() is insanely slow in userland
bonwick
parents:
5621
diff
changeset
|
4111 * If there are no dirty vdevs, we sync the uberblock to a few |
|
c0b02c8fd2c0
6640580 spa_get_random() is insanely slow in userland
bonwick
parents:
5621
diff
changeset
|
4112 * random top-level vdevs that are known to be visible in the |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4113 * config cache (see spa_vdev_add() for a complete description). |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4114 * If there *are* dirty vdevs, sync the uberblock to all vdevs. |
| 789 | 4115 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4116 for (;;) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4117 /* |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4118 * We hold SCL_STATE to prevent vdev open/close/etc. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4119 * while we're attempting to write the vdev labels. |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4120 */ |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4121 spa_config_enter(spa, SCL_STATE, FTAG, RW_READER); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4122 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4123 if (list_is_empty(&spa->spa_config_dirty_list)) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4124 vdev_t *svd[SPA_DVAS_PER_BP]; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4125 int svdcount = 0; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4126 int children = rvd->vdev_children; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4127 int c0 = spa_get_random(children); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4128 int c; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4129 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4130 for (c = 0; c < children; c++) { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4131 vd = rvd->vdev_child[(c0 + c) % children]; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4132 if (vd->vdev_ms_array == 0 || vd->vdev_islog) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4133 continue; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4134 svd[svdcount++] = vd; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4135 if (svdcount == SPA_DVAS_PER_BP) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4136 break; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4137 } |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4138 error = vdev_config_sync(svd, svdcount, txg); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4139 } else { |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4140 error = vdev_config_sync(rvd->vdev_child, |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4141 rvd->vdev_children, txg); |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4142 } |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4143 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4144 spa_config_exit(spa, SCL_STATE, FTAG); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4145 |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4146 if (error == 0) |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4147 break; |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4148 zio_suspend(spa, NULL); |
|
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4149 zio_resume_wait(spa); |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4150 } |
| 2082 | 4151 dmu_tx_commit(tx); |
| 4152 | |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4153 /* |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4154 * Clear the dirty config list. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4155 */ |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4156 while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL) |
|
1635
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4157 vdev_config_clean(vd); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4158 |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4159 /* |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4160 * Now that the new config has synced transactionally, |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4161 * let it become visible to the config cache. |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4162 */ |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4163 if (spa->spa_config_syncing != NULL) { |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4164 spa_config_set(spa, spa->spa_config_syncing); |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4165 spa->spa_config_txg = txg; |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4166 spa->spa_config_syncing = NULL; |
|
0ab1193d47cb
6398664 zpool detach: missing argument to error message causes core dump
bonwick
parents:
1601
diff
changeset
|
4167 } |
| 789 | 4168 |
| 4169 spa->spa_ubsync = spa->spa_uberblock; | |
| 4170 | |
| 4171 /* | |
| 4172 * Clean up the ZIL records for the synced txg. | |
| 4173 */ | |
| 4174 dsl_pool_zil_clean(dp); | |
| 4175 | |
| 4176 /* | |
| 4177 * Update usable space statistics. | |
| 4178 */ | |
| 4179 while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg))) | |
| 4180 vdev_sync_done(vd, txg); | |
| 4181 | |
| 4182 /* | |
| 4183 * It had better be the case that we didn't dirty anything | |
| 2082 | 4184 * since vdev_config_sync(). |
| 789 | 4185 */ |
| 4186 ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg)); | |
| 4187 ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg)); | |
| 4188 ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg)); | |
| 4189 ASSERT(bpl->bpl_queue == NULL); | |
| 4190 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4191 spa_config_exit(spa, SCL_CONFIG, FTAG); |
| 1544 | 4192 |
| 4193 /* | |
| 4194 * If any async tasks have been requested, kick them off. | |
| 4195 */ | |
| 4196 spa_async_dispatch(spa); | |
| 789 | 4197 } |
| 4198 | |
| 4199 /* | |
| 4200 * Sync all pools. We don't want to hold the namespace lock across these | |
| 4201 * operations, so we take a reference on the spa_t and drop the lock during the | |
| 4202 * sync. | |
| 4203 */ | |
| 4204 void | |
| 4205 spa_sync_allpools(void) | |
| 4206 { | |
| 4207 spa_t *spa = NULL; | |
| 4208 mutex_enter(&spa_namespace_lock); | |
| 4209 while ((spa = spa_next(spa)) != NULL) { | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4210 if (spa_state(spa) != POOL_STATE_ACTIVE || spa_suspended(spa)) |
| 789 | 4211 continue; |
| 4212 spa_open_ref(spa, FTAG); | |
| 4213 mutex_exit(&spa_namespace_lock); | |
| 4214 txg_wait_synced(spa_get_dsl(spa), 0); | |
| 4215 mutex_enter(&spa_namespace_lock); | |
| 4216 spa_close(spa, FTAG); | |
| 4217 } | |
| 4218 mutex_exit(&spa_namespace_lock); | |
| 4219 } | |
| 4220 | |
| 4221 /* | |
| 4222 * ========================================================================== | |
| 4223 * Miscellaneous routines | |
| 4224 * ========================================================================== | |
| 4225 */ | |
| 4226 | |
| 4227 /* | |
| 4228 * Remove all pools in the system. | |
| 4229 */ | |
| 4230 void | |
| 4231 spa_evict_all(void) | |
| 4232 { | |
| 4233 spa_t *spa; | |
| 4234 | |
| 4235 /* | |
| 4236 * Remove all cached state. All pools should be closed now, | |
| 4237 * so every spa in the AVL tree should be unreferenced. | |
| 4238 */ | |
| 4239 mutex_enter(&spa_namespace_lock); | |
| 4240 while ((spa = spa_next(NULL)) != NULL) { | |
| 4241 /* | |
| 1544 | 4242 * Stop async tasks. The async thread may need to detach |
| 4243 * a device that's been replaced, which requires grabbing | |
| 4244 * spa_namespace_lock, so we must drop it here. | |
| 789 | 4245 */ |
| 4246 spa_open_ref(spa, FTAG); | |
| 4247 mutex_exit(&spa_namespace_lock); | |
| 1544 | 4248 spa_async_suspend(spa); |
| 4808 | 4249 mutex_enter(&spa_namespace_lock); |
| 789 | 4250 spa_close(spa, FTAG); |
| 4251 | |
| 4252 if (spa->spa_state != POOL_STATE_UNINITIALIZED) { | |
| 4253 spa_unload(spa); | |
| 4254 spa_deactivate(spa); | |
| 4255 } | |
| 4256 spa_remove(spa); | |
| 4257 } | |
| 4258 mutex_exit(&spa_namespace_lock); | |
| 4259 } | |
| 1544 | 4260 |
| 4261 vdev_t * | |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4262 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux) |
| 1544 | 4263 { |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4264 vdev_t *vd; |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4265 int i; |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4266 |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4267 if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL) |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4268 return (vd); |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4269 |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4270 if (aux) { |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4271 for (i = 0; i < spa->spa_l2cache.sav_count; i++) { |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4272 vd = spa->spa_l2cache.sav_vdevs[i]; |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4273 if (vd->vdev_guid == guid) |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4274 return (vd); |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4275 } |
|
9425
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4276 |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4277 for (i = 0; i < spa->spa_spares.sav_count; i++) { |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4278 vd = spa->spa_spares.sav_vdevs[i]; |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4279 if (vd->vdev_guid == guid) |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4280 return (vd); |
|
e7ffacaec3a8
6799895 spa_add_spares() needs to be protected by config lock
Eric Schrock <Eric.Schrock@Sun.COM>
parents:
9276
diff
changeset
|
4281 } |
|
6643
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4282 } |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4283 |
|
3a34b0dbb107
6625086 changing cachefile doesn't remove old cache on last user
eschrock
parents:
6615
diff
changeset
|
4284 return (NULL); |
| 1544 | 4285 } |
| 1760 | 4286 |
| 4287 void | |
| 5094 | 4288 spa_upgrade(spa_t *spa, uint64_t version) |
| 1760 | 4289 { |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4290 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); |
| 1760 | 4291 |
| 4292 /* | |
| 4293 * This should only be called for a non-faulted pool, and since a | |
| 4294 * future version would result in an unopenable pool, this shouldn't be | |
| 4295 * possible. | |
| 4296 */ | |
| 4577 | 4297 ASSERT(spa->spa_uberblock.ub_version <= SPA_VERSION); |
| 5094 | 4298 ASSERT(version >= spa->spa_uberblock.ub_version); |
| 4299 | |
| 4300 spa->spa_uberblock.ub_version = version; | |
| 1760 | 4301 vdev_config_dirty(spa->spa_root_vdev); |
| 4302 | |
|
7754
b80e4842ad54
6754011 SPA 3.0: lock breakup, i/o pipeline refactoring, device failure handling
Jeff Bonwick <Jeff.Bonwick@Sun.COM>
parents:
7706
diff
changeset
|
4303 spa_config_exit(spa, SCL_ALL, FTAG); |
| 2082 | 4304 |
| 4305 txg_wait_synced(spa_get_dsl(spa), 0); | |
| 1760 | 4306 } |
| 2082 | 4307 |
| 4308 boolean_t | |
| 4309 spa_has_spare(spa_t *spa, uint64_t guid) | |
| 4310 { | |
| 4311 int i; | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
4312 uint64_t spareguid; |
| 5450 | 4313 spa_aux_vdev_t *sav = &spa->spa_spares; |
| 4314 | |
| 4315 for (i = 0; i < sav->sav_count; i++) | |
| 4316 if (sav->sav_vdevs[i]->vdev_guid == guid) | |
| 2082 | 4317 return (B_TRUE); |
| 4318 | |
| 5450 | 4319 for (i = 0; i < sav->sav_npending; i++) { |
| 4320 if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID, | |
| 4321 &spareguid) == 0 && spareguid == guid) | |
|
3377
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
4322 return (B_TRUE); |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
4323 } |
|
a2fa338530c1
6393525 vdev_reopen() should verify that it's still the same device
eschrock
parents:
3290
diff
changeset
|
4324 |
| 2082 | 4325 return (B_FALSE); |
| 4326 } | |
| 3912 | 4327 |
| 4451 | 4328 /* |
|
7214
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4329 * Check if a pool has an active shared spare device. |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4330 * Note: reference count of an active spare is 2, as a spare and as a replace |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4331 */ |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4332 static boolean_t |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4333 spa_has_active_shared_spare(spa_t *spa) |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4334 { |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4335 int i, refcnt; |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4336 uint64_t pool; |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4337 spa_aux_vdev_t *sav = &spa->spa_spares; |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4338 |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4339 for (i = 0; i < sav->sav_count; i++) { |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4340 if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool, |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4341 &refcnt) && pool != 0ULL && pool == spa_guid(spa) && |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4342 refcnt > 2) |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4343 return (B_TRUE); |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4344 } |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4345 |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4346 return (B_FALSE); |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4347 } |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4348 |
|
04c540040a32
6721908 A hot spare "in use" in an exported zpool, is stolen when a disk fails in an imported pool.
lling
parents:
7184
diff
changeset
|
4349 /* |
| 4451 | 4350 * Post a sysevent corresponding to the given event. The 'name' must be one of |
| 4351 * the event definitions in sys/sysevent/eventdefs.h. The payload will be | |
| 4352 * filled in from the spa and (optionally) the vdev. This doesn't do anything | |
| 4353 * in the userland libzpool, as we don't want consumers to misinterpret ztest | |
| 4354 * or zdb as real changes. | |
| 4355 */ | |
| 4356 void | |
| 4357 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name) | |
| 4358 { | |
| 4359 #ifdef _KERNEL | |
| 4360 sysevent_t *ev; | |
| 4361 sysevent_attr_list_t *attr = NULL; | |
| 4362 sysevent_value_t value; | |
| 4363 sysevent_id_t eid; | |
| 4364 | |
| 4365 ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs", | |
| 4366 SE_SLEEP); | |
| 4367 | |
| 4368 value.value_type = SE_DATA_TYPE_STRING; | |
| 4369 value.value.sv_string = spa_name(spa); | |
| 4370 if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0) | |
| 4371 goto done; | |
| 4372 | |
| 4373 value.value_type = SE_DATA_TYPE_UINT64; | |
| 4374 value.value.sv_uint64 = spa_guid(spa); | |
| 4375 if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0) | |
| 4376 goto done; | |
| 4377 | |
| 4378 if (vd) { | |
| 4379 value.value_type = SE_DATA_TYPE_UINT64; | |
| 4380 value.value.sv_uint64 = vd->vdev_guid; | |
| 4381 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value, | |
| 4382 SE_SLEEP) != 0) | |
| 4383 goto done; | |
| 4384 | |
| 4385 if (vd->vdev_path) { | |
| 4386 value.value_type = SE_DATA_TYPE_STRING; | |
| 4387 value.value.sv_string = vd->vdev_path; | |
| 4388 if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH, | |
| 4389 &value, SE_SLEEP) != 0) | |
| 4390 goto done; | |
| 4391 } | |
| 4392 } | |
| 4393 | |
|
5756
05eb4c1ff492
6585441 spa_event_notify() doesn't pass its attributes
eschrock
parents:
5688
diff
changeset
|
4394 if (sysevent_attach_attributes(ev, attr) != 0) |
|
05eb4c1ff492
6585441 spa_event_notify() doesn't pass its attributes
eschrock
parents:
5688
diff
changeset
|
4395 goto done; |
|
05eb4c1ff492
6585441 spa_event_notify() doesn't pass its attributes
eschrock
parents:
5688
diff
changeset
|
4396 attr = NULL; |
|
05eb4c1ff492
6585441 spa_event_notify() doesn't pass its attributes
eschrock
parents:
5688
diff
changeset
|
4397 |
| 4451 | 4398 (void) log_sysevent(ev, SE_SLEEP, &eid); |
| 4399 | |
| 4400 done: | |
| 4401 if (attr) | |
| 4402 sysevent_free_attr(attr); | |
| 4403 sysevent_free(ev); | |
| 4404 #endif | |
| 4405 } |