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/*
23 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27/*
28 * Copyright (c) 2012 by Delphix. All rights reserved.
29 * Copyright (c) 2015 by Syneto S.R.L. All rights reserved.
30 * Copyright 2016 Nexenta Systems, Inc.
31 */
32
33/*
34 * The pool configuration repository is stored in /etc/zfs/zpool.cache as a
35 * single packed nvlist.  While it would be nice to just read in this
36 * file from userland, this wouldn't work from a local zone.  So we have to have
37 * a zpool ioctl to return the complete configuration for all pools.  In the
38 * global zone, this will be identical to reading the file and unpacking it in
39 * userland.
40 */
41
42#include <errno.h>
43#include <sys/stat.h>
44#include <fcntl.h>
45#include <stddef.h>
46#include <string.h>
47#include <unistd.h>
48#include <libintl.h>
49#include <libuutil.h>
50
51#include "libzfs_impl.h"
52
53typedef struct config_node {
54	char		*cn_name;
55	nvlist_t	*cn_config;
56	uu_avl_node_t	cn_avl;
57} config_node_t;
58
59static int
60config_node_compare(const void *a, const void *b, void *unused)
61{
62	(void) unused;
63	const config_node_t *ca = (config_node_t *)a;
64	const config_node_t *cb = (config_node_t *)b;
65
66	int ret = strcmp(ca->cn_name, cb->cn_name);
67
68	if (ret < 0)
69		return (-1);
70	else if (ret > 0)
71		return (1);
72	else
73		return (0);
74}
75
76void
77namespace_clear(libzfs_handle_t *hdl)
78{
79	if (hdl->libzfs_ns_avl) {
80		config_node_t *cn;
81		void *cookie = NULL;
82
83		while ((cn = uu_avl_teardown(hdl->libzfs_ns_avl,
84		    &cookie)) != NULL) {
85			nvlist_free(cn->cn_config);
86			free(cn->cn_name);
87			free(cn);
88		}
89
90		uu_avl_destroy(hdl->libzfs_ns_avl);
91		hdl->libzfs_ns_avl = NULL;
92	}
93
94	if (hdl->libzfs_ns_avlpool) {
95		uu_avl_pool_destroy(hdl->libzfs_ns_avlpool);
96		hdl->libzfs_ns_avlpool = NULL;
97	}
98}
99
100/*
101 * Loads the pool namespace, or re-loads it if the cache has changed.
102 */
103static int
104namespace_reload(libzfs_handle_t *hdl)
105{
106	nvlist_t *config;
107	config_node_t *cn;
108	nvpair_t *elem;
109	zfs_cmd_t zc = {"\0"};
110	void *cookie;
111
112	if (hdl->libzfs_ns_gen == 0) {
113		/*
114		 * This is the first time we've accessed the configuration
115		 * cache.  Initialize the AVL tree and then fall through to the
116		 * common code.
117		 */
118		if ((hdl->libzfs_ns_avlpool = uu_avl_pool_create("config_pool",
119		    sizeof (config_node_t),
120		    offsetof(config_node_t, cn_avl),
121		    config_node_compare, UU_DEFAULT)) == NULL)
122			return (no_memory(hdl));
123
124		if ((hdl->libzfs_ns_avl = uu_avl_create(hdl->libzfs_ns_avlpool,
125		    NULL, UU_DEFAULT)) == NULL)
126			return (no_memory(hdl));
127	}
128
129	zcmd_alloc_dst_nvlist(hdl, &zc, 0);
130
131	for (;;) {
132		zc.zc_cookie = hdl->libzfs_ns_gen;
133		if (zfs_ioctl(hdl, ZFS_IOC_POOL_CONFIGS, &zc) != 0) {
134			switch (errno) {
135			case EEXIST:
136				/*
137				 * The namespace hasn't changed.
138				 */
139				zcmd_free_nvlists(&zc);
140				return (0);
141
142			case ENOMEM:
143				zcmd_expand_dst_nvlist(hdl, &zc);
144				break;
145
146			default:
147				zcmd_free_nvlists(&zc);
148				return (zfs_standard_error(hdl, errno,
149				    dgettext(TEXT_DOMAIN, "failed to read "
150				    "pool configuration")));
151			}
152		} else {
153			hdl->libzfs_ns_gen = zc.zc_cookie;
154			break;
155		}
156	}
157
158	if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) {
159		zcmd_free_nvlists(&zc);
160		return (-1);
161	}
162
163	zcmd_free_nvlists(&zc);
164
165	/*
166	 * Clear out any existing configuration information.
167	 */
168	cookie = NULL;
169	while ((cn = uu_avl_teardown(hdl->libzfs_ns_avl, &cookie)) != NULL) {
170		nvlist_free(cn->cn_config);
171		free(cn->cn_name);
172		free(cn);
173	}
174
175	elem = NULL;
176	while ((elem = nvlist_next_nvpair(config, elem)) != NULL) {
177		nvlist_t *child;
178		uu_avl_index_t where;
179
180		cn = zfs_alloc(hdl, sizeof (config_node_t));
181		cn->cn_name = zfs_strdup(hdl, nvpair_name(elem));
182		child = fnvpair_value_nvlist(elem);
183		if (nvlist_dup(child, &cn->cn_config, 0) != 0) {
184			free(cn->cn_name);
185			free(cn);
186			nvlist_free(config);
187			return (no_memory(hdl));
188		}
189		verify(uu_avl_find(hdl->libzfs_ns_avl, cn, NULL, &where)
190		    == NULL);
191
192		uu_avl_insert(hdl->libzfs_ns_avl, cn, where);
193	}
194
195	nvlist_free(config);
196	return (0);
197}
198
199/*
200 * Retrieve the configuration for the given pool. The configuration is an nvlist
201 * describing the vdevs, as well as the statistics associated with each one.
202 */
203nvlist_t *
204zpool_get_config(zpool_handle_t *zhp, nvlist_t **oldconfig)
205{
206	if (oldconfig)
207		*oldconfig = zhp->zpool_old_config;
208	return (zhp->zpool_config);
209}
210
211/*
212 * Retrieves a list of enabled features and their refcounts and caches it in
213 * the pool handle.
214 */
215nvlist_t *
216zpool_get_features(zpool_handle_t *zhp)
217{
218	nvlist_t *config, *features;
219
220	config = zpool_get_config(zhp, NULL);
221
222	if (config == NULL || !nvlist_exists(config,
223	    ZPOOL_CONFIG_FEATURE_STATS)) {
224		int error;
225		boolean_t missing = B_FALSE;
226
227		error = zpool_refresh_stats(zhp, &missing);
228
229		if (error != 0 || missing)
230			return (NULL);
231
232		config = zpool_get_config(zhp, NULL);
233	}
234
235	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_FEATURE_STATS,
236	    &features) != 0)
237		return (NULL);
238
239	return (features);
240}
241
242/*
243 * Refresh the vdev statistics associated with the given pool.  This is used in
244 * iostat to show configuration changes and determine the delta from the last
245 * time the function was called.  This function can fail, in case the pool has
246 * been destroyed.
247 */
248int
249zpool_refresh_stats(zpool_handle_t *zhp, boolean_t *missing)
250{
251	zfs_cmd_t zc = {"\0"};
252	int error;
253	nvlist_t *config;
254	libzfs_handle_t *hdl = zhp->zpool_hdl;
255
256	*missing = B_FALSE;
257	(void) strcpy(zc.zc_name, zhp->zpool_name);
258
259	if (zhp->zpool_config_size == 0)
260		zhp->zpool_config_size = 1 << 16;
261
262	zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size);
263
264	for (;;) {
265		if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_STATS,
266		    &zc) == 0) {
267			/*
268			 * The real error is returned in the zc_cookie field.
269			 */
270			error = zc.zc_cookie;
271			break;
272		}
273
274		if (errno == ENOMEM)
275			zcmd_expand_dst_nvlist(hdl, &zc);
276		else {
277			zcmd_free_nvlists(&zc);
278			if (errno == ENOENT || errno == EINVAL)
279				*missing = B_TRUE;
280			zhp->zpool_state = POOL_STATE_UNAVAIL;
281			return (0);
282		}
283	}
284
285	if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) {
286		zcmd_free_nvlists(&zc);
287		return (-1);
288	}
289
290	zcmd_free_nvlists(&zc);
291
292	zhp->zpool_config_size = zc.zc_nvlist_dst_size;
293
294	if (zhp->zpool_config != NULL) {
295		nvlist_free(zhp->zpool_old_config);
296
297		zhp->zpool_old_config = zhp->zpool_config;
298	}
299
300	zhp->zpool_config = config;
301	if (error)
302		zhp->zpool_state = POOL_STATE_UNAVAIL;
303	else
304		zhp->zpool_state = POOL_STATE_ACTIVE;
305
306	return (0);
307}
308
309/*
310 * The following environment variables are undocumented
311 * and should be used for testing purposes only:
312 *
313 * __ZFS_POOL_EXCLUDE - don't iterate over the pools it lists
314 * __ZFS_POOL_RESTRICT - iterate only over the pools it lists
315 *
316 * This function returns B_TRUE if the pool should be skipped
317 * during iteration.
318 */
319boolean_t
320zpool_skip_pool(const char *poolname)
321{
322	static boolean_t initialized = B_FALSE;
323	static const char *exclude = NULL;
324	static const char *restricted = NULL;
325
326	const char *cur, *end;
327	int len;
328	int namelen = strlen(poolname);
329
330	if (!initialized) {
331		initialized = B_TRUE;
332		exclude = getenv("__ZFS_POOL_EXCLUDE");
333		restricted = getenv("__ZFS_POOL_RESTRICT");
334	}
335
336	if (exclude != NULL) {
337		cur = exclude;
338		do {
339			end = strchr(cur, ' ');
340			len = (NULL == end) ? strlen(cur) : (end - cur);
341			if (len == namelen && 0 == strncmp(cur, poolname, len))
342				return (B_TRUE);
343			cur += (len + 1);
344		} while (NULL != end);
345	}
346
347	if (NULL == restricted)
348		return (B_FALSE);
349
350	cur = restricted;
351	do {
352		end = strchr(cur, ' ');
353		len = (NULL == end) ? strlen(cur) : (end - cur);
354
355		if (len == namelen && 0 == strncmp(cur, poolname, len)) {
356			return (B_FALSE);
357		}
358
359		cur += (len + 1);
360	} while (NULL != end);
361
362	return (B_TRUE);
363}
364
365/*
366 * Iterate over all pools in the system.
367 */
368int
369zpool_iter(libzfs_handle_t *hdl, zpool_iter_f func, void *data)
370{
371	config_node_t *cn;
372	zpool_handle_t *zhp;
373	int ret;
374
375	/*
376	 * If someone makes a recursive call to zpool_iter(), we want to avoid
377	 * refreshing the namespace because that will invalidate the parent
378	 * context.  We allow recursive calls, but simply re-use the same
379	 * namespace AVL tree.
380	 */
381	if (!hdl->libzfs_pool_iter && namespace_reload(hdl) != 0)
382		return (-1);
383
384	hdl->libzfs_pool_iter++;
385	for (cn = uu_avl_first(hdl->libzfs_ns_avl); cn != NULL;
386	    cn = uu_avl_next(hdl->libzfs_ns_avl, cn)) {
387
388		if (zpool_skip_pool(cn->cn_name))
389			continue;
390
391		if (zpool_open_silent(hdl, cn->cn_name, &zhp) != 0) {
392			hdl->libzfs_pool_iter--;
393			return (-1);
394		}
395
396		if (zhp == NULL)
397			continue;
398
399		if ((ret = func(zhp, data)) != 0) {
400			hdl->libzfs_pool_iter--;
401			return (ret);
402		}
403	}
404	hdl->libzfs_pool_iter--;
405
406	return (0);
407}
408
409/*
410 * Iterate over root datasets, calling the given function for each.  The zfs
411 * handle passed each time must be explicitly closed by the callback.
412 */
413int
414zfs_iter_root(libzfs_handle_t *hdl, zfs_iter_f func, void *data)
415{
416	config_node_t *cn;
417	zfs_handle_t *zhp;
418	int ret;
419
420	if (namespace_reload(hdl) != 0)
421		return (-1);
422
423	for (cn = uu_avl_first(hdl->libzfs_ns_avl); cn != NULL;
424	    cn = uu_avl_next(hdl->libzfs_ns_avl, cn)) {
425
426		if (zpool_skip_pool(cn->cn_name))
427			continue;
428
429		if ((zhp = make_dataset_handle(hdl, cn->cn_name)) == NULL)
430			continue;
431
432		if ((ret = func(zhp, data)) != 0)
433			return (ret);
434	}
435
436	return (0);
437}
438