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 2006 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 /*
29  * The pool configuration repository is stored in /etc/zfs/zpool.cache as a
30  * single packed nvlist.  While it would be nice to just read in this
31  * file from userland, this wouldn't work from a local zone.  So we have to have
32  * a zpool ioctl to return the complete configuration for all pools.  In the
33  * global zone, this will be identical to reading the file and unpacking it in
34  * userland.
35  */
36 
37 #include <errno.h>
38 #include <sys/stat.h>
39 #include <fcntl.h>
40 #include <stddef.h>
41 #include <string.h>
42 #include <unistd.h>
43 #include <libintl.h>
44 #include <libuutil.h>
45 
46 #include "libzfs_impl.h"
47 
48 typedef struct config_node {
49 	char		*cn_name;
50 	nvlist_t	*cn_config;
51 	uu_avl_node_t	cn_avl;
52 } config_node_t;
53 
54 /* ARGSUSED */
55 static int
56 config_node_compare(const void *a, const void *b, void *unused)
57 {
58 	int ret;
59 
60 	const config_node_t *ca = (config_node_t *)a;
61 	const config_node_t *cb = (config_node_t *)b;
62 
63 	ret = strcmp(ca->cn_name, cb->cn_name);
64 
65 	if (ret < 0)
66 		return (-1);
67 	else if (ret > 0)
68 		return (1);
69 	else
70 		return (0);
71 }
72 
73 void
74 namespace_clear(libzfs_handle_t *hdl)
75 {
76 	if (hdl->libzfs_ns_avl) {
77 		uu_avl_walk_t *walk;
78 		config_node_t *cn;
79 
80 		if ((walk = uu_avl_walk_start(hdl->libzfs_ns_avl,
81 		    UU_WALK_ROBUST)) == NULL)
82 			return;
83 
84 		while ((cn = uu_avl_walk_next(walk)) != NULL) {
85 			uu_avl_remove(hdl->libzfs_ns_avl, cn);
86 			nvlist_free(cn->cn_config);
87 			free(cn->cn_name);
88 			free(cn);
89 		}
90 
91 		uu_avl_walk_end(walk);
92 
93 		uu_avl_destroy(hdl->libzfs_ns_avl);
94 		hdl->libzfs_ns_avl = NULL;
95 	}
96 
97 	if (hdl->libzfs_ns_avlpool) {
98 		uu_avl_pool_destroy(hdl->libzfs_ns_avlpool);
99 		hdl->libzfs_ns_avlpool = NULL;
100 	}
101 }
102 
103 /*
104  * Loads the pool namespace, or re-loads it if the cache has changed.
105  */
106 static int
107 namespace_reload(libzfs_handle_t *hdl)
108 {
109 	nvlist_t *config;
110 	config_node_t *cn;
111 	nvpair_t *elem;
112 	zfs_cmd_t zc = { 0 };
113 	uu_avl_walk_t *walk;
114 
115 	if (hdl->libzfs_ns_gen == 0) {
116 		/*
117 		 * This is the first time we've accessed the configuration
118 		 * cache.  Initialize the AVL tree and then fall through to the
119 		 * common code.
120 		 */
121 		if ((hdl->libzfs_ns_avlpool = uu_avl_pool_create("config_pool",
122 		    sizeof (config_node_t),
123 		    offsetof(config_node_t, cn_avl),
124 		    config_node_compare, UU_DEFAULT)) == NULL)
125 			return (no_memory(hdl));
126 
127 		if ((hdl->libzfs_ns_avl = uu_avl_create(hdl->libzfs_ns_avlpool,
128 		    NULL, UU_DEFAULT)) == NULL)
129 			return (no_memory(hdl));
130 	}
131 
132 	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
133 		return (-1);
134 
135 	for (;;) {
136 		zc.zc_cookie = hdl->libzfs_ns_gen;
137 		if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CONFIGS, &zc) != 0) {
138 			switch (errno) {
139 			case EEXIST:
140 				/*
141 				 * The namespace hasn't changed.
142 				 */
143 				zcmd_free_nvlists(&zc);
144 				return (0);
145 
146 			case ENOMEM:
147 				if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
148 					zcmd_free_nvlists(&zc);
149 					return (-1);
150 				}
151 				break;
152 
153 			default:
154 				zcmd_free_nvlists(&zc);
155 				return (zfs_standard_error(hdl, errno,
156 				    dgettext(TEXT_DOMAIN, "failed to read "
157 				    "pool configuration")));
158 			}
159 		} else {
160 			hdl->libzfs_ns_gen = zc.zc_cookie;
161 			break;
162 		}
163 	}
164 
165 	if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) {
166 		zcmd_free_nvlists(&zc);
167 		return (-1);
168 	}
169 
170 	zcmd_free_nvlists(&zc);
171 
172 	/*
173 	 * Clear out any existing configuration information.
174 	 */
175 	if ((walk = uu_avl_walk_start(hdl->libzfs_ns_avl,
176 	    UU_WALK_ROBUST)) == NULL) {
177 		nvlist_free(config);
178 		return (no_memory(hdl));
179 	}
180 
181 	while ((cn = uu_avl_walk_next(walk)) != NULL) {
182 		uu_avl_remove(hdl->libzfs_ns_avl, cn);
183 		nvlist_free(cn->cn_config);
184 		free(cn->cn_name);
185 		free(cn);
186 	}
187 
188 	uu_avl_walk_end(walk);
189 
190 	elem = NULL;
191 	while ((elem = nvlist_next_nvpair(config, elem)) != NULL) {
192 		nvlist_t *child;
193 		uu_avl_index_t where;
194 
195 		if ((cn = zfs_alloc(hdl, sizeof (config_node_t))) == NULL) {
196 			nvlist_free(config);
197 			return (-1);
198 		}
199 
200 		if ((cn->cn_name = zfs_strdup(hdl,
201 		    nvpair_name(elem))) == NULL) {
202 			free(cn);
203 			nvlist_free(config);
204 			return (-1);
205 		}
206 
207 		verify(nvpair_value_nvlist(elem, &child) == 0);
208 		if (nvlist_dup(child, &cn->cn_config, 0) != 0) {
209 			free(cn->cn_name);
210 			free(cn);
211 			nvlist_free(config);
212 			return (no_memory(hdl));
213 		}
214 		verify(uu_avl_find(hdl->libzfs_ns_avl, cn, NULL, &where)
215 		    == NULL);
216 
217 		uu_avl_insert(hdl->libzfs_ns_avl, cn, where);
218 	}
219 
220 	nvlist_free(config);
221 	return (0);
222 }
223 
224 /*
225  * Retrive the configuration for the given pool.  The configuration is a nvlist
226  * describing the vdevs, as well as the statistics associated with each one.
227  */
228 nvlist_t *
229 zpool_get_config(zpool_handle_t *zhp, nvlist_t **oldconfig)
230 {
231 	if (oldconfig)
232 		*oldconfig = zhp->zpool_old_config;
233 	return (zhp->zpool_config);
234 }
235 
236 /*
237  * Refresh the vdev statistics associated with the given pool.  This is used in
238  * iostat to show configuration changes and determine the delta from the last
239  * time the function was called.  This function can fail, in case the pool has
240  * been destroyed.
241  */
242 int
243 zpool_refresh_stats(zpool_handle_t *zhp, boolean_t *missing)
244 {
245 	zfs_cmd_t zc = { 0 };
246 	int error;
247 	nvlist_t *config;
248 	libzfs_handle_t *hdl = zhp->zpool_hdl;
249 
250 	*missing = B_FALSE;
251 	(void) strcpy(zc.zc_name, zhp->zpool_name);
252 
253 	if (zhp->zpool_config_size == 0)
254 		zhp->zpool_config_size = 1 << 16;
255 
256 	if (zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size) != 0)
257 		return (-1);
258 
259 	for (;;) {
260 		if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_POOL_STATS,
261 		    &zc) == 0) {
262 			/*
263 			 * The real error is returned in the zc_cookie field.
264 			 */
265 			error = zc.zc_cookie;
266 			break;
267 		}
268 
269 		if (errno == ENOMEM) {
270 			if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
271 				zcmd_free_nvlists(&zc);
272 				return (-1);
273 			}
274 		} else {
275 			zcmd_free_nvlists(&zc);
276 			if (errno == ENOENT || errno == EINVAL)
277 				*missing = B_TRUE;
278 			zhp->zpool_state = POOL_STATE_UNAVAIL;
279 			return (0);
280 		}
281 	}
282 
283 	if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) {
284 		zcmd_free_nvlists(&zc);
285 		return (-1);
286 	}
287 
288 	zcmd_free_nvlists(&zc);
289 
290 	zhp->zpool_config_size = zc.zc_nvlist_dst_size;
291 
292 	if (set_pool_health(config) != 0) {
293 		nvlist_free(config);
294 		return (no_memory(zhp->zpool_hdl));
295 	}
296 
297 	if (zhp->zpool_config != NULL) {
298 		uint64_t oldtxg, newtxg;
299 
300 		verify(nvlist_lookup_uint64(zhp->zpool_config,
301 		    ZPOOL_CONFIG_POOL_TXG, &oldtxg) == 0);
302 		verify(nvlist_lookup_uint64(config,
303 		    ZPOOL_CONFIG_POOL_TXG, &newtxg) == 0);
304 
305 		if (zhp->zpool_old_config != NULL)
306 			nvlist_free(zhp->zpool_old_config);
307 
308 		if (oldtxg != newtxg) {
309 			nvlist_free(zhp->zpool_config);
310 			zhp->zpool_old_config = NULL;
311 		} else {
312 			zhp->zpool_old_config = zhp->zpool_config;
313 		}
314 	}
315 
316 	zhp->zpool_config = config;
317 	if (error)
318 		zhp->zpool_state = POOL_STATE_UNAVAIL;
319 	else
320 		zhp->zpool_state = POOL_STATE_ACTIVE;
321 
322 	return (0);
323 }
324 
325 /*
326  * Iterate over all pools in the system.
327  */
328 int
329 zpool_iter(libzfs_handle_t *hdl, zpool_iter_f func, void *data)
330 {
331 	config_node_t *cn;
332 	zpool_handle_t *zhp;
333 	int ret;
334 
335 	if (namespace_reload(hdl) != 0)
336 		return (-1);
337 
338 	for (cn = uu_avl_first(hdl->libzfs_ns_avl); cn != NULL;
339 	    cn = uu_avl_next(hdl->libzfs_ns_avl, cn)) {
340 
341 		if (zpool_open_silent(hdl, cn->cn_name, &zhp) != 0)
342 			return (-1);
343 
344 		if (zhp == NULL)
345 			continue;
346 
347 		if ((ret = func(zhp, data)) != 0)
348 			return (ret);
349 	}
350 
351 	return (0);
352 }
353 
354 /*
355  * Iterate over root datasets, calling the given function for each.  The zfs
356  * handle passed each time must be explicitly closed by the callback.
357  */
358 int
359 zfs_iter_root(libzfs_handle_t *hdl, zfs_iter_f func, void *data)
360 {
361 	config_node_t *cn;
362 	zfs_handle_t *zhp;
363 	int ret;
364 
365 	if (namespace_reload(hdl) != 0)
366 		return (-1);
367 
368 	for (cn = uu_avl_first(hdl->libzfs_ns_avl); cn != NULL;
369 	    cn = uu_avl_next(hdl->libzfs_ns_avl, cn)) {
370 
371 		if ((zhp = make_dataset_handle(hdl, cn->cn_name)) == NULL)
372 			continue;
373 
374 		if ((ret = func(zhp, data)) != 0)
375 			return (ret);
376 	}
377 
378 	return (0);
379 }
380