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 https://opensource.org/licenses/CDDL-1.0.
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 */
46static int
47pool_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
69static nvlist_t *
70refresh_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
100static nvlist_t *
101refresh_config_libzfs(void *handle, nvlist_t *tryconfig)
102{
103	return (refresh_config((libzfs_handle_t *)handle, tryconfig));
104}
105
106static int
107pool_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
113const 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 */
121static uint64_t
122label_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 */
134int
135zpool_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
222static boolean_t
223find_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
241typedef struct aux_cbdata {
242	const char	*cb_type;
243	uint64_t	cb_guid;
244	zpool_handle_t	*cb_zhp;
245} aux_cbdata_t;
246
247static int
248find_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 */
278int
279zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr,
280    boolean_t *inuse)
281{
282	nvlist_t *config;
283	const 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		return (-1);
296
297	if (config == NULL)
298		return (0);
299
300	stateval = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE);
301	vdev_guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID);
302
303	if (stateval != POOL_STATE_SPARE && stateval != POOL_STATE_L2CACHE) {
304		name = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME);
305		guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID);
306	}
307
308	switch (stateval) {
309	case POOL_STATE_EXPORTED:
310		/*
311		 * A pool with an exported state may in fact be imported
312		 * read-only, so check the in-core state to see if it's
313		 * active and imported read-only.  If it is, set
314		 * its state to active.
315		 */
316		if (pool_active(hdl, name, guid, &isactive) == 0 && isactive &&
317		    (zhp = zpool_open_canfail(hdl, name)) != NULL) {
318			if (zpool_get_prop_int(zhp, ZPOOL_PROP_READONLY, NULL))
319				stateval = POOL_STATE_ACTIVE;
320
321			/*
322			 * All we needed the zpool handle for is the
323			 * readonly prop check.
324			 */
325			zpool_close(zhp);
326		}
327
328		ret = B_TRUE;
329		break;
330
331	case POOL_STATE_ACTIVE:
332		/*
333		 * For an active pool, we have to determine if it's really part
334		 * of a currently active pool (in which case the pool will exist
335		 * and the guid will be the same), or whether it's part of an
336		 * active pool that was disconnected without being explicitly
337		 * exported.
338		 */
339		if (pool_active(hdl, name, guid, &isactive) != 0) {
340			nvlist_free(config);
341			return (-1);
342		}
343
344		if (isactive) {
345			/*
346			 * Because the device may have been removed while
347			 * offlined, we only report it as active if the vdev is
348			 * still present in the config.  Otherwise, pretend like
349			 * it's not in use.
350			 */
351			if ((zhp = zpool_open_canfail(hdl, name)) != NULL &&
352			    (pool_config = zpool_get_config(zhp, NULL))
353			    != NULL) {
354				nvlist_t *nvroot = fnvlist_lookup_nvlist(
355				    pool_config, ZPOOL_CONFIG_VDEV_TREE);
356				ret = find_guid(nvroot, vdev_guid);
357			} else {
358				ret = B_FALSE;
359			}
360
361			/*
362			 * If this is an active spare within another pool, we
363			 * treat it like an unused hot spare.  This allows the
364			 * user to create a pool with a hot spare that currently
365			 * in use within another pool.  Since we return B_TRUE,
366			 * libdiskmgt will continue to prevent generic consumers
367			 * from using the device.
368			 */
369			if (ret && nvlist_lookup_uint64(config,
370			    ZPOOL_CONFIG_IS_SPARE, &isspare) == 0 && isspare)
371				stateval = POOL_STATE_SPARE;
372
373			if (zhp != NULL)
374				zpool_close(zhp);
375		} else {
376			stateval = POOL_STATE_POTENTIALLY_ACTIVE;
377			ret = B_TRUE;
378		}
379		break;
380
381	case POOL_STATE_SPARE:
382		/*
383		 * For a hot spare, it can be either definitively in use, or
384		 * potentially active.  To determine if it's in use, we iterate
385		 * over all pools in the system and search for one with a spare
386		 * with a matching guid.
387		 *
388		 * Due to the shared nature of spares, we don't actually report
389		 * the potentially active case as in use.  This means the user
390		 * can freely create pools on the hot spares of exported pools,
391		 * but to do otherwise makes the resulting code complicated, and
392		 * we end up having to deal with this case anyway.
393		 */
394		cb.cb_zhp = NULL;
395		cb.cb_guid = vdev_guid;
396		cb.cb_type = ZPOOL_CONFIG_SPARES;
397		if (zpool_iter(hdl, find_aux, &cb) == 1) {
398			name = (char *)zpool_get_name(cb.cb_zhp);
399			ret = B_TRUE;
400		} else {
401			ret = B_FALSE;
402		}
403		break;
404
405	case POOL_STATE_L2CACHE:
406
407		/*
408		 * Check if any pool is currently using this l2cache device.
409		 */
410		cb.cb_zhp = NULL;
411		cb.cb_guid = vdev_guid;
412		cb.cb_type = ZPOOL_CONFIG_L2CACHE;
413		if (zpool_iter(hdl, find_aux, &cb) == 1) {
414			name = (char *)zpool_get_name(cb.cb_zhp);
415			ret = B_TRUE;
416		} else {
417			ret = B_FALSE;
418		}
419		break;
420
421	default:
422		ret = B_FALSE;
423	}
424
425
426	if (ret) {
427		*namestr = zfs_strdup(hdl, name);
428		*state = (pool_state_t)stateval;
429	}
430
431	if (cb.cb_zhp)
432		zpool_close(cb.cb_zhp);
433
434	nvlist_free(config);
435	*inuse = ret;
436	return (0);
437}
438