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
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 static int
config_node_compare(const void * a,const void * b,void * unused)60 config_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
76 void
namespace_clear(libzfs_handle_t * hdl)77 namespace_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 */
103 static int
namespace_reload(libzfs_handle_t * hdl)104 namespace_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 */
203 nvlist_t *
zpool_get_config(zpool_handle_t * zhp,nvlist_t ** oldconfig)204 zpool_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 */
215 nvlist_t *
zpool_get_features(zpool_handle_t * zhp)216 zpool_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 */
248 int
zpool_refresh_stats(zpool_handle_t * zhp,boolean_t * missing)249 zpool_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 */
319 boolean_t
zpool_skip_pool(const char * poolname)320 zpool_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 */
368 int
zpool_iter(libzfs_handle_t * hdl,zpool_iter_f func,void * data)369 zpool_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 */
413 int
zfs_iter_root(libzfs_handle_t * hdl,zfs_iter_f func,void * data)414 zfs_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