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