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