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 /*
27 * Copyright 2016 Igor Kozhukhov <[email protected]>.
28 */
29
30 #include <libintl.h>
31 #include <libuutil.h>
32 #include <stddef.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <strings.h>
36 #include <thread_pool.h>
37
38 #include <libzfs.h>
39 #include <libzutil.h>
40 #include <sys/zfs_context.h>
41 #include <sys/wait.h>
42
43 #include "zpool_util.h"
44
45 /*
46 * Private interface for iterating over pools specified on the command line.
47 * Most consumers will call for_each_pool, but in order to support iostat, we
48 * allow fined grained control through the zpool_list_t interface.
49 */
50
51 typedef struct zpool_node {
52 zpool_handle_t *zn_handle;
53 uu_avl_node_t zn_avlnode;
54 int zn_mark;
55 } zpool_node_t;
56
57 struct zpool_list {
58 boolean_t zl_findall;
59 boolean_t zl_literal;
60 uu_avl_t *zl_avl;
61 uu_avl_pool_t *zl_pool;
62 zprop_list_t **zl_proplist;
63 };
64
65 /* ARGSUSED */
66 static int
zpool_compare(const void * larg,const void * rarg,void * unused)67 zpool_compare(const void *larg, const void *rarg, void *unused)
68 {
69 zpool_handle_t *l = ((zpool_node_t *)larg)->zn_handle;
70 zpool_handle_t *r = ((zpool_node_t *)rarg)->zn_handle;
71 const char *lname = zpool_get_name(l);
72 const char *rname = zpool_get_name(r);
73
74 return (strcmp(lname, rname));
75 }
76
77 /*
78 * Callback function for pool_list_get(). Adds the given pool to the AVL tree
79 * of known pools.
80 */
81 static int
add_pool(zpool_handle_t * zhp,void * data)82 add_pool(zpool_handle_t *zhp, void *data)
83 {
84 zpool_list_t *zlp = data;
85 zpool_node_t *node = safe_malloc(sizeof (zpool_node_t));
86 uu_avl_index_t idx;
87
88 node->zn_handle = zhp;
89 uu_avl_node_init(node, &node->zn_avlnode, zlp->zl_pool);
90 if (uu_avl_find(zlp->zl_avl, node, NULL, &idx) == NULL) {
91 if (zlp->zl_proplist &&
92 zpool_expand_proplist(zhp, zlp->zl_proplist,
93 zlp->zl_literal)
94 != 0) {
95 zpool_close(zhp);
96 free(node);
97 return (-1);
98 }
99 uu_avl_insert(zlp->zl_avl, node, idx);
100 } else {
101 zpool_close(zhp);
102 free(node);
103 return (-1);
104 }
105
106 return (0);
107 }
108
109 /*
110 * Create a list of pools based on the given arguments. If we're given no
111 * arguments, then iterate over all pools in the system and add them to the AVL
112 * tree. Otherwise, add only those pool explicitly specified on the command
113 * line.
114 */
115 zpool_list_t *
pool_list_get(int argc,char ** argv,zprop_list_t ** proplist,boolean_t literal,int * err)116 pool_list_get(int argc, char **argv, zprop_list_t **proplist,
117 boolean_t literal, int *err)
118 {
119 zpool_list_t *zlp;
120
121 zlp = safe_malloc(sizeof (zpool_list_t));
122
123 zlp->zl_pool = uu_avl_pool_create("zfs_pool", sizeof (zpool_node_t),
124 offsetof(zpool_node_t, zn_avlnode), zpool_compare, UU_DEFAULT);
125
126 if (zlp->zl_pool == NULL)
127 zpool_no_memory();
128
129 if ((zlp->zl_avl = uu_avl_create(zlp->zl_pool, NULL,
130 UU_DEFAULT)) == NULL)
131 zpool_no_memory();
132
133 zlp->zl_proplist = proplist;
134
135 zlp->zl_literal = literal;
136
137 if (argc == 0) {
138 (void) zpool_iter(g_zfs, add_pool, zlp);
139 zlp->zl_findall = B_TRUE;
140 } else {
141 int i;
142
143 for (i = 0; i < argc; i++) {
144 zpool_handle_t *zhp;
145
146 if ((zhp = zpool_open_canfail(g_zfs, argv[i])) !=
147 NULL) {
148 if (add_pool(zhp, zlp) != 0)
149 *err = B_TRUE;
150 } else {
151 *err = B_TRUE;
152 }
153 }
154 }
155
156 return (zlp);
157 }
158
159 /*
160 * Search for any new pools, adding them to the list. We only add pools when no
161 * options were given on the command line. Otherwise, we keep the list fixed as
162 * those that were explicitly specified.
163 */
164 void
pool_list_update(zpool_list_t * zlp)165 pool_list_update(zpool_list_t *zlp)
166 {
167 if (zlp->zl_findall)
168 (void) zpool_iter(g_zfs, add_pool, zlp);
169 }
170
171 /*
172 * Iterate over all pools in the list, executing the callback for each
173 */
174 int
pool_list_iter(zpool_list_t * zlp,int unavail,zpool_iter_f func,void * data)175 pool_list_iter(zpool_list_t *zlp, int unavail, zpool_iter_f func,
176 void *data)
177 {
178 zpool_node_t *node, *next_node;
179 int ret = 0;
180
181 for (node = uu_avl_first(zlp->zl_avl); node != NULL; node = next_node) {
182 next_node = uu_avl_next(zlp->zl_avl, node);
183 if (zpool_get_state(node->zn_handle) != POOL_STATE_UNAVAIL ||
184 unavail)
185 ret |= func(node->zn_handle, data);
186 }
187
188 return (ret);
189 }
190
191 /*
192 * Remove the given pool from the list. When running iostat, we want to remove
193 * those pools that no longer exist.
194 */
195 void
pool_list_remove(zpool_list_t * zlp,zpool_handle_t * zhp)196 pool_list_remove(zpool_list_t *zlp, zpool_handle_t *zhp)
197 {
198 zpool_node_t search, *node;
199
200 search.zn_handle = zhp;
201 if ((node = uu_avl_find(zlp->zl_avl, &search, NULL, NULL)) != NULL) {
202 uu_avl_remove(zlp->zl_avl, node);
203 zpool_close(node->zn_handle);
204 free(node);
205 }
206 }
207
208 /*
209 * Free all the handles associated with this list.
210 */
211 void
pool_list_free(zpool_list_t * zlp)212 pool_list_free(zpool_list_t *zlp)
213 {
214 uu_avl_walk_t *walk;
215 zpool_node_t *node;
216
217 if ((walk = uu_avl_walk_start(zlp->zl_avl, UU_WALK_ROBUST)) == NULL) {
218 (void) fprintf(stderr,
219 gettext("internal error: out of memory"));
220 exit(1);
221 }
222
223 while ((node = uu_avl_walk_next(walk)) != NULL) {
224 uu_avl_remove(zlp->zl_avl, node);
225 zpool_close(node->zn_handle);
226 free(node);
227 }
228
229 uu_avl_walk_end(walk);
230 uu_avl_destroy(zlp->zl_avl);
231 uu_avl_pool_destroy(zlp->zl_pool);
232
233 free(zlp);
234 }
235
236 /*
237 * Returns the number of elements in the pool list.
238 */
239 int
pool_list_count(zpool_list_t * zlp)240 pool_list_count(zpool_list_t *zlp)
241 {
242 return (uu_avl_numnodes(zlp->zl_avl));
243 }
244
245 /*
246 * High level function which iterates over all pools given on the command line,
247 * using the pool_list_* interfaces.
248 */
249 int
for_each_pool(int argc,char ** argv,boolean_t unavail,zprop_list_t ** proplist,boolean_t literal,zpool_iter_f func,void * data)250 for_each_pool(int argc, char **argv, boolean_t unavail,
251 zprop_list_t **proplist, boolean_t literal, zpool_iter_f func, void *data)
252 {
253 zpool_list_t *list;
254 int ret = 0;
255
256 if ((list = pool_list_get(argc, argv, proplist, literal, &ret)) == NULL)
257 return (1);
258
259 if (pool_list_iter(list, unavail, func, data) != 0)
260 ret = 1;
261
262 pool_list_free(list);
263
264 return (ret);
265 }
266
267 static int
for_each_vdev_cb(zpool_handle_t * zhp,nvlist_t * nv,pool_vdev_iter_f func,void * data)268 for_each_vdev_cb(zpool_handle_t *zhp, nvlist_t *nv, pool_vdev_iter_f func,
269 void *data)
270 {
271 nvlist_t **child;
272 uint_t c, children;
273 int ret = 0;
274 int i;
275 char *type;
276
277 const char *list[] = {
278 ZPOOL_CONFIG_SPARES,
279 ZPOOL_CONFIG_L2CACHE,
280 ZPOOL_CONFIG_CHILDREN
281 };
282
283 for (i = 0; i < ARRAY_SIZE(list); i++) {
284 if (nvlist_lookup_nvlist_array(nv, list[i], &child,
285 &children) == 0) {
286 for (c = 0; c < children; c++) {
287 uint64_t ishole = 0;
288
289 (void) nvlist_lookup_uint64(child[c],
290 ZPOOL_CONFIG_IS_HOLE, &ishole);
291
292 if (ishole)
293 continue;
294
295 ret |= for_each_vdev_cb(zhp, child[c], func,
296 data);
297 }
298 }
299 }
300
301 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
302 return (ret);
303
304 /* Don't run our function on root vdevs */
305 if (strcmp(type, VDEV_TYPE_ROOT) != 0) {
306 ret |= func(zhp, nv, data);
307 }
308
309 return (ret);
310 }
311
312 /*
313 * This is the equivalent of for_each_pool() for vdevs. It iterates thorough
314 * all vdevs in the pool, ignoring root vdevs and holes, calling func() on
315 * each one.
316 *
317 * @zhp: Zpool handle
318 * @func: Function to call on each vdev
319 * @data: Custom data to pass to the function
320 */
321 int
for_each_vdev(zpool_handle_t * zhp,pool_vdev_iter_f func,void * data)322 for_each_vdev(zpool_handle_t *zhp, pool_vdev_iter_f func, void *data)
323 {
324 nvlist_t *config, *nvroot = NULL;
325
326 if ((config = zpool_get_config(zhp, NULL)) != NULL) {
327 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
328 &nvroot) == 0);
329 }
330 return (for_each_vdev_cb(zhp, nvroot, func, data));
331 }
332
333 /*
334 * Process the vcdl->vdev_cmd_data[] array to figure out all the unique column
335 * names and their widths. When this function is done, vcdl->uniq_cols,
336 * vcdl->uniq_cols_cnt, and vcdl->uniq_cols_width will be filled in.
337 */
338 static void
process_unique_cmd_columns(vdev_cmd_data_list_t * vcdl)339 process_unique_cmd_columns(vdev_cmd_data_list_t *vcdl)
340 {
341 char **uniq_cols = NULL, **tmp = NULL;
342 int *uniq_cols_width;
343 vdev_cmd_data_t *data;
344 int cnt = 0;
345 int k;
346
347 /* For each vdev */
348 for (int i = 0; i < vcdl->count; i++) {
349 data = &vcdl->data[i];
350 /* For each column the vdev reported */
351 for (int j = 0; j < data->cols_cnt; j++) {
352 /* Is this column in our list of unique column names? */
353 for (k = 0; k < cnt; k++) {
354 if (strcmp(data->cols[j], uniq_cols[k]) == 0)
355 break; /* yes it is */
356 }
357 if (k == cnt) {
358 /* No entry for column, add to list */
359 tmp = realloc(uniq_cols, sizeof (*uniq_cols) *
360 (cnt + 1));
361 if (tmp == NULL)
362 break; /* Nothing we can do... */
363 uniq_cols = tmp;
364 uniq_cols[cnt] = data->cols[j];
365 cnt++;
366 }
367 }
368 }
369
370 /*
371 * We now have a list of all the unique column names. Figure out the
372 * max width of each column by looking at the column name and all its
373 * values.
374 */
375 uniq_cols_width = safe_malloc(sizeof (*uniq_cols_width) * cnt);
376 for (int i = 0; i < cnt; i++) {
377 /* Start off with the column title's width */
378 uniq_cols_width[i] = strlen(uniq_cols[i]);
379 /* For each vdev */
380 for (int j = 0; j < vcdl->count; j++) {
381 /* For each of the vdev's values in a column */
382 data = &vcdl->data[j];
383 for (k = 0; k < data->cols_cnt; k++) {
384 /* Does this vdev have a value for this col? */
385 if (strcmp(data->cols[k], uniq_cols[i]) == 0) {
386 /* Is the value width larger? */
387 uniq_cols_width[i] =
388 MAX(uniq_cols_width[i],
389 strlen(data->lines[k]));
390 }
391 }
392 }
393 }
394
395 vcdl->uniq_cols = uniq_cols;
396 vcdl->uniq_cols_cnt = cnt;
397 vcdl->uniq_cols_width = uniq_cols_width;
398 }
399
400
401 /*
402 * Process a line of command output
403 *
404 * When running 'zpool iostat|status -c' the lines of output can either be
405 * in the form of:
406 *
407 * column_name=value
408 *
409 * Or just:
410 *
411 * value
412 *
413 * Process the column_name (if any) and value.
414 *
415 * Returns 0 if line was processed, and there are more lines can still be
416 * processed.
417 *
418 * Returns 1 if this was the last line to process, or error.
419 */
420 static int
vdev_process_cmd_output(vdev_cmd_data_t * data,char * line)421 vdev_process_cmd_output(vdev_cmd_data_t *data, char *line)
422 {
423 char *col = NULL;
424 char *val = line;
425 char *equals;
426 char **tmp;
427
428 if (line == NULL)
429 return (1);
430
431 equals = strchr(line, '=');
432 if (equals != NULL) {
433 /*
434 * We have a 'column=value' type line. Split it into the
435 * column and value strings by turning the '=' into a '\0'.
436 */
437 *equals = '\0';
438 col = line;
439 val = equals + 1;
440 } else {
441 val = line;
442 }
443
444 /* Do we already have a column by this name? If so, skip it. */
445 if (col != NULL) {
446 for (int i = 0; i < data->cols_cnt; i++) {
447 if (strcmp(col, data->cols[i]) == 0)
448 return (0); /* Duplicate, skip */
449 }
450 }
451
452 if (val != NULL) {
453 tmp = realloc(data->lines,
454 (data->lines_cnt + 1) * sizeof (*data->lines));
455 if (tmp == NULL)
456 return (1);
457
458 data->lines = tmp;
459 data->lines[data->lines_cnt] = strdup(val);
460 data->lines_cnt++;
461 }
462
463 if (col != NULL) {
464 tmp = realloc(data->cols,
465 (data->cols_cnt + 1) * sizeof (*data->cols));
466 if (tmp == NULL)
467 return (1);
468
469 data->cols = tmp;
470 data->cols[data->cols_cnt] = strdup(col);
471 data->cols_cnt++;
472 }
473
474 if (val != NULL && col == NULL)
475 return (1);
476
477 return (0);
478 }
479
480 /*
481 * Run the cmd and store results in *data.
482 */
483 static void
vdev_run_cmd(vdev_cmd_data_t * data,char * cmd)484 vdev_run_cmd(vdev_cmd_data_t *data, char *cmd)
485 {
486 int rc;
487 char *argv[2] = {cmd, 0};
488 char *env[5] = {"PATH=/bin:/sbin:/usr/bin:/usr/sbin", NULL, NULL, NULL,
489 NULL};
490 char **lines = NULL;
491 int lines_cnt = 0;
492 int i;
493
494 /* Setup our custom environment variables */
495 rc = asprintf(&env[1], "VDEV_PATH=%s",
496 data->path ? data->path : "");
497 if (rc == -1)
498 goto out;
499
500 rc = asprintf(&env[2], "VDEV_UPATH=%s",
501 data->upath ? data->upath : "");
502 if (rc == -1)
503 goto out;
504
505 rc = asprintf(&env[3], "VDEV_ENC_SYSFS_PATH=%s",
506 data->vdev_enc_sysfs_path ?
507 data->vdev_enc_sysfs_path : "");
508 if (rc == -1)
509 goto out;
510
511 /* Run the command */
512 rc = libzfs_run_process_get_stdout_nopath(cmd, argv, env, &lines,
513 &lines_cnt);
514 if (rc != 0)
515 goto out;
516
517 /* Process the output we got */
518 for (i = 0; i < lines_cnt; i++)
519 if (vdev_process_cmd_output(data, lines[i]) != 0)
520 break;
521
522 out:
523 if (lines != NULL)
524 libzfs_free_str_array(lines, lines_cnt);
525
526 /* Start with i = 1 since env[0] was statically allocated */
527 for (i = 1; i < ARRAY_SIZE(env); i++)
528 if (env[i] != NULL)
529 free(env[i]);
530 }
531
532 /*
533 * Generate the search path for zpool iostat/status -c scripts.
534 * The string returned must be freed.
535 */
536 char *
zpool_get_cmd_search_path(void)537 zpool_get_cmd_search_path(void)
538 {
539 const char *env;
540 char *sp = NULL;
541
542 env = getenv("ZPOOL_SCRIPTS_PATH");
543 if (env != NULL)
544 return (strdup(env));
545
546 env = getenv("HOME");
547 if (env != NULL) {
548 if (asprintf(&sp, "%s/.zpool.d:%s",
549 env, ZPOOL_SCRIPTS_DIR) != -1) {
550 return (sp);
551 }
552 }
553
554 if (asprintf(&sp, "%s", ZPOOL_SCRIPTS_DIR) != -1)
555 return (sp);
556
557 return (NULL);
558 }
559
560 /* Thread function run for each vdev */
561 static void
vdev_run_cmd_thread(void * cb_cmd_data)562 vdev_run_cmd_thread(void *cb_cmd_data)
563 {
564 vdev_cmd_data_t *data = cb_cmd_data;
565 char *cmd = NULL, *cmddup, *cmdrest;
566
567 cmddup = strdup(data->cmd);
568 if (cmddup == NULL)
569 return;
570
571 cmdrest = cmddup;
572 while ((cmd = strtok_r(cmdrest, ",", &cmdrest))) {
573 char *dir = NULL, *sp, *sprest;
574 char fullpath[MAXPATHLEN];
575
576 if (strchr(cmd, '/') != NULL)
577 continue;
578
579 sp = zpool_get_cmd_search_path();
580 if (sp == NULL)
581 continue;
582
583 sprest = sp;
584 while ((dir = strtok_r(sprest, ":", &sprest))) {
585 if (snprintf(fullpath, sizeof (fullpath),
586 "%s/%s", dir, cmd) == -1)
587 continue;
588
589 if (access(fullpath, X_OK) == 0) {
590 vdev_run_cmd(data, fullpath);
591 break;
592 }
593 }
594 free(sp);
595 }
596 free(cmddup);
597 }
598
599 /* For each vdev in the pool run a command */
600 static int
for_each_vdev_run_cb(zpool_handle_t * zhp,nvlist_t * nv,void * cb_vcdl)601 for_each_vdev_run_cb(zpool_handle_t *zhp, nvlist_t *nv, void *cb_vcdl)
602 {
603 vdev_cmd_data_list_t *vcdl = cb_vcdl;
604 vdev_cmd_data_t *data;
605 char *path = NULL;
606 char *vname = NULL;
607 char *vdev_enc_sysfs_path = NULL;
608 int i, match = 0;
609
610 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
611 return (1);
612
613 nvlist_lookup_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
614 &vdev_enc_sysfs_path);
615
616 /* Spares show more than once if they're in use, so skip if exists */
617 for (i = 0; i < vcdl->count; i++) {
618 if ((strcmp(vcdl->data[i].path, path) == 0) &&
619 (strcmp(vcdl->data[i].pool, zpool_get_name(zhp)) == 0)) {
620 /* vdev already exists, skip it */
621 return (0);
622 }
623 }
624
625 /* Check for selected vdevs here, if any */
626 for (i = 0; i < vcdl->vdev_names_count; i++) {
627 vname = zpool_vdev_name(g_zfs, zhp, nv, vcdl->cb_name_flags);
628 if (strcmp(vcdl->vdev_names[i], vname) == 0) {
629 free(vname);
630 match = 1;
631 break; /* match */
632 }
633 free(vname);
634 }
635
636 /* If we selected vdevs, and this isn't one of them, then bail out */
637 if (!match && vcdl->vdev_names_count)
638 return (0);
639
640 /*
641 * Resize our array and add in the new element.
642 */
643 if (!(vcdl->data = realloc(vcdl->data,
644 sizeof (*vcdl->data) * (vcdl->count + 1))))
645 return (ENOMEM); /* couldn't realloc */
646
647 data = &vcdl->data[vcdl->count];
648
649 data->pool = strdup(zpool_get_name(zhp));
650 data->path = strdup(path);
651 data->upath = zfs_get_underlying_path(path);
652 data->cmd = vcdl->cmd;
653 data->lines = data->cols = NULL;
654 data->lines_cnt = data->cols_cnt = 0;
655 if (vdev_enc_sysfs_path)
656 data->vdev_enc_sysfs_path = strdup(vdev_enc_sysfs_path);
657 else
658 data->vdev_enc_sysfs_path = NULL;
659
660 vcdl->count++;
661
662 return (0);
663 }
664
665 /* Get the names and count of the vdevs */
666 static int
all_pools_for_each_vdev_gather_cb(zpool_handle_t * zhp,void * cb_vcdl)667 all_pools_for_each_vdev_gather_cb(zpool_handle_t *zhp, void *cb_vcdl)
668 {
669 return (for_each_vdev(zhp, for_each_vdev_run_cb, cb_vcdl));
670 }
671
672 /*
673 * Now that vcdl is populated with our complete list of vdevs, spawn
674 * off the commands.
675 */
676 static void
all_pools_for_each_vdev_run_vcdl(vdev_cmd_data_list_t * vcdl)677 all_pools_for_each_vdev_run_vcdl(vdev_cmd_data_list_t *vcdl)
678 {
679 tpool_t *t;
680
681 t = tpool_create(1, 5 * sysconf(_SC_NPROCESSORS_ONLN), 0, NULL);
682 if (t == NULL)
683 return;
684
685 /* Spawn off the command for each vdev */
686 for (int i = 0; i < vcdl->count; i++) {
687 (void) tpool_dispatch(t, vdev_run_cmd_thread,
688 (void *) &vcdl->data[i]);
689 }
690
691 /* Wait for threads to finish */
692 tpool_wait(t);
693 tpool_destroy(t);
694 }
695
696 /*
697 * Run command 'cmd' on all vdevs in all pools in argv. Saves the first line of
698 * output from the command in vcdk->data[].line for all vdevs. If you want
699 * to run the command on only certain vdevs, fill in g_zfs, vdev_names,
700 * vdev_names_count, and cb_name_flags. Otherwise leave them as zero.
701 *
702 * Returns a vdev_cmd_data_list_t that must be freed with
703 * free_vdev_cmd_data_list();
704 */
705 vdev_cmd_data_list_t *
all_pools_for_each_vdev_run(int argc,char ** argv,char * cmd,libzfs_handle_t * g_zfs,char ** vdev_names,int vdev_names_count,int cb_name_flags)706 all_pools_for_each_vdev_run(int argc, char **argv, char *cmd,
707 libzfs_handle_t *g_zfs, char **vdev_names, int vdev_names_count,
708 int cb_name_flags)
709 {
710 vdev_cmd_data_list_t *vcdl;
711 vcdl = safe_malloc(sizeof (vdev_cmd_data_list_t));
712 vcdl->cmd = cmd;
713
714 vcdl->vdev_names = vdev_names;
715 vcdl->vdev_names_count = vdev_names_count;
716 vcdl->cb_name_flags = cb_name_flags;
717 vcdl->g_zfs = g_zfs;
718
719 /* Gather our list of all vdevs in all pools */
720 for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE,
721 all_pools_for_each_vdev_gather_cb, vcdl);
722
723 /* Run command on all vdevs in all pools */
724 all_pools_for_each_vdev_run_vcdl(vcdl);
725
726 /*
727 * vcdl->data[] now contains all the column names and values for each
728 * vdev. We need to process that into a master list of unique column
729 * names, and figure out the width of each column.
730 */
731 process_unique_cmd_columns(vcdl);
732
733 return (vcdl);
734 }
735
736 /*
737 * Free the vdev_cmd_data_list_t created by all_pools_for_each_vdev_run()
738 */
739 void
free_vdev_cmd_data_list(vdev_cmd_data_list_t * vcdl)740 free_vdev_cmd_data_list(vdev_cmd_data_list_t *vcdl)
741 {
742 free(vcdl->uniq_cols);
743 free(vcdl->uniq_cols_width);
744
745 for (int i = 0; i < vcdl->count; i++) {
746 free(vcdl->data[i].path);
747 free(vcdl->data[i].pool);
748 free(vcdl->data[i].upath);
749
750 for (int j = 0; j < vcdl->data[i].lines_cnt; j++)
751 free(vcdl->data[i].lines[j]);
752
753 free(vcdl->data[i].lines);
754
755 for (int j = 0; j < vcdl->data[i].cols_cnt; j++)
756 free(vcdl->data[i].cols[j]);
757
758 free(vcdl->data[i].cols);
759 free(vcdl->data[i].vdev_enc_sysfs_path);
760 }
761 free(vcdl->data);
762 free(vcdl);
763 }
764