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.
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.
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]
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
27 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
38 #include <sys/zfs_context.h>
41 #include "zpool_util.h"
44 * Private interface for iterating over pools specified on the command line.
45 * Most consumers will call for_each_pool, but in order to support iostat, we
46 * allow fined grained control through the zpool_list_t interface.
49 typedef struct zpool_node {
50 zpool_handle_t *zn_handle;
51 uu_avl_node_t zn_avlnode;
58 uu_avl_pool_t *zl_pool;
59 zprop_list_t **zl_proplist;
64 zpool_compare(const void *larg, const void *rarg, void *unused)
66 zpool_handle_t *l = ((zpool_node_t *)larg)->zn_handle;
67 zpool_handle_t *r = ((zpool_node_t *)rarg)->zn_handle;
68 const char *lname = zpool_get_name(l);
69 const char *rname = zpool_get_name(r);
71 return (strcmp(lname, rname));
75 * Callback function for pool_list_get(). Adds the given pool to the AVL tree
79 add_pool(zpool_handle_t *zhp, void *data)
81 zpool_list_t *zlp = data;
82 zpool_node_t *node = safe_malloc(sizeof (zpool_node_t));
85 node->zn_handle = zhp;
86 uu_avl_node_init(node, &node->zn_avlnode, zlp->zl_pool);
87 if (uu_avl_find(zlp->zl_avl, node, NULL, &idx) == NULL) {
88 if (zlp->zl_proplist &&
89 zpool_expand_proplist(zhp, zlp->zl_proplist) != 0) {
94 uu_avl_insert(zlp->zl_avl, node, idx);
105 * Create a list of pools based on the given arguments. If we're given no
106 * arguments, then iterate over all pools in the system and add them to the AVL
107 * tree. Otherwise, add only those pool explicitly specified on the command
111 pool_list_get(int argc, char **argv, zprop_list_t **proplist, int *err)
115 zlp = safe_malloc(sizeof (zpool_list_t));
117 zlp->zl_pool = uu_avl_pool_create("zfs_pool", sizeof (zpool_node_t),
118 offsetof(zpool_node_t, zn_avlnode), zpool_compare, UU_DEFAULT);
120 if (zlp->zl_pool == NULL)
123 if ((zlp->zl_avl = uu_avl_create(zlp->zl_pool, NULL,
124 UU_DEFAULT)) == NULL)
127 zlp->zl_proplist = proplist;
130 (void) zpool_iter(g_zfs, add_pool, zlp);
131 zlp->zl_findall = B_TRUE;
135 for (i = 0; i < argc; i++) {
138 if ((zhp = zpool_open_canfail(g_zfs, argv[i])) !=
140 if (add_pool(zhp, zlp) != 0)
152 * Search for any new pools, adding them to the list. We only add pools when no
153 * options were given on the command line. Otherwise, we keep the list fixed as
154 * those that were explicitly specified.
157 pool_list_update(zpool_list_t *zlp)
160 (void) zpool_iter(g_zfs, add_pool, zlp);
164 * Iterate over all pools in the list, executing the callback for each
167 pool_list_iter(zpool_list_t *zlp, int unavail, zpool_iter_f func,
170 zpool_node_t *node, *next_node;
173 for (node = uu_avl_first(zlp->zl_avl); node != NULL; node = next_node) {
174 next_node = uu_avl_next(zlp->zl_avl, node);
175 if (zpool_get_state(node->zn_handle) != POOL_STATE_UNAVAIL ||
177 ret |= func(node->zn_handle, data);
184 * Remove the given pool from the list. When running iostat, we want to remove
185 * those pools that no longer exist.
188 pool_list_remove(zpool_list_t *zlp, zpool_handle_t *zhp)
190 zpool_node_t search, *node;
192 search.zn_handle = zhp;
193 if ((node = uu_avl_find(zlp->zl_avl, &search, NULL, NULL)) != NULL) {
194 uu_avl_remove(zlp->zl_avl, node);
195 zpool_close(node->zn_handle);
201 * Free all the handles associated with this list.
204 pool_list_free(zpool_list_t *zlp)
209 if ((walk = uu_avl_walk_start(zlp->zl_avl, UU_WALK_ROBUST)) == NULL) {
210 (void) fprintf(stderr,
211 gettext("internal error: out of memory"));
215 while ((node = uu_avl_walk_next(walk)) != NULL) {
216 uu_avl_remove(zlp->zl_avl, node);
217 zpool_close(node->zn_handle);
221 uu_avl_walk_end(walk);
222 uu_avl_destroy(zlp->zl_avl);
223 uu_avl_pool_destroy(zlp->zl_pool);
229 * Returns the number of elements in the pool list.
232 pool_list_count(zpool_list_t *zlp)
234 return (uu_avl_numnodes(zlp->zl_avl));
238 * High level function which iterates over all pools given on the command line,
239 * using the pool_list_* interfaces.
242 for_each_pool(int argc, char **argv, boolean_t unavail,
243 zprop_list_t **proplist, zpool_iter_f func, void *data)
248 if ((list = pool_list_get(argc, argv, proplist, &ret)) == NULL)
251 if (pool_list_iter(list, unavail, func, data) != 0)
254 pool_list_free(list);
260 for_each_vdev_cb(zpool_handle_t *zhp, nvlist_t *nv, pool_vdev_iter_f func,
269 const char *list[] = {
271 ZPOOL_CONFIG_L2CACHE,
272 ZPOOL_CONFIG_CHILDREN
275 for (i = 0; i < ARRAY_SIZE(list); i++) {
276 if (nvlist_lookup_nvlist_array(nv, list[i], &child,
278 for (c = 0; c < children; c++) {
281 (void) nvlist_lookup_uint64(child[c],
282 ZPOOL_CONFIG_IS_HOLE, &ishole);
287 ret |= for_each_vdev_cb(zhp, child[c], func,
293 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
296 /* Don't run our function on root vdevs */
297 if (strcmp(type, VDEV_TYPE_ROOT) != 0) {
298 ret |= func(zhp, nv, data);
305 * This is the equivalent of for_each_pool() for vdevs. It iterates thorough
306 * all vdevs in the pool, ignoring root vdevs and holes, calling func() on
310 * @func: Function to call on each vdev
311 * @data: Custom data to pass to the function
314 for_each_vdev(zpool_handle_t *zhp, pool_vdev_iter_f func, void *data)
316 nvlist_t *config, *nvroot = NULL;
318 if ((config = zpool_get_config(zhp, NULL)) != NULL) {
319 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
322 return (for_each_vdev_cb(zhp, nvroot, func, data));
326 * Process the vcdl->vdev_cmd_data[] array to figure out all the unique column
327 * names and their widths. When this function is done, vcdl->uniq_cols,
328 * vcdl->uniq_cols_cnt, and vcdl->uniq_cols_width will be filled in.
331 process_unique_cmd_columns(vdev_cmd_data_list_t *vcdl)
333 char **uniq_cols = NULL, **tmp = NULL;
334 int *uniq_cols_width;
335 vdev_cmd_data_t *data;
340 for (int i = 0; i < vcdl->count; i++) {
341 data = &vcdl->data[i];
342 /* For each column the vdev reported */
343 for (int j = 0; j < data->cols_cnt; j++) {
344 /* Is this column in our list of unique column names? */
345 for (k = 0; k < cnt; k++) {
346 if (strcmp(data->cols[j], uniq_cols[k]) == 0)
347 break; /* yes it is */
350 /* No entry for column, add to list */
351 tmp = realloc(uniq_cols, sizeof (*uniq_cols) *
354 break; /* Nothing we can do... */
356 uniq_cols[cnt] = data->cols[j];
363 * We now have a list of all the unique column names. Figure out the
364 * max width of each column by looking at the column name and all its
367 uniq_cols_width = safe_malloc(sizeof (*uniq_cols_width) * cnt);
368 for (int i = 0; i < cnt; i++) {
369 /* Start off with the column title's width */
370 uniq_cols_width[i] = strlen(uniq_cols[i]);
372 for (int j = 0; j < vcdl->count; j++) {
373 /* For each of the vdev's values in a column */
374 data = &vcdl->data[j];
375 for (k = 0; k < data->cols_cnt; k++) {
376 /* Does this vdev have a value for this col? */
377 if (strcmp(data->cols[k], uniq_cols[i]) == 0) {
378 /* Is the value width larger? */
380 MAX(uniq_cols_width[i],
381 strlen(data->lines[k]));
387 vcdl->uniq_cols = uniq_cols;
388 vcdl->uniq_cols_cnt = cnt;
389 vcdl->uniq_cols_width = uniq_cols_width;
394 * Process a line of command output
396 * When running 'zpool iostat|status -c' the lines of output can either be
405 * Process the column_name (if any) and value.
407 * Returns 0 if line was processed, and there are more lines can still be
410 * Returns 1 if this was the last line to process, or error.
413 vdev_process_cmd_output(vdev_cmd_data_t *data, char *line)
423 equals = strchr(line, '=');
424 if (equals != NULL) {
426 * We have a 'column=value' type line. Split it into the
427 * column and value strings by turning the '=' into a '\0'.
436 /* Do we already have a column by this name? If so, skip it. */
438 for (int i = 0; i < data->cols_cnt; i++) {
439 if (strcmp(col, data->cols[i]) == 0)
440 return (0); /* Duplicate, skip */
445 tmp = realloc(data->lines,
446 (data->lines_cnt + 1) * sizeof (*data->lines));
451 data->lines[data->lines_cnt] = strdup(val);
456 tmp = realloc(data->cols,
457 (data->cols_cnt + 1) * sizeof (*data->cols));
462 data->cols[data->cols_cnt] = strdup(col);
466 if (val != NULL && col == NULL)
473 * Run the cmd and store results in *data.
476 vdev_run_cmd(vdev_cmd_data_t *data, char *cmd)
479 char *argv[2] = {cmd, 0};
480 char *env[5] = {"PATH=/bin:/sbin:/usr/bin:/usr/sbin", NULL, NULL, NULL,
486 /* Setup our custom environment variables */
487 rc = asprintf(&env[1], "VDEV_PATH=%s",
488 data->path ? data->path : "");
492 rc = asprintf(&env[2], "VDEV_UPATH=%s",
493 data->upath ? data->upath : "");
497 rc = asprintf(&env[3], "VDEV_ENC_SYSFS_PATH=%s",
498 data->vdev_enc_sysfs_path ?
499 data->vdev_enc_sysfs_path : "");
503 /* Run the command */
504 rc = libzfs_run_process_get_stdout_nopath(cmd, argv, env, &lines,
509 /* Process the output we got */
510 for (i = 0; i < lines_cnt; i++)
511 if (vdev_process_cmd_output(data, lines[i]) != 0)
516 libzfs_free_str_array(lines, lines_cnt);
518 /* Start with i = 1 since env[0] was statically allocated */
519 for (i = 1; i < ARRAY_SIZE(env); i++)
525 * Generate the search path for zpool iostat/status -c scripts.
526 * The string returned must be freed.
529 zpool_get_cmd_search_path(void)
534 env = getenv("ZPOOL_SCRIPTS_PATH");
536 return (strdup(env));
538 env = getenv("HOME");
540 if (asprintf(&sp, "%s/.zpool.d:%s",
541 env, ZPOOL_SCRIPTS_DIR) != -1) {
546 if (asprintf(&sp, "%s", ZPOOL_SCRIPTS_DIR) != -1)
552 /* Thread function run for each vdev */
554 vdev_run_cmd_thread(void *cb_cmd_data)
556 vdev_cmd_data_t *data = cb_cmd_data;
557 char *cmd = NULL, *cmddup, *cmdrest;
559 cmddup = strdup(data->cmd);
564 while ((cmd = strtok_r(cmdrest, ",", &cmdrest))) {
565 char *dir = NULL, *sp, *sprest;
566 char fullpath[MAXPATHLEN];
568 sp = zpool_get_cmd_search_path();
573 while ((dir = strtok_r(sprest, ":", &sprest))) {
574 if (snprintf(fullpath, sizeof (fullpath),
575 "%s/%s", dir, cmd) == -1)
578 if (access(fullpath, X_OK) == 0) {
579 vdev_run_cmd(data, fullpath);
588 /* For each vdev in the pool run a command */
590 for_each_vdev_run_cb(zpool_handle_t *zhp, nvlist_t *nv, void *cb_vcdl)
592 vdev_cmd_data_list_t *vcdl = cb_vcdl;
593 vdev_cmd_data_t *data;
596 char *vdev_enc_sysfs_path = NULL;
599 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
602 nvlist_lookup_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
603 &vdev_enc_sysfs_path);
605 /* Spares show more than once if they're in use, so skip if exists */
606 for (i = 0; i < vcdl->count; i++) {
607 if ((strcmp(vcdl->data[i].path, path) == 0) &&
608 (strcmp(vcdl->data[i].pool, zpool_get_name(zhp)) == 0)) {
609 /* vdev already exists, skip it */
614 /* Check for whitelisted vdevs here, if any */
615 for (i = 0; i < vcdl->vdev_names_count; i++) {
616 vname = zpool_vdev_name(g_zfs, zhp, nv, vcdl->cb_name_flags);
617 if (strcmp(vcdl->vdev_names[i], vname) == 0) {
625 /* If we whitelisted vdevs, and this isn't one of them, then bail out */
626 if (!match && vcdl->vdev_names_count)
630 * Resize our array and add in the new element.
632 if (!(vcdl->data = realloc(vcdl->data,
633 sizeof (*vcdl->data) * (vcdl->count + 1))))
634 return (ENOMEM); /* couldn't realloc */
636 data = &vcdl->data[vcdl->count];
638 data->pool = strdup(zpool_get_name(zhp));
639 data->path = strdup(path);
640 data->upath = zfs_get_underlying_path(path);
641 data->cmd = vcdl->cmd;
642 data->lines = data->cols = NULL;
643 data->lines_cnt = data->cols_cnt = 0;
644 if (vdev_enc_sysfs_path)
645 data->vdev_enc_sysfs_path = strdup(vdev_enc_sysfs_path);
647 data->vdev_enc_sysfs_path = NULL;
654 /* Get the names and count of the vdevs */
656 all_pools_for_each_vdev_gather_cb(zpool_handle_t *zhp, void *cb_vcdl)
658 return (for_each_vdev(zhp, for_each_vdev_run_cb, cb_vcdl));
662 * Now that vcdl is populated with our complete list of vdevs, spawn
666 all_pools_for_each_vdev_run_vcdl(vdev_cmd_data_list_t *vcdl)
670 /* 5 * boot_ncpus selfishly chosen since it works best on LLNL's HW */
671 int max_threads = 5 * boot_ncpus;
674 * Under Linux we use a taskq to parallelize running a command
675 * on each vdev. It is therefore necessary to initialize this
676 * functionality for the duration of the threads.
680 t = taskq_create("z_pool_cmd", max_threads, defclsyspri, max_threads,
685 /* Spawn off the command for each vdev */
686 for (i = 0; i < vcdl->count; i++) {
687 (void) taskq_dispatch(t, vdev_run_cmd_thread,
688 (void *) &vcdl->data[i], TQ_SLEEP);
691 /* Wait for threads to finish */
699 * Run command 'cmd' on all vdevs in all pools in argv. Saves the first line of
700 * output from the command in vcdk->data[].line for all vdevs. If you want
701 * to run the command on only certain vdevs, fill in g_zfs, vdev_names,
702 * vdev_names_count, and cb_name_flags. Otherwise leave them as zero.
704 * Returns a vdev_cmd_data_list_t that must be freed with
705 * free_vdev_cmd_data_list();
707 vdev_cmd_data_list_t *
708 all_pools_for_each_vdev_run(int argc, char **argv, char *cmd,
709 libzfs_handle_t *g_zfs, char **vdev_names, int vdev_names_count,
712 vdev_cmd_data_list_t *vcdl;
713 vcdl = safe_malloc(sizeof (vdev_cmd_data_list_t));
716 vcdl->vdev_names = vdev_names;
717 vcdl->vdev_names_count = vdev_names_count;
718 vcdl->cb_name_flags = cb_name_flags;
721 /* Gather our list of all vdevs in all pools */
722 for_each_pool(argc, argv, B_TRUE, NULL,
723 all_pools_for_each_vdev_gather_cb, vcdl);
725 /* Run command on all vdevs in all pools */
726 all_pools_for_each_vdev_run_vcdl(vcdl);
729 * vcdl->data[] now contains all the column names and values for each
730 * vdev. We need to process that into a master list of unique column
731 * names, and figure out the width of each column.
733 process_unique_cmd_columns(vcdl);
739 * Free the vdev_cmd_data_list_t created by all_pools_for_each_vdev_run()
742 free_vdev_cmd_data_list(vdev_cmd_data_list_t *vcdl)
744 free(vcdl->uniq_cols);
745 free(vcdl->uniq_cols_width);
747 for (int i = 0; i < vcdl->count; i++) {
748 free(vcdl->data[i].path);
749 free(vcdl->data[i].pool);
750 free(vcdl->data[i].upath);
752 for (int j = 0; j < vcdl->data[i].lines_cnt; j++)
753 free(vcdl->data[i].lines[j]);
755 free(vcdl->data[i].lines);
757 for (int j = 0; j < vcdl->data[i].cols_cnt; j++)
758 free(vcdl->data[i].cols[j]);
760 free(vcdl->data[i].cols);
761 free(vcdl->data[i].vdev_enc_sysfs_path);