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 2007 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 config_node_t *cn; 78 void *cookie = NULL; 79 80 while ((cn = uu_avl_teardown(hdl->libzfs_ns_avl, 81 &cookie)) != NULL) { 82 nvlist_free(cn->cn_config); 83 free(cn->cn_name); 84 free(cn); 85 } 86 87 uu_avl_destroy(hdl->libzfs_ns_avl); 88 hdl->libzfs_ns_avl = NULL; 89 } 90 91 if (hdl->libzfs_ns_avlpool) { 92 uu_avl_pool_destroy(hdl->libzfs_ns_avlpool); 93 hdl->libzfs_ns_avlpool = NULL; 94 } 95 } 96 97 /* 98 * Loads the pool namespace, or re-loads it if the cache has changed. 99 */ 100 static int 101 namespace_reload(libzfs_handle_t *hdl) 102 { 103 nvlist_t *config; 104 config_node_t *cn; 105 nvpair_t *elem; 106 zfs_cmd_t zc = { 0 }; 107 void *cookie; 108 109 if (hdl->libzfs_ns_gen == 0) { 110 /* 111 * This is the first time we've accessed the configuration 112 * cache. Initialize the AVL tree and then fall through to the 113 * common code. 114 */ 115 if ((hdl->libzfs_ns_avlpool = uu_avl_pool_create("config_pool", 116 sizeof (config_node_t), 117 offsetof(config_node_t, cn_avl), 118 config_node_compare, UU_DEFAULT)) == NULL) 119 return (no_memory(hdl)); 120 121 if ((hdl->libzfs_ns_avl = uu_avl_create(hdl->libzfs_ns_avlpool, 122 NULL, UU_DEFAULT)) == NULL) 123 return (no_memory(hdl)); 124 } 125 126 if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) 127 return (-1); 128 129 for (;;) { 130 zc.zc_cookie = hdl->libzfs_ns_gen; 131 if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CONFIGS, &zc) != 0) { 132 switch (errno) { 133 case EEXIST: 134 /* 135 * The namespace hasn't changed. 136 */ 137 zcmd_free_nvlists(&zc); 138 return (0); 139 140 case ENOMEM: 141 if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) { 142 zcmd_free_nvlists(&zc); 143 return (-1); 144 } 145 break; 146 147 default: 148 zcmd_free_nvlists(&zc); 149 return (zfs_standard_error(hdl, errno, 150 dgettext(TEXT_DOMAIN, "failed to read " 151 "pool configuration"))); 152 } 153 } else { 154 hdl->libzfs_ns_gen = zc.zc_cookie; 155 break; 156 } 157 } 158 159 if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) { 160 zcmd_free_nvlists(&zc); 161 return (-1); 162 } 163 164 zcmd_free_nvlists(&zc); 165 166 /* 167 * Clear out any existing configuration information. 168 */ 169 cookie = NULL; 170 while ((cn = uu_avl_teardown(hdl->libzfs_ns_avl, &cookie)) != NULL) { 171 nvlist_free(cn->cn_config); 172 free(cn->cn_name); 173 free(cn); 174 } 175 176 elem = NULL; 177 while ((elem = nvlist_next_nvpair(config, elem)) != NULL) { 178 nvlist_t *child; 179 uu_avl_index_t where; 180 181 if ((cn = zfs_alloc(hdl, sizeof (config_node_t))) == NULL) { 182 nvlist_free(config); 183 return (-1); 184 } 185 186 if ((cn->cn_name = zfs_strdup(hdl, 187 nvpair_name(elem))) == NULL) { 188 free(cn); 189 nvlist_free(config); 190 return (-1); 191 } 192 193 verify(nvpair_value_nvlist(elem, &child) == 0); 194 if (nvlist_dup(child, &cn->cn_config, 0) != 0) { 195 free(cn->cn_name); 196 free(cn); 197 nvlist_free(config); 198 return (no_memory(hdl)); 199 } 200 verify(uu_avl_find(hdl->libzfs_ns_avl, cn, NULL, &where) 201 == NULL); 202 203 uu_avl_insert(hdl->libzfs_ns_avl, cn, where); 204 } 205 206 nvlist_free(config); 207 return (0); 208 } 209 210 /* 211 * Retrieve the configuration for the given pool. The configuration is a nvlist 212 * describing the vdevs, as well as the statistics associated with each one. 213 */ 214 nvlist_t * 215 zpool_get_config(zpool_handle_t *zhp, nvlist_t **oldconfig) 216 { 217 if (oldconfig) 218 *oldconfig = zhp->zpool_old_config; 219 return (zhp->zpool_config); 220 } 221 222 /* 223 * Refresh the vdev statistics associated with the given pool. This is used in 224 * iostat to show configuration changes and determine the delta from the last 225 * time the function was called. This function can fail, in case the pool has 226 * been destroyed. 227 */ 228 int 229 zpool_refresh_stats(zpool_handle_t *zhp, boolean_t *missing) 230 { 231 zfs_cmd_t zc = { 0 }; 232 int error; 233 nvlist_t *config; 234 libzfs_handle_t *hdl = zhp->zpool_hdl; 235 236 *missing = B_FALSE; 237 (void) strcpy(zc.zc_name, zhp->zpool_name); 238 239 if (zhp->zpool_config_size == 0) 240 zhp->zpool_config_size = 1 << 16; 241 242 if (zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size) != 0) 243 return (-1); 244 245 for (;;) { 246 if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_POOL_STATS, 247 &zc) == 0) { 248 /* 249 * The real error is returned in the zc_cookie field. 250 */ 251 error = zc.zc_cookie; 252 break; 253 } 254 255 if (errno == ENOMEM) { 256 if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) { 257 zcmd_free_nvlists(&zc); 258 return (-1); 259 } 260 } else { 261 zcmd_free_nvlists(&zc); 262 if (errno == ENOENT || errno == EINVAL) 263 *missing = B_TRUE; 264 zhp->zpool_state = POOL_STATE_UNAVAIL; 265 return (0); 266 } 267 } 268 269 if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) { 270 zcmd_free_nvlists(&zc); 271 return (-1); 272 } 273 274 zcmd_free_nvlists(&zc); 275 276 zhp->zpool_config_size = zc.zc_nvlist_dst_size; 277 278 if (zhp->zpool_config != NULL) { 279 uint64_t oldtxg, newtxg; 280 281 verify(nvlist_lookup_uint64(zhp->zpool_config, 282 ZPOOL_CONFIG_POOL_TXG, &oldtxg) == 0); 283 verify(nvlist_lookup_uint64(config, 284 ZPOOL_CONFIG_POOL_TXG, &newtxg) == 0); 285 286 if (zhp->zpool_old_config != NULL) 287 nvlist_free(zhp->zpool_old_config); 288 289 if (oldtxg != newtxg) { 290 nvlist_free(zhp->zpool_config); 291 zhp->zpool_old_config = NULL; 292 } else { 293 zhp->zpool_old_config = zhp->zpool_config; 294 } 295 } 296 297 zhp->zpool_config = config; 298 if (error) 299 zhp->zpool_state = POOL_STATE_UNAVAIL; 300 else 301 zhp->zpool_state = POOL_STATE_ACTIVE; 302 303 return (0); 304 } 305 306 /* 307 * Iterate over all pools in the system. 308 */ 309 int 310 zpool_iter(libzfs_handle_t *hdl, zpool_iter_f func, void *data) 311 { 312 config_node_t *cn; 313 zpool_handle_t *zhp; 314 int ret; 315 316 if (namespace_reload(hdl) != 0) 317 return (-1); 318 319 for (cn = uu_avl_first(hdl->libzfs_ns_avl); cn != NULL; 320 cn = uu_avl_next(hdl->libzfs_ns_avl, cn)) { 321 322 if (zpool_open_silent(hdl, cn->cn_name, &zhp) != 0) 323 return (-1); 324 325 if (zhp == NULL) 326 continue; 327 328 if ((ret = func(zhp, data)) != 0) 329 return (ret); 330 } 331 332 return (0); 333 } 334 335 /* 336 * Iterate over root datasets, calling the given function for each. The zfs 337 * handle passed each time must be explicitly closed by the callback. 338 */ 339 int 340 zfs_iter_root(libzfs_handle_t *hdl, zfs_iter_f func, void *data) 341 { 342 config_node_t *cn; 343 zfs_handle_t *zhp; 344 int ret; 345 346 if (namespace_reload(hdl) != 0) 347 return (-1); 348 349 for (cn = uu_avl_first(hdl->libzfs_ns_avl); cn != NULL; 350 cn = uu_avl_next(hdl->libzfs_ns_avl, cn)) { 351 352 if ((zhp = make_dataset_handle(hdl, cn->cn_name)) == NULL) 353 continue; 354 355 if ((ret = func(zhp, data)) != 0) 356 return (ret); 357 } 358 359 return (0); 360 } 361