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