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