1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 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 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/spa.h> 28 #include <sys/spa_impl.h> 29 #include <sys/nvpair.h> 30 #include <sys/uio.h> 31 #include <sys/fs/zfs.h> 32 #include <sys/vdev_impl.h> 33 #include <sys/zfs_ioctl.h> 34 #include <sys/utsname.h> 35 #include <sys/systeminfo.h> 36 #include <sys/sunddi.h> 37 #ifdef _KERNEL 38 #include <sys/kobj.h> 39 #include <sys/zone.h> 40 #endif 41 42 /* 43 * Pool configuration repository. 44 * 45 * Pool configuration is stored as a packed nvlist on the filesystem. By 46 * default, all pools are stored in /etc/zfs/zpool.cache and loaded on boot 47 * (when the ZFS module is loaded). Pools can also have the 'cachefile' 48 * property set that allows them to be stored in an alternate location until 49 * the control of external software. 50 * 51 * For each cache file, we have a single nvlist which holds all the 52 * configuration information. When the module loads, we read this information 53 * from /etc/zfs/zpool.cache and populate the SPA namespace. This namespace is 54 * maintained independently in spa.c. Whenever the namespace is modified, or 55 * the configuration of a pool is changed, we call spa_config_sync(), which 56 * walks through all the active pools and writes the configuration to disk. 57 */ 58 59 static uint64_t spa_config_generation = 1; 60 61 /* 62 * This can be overridden in userland to preserve an alternate namespace for 63 * userland pools when doing testing. 64 */ 65 const char *spa_config_path = ZPOOL_CACHE; 66 67 /* 68 * Called when the module is first loaded, this routine loads the configuration 69 * file into the SPA namespace. It does not actually open or load the pools; it 70 * only populates the namespace. 71 */ 72 void 73 spa_config_load(void) 74 { 75 void *buf = NULL; 76 nvlist_t *nvlist, *child; 77 nvpair_t *nvpair; 78 char *pathname; 79 struct _buf *file; 80 uint64_t fsize; 81 82 /* 83 * Open the configuration file. 84 */ 85 pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 86 87 (void) snprintf(pathname, MAXPATHLEN, "%s%s", 88 (rootdir != NULL) ? "./" : "", spa_config_path); 89 90 file = kobj_open_file(pathname); 91 92 kmem_free(pathname, MAXPATHLEN); 93 94 if (file == (struct _buf *)-1) 95 return; 96 97 if (kobj_get_filesize(file, &fsize) != 0) 98 goto out; 99 100 buf = kmem_alloc(fsize, KM_SLEEP); 101 102 /* 103 * Read the nvlist from the file. 104 */ 105 if (kobj_read_file(file, buf, fsize, 0) < 0) 106 goto out; 107 108 /* 109 * Unpack the nvlist. 110 */ 111 if (nvlist_unpack(buf, fsize, &nvlist, KM_SLEEP) != 0) 112 goto out; 113 114 /* 115 * Iterate over all elements in the nvlist, creating a new spa_t for 116 * each one with the specified configuration. 117 */ 118 mutex_enter(&spa_namespace_lock); 119 nvpair = NULL; 120 while ((nvpair = nvlist_next_nvpair(nvlist, nvpair)) != NULL) { 121 if (nvpair_type(nvpair) != DATA_TYPE_NVLIST) 122 continue; 123 124 VERIFY(nvpair_value_nvlist(nvpair, &child) == 0); 125 126 if (spa_lookup(nvpair_name(nvpair)) != NULL) 127 continue; 128 (void) spa_add(nvpair_name(nvpair), child, NULL); 129 } 130 mutex_exit(&spa_namespace_lock); 131 132 nvlist_free(nvlist); 133 134 out: 135 if (buf != NULL) 136 kmem_free(buf, fsize); 137 138 kobj_close_file(file); 139 } 140 141 static void 142 spa_config_write(spa_config_dirent_t *dp, nvlist_t *nvl) 143 { 144 size_t buflen; 145 char *buf; 146 vnode_t *vp; 147 int oflags = FWRITE | FTRUNC | FCREAT | FOFFMAX; 148 char *temp; 149 150 /* 151 * If the nvlist is empty (NULL), then remove the old cachefile. 152 */ 153 if (nvl == NULL) { 154 (void) vn_remove(dp->scd_path, UIO_SYSSPACE, RMFILE); 155 return; 156 } 157 158 /* 159 * Pack the configuration into a buffer. 160 */ 161 VERIFY(nvlist_size(nvl, &buflen, NV_ENCODE_XDR) == 0); 162 163 buf = kmem_alloc(buflen, KM_SLEEP); 164 temp = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 165 166 VERIFY(nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_XDR, 167 KM_SLEEP) == 0); 168 169 /* 170 * Write the configuration to disk. We need to do the traditional 171 * 'write to temporary file, sync, move over original' to make sure we 172 * always have a consistent view of the data. 173 */ 174 (void) snprintf(temp, MAXPATHLEN, "%s.tmp", dp->scd_path); 175 176 if (vn_open(temp, UIO_SYSSPACE, oflags, 0644, &vp, CRCREAT, 0) == 0) { 177 if (vn_rdwr(UIO_WRITE, vp, buf, buflen, 0, UIO_SYSSPACE, 178 0, RLIM64_INFINITY, kcred, NULL) == 0 && 179 VOP_FSYNC(vp, FSYNC, kcred, NULL) == 0) { 180 (void) vn_rename(temp, dp->scd_path, UIO_SYSSPACE); 181 } 182 (void) VOP_CLOSE(vp, oflags, 1, 0, kcred, NULL); 183 VN_RELE(vp); 184 } 185 186 (void) vn_remove(temp, UIO_SYSSPACE, RMFILE); 187 188 kmem_free(buf, buflen); 189 kmem_free(temp, MAXPATHLEN); 190 } 191 192 /* 193 * Synchronize pool configuration to disk. This must be called with the 194 * namespace lock held. 195 */ 196 void 197 spa_config_sync(spa_t *target, boolean_t removing, boolean_t postsysevent) 198 { 199 spa_config_dirent_t *dp, *tdp; 200 nvlist_t *nvl; 201 202 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 203 204 if (rootdir == NULL || !(spa_mode_global & FWRITE)) 205 return; 206 207 /* 208 * Iterate over all cachefiles for the pool, past or present. When the 209 * cachefile is changed, the new one is pushed onto this list, allowing 210 * us to update previous cachefiles that no longer contain this pool. 211 */ 212 for (dp = list_head(&target->spa_config_list); dp != NULL; 213 dp = list_next(&target->spa_config_list, dp)) { 214 spa_t *spa = NULL; 215 if (dp->scd_path == NULL) 216 continue; 217 218 /* 219 * Iterate over all pools, adding any matching pools to 'nvl'. 220 */ 221 nvl = NULL; 222 while ((spa = spa_next(spa)) != NULL) { 223 if (spa == target && removing) 224 continue; 225 226 mutex_enter(&spa->spa_props_lock); 227 tdp = list_head(&spa->spa_config_list); 228 if (spa->spa_config == NULL || 229 tdp->scd_path == NULL || 230 strcmp(tdp->scd_path, dp->scd_path) != 0) { 231 mutex_exit(&spa->spa_props_lock); 232 continue; 233 } 234 235 if (nvl == NULL) 236 VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, 237 KM_SLEEP) == 0); 238 239 VERIFY(nvlist_add_nvlist(nvl, spa->spa_name, 240 spa->spa_config) == 0); 241 mutex_exit(&spa->spa_props_lock); 242 } 243 244 spa_config_write(dp, nvl); 245 nvlist_free(nvl); 246 } 247 248 /* 249 * Remove any config entries older than the current one. 250 */ 251 dp = list_head(&target->spa_config_list); 252 while ((tdp = list_next(&target->spa_config_list, dp)) != NULL) { 253 list_remove(&target->spa_config_list, tdp); 254 if (tdp->scd_path != NULL) 255 spa_strfree(tdp->scd_path); 256 kmem_free(tdp, sizeof (spa_config_dirent_t)); 257 } 258 259 spa_config_generation++; 260 261 if (postsysevent) 262 spa_event_notify(target, NULL, ESC_ZFS_CONFIG_SYNC); 263 } 264 265 /* 266 * Sigh. Inside a local zone, we don't have access to /etc/zfs/zpool.cache, 267 * and we don't want to allow the local zone to see all the pools anyway. 268 * So we have to invent the ZFS_IOC_CONFIG ioctl to grab the configuration 269 * information for all pool visible within the zone. 270 */ 271 nvlist_t * 272 spa_all_configs(uint64_t *generation) 273 { 274 nvlist_t *pools; 275 spa_t *spa = NULL; 276 277 if (*generation == spa_config_generation) 278 return (NULL); 279 280 VERIFY(nvlist_alloc(&pools, NV_UNIQUE_NAME, KM_SLEEP) == 0); 281 282 mutex_enter(&spa_namespace_lock); 283 while ((spa = spa_next(spa)) != NULL) { 284 if (INGLOBALZONE(curproc) || 285 zone_dataset_visible(spa_name(spa), NULL)) { 286 mutex_enter(&spa->spa_props_lock); 287 VERIFY(nvlist_add_nvlist(pools, spa_name(spa), 288 spa->spa_config) == 0); 289 mutex_exit(&spa->spa_props_lock); 290 } 291 } 292 *generation = spa_config_generation; 293 mutex_exit(&spa_namespace_lock); 294 295 return (pools); 296 } 297 298 void 299 spa_config_set(spa_t *spa, nvlist_t *config) 300 { 301 mutex_enter(&spa->spa_props_lock); 302 if (spa->spa_config != NULL) 303 nvlist_free(spa->spa_config); 304 spa->spa_config = config; 305 mutex_exit(&spa->spa_props_lock); 306 } 307 308 /* Add discovered rewind info, if any to the provided nvlist */ 309 void 310 spa_rewind_data_to_nvlist(spa_t *spa, nvlist_t *tonvl) 311 { 312 int64_t loss = 0; 313 314 if (tonvl == NULL || spa->spa_load_txg == 0) 315 return; 316 317 VERIFY(nvlist_add_uint64(tonvl, ZPOOL_CONFIG_LOAD_TIME, 318 spa->spa_load_txg_ts) == 0); 319 if (spa->spa_last_ubsync_txg) 320 loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts; 321 VERIFY(nvlist_add_int64(tonvl, ZPOOL_CONFIG_REWIND_TIME, loss) == 0); 322 VERIFY(nvlist_add_uint64(tonvl, ZPOOL_CONFIG_LOAD_DATA_ERRORS, 323 spa->spa_load_data_errors) == 0); 324 } 325 326 /* 327 * Generate the pool's configuration based on the current in-core state. 328 * We infer whether to generate a complete config or just one top-level config 329 * based on whether vd is the root vdev. 330 */ 331 nvlist_t * 332 spa_config_generate(spa_t *spa, vdev_t *vd, uint64_t txg, int getstats) 333 { 334 nvlist_t *config, *nvroot; 335 vdev_t *rvd = spa->spa_root_vdev; 336 unsigned long hostid = 0; 337 boolean_t locked = B_FALSE; 338 339 if (vd == NULL) { 340 vd = rvd; 341 locked = B_TRUE; 342 spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER); 343 } 344 345 ASSERT(spa_config_held(spa, SCL_CONFIG | SCL_STATE, RW_READER) == 346 (SCL_CONFIG | SCL_STATE)); 347 348 /* 349 * If txg is -1, report the current value of spa->spa_config_txg. 350 */ 351 if (txg == -1ULL) 352 txg = spa->spa_config_txg; 353 354 VERIFY(nvlist_alloc(&config, NV_UNIQUE_NAME, KM_SLEEP) == 0); 355 356 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION, 357 spa_version(spa)) == 0); 358 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, 359 spa_name(spa)) == 0); 360 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE, 361 spa_state(spa)) == 0); 362 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG, 363 txg) == 0); 364 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID, 365 spa_guid(spa)) == 0); 366 #ifdef _KERNEL 367 hostid = zone_get_hostid(NULL); 368 #else /* _KERNEL */ 369 /* 370 * We're emulating the system's hostid in userland, so we can't use 371 * zone_get_hostid(). 372 */ 373 (void) ddi_strtoul(hw_serial, NULL, 10, &hostid); 374 #endif /* _KERNEL */ 375 if (hostid != 0) { 376 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_HOSTID, 377 hostid) == 0); 378 } 379 VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_HOSTNAME, 380 utsname.nodename) == 0); 381 382 if (vd != rvd) { 383 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TOP_GUID, 384 vd->vdev_top->vdev_guid) == 0); 385 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_GUID, 386 vd->vdev_guid) == 0); 387 if (vd->vdev_isspare) 388 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_IS_SPARE, 389 1ULL) == 0); 390 if (vd->vdev_islog) 391 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_IS_LOG, 392 1ULL) == 0); 393 vd = vd->vdev_top; /* label contains top config */ 394 } 395 396 /* 397 * Add the top-level config. We even add this on pools which 398 * don't support holes in the namespace as older pools will 399 * just ignore it. 400 */ 401 vdev_top_config_generate(spa, config); 402 403 nvroot = vdev_config_generate(spa, vd, getstats, B_FALSE, B_FALSE); 404 VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0); 405 nvlist_free(nvroot); 406 407 spa_rewind_data_to_nvlist(spa, config); 408 409 if (locked) 410 spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG); 411 412 return (config); 413 } 414 415 /* 416 * Update all disk labels, generate a fresh config based on the current 417 * in-core state, and sync the global config cache (do not sync the config 418 * cache if this is a booting rootpool). 419 */ 420 void 421 spa_config_update(spa_t *spa, int what) 422 { 423 vdev_t *rvd = spa->spa_root_vdev; 424 uint64_t txg; 425 int c; 426 427 ASSERT(MUTEX_HELD(&spa_namespace_lock)); 428 429 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER); 430 txg = spa_last_synced_txg(spa) + 1; 431 if (what == SPA_CONFIG_UPDATE_POOL) { 432 vdev_config_dirty(rvd); 433 } else { 434 /* 435 * If we have top-level vdevs that were added but have 436 * not yet been prepared for allocation, do that now. 437 * (It's safe now because the config cache is up to date, 438 * so it will be able to translate the new DVAs.) 439 * See comments in spa_vdev_add() for full details. 440 */ 441 for (c = 0; c < rvd->vdev_children; c++) { 442 vdev_t *tvd = rvd->vdev_child[c]; 443 if (tvd->vdev_ms_array == 0) 444 vdev_metaslab_set_size(tvd); 445 vdev_expand(tvd, txg); 446 } 447 } 448 spa_config_exit(spa, SCL_ALL, FTAG); 449 450 /* 451 * Wait for the mosconfig to be regenerated and synced. 452 */ 453 txg_wait_synced(spa->spa_dsl_pool, txg); 454 455 /* 456 * Update the global config cache to reflect the new mosconfig. 457 */ 458 if (!spa->spa_is_root) 459 spa_config_sync(spa, B_FALSE, what != SPA_CONFIG_UPDATE_POOL); 460 461 if (what == SPA_CONFIG_UPDATE_POOL) 462 spa_config_update(spa, SPA_CONFIG_UPDATE_VDEVS); 463 } 464