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 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2012, 2018 by Delphix. All rights reserved. 25 * Copyright 2015 RackTop Systems. 26 * Copyright (c) 2016, Intel Corporation. 27 */ 28 29 #include <errno.h> 30 #include <libintl.h> 31 #include <libgen.h> 32 #include <stddef.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <sys/stat.h> 36 #include <unistd.h> 37 #include <sys/vdev_impl.h> 38 #include <libzfs.h> 39 #include "libzfs_impl.h" 40 #include <libzutil.h> 41 #include <sys/arc_impl.h> 42 43 /* 44 * Returns true if the named pool matches the given GUID. 45 */ 46 static int 47 pool_active(libzfs_handle_t *hdl, const char *name, uint64_t guid, 48 boolean_t *isactive) 49 { 50 zpool_handle_t *zhp; 51 52 if (zpool_open_silent(hdl, name, &zhp) != 0) 53 return (-1); 54 55 if (zhp == NULL) { 56 *isactive = B_FALSE; 57 return (0); 58 } 59 60 uint64_t theguid = fnvlist_lookup_uint64(zhp->zpool_config, 61 ZPOOL_CONFIG_POOL_GUID); 62 63 zpool_close(zhp); 64 65 *isactive = (theguid == guid); 66 return (0); 67 } 68 69 static nvlist_t * 70 refresh_config(libzfs_handle_t *hdl, nvlist_t *config) 71 { 72 nvlist_t *nvl; 73 zfs_cmd_t zc = {"\0"}; 74 int err, dstbuf_size; 75 76 zcmd_write_conf_nvlist(hdl, &zc, config); 77 78 dstbuf_size = MAX(CONFIG_BUF_MINSIZE, zc.zc_nvlist_conf_size * 32); 79 80 zcmd_alloc_dst_nvlist(hdl, &zc, dstbuf_size); 81 82 while ((err = zfs_ioctl(hdl, ZFS_IOC_POOL_TRYIMPORT, 83 &zc)) != 0 && errno == ENOMEM) 84 zcmd_expand_dst_nvlist(hdl, &zc); 85 86 if (err) { 87 zcmd_free_nvlists(&zc); 88 return (NULL); 89 } 90 91 if (zcmd_read_dst_nvlist(hdl, &zc, &nvl) != 0) { 92 zcmd_free_nvlists(&zc); 93 return (NULL); 94 } 95 96 zcmd_free_nvlists(&zc); 97 return (nvl); 98 } 99 100 static nvlist_t * 101 refresh_config_libzfs(void *handle, nvlist_t *tryconfig) 102 { 103 return (refresh_config((libzfs_handle_t *)handle, tryconfig)); 104 } 105 106 static int 107 pool_active_libzfs(void *handle, const char *name, uint64_t guid, 108 boolean_t *isactive) 109 { 110 return (pool_active((libzfs_handle_t *)handle, name, guid, isactive)); 111 } 112 113 const pool_config_ops_t libzfs_config_ops = { 114 .pco_refresh_config = refresh_config_libzfs, 115 .pco_pool_active = pool_active_libzfs, 116 }; 117 118 /* 119 * Return the offset of the given label. 120 */ 121 static uint64_t 122 label_offset(uint64_t size, int l) 123 { 124 ASSERT(P2PHASE_TYPED(size, sizeof (vdev_label_t), uint64_t) == 0); 125 return (l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ? 126 0 : size - VDEV_LABELS * sizeof (vdev_label_t))); 127 } 128 129 /* 130 * Given a file descriptor, clear (zero) the label information. This function 131 * is used in the appliance stack as part of the ZFS sysevent module and 132 * to implement the "zpool labelclear" command. 133 */ 134 int 135 zpool_clear_label(int fd) 136 { 137 struct stat64 statbuf; 138 int l; 139 vdev_label_t *label; 140 uint64_t size; 141 boolean_t labels_cleared = B_FALSE, clear_l2arc_header = B_FALSE, 142 header_cleared = B_FALSE; 143 144 if (fstat64_blk(fd, &statbuf) == -1) 145 return (0); 146 147 size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t); 148 149 if ((label = calloc(1, sizeof (vdev_label_t))) == NULL) 150 return (-1); 151 152 for (l = 0; l < VDEV_LABELS; l++) { 153 uint64_t state, guid, l2cache; 154 nvlist_t *config; 155 156 if (pread64(fd, label, sizeof (vdev_label_t), 157 label_offset(size, l)) != sizeof (vdev_label_t)) { 158 continue; 159 } 160 161 if (nvlist_unpack(label->vl_vdev_phys.vp_nvlist, 162 sizeof (label->vl_vdev_phys.vp_nvlist), &config, 0) != 0) { 163 continue; 164 } 165 166 /* Skip labels which do not have a valid guid. */ 167 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, 168 &guid) != 0 || guid == 0) { 169 nvlist_free(config); 170 continue; 171 } 172 173 /* Skip labels which are not in a known valid state. */ 174 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 175 &state) != 0 || state > POOL_STATE_L2CACHE) { 176 nvlist_free(config); 177 continue; 178 } 179 180 /* If the device is a cache device clear the header. */ 181 if (!clear_l2arc_header) { 182 if (nvlist_lookup_uint64(config, 183 ZPOOL_CONFIG_POOL_STATE, &l2cache) == 0 && 184 l2cache == POOL_STATE_L2CACHE) { 185 clear_l2arc_header = B_TRUE; 186 } 187 } 188 189 nvlist_free(config); 190 191 /* 192 * A valid label was found, overwrite this label's nvlist 193 * and uberblocks with zeros on disk. This is done to prevent 194 * system utilities, like blkid, from incorrectly detecting a 195 * partial label. The leading pad space is left untouched. 196 */ 197 memset(label, 0, sizeof (vdev_label_t)); 198 size_t label_size = sizeof (vdev_label_t) - (2 * VDEV_PAD_SIZE); 199 200 if (pwrite64(fd, label, label_size, label_offset(size, l) + 201 (2 * VDEV_PAD_SIZE)) == label_size) 202 labels_cleared = B_TRUE; 203 } 204 205 if (clear_l2arc_header) { 206 _Static_assert(sizeof (*label) >= sizeof (l2arc_dev_hdr_phys_t), 207 "label < l2arc_dev_hdr_phys_t"); 208 memset(label, 0, sizeof (l2arc_dev_hdr_phys_t)); 209 if (pwrite64(fd, label, sizeof (l2arc_dev_hdr_phys_t), 210 VDEV_LABEL_START_SIZE) == sizeof (l2arc_dev_hdr_phys_t)) 211 header_cleared = B_TRUE; 212 } 213 214 free(label); 215 216 if (!labels_cleared || (clear_l2arc_header && !header_cleared)) 217 return (-1); 218 219 return (0); 220 } 221 222 static boolean_t 223 find_guid(nvlist_t *nv, uint64_t guid) 224 { 225 nvlist_t **child; 226 uint_t c, children; 227 228 if (fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID) == guid) 229 return (B_TRUE); 230 231 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 232 &child, &children) == 0) { 233 for (c = 0; c < children; c++) 234 if (find_guid(child[c], guid)) 235 return (B_TRUE); 236 } 237 238 return (B_FALSE); 239 } 240 241 typedef struct aux_cbdata { 242 const char *cb_type; 243 uint64_t cb_guid; 244 zpool_handle_t *cb_zhp; 245 } aux_cbdata_t; 246 247 static int 248 find_aux(zpool_handle_t *zhp, void *data) 249 { 250 aux_cbdata_t *cbp = data; 251 nvlist_t **list; 252 uint_t count; 253 254 nvlist_t *nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, 255 ZPOOL_CONFIG_VDEV_TREE); 256 257 if (nvlist_lookup_nvlist_array(nvroot, cbp->cb_type, 258 &list, &count) == 0) { 259 for (uint_t i = 0; i < count; i++) { 260 uint64_t guid = fnvlist_lookup_uint64(list[i], 261 ZPOOL_CONFIG_GUID); 262 if (guid == cbp->cb_guid) { 263 cbp->cb_zhp = zhp; 264 return (1); 265 } 266 } 267 } 268 269 zpool_close(zhp); 270 return (0); 271 } 272 273 /* 274 * Determines if the pool is in use. If so, it returns true and the state of 275 * the pool as well as the name of the pool. Name string is allocated and 276 * must be freed by the caller. 277 */ 278 int 279 zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr, 280 boolean_t *inuse) 281 { 282 nvlist_t *config; 283 char *name = NULL; 284 boolean_t ret; 285 uint64_t guid = 0, vdev_guid; 286 zpool_handle_t *zhp; 287 nvlist_t *pool_config; 288 uint64_t stateval, isspare; 289 aux_cbdata_t cb = { 0 }; 290 boolean_t isactive; 291 292 *inuse = B_FALSE; 293 294 if (zpool_read_label(fd, &config, NULL) != 0) { 295 (void) no_memory(hdl); 296 return (-1); 297 } 298 299 if (config == NULL) 300 return (0); 301 302 stateval = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE); 303 vdev_guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID); 304 305 if (stateval != POOL_STATE_SPARE && stateval != POOL_STATE_L2CACHE) { 306 name = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME); 307 guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID); 308 } 309 310 switch (stateval) { 311 case POOL_STATE_EXPORTED: 312 /* 313 * A pool with an exported state may in fact be imported 314 * read-only, so check the in-core state to see if it's 315 * active and imported read-only. If it is, set 316 * its state to active. 317 */ 318 if (pool_active(hdl, name, guid, &isactive) == 0 && isactive && 319 (zhp = zpool_open_canfail(hdl, name)) != NULL) { 320 if (zpool_get_prop_int(zhp, ZPOOL_PROP_READONLY, NULL)) 321 stateval = POOL_STATE_ACTIVE; 322 323 /* 324 * All we needed the zpool handle for is the 325 * readonly prop check. 326 */ 327 zpool_close(zhp); 328 } 329 330 ret = B_TRUE; 331 break; 332 333 case POOL_STATE_ACTIVE: 334 /* 335 * For an active pool, we have to determine if it's really part 336 * of a currently active pool (in which case the pool will exist 337 * and the guid will be the same), or whether it's part of an 338 * active pool that was disconnected without being explicitly 339 * exported. 340 */ 341 if (pool_active(hdl, name, guid, &isactive) != 0) { 342 nvlist_free(config); 343 return (-1); 344 } 345 346 if (isactive) { 347 /* 348 * Because the device may have been removed while 349 * offlined, we only report it as active if the vdev is 350 * still present in the config. Otherwise, pretend like 351 * it's not in use. 352 */ 353 if ((zhp = zpool_open_canfail(hdl, name)) != NULL && 354 (pool_config = zpool_get_config(zhp, NULL)) 355 != NULL) { 356 nvlist_t *nvroot = fnvlist_lookup_nvlist( 357 pool_config, ZPOOL_CONFIG_VDEV_TREE); 358 ret = find_guid(nvroot, vdev_guid); 359 } else { 360 ret = B_FALSE; 361 } 362 363 /* 364 * If this is an active spare within another pool, we 365 * treat it like an unused hot spare. This allows the 366 * user to create a pool with a hot spare that currently 367 * in use within another pool. Since we return B_TRUE, 368 * libdiskmgt will continue to prevent generic consumers 369 * from using the device. 370 */ 371 if (ret && nvlist_lookup_uint64(config, 372 ZPOOL_CONFIG_IS_SPARE, &isspare) == 0 && isspare) 373 stateval = POOL_STATE_SPARE; 374 375 if (zhp != NULL) 376 zpool_close(zhp); 377 } else { 378 stateval = POOL_STATE_POTENTIALLY_ACTIVE; 379 ret = B_TRUE; 380 } 381 break; 382 383 case POOL_STATE_SPARE: 384 /* 385 * For a hot spare, it can be either definitively in use, or 386 * potentially active. To determine if it's in use, we iterate 387 * over all pools in the system and search for one with a spare 388 * with a matching guid. 389 * 390 * Due to the shared nature of spares, we don't actually report 391 * the potentially active case as in use. This means the user 392 * can freely create pools on the hot spares of exported pools, 393 * but to do otherwise makes the resulting code complicated, and 394 * we end up having to deal with this case anyway. 395 */ 396 cb.cb_zhp = NULL; 397 cb.cb_guid = vdev_guid; 398 cb.cb_type = ZPOOL_CONFIG_SPARES; 399 if (zpool_iter(hdl, find_aux, &cb) == 1) { 400 name = (char *)zpool_get_name(cb.cb_zhp); 401 ret = B_TRUE; 402 } else { 403 ret = B_FALSE; 404 } 405 break; 406 407 case POOL_STATE_L2CACHE: 408 409 /* 410 * Check if any pool is currently using this l2cache device. 411 */ 412 cb.cb_zhp = NULL; 413 cb.cb_guid = vdev_guid; 414 cb.cb_type = ZPOOL_CONFIG_L2CACHE; 415 if (zpool_iter(hdl, find_aux, &cb) == 1) { 416 name = (char *)zpool_get_name(cb.cb_zhp); 417 ret = B_TRUE; 418 } else { 419 ret = B_FALSE; 420 } 421 break; 422 423 default: 424 ret = B_FALSE; 425 } 426 427 428 if (ret) { 429 *namestr = zfs_strdup(hdl, name); 430 *state = (pool_state_t)stateval; 431 } 432 433 if (cb.cb_zhp) 434 zpool_close(cb.cb_zhp); 435 436 nvlist_free(config); 437 *inuse = ret; 438 return (0); 439 } 440