?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8567 Inconsistent return value in zpool_read_label
[unleashed.git] / usr / src / cmd / zpool / zpool_main.c
blobd3af687dc4f1b88a4b3c1214d8657ad94ff99130
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 /*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011, 2016 by Delphix. All rights reserved.
25 * Copyright (c) 2012 by Frederik Wessels. All rights reserved.
26 * Copyright (c) 2013 by Prasad Joshi (sTec). All rights reserved.
27 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
28 * Copyright 2016 Nexenta Systems, Inc.
29 * Copyright (c) 2017 Datto Inc.
30 */
31
32 #include <assert.h>
33 #include <ctype.h>
34 #include <dirent.h>
35 #include <errno.h>
36 #include <fcntl.h>
37 #include <libgen.h>
38 #include <libintl.h>
39 #include <libuutil.h>
40 #include <locale.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <strings.h>
45 #include <unistd.h>
46 #include <priv.h>
47 #include <pwd.h>
48 #include <zone.h>
49 #include <zfs_prop.h>
50 #include <sys/fs/zfs.h>
51 #include <sys/stat.h>
52
53 #include <libzfs.h>
54
55 #include "zpool_util.h"
56 #include "zfs_comutil.h"
57 #include "zfeature_common.h"
58
59 #include "statcommon.h"
60
61 static int zpool_do_create(int, char **);
62 static int zpool_do_destroy(int, char **);
63
64 static int zpool_do_add(int, char **);
65 static int zpool_do_remove(int, char **);
66 static int zpool_do_labelclear(int, char **);
67
68 static int zpool_do_list(int, char **);
69 static int zpool_do_iostat(int, char **);
70 static int zpool_do_status(int, char **);
71
72 static int zpool_do_online(int, char **);
73 static int zpool_do_offline(int, char **);
74 static int zpool_do_clear(int, char **);
75 static int zpool_do_reopen(int, char **);
76
77 static int zpool_do_reguid(int, char **);
78
79 static int zpool_do_attach(int, char **);
80 static int zpool_do_detach(int, char **);
81 static int zpool_do_replace(int, char **);
82 static int zpool_do_split(int, char **);
83
84 static int zpool_do_scrub(int, char **);
85
86 static int zpool_do_import(int, char **);
87 static int zpool_do_export(int, char **);
88
89 static int zpool_do_upgrade(int, char **);
90
91 static int zpool_do_history(int, char **);
92
93 static int zpool_do_get(int, char **);
94 static int zpool_do_set(int, char **);
95
96 /*
97 * These libumem hooks provide a reasonable set of defaults for the allocator's
98 * debugging facilities.
99 */
100
101 #ifdef DEBUG
102 const char *
103 _umem_debug_init(void)
104 {
105 return ("default,verbose"); /* $UMEM_DEBUG setting */
106 }
107
108 const char *
109 _umem_logging_init(void)
110 {
111 return ("fail,contents"); /* $UMEM_LOGGING setting */
112 }
113 #endif
114
115 typedef enum {
116 HELP_ADD,
117 HELP_ATTACH,
118 HELP_CLEAR,
119 HELP_CREATE,
120 HELP_DESTROY,
121 HELP_DETACH,
122 HELP_EXPORT,
123 HELP_HISTORY,
124 HELP_IMPORT,
125 HELP_IOSTAT,
126 HELP_LABELCLEAR,
127 HELP_LIST,
128 HELP_OFFLINE,
129 HELP_ONLINE,
130 HELP_REPLACE,
131 HELP_REMOVE,
132 HELP_SCRUB,
133 HELP_STATUS,
134 HELP_UPGRADE,
135 HELP_GET,
136 HELP_SET,
137 HELP_SPLIT,
138 HELP_REGUID,
139 HELP_REOPEN
140 } zpool_help_t;
141
142
143 typedef struct zpool_command {
144 const char *name;
145 int (*func)(int, char **);
146 zpool_help_t usage;
147 } zpool_command_t;
148
149 /*
150 * Master command table. Each ZFS command has a name, associated function, and
151 * usage message. The usage messages need to be internationalized, so we have
152 * to have a function to return the usage message based on a command index.
153 *
154 * These commands are organized according to how they are displayed in the usage
155 * message. An empty command (one with a NULL name) indicates an empty line in
156 * the generic usage message.
157 */
158 static zpool_command_t command_table[] = {
159 { "create", zpool_do_create, HELP_CREATE },
160 { "destroy", zpool_do_destroy, HELP_DESTROY },
161 { NULL },
162 { "add", zpool_do_add, HELP_ADD },
163 { "remove", zpool_do_remove, HELP_REMOVE },
164 { NULL },
165 { "labelclear", zpool_do_labelclear, HELP_LABELCLEAR },
166 { NULL },
167 { "list", zpool_do_list, HELP_LIST },
168 { "iostat", zpool_do_iostat, HELP_IOSTAT },
169 { "status", zpool_do_status, HELP_STATUS },
170 { NULL },
171 { "online", zpool_do_online, HELP_ONLINE },
172 { "offline", zpool_do_offline, HELP_OFFLINE },
173 { "clear", zpool_do_clear, HELP_CLEAR },
174 { "reopen", zpool_do_reopen, HELP_REOPEN },
175 { NULL },
176 { "attach", zpool_do_attach, HELP_ATTACH },
177 { "detach", zpool_do_detach, HELP_DETACH },
178 { "replace", zpool_do_replace, HELP_REPLACE },
179 { "split", zpool_do_split, HELP_SPLIT },
180 { NULL },
181 { "scrub", zpool_do_scrub, HELP_SCRUB },
182 { NULL },
183 { "import", zpool_do_import, HELP_IMPORT },
184 { "export", zpool_do_export, HELP_EXPORT },
185 { "upgrade", zpool_do_upgrade, HELP_UPGRADE },
186 { "reguid", zpool_do_reguid, HELP_REGUID },
187 { NULL },
188 { "history", zpool_do_history, HELP_HISTORY },
189 { "get", zpool_do_get, HELP_GET },
190 { "set", zpool_do_set, HELP_SET },
191 };
192
193 #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0]))
194
195 static zpool_command_t *current_command;
196 static char history_str[HIS_MAX_RECORD_LEN];
197 static boolean_t log_history = B_TRUE;
198 static uint_t timestamp_fmt = NODATE;
199
200 static const char *
201 get_usage(zpool_help_t idx)
202 {
203 switch (idx) {
204 case HELP_ADD:
205 return (gettext("\tadd [-fn] <pool> <vdev> ...\n"));
206 case HELP_ATTACH:
207 return (gettext("\tattach [-f] <pool> <device> "
208 "<new-device>\n"));
209 case HELP_CLEAR:
210 return (gettext("\tclear [-nF] <pool> [device]\n"));
211 case HELP_CREATE:
212 return (gettext("\tcreate [-fnd] [-B] "
213 "[-o property=value] ... \n"
214 "\t [-O file-system-property=value] ... \n"
215 "\t [-m mountpoint] [-R root] <pool> <vdev> ...\n"));
216 case HELP_DESTROY:
217 return (gettext("\tdestroy [-f] <pool>\n"));
218 case HELP_DETACH:
219 return (gettext("\tdetach <pool> <device>\n"));
220 case HELP_EXPORT:
221 return (gettext("\texport [-f] <pool> ...\n"));
222 case HELP_HISTORY:
223 return (gettext("\thistory [-il] [<pool>] ...\n"));
224 case HELP_IMPORT:
225 return (gettext("\timport [-d dir] [-D]\n"
226 "\timport [-d dir | -c cachefile] [-F [-n]] <pool | id>\n"
227 "\timport [-o mntopts] [-o property=value] ... \n"
228 "\t [-d dir | -c cachefile] [-D] [-f] [-m] [-N] "
229 "[-R root] [-F [-n]] -a\n"
230 "\timport [-o mntopts] [-o property=value] ... \n"
231 "\t [-d dir | -c cachefile] [-D] [-f] [-m] [-N] "
232 "[-R root] [-F [-n]]\n"
233 "\t <pool | id> [newpool]\n"));
234 case HELP_IOSTAT:
235 return (gettext("\tiostat [-v] [-T d|u] [pool] ... [interval "
236 "[count]]\n"));
237 case HELP_LABELCLEAR:
238 return (gettext("\tlabelclear [-f] <vdev>\n"));
239 case HELP_LIST:
240 return (gettext("\tlist [-Hp] [-o property[,...]] "
241 "[-T d|u] [pool] ... [interval [count]]\n"));
242 case HELP_OFFLINE:
243 return (gettext("\toffline [-t] <pool> <device> ...\n"));
244 case HELP_ONLINE:
245 return (gettext("\tonline <pool> <device> ...\n"));
246 case HELP_REPLACE:
247 return (gettext("\treplace [-f] <pool> <device> "
248 "[new-device]\n"));
249 case HELP_REMOVE:
250 return (gettext("\tremove <pool> <device> ...\n"));
251 case HELP_REOPEN:
252 return (gettext("\treopen <pool>\n"));
253 case HELP_SCRUB:
254 return (gettext("\tscrub [-s | -p] <pool> ...\n"));
255 case HELP_STATUS:
256 return (gettext("\tstatus [-vx] [-T d|u] [pool] ... [interval "
257 "[count]]\n"));
258 case HELP_UPGRADE:
259 return (gettext("\tupgrade\n"
260 "\tupgrade -v\n"
261 "\tupgrade [-V version] <-a | pool ...>\n"));
262 case HELP_GET:
263 return (gettext("\tget [-Hp] [-o \"all\" | field[,...]] "
264 "<\"all\" | property[,...]> <pool> ...\n"));
265 case HELP_SET:
266 return (gettext("\tset <property=value> <pool> \n"));
267 case HELP_SPLIT:
268 return (gettext("\tsplit [-n] [-R altroot] [-o mntopts]\n"
269 "\t [-o property=value] <pool> <newpool> "
270 "[<device> ...]\n"));
271 case HELP_REGUID:
272 return (gettext("\treguid <pool>\n"));
273 }
274
275 abort();
276 /* NOTREACHED */
277 }
278
279
280 /*
281 * Callback routine that will print out a pool property value.
282 */
283 static int
284 print_prop_cb(int prop, void *cb)
285 {
286 FILE *fp = cb;
287
288 (void) fprintf(fp, "\t%-15s ", zpool_prop_to_name(prop));
289
290 if (zpool_prop_readonly(prop))
291 (void) fprintf(fp, " NO ");
292 else
293 (void) fprintf(fp, " YES ");
294
295 if (zpool_prop_values(prop) == NULL)
296 (void) fprintf(fp, "-\n");
297 else
298 (void) fprintf(fp, "%s\n", zpool_prop_values(prop));
299
300 return (ZPROP_CONT);
301 }
302
303 /*
304 * Display usage message. If we're inside a command, display only the usage for
305 * that command. Otherwise, iterate over the entire command table and display
306 * a complete usage message.
307 */
308 void
309 usage(boolean_t requested)
310 {
311 FILE *fp = requested ? stdout : stderr;
312
313 if (current_command == NULL) {
314 int i;
315
316 (void) fprintf(fp, gettext("usage: zpool command args ...\n"));
317 (void) fprintf(fp,
318 gettext("where 'command' is one of the following:\n\n"));
319
320 for (i = 0; i < NCOMMAND; i++) {
321 if (command_table[i].name == NULL)
322 (void) fprintf(fp, "\n");
323 else
324 (void) fprintf(fp, "%s",
325 get_usage(command_table[i].usage));
326 }
327 } else {
328 (void) fprintf(fp, gettext("usage:\n"));
329 (void) fprintf(fp, "%s", get_usage(current_command->usage));
330 }
331
332 if (current_command != NULL &&
333 ((strcmp(current_command->name, "set") == 0) ||
334 (strcmp(current_command->name, "get") == 0) ||
335 (strcmp(current_command->name, "list") == 0))) {
336
337 (void) fprintf(fp,
338 gettext("\nthe following properties are supported:\n"));
339
340 (void) fprintf(fp, "\n\t%-15s %s %s\n\n",
341 "PROPERTY", "EDIT", "VALUES");
342
343 /* Iterate over all properties */
344 (void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE,
345 ZFS_TYPE_POOL);
346
347 (void) fprintf(fp, "\t%-15s ", "feature@...");
348 (void) fprintf(fp, "YES disabled | enabled | active\n");
349
350 (void) fprintf(fp, gettext("\nThe feature@ properties must be "
351 "appended with a feature name.\nSee zpool-features(5).\n"));
352 }
353
354 /*
355 * See comments at end of main().
356 */
357 if (getenv("ZFS_ABORT") != NULL) {
358 (void) printf("dumping core by request\n");
359 abort();
360 }
361
362 exit(requested ? 0 : 2);
363 }
364
365 void
366 print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent,
367 boolean_t print_logs)
368 {
369 nvlist_t **child;
370 uint_t c, children;
371 char *vname;
372
373 if (name != NULL)
374 (void) printf("\t%*s%s\n", indent, "", name);
375
376 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
377 &child, &children) != 0)
378 return;
379
380 for (c = 0; c < children; c++) {
381 uint64_t is_log = B_FALSE;
382
383 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
384 &is_log);
385 if ((is_log && !print_logs) || (!is_log && print_logs))
386 continue;
387
388 vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE);
389 print_vdev_tree(zhp, vname, child[c], indent + 2,
390 B_FALSE);
391 free(vname);
392 }
393 }
394
395 static boolean_t
396 prop_list_contains_feature(nvlist_t *proplist)
397 {
398 nvpair_t *nvp;
399 for (nvp = nvlist_next_nvpair(proplist, NULL); NULL != nvp;
400 nvp = nvlist_next_nvpair(proplist, nvp)) {
401 if (zpool_prop_feature(nvpair_name(nvp)))
402 return (B_TRUE);
403 }
404 return (B_FALSE);
405 }
406
407 /*
408 * Add a property pair (name, string-value) into a property nvlist.
409 */
410 static int
411 add_prop_list(const char *propname, char *propval, nvlist_t **props,
412 boolean_t poolprop)
413 {
414 zpool_prop_t prop = ZPROP_INVAL;
415 zfs_prop_t fprop;
416 nvlist_t *proplist;
417 const char *normnm;
418 char *strval;
419
420 if (*props == NULL &&
421 nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) {
422 (void) fprintf(stderr,
423 gettext("internal error: out of memory\n"));
424 return (1);
425 }
426
427 proplist = *props;
428
429 if (poolprop) {
430 const char *vname = zpool_prop_to_name(ZPOOL_PROP_VERSION);
431
432 if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL &&
433 !zpool_prop_feature(propname)) {
434 (void) fprintf(stderr, gettext("property '%s' is "
435 "not a valid pool property\n"), propname);
436 return (2);
437 }
438
439 /*
440 * feature@ properties and version should not be specified
441 * at the same time.
442 */
443 if ((prop == ZPROP_INVAL && zpool_prop_feature(propname) &&
444 nvlist_exists(proplist, vname)) ||
445 (prop == ZPOOL_PROP_VERSION &&
446 prop_list_contains_feature(proplist))) {
447 (void) fprintf(stderr, gettext("'feature@' and "
448 "'version' properties cannot be specified "
449 "together\n"));
450 return (2);
451 }
452
453
454 if (zpool_prop_feature(propname))
455 normnm = propname;
456 else
457 normnm = zpool_prop_to_name(prop);
458 } else {
459 if ((fprop = zfs_name_to_prop(propname)) != ZPROP_INVAL) {
460 normnm = zfs_prop_to_name(fprop);
461 } else {
462 normnm = propname;
463 }
464 }
465
466 if (nvlist_lookup_string(proplist, normnm, &strval) == 0 &&
467 prop != ZPOOL_PROP_CACHEFILE) {
468 (void) fprintf(stderr, gettext("property '%s' "
469 "specified multiple times\n"), propname);
470 return (2);
471 }
472
473 if (nvlist_add_string(proplist, normnm, propval) != 0) {
474 (void) fprintf(stderr, gettext("internal "
475 "error: out of memory\n"));
476 return (1);
477 }
478
479 return (0);
480 }
481
482 /*
483 * zpool add [-fn] <pool> <vdev> ...
484 *
485 * -f Force addition of devices, even if they appear in use
486 * -n Do not add the devices, but display the resulting layout if
487 * they were to be added.
488 *
489 * Adds the given vdevs to 'pool'. As with create, the bulk of this work is
490 * handled by get_vdev_spec(), which constructs the nvlist needed to pass to
491 * libzfs.
492 */
493 int
494 zpool_do_add(int argc, char **argv)
495 {
496 boolean_t force = B_FALSE;
497 boolean_t dryrun = B_FALSE;
498 int c;
499 nvlist_t *nvroot;
500 char *poolname;
501 zpool_boot_label_t boot_type;
502 uint64_t boot_size;
503 int ret;
504 zpool_handle_t *zhp;
505 nvlist_t *config;
506
507 /* check options */
508 while ((c = getopt(argc, argv, "fn")) != -1) {
509 switch (c) {
510 case 'f':
511 force = B_TRUE;
512 break;
513 case 'n':
514 dryrun = B_TRUE;
515 break;
516 case '?':
517 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
518 optopt);
519 usage(B_FALSE);
520 }
521 }
522
523 argc -= optind;
524 argv += optind;
525
526 /* get pool name and check number of arguments */
527 if (argc < 1) {
528 (void) fprintf(stderr, gettext("missing pool name argument\n"));
529 usage(B_FALSE);
530 }
531 if (argc < 2) {
532 (void) fprintf(stderr, gettext("missing vdev specification\n"));
533 usage(B_FALSE);
534 }
535
536 poolname = argv[0];
537
538 argc--;
539 argv++;
540
541 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
542 return (1);
543
544 if ((config = zpool_get_config(zhp, NULL)) == NULL) {
545 (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),
546 poolname);
547 zpool_close(zhp);
548 return (1);
549 }
550
551 if (zpool_is_bootable(zhp))
552 boot_type = ZPOOL_COPY_BOOT_LABEL;
553 else
554 boot_type = ZPOOL_NO_BOOT_LABEL;
555
556 /* pass off to get_vdev_spec for processing */
557 boot_size = zpool_get_prop_int(zhp, ZPOOL_PROP_BOOTSIZE, NULL);
558 nvroot = make_root_vdev(zhp, force, !force, B_FALSE, dryrun,
559 boot_type, boot_size, argc, argv);
560 if (nvroot == NULL) {
561 zpool_close(zhp);
562 return (1);
563 }
564
565 if (dryrun) {
566 nvlist_t *poolnvroot;
567
568 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
569 &poolnvroot) == 0);
570
571 (void) printf(gettext("would update '%s' to the following "
572 "configuration:\n"), zpool_get_name(zhp));
573
574 /* print original main pool and new tree */
575 print_vdev_tree(zhp, poolname, poolnvroot, 0, B_FALSE);
576 print_vdev_tree(zhp, NULL, nvroot, 0, B_FALSE);
577
578 /* Do the same for the logs */
579 if (num_logs(poolnvroot) > 0) {
580 print_vdev_tree(zhp, "logs", poolnvroot, 0, B_TRUE);
581 print_vdev_tree(zhp, NULL, nvroot, 0, B_TRUE);
582 } else if (num_logs(nvroot) > 0) {
583 print_vdev_tree(zhp, "logs", nvroot, 0, B_TRUE);
584 }
585
586 ret = 0;
587 } else {
588 ret = (zpool_add(zhp, nvroot) != 0);
589 }
590
591 nvlist_free(nvroot);
592 zpool_close(zhp);
593
594 return (ret);
595 }
596
597 /*
598 * zpool remove <pool> <vdev> ...
599 *
600 * Removes the given vdev from the pool. Currently, this supports removing
601 * spares, cache, and log devices from the pool.
602 */
603 int
604 zpool_do_remove(int argc, char **argv)
605 {
606 char *poolname;
607 int i, ret = 0;
608 zpool_handle_t *zhp;
609
610 argc--;
611 argv++;
612
613 /* get pool name and check number of arguments */
614 if (argc < 1) {
615 (void) fprintf(stderr, gettext("missing pool name argument\n"));
616 usage(B_FALSE);
617 }
618 if (argc < 2) {
619 (void) fprintf(stderr, gettext("missing device\n"));
620 usage(B_FALSE);
621 }
622
623 poolname = argv[0];
624
625 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
626 return (1);
627
628 for (i = 1; i < argc; i++) {
629 if (zpool_vdev_remove(zhp, argv[i]) != 0)
630 ret = 1;
631 }
632
633 return (ret);
634 }
635
636 /*
637 * zpool labelclear [-f] <vdev>
638 *
639 * -f Force clearing the label for the vdevs which are members of
640 * the exported or foreign pools.
641 *
642 * Verifies that the vdev is not active and zeros out the label information
643 * on the device.
644 */
645 int
646 zpool_do_labelclear(int argc, char **argv)
647 {
648 char vdev[MAXPATHLEN];
649 char *name = NULL;
650 struct stat st;
651 int c, fd, ret = 0;
652 nvlist_t *config;
653 pool_state_t state;
654 boolean_t inuse = B_FALSE;
655 boolean_t force = B_FALSE;
656
657 /* check options */
658 while ((c = getopt(argc, argv, "f")) != -1) {
659 switch (c) {
660 case 'f':
661 force = B_TRUE;
662 break;
663 default:
664 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
665 optopt);
666 usage(B_FALSE);
667 }
668 }
669
670 argc -= optind;
671 argv += optind;
672
673 /* get vdev name */
674 if (argc < 1) {
675 (void) fprintf(stderr, gettext("missing vdev name\n"));
676 usage(B_FALSE);
677 }
678 if (argc > 1) {
679 (void) fprintf(stderr, gettext("too many arguments\n"));
680 usage(B_FALSE);
681 }
682
683 /*
684 * Check if we were given absolute path and use it as is.
685 * Otherwise if the provided vdev name doesn't point to a file,
686 * try prepending dsk path and appending s0.
687 */
688 (void) strlcpy(vdev, argv[0], sizeof (vdev));
689 if (vdev[0] != '/' && stat(vdev, &st) != 0) {
690 char *s;
691
692 (void) snprintf(vdev, sizeof (vdev), "%s/%s",
693 ZFS_DISK_ROOT, argv[0]);
694 if ((s = strrchr(argv[0], 's')) == NULL ||
695 !isdigit(*(s + 1)))
696 (void) strlcat(vdev, "s0", sizeof (vdev));
697 if (stat(vdev, &st) != 0) {
698 (void) fprintf(stderr, gettext(
699 "failed to find device %s, try specifying absolute "
700 "path instead\n"), argv[0]);
701 return (1);
702 }
703 }
704
705 if ((fd = open(vdev, O_RDWR)) < 0) {
706 (void) fprintf(stderr, gettext("failed to open %s: %s\n"),
707 vdev, strerror(errno));
708 return (1);
709 }
710
711 if (zpool_read_label(fd, &config) != 0) {
712 (void) fprintf(stderr,
713 gettext("failed to read label from %s\n"), vdev);
714 return (1);
715 }
716 nvlist_free(config);
717
718 ret = zpool_in_use(g_zfs, fd, &state, &name, &inuse);
719 if (ret != 0) {
720 (void) fprintf(stderr,
721 gettext("failed to check state for %s\n"), vdev);
722 return (1);
723 }
724
725 if (!inuse)
726 goto wipe_label;
727
728 switch (state) {
729 default:
730 case POOL_STATE_ACTIVE:
731 case POOL_STATE_SPARE:
732 case POOL_STATE_L2CACHE:
733 (void) fprintf(stderr, gettext(
734 "%s is a member (%s) of pool \"%s\"\n"),
735 vdev, zpool_pool_state_to_name(state), name);
736 ret = 1;
737 goto errout;
738
739 case POOL_STATE_EXPORTED:
740 if (force)
741 break;
742 (void) fprintf(stderr, gettext(
743 "use '-f' to override the following error:\n"
744 "%s is a member of exported pool \"%s\"\n"),
745 vdev, name);
746 ret = 1;
747 goto errout;
748
749 case POOL_STATE_POTENTIALLY_ACTIVE:
750 if (force)
751 break;
752 (void) fprintf(stderr, gettext(
753 "use '-f' to override the following error:\n"
754 "%s is a member of potentially active pool \"%s\"\n"),
755 vdev, name);
756 ret = 1;
757 goto errout;
758
759 case POOL_STATE_DESTROYED:
760 /* inuse should never be set for a destroyed pool */
761 assert(0);
762 break;
763 }
764
765 wipe_label:
766 ret = zpool_clear_label(fd);
767 if (ret != 0) {
768 (void) fprintf(stderr,
769 gettext("failed to clear label for %s\n"), vdev);
770 }
771
772 errout:
773 free(name);
774 (void) close(fd);
775
776 return (ret);
777 }
778
779 /*
780 * zpool create [-fnd] [-B] [-o property=value] ...
781 * [-O file-system-property=value] ...
782 * [-R root] [-m mountpoint] <pool> <dev> ...
783 *
784 * -B Create boot partition.
785 * -f Force creation, even if devices appear in use
786 * -n Do not create the pool, but display the resulting layout if it
787 * were to be created.
788 * -R Create a pool under an alternate root
789 * -m Set default mountpoint for the root dataset. By default it's
790 * '/<pool>'
791 * -o Set property=value.
792 * -d Don't automatically enable all supported pool features
793 * (individual features can be enabled with -o).
794 * -O Set fsproperty=value in the pool's root file system
795 *
796 * Creates the named pool according to the given vdev specification. The
797 * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once
798 * we get the nvlist back from get_vdev_spec(), we either print out the contents
799 * (if '-n' was specified), or pass it to libzfs to do the creation.
800 */
801
802 #define SYSTEM256 (256 * 1024 * 1024)
803 int
804 zpool_do_create(int argc, char **argv)
805 {
806 boolean_t force = B_FALSE;
807 boolean_t dryrun = B_FALSE;
808 boolean_t enable_all_pool_feat = B_TRUE;
809 zpool_boot_label_t boot_type = ZPOOL_NO_BOOT_LABEL;
810 uint64_t boot_size = 0;
811 int c;
812 nvlist_t *nvroot = NULL;
813 char *poolname;
814 int ret = 1;
815 char *altroot = NULL;
816 char *mountpoint = NULL;
817 nvlist_t *fsprops = NULL;
818 nvlist_t *props = NULL;
819 char *propval;
820
821 /* check options */
822 while ((c = getopt(argc, argv, ":fndBR:m:o:O:")) != -1) {
823 switch (c) {
824 case 'f':
825 force = B_TRUE;
826 break;
827 case 'n':
828 dryrun = B_TRUE;
829 break;
830 case 'd':
831 enable_all_pool_feat = B_FALSE;
832 break;
833 case 'B':
834 /*
835 * We should create the system partition.
836 * Also make sure the size is set.
837 */
838 boot_type = ZPOOL_CREATE_BOOT_LABEL;
839 if (boot_size == 0)
840 boot_size = SYSTEM256;
841 break;
842 case 'R':
843 altroot = optarg;
844 if (add_prop_list(zpool_prop_to_name(
845 ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE))
846 goto errout;
847 if (nvlist_lookup_string(props,
848 zpool_prop_to_name(ZPOOL_PROP_CACHEFILE),
849 &propval) == 0)
850 break;
851 if (add_prop_list(zpool_prop_to_name(
852 ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
853 goto errout;
854 break;
855 case 'm':
856 /* Equivalent to -O mountpoint=optarg */
857 mountpoint = optarg;
858 break;
859 case 'o':
860 if ((propval = strchr(optarg, '=')) == NULL) {
861 (void) fprintf(stderr, gettext("missing "
862 "'=' for -o option\n"));
863 goto errout;
864 }
865 *propval = '\0';
866 propval++;
867
868 if (add_prop_list(optarg, propval, &props, B_TRUE))
869 goto errout;
870
871 /*
872 * Get bootsize value for make_root_vdev().
873 */
874 if (zpool_name_to_prop(optarg) == ZPOOL_PROP_BOOTSIZE) {
875 if (zfs_nicestrtonum(g_zfs, propval,
876 &boot_size) < 0 || boot_size == 0) {
877 (void) fprintf(stderr,
878 gettext("bad boot partition size "
879 "'%s': %s\n"), propval,
880 libzfs_error_description(g_zfs));
881 goto errout;
882 }
883 }
884
885 /*
886 * If the user is creating a pool that doesn't support
887 * feature flags, don't enable any features.
888 */
889 if (zpool_name_to_prop(optarg) == ZPOOL_PROP_VERSION) {
890 char *end;
891 u_longlong_t ver;
892
893 ver = strtoull(propval, &end, 10);
894 if (*end == '\0' &&
895 ver < SPA_VERSION_FEATURES) {
896 enable_all_pool_feat = B_FALSE;
897 }
898 }
899 if (zpool_name_to_prop(optarg) == ZPOOL_PROP_ALTROOT)
900 altroot = propval;
901 break;
902 case 'O':
903 if ((propval = strchr(optarg, '=')) == NULL) {
904 (void) fprintf(stderr, gettext("missing "
905 "'=' for -O option\n"));
906 goto errout;
907 }
908 *propval = '\0';
909 propval++;
910
911 /*
912 * Mountpoints are checked and then added later.
913 * Uniquely among properties, they can be specified
914 * more than once, to avoid conflict with -m.
915 */
916 if (0 == strcmp(optarg,
917 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT))) {
918 mountpoint = propval;
919 } else if (add_prop_list(optarg, propval, &fsprops,
920 B_FALSE)) {
921 goto errout;
922 }
923 break;
924 case ':':
925 (void) fprintf(stderr, gettext("missing argument for "
926 "'%c' option\n"), optopt);
927 goto badusage;
928 case '?':
929 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
930 optopt);
931 goto badusage;
932 }
933 }
934
935 argc -= optind;
936 argv += optind;
937
938 /* get pool name and check number of arguments */
939 if (argc < 1) {
940 (void) fprintf(stderr, gettext("missing pool name argument\n"));
941 goto badusage;
942 }
943 if (argc < 2) {
944 (void) fprintf(stderr, gettext("missing vdev specification\n"));
945 goto badusage;
946 }
947
948 poolname = argv[0];
949
950 /*
951 * As a special case, check for use of '/' in the name, and direct the
952 * user to use 'zfs create' instead.
953 */
954 if (strchr(poolname, '/') != NULL) {
955 (void) fprintf(stderr, gettext("cannot create '%s': invalid "
956 "character '/' in pool name\n"), poolname);
957 (void) fprintf(stderr, gettext("use 'zfs create' to "
958 "create a dataset\n"));
959 goto errout;
960 }
961
962 /*
963 * Make sure the bootsize is set when ZPOOL_CREATE_BOOT_LABEL is used,
964 * and not set otherwise.
965 */
966 if (boot_type == ZPOOL_CREATE_BOOT_LABEL) {
967 const char *propname;
968 char *strptr, *buf = NULL;
969 int rv;
970
971 propname = zpool_prop_to_name(ZPOOL_PROP_BOOTSIZE);
972 if (nvlist_lookup_string(props, propname, &strptr) != 0) {
973 (void) asprintf(&buf, "%" PRIu64, boot_size);
974 if (buf == NULL) {
975 (void) fprintf(stderr,
976 gettext("internal error: out of memory\n"));
977 goto errout;
978 }
979 rv = add_prop_list(propname, buf, &props, B_TRUE);
980 free(buf);
981 if (rv != 0)
982 goto errout;
983 }
984 } else {
985 const char *propname;
986 char *strptr;
987
988 propname = zpool_prop_to_name(ZPOOL_PROP_BOOTSIZE);
989 if (nvlist_lookup_string(props, propname, &strptr) == 0) {
990 (void) fprintf(stderr, gettext("error: setting boot "
991 "partition size requires option '-B'\n"));
992 goto errout;
993 }
994 }
995
996 /* pass off to get_vdev_spec for bulk processing */
997 nvroot = make_root_vdev(NULL, force, !force, B_FALSE, dryrun,
998 boot_type, boot_size, argc - 1, argv + 1);
999 if (nvroot == NULL)
1000 goto errout;
1001
1002 /* make_root_vdev() allows 0 toplevel children if there are spares */
1003 if (!zfs_allocatable_devs(nvroot)) {
1004 (void) fprintf(stderr, gettext("invalid vdev "
1005 "specification: at least one toplevel vdev must be "
1006 "specified\n"));
1007 goto errout;
1008 }
1009
1010 if (altroot != NULL && altroot[0] != '/') {
1011 (void) fprintf(stderr, gettext("invalid alternate root '%s': "
1012 "must be an absolute path\n"), altroot);
1013 goto errout;
1014 }
1015
1016 /*
1017 * Check the validity of the mountpoint and direct the user to use the
1018 * '-m' mountpoint option if it looks like its in use.
1019 */
1020 if (mountpoint == NULL ||
1021 (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 &&
1022 strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) {
1023 char buf[MAXPATHLEN];
1024 DIR *dirp;
1025
1026 if (mountpoint && mountpoint[0] != '/') {
1027 (void) fprintf(stderr, gettext("invalid mountpoint "
1028 "'%s': must be an absolute path, 'legacy', or "
1029 "'none'\n"), mountpoint);
1030 goto errout;
1031 }
1032
1033 if (mountpoint == NULL) {
1034 if (altroot != NULL)
1035 (void) snprintf(buf, sizeof (buf), "%s/%s",
1036 altroot, poolname);
1037 else
1038 (void) snprintf(buf, sizeof (buf), "/%s",
1039 poolname);
1040 } else {
1041 if (altroot != NULL)
1042 (void) snprintf(buf, sizeof (buf), "%s%s",
1043 altroot, mountpoint);
1044 else
1045 (void) snprintf(buf, sizeof (buf), "%s",
1046 mountpoint);
1047 }
1048
1049 if ((dirp = opendir(buf)) == NULL && errno != ENOENT) {
1050 (void) fprintf(stderr, gettext("mountpoint '%s' : "
1051 "%s\n"), buf, strerror(errno));
1052 (void) fprintf(stderr, gettext("use '-m' "
1053 "option to provide a different default\n"));
1054 goto errout;
1055 } else if (dirp) {
1056 int count = 0;
1057
1058 while (count < 3 && readdir(dirp) != NULL)
1059 count++;
1060 (void) closedir(dirp);
1061
1062 if (count > 2) {
1063 (void) fprintf(stderr, gettext("mountpoint "
1064 "'%s' exists and is not empty\n"), buf);
1065 (void) fprintf(stderr, gettext("use '-m' "
1066 "option to provide a "
1067 "different default\n"));
1068 goto errout;
1069 }
1070 }
1071 }
1072
1073 /*
1074 * Now that the mountpoint's validity has been checked, ensure that
1075 * the property is set appropriately prior to creating the pool.
1076 */
1077 if (mountpoint != NULL) {
1078 ret = add_prop_list(zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1079 mountpoint, &fsprops, B_FALSE);
1080 if (ret != 0)
1081 goto errout;
1082 }
1083
1084 ret = 1;
1085 if (dryrun) {
1086 /*
1087 * For a dry run invocation, print out a basic message and run
1088 * through all the vdevs in the list and print out in an
1089 * appropriate hierarchy.
1090 */
1091 (void) printf(gettext("would create '%s' with the "
1092 "following layout:\n\n"), poolname);
1093
1094 print_vdev_tree(NULL, poolname, nvroot, 0, B_FALSE);
1095 if (num_logs(nvroot) > 0)
1096 print_vdev_tree(NULL, "logs", nvroot, 0, B_TRUE);
1097
1098 ret = 0;
1099 } else {
1100 /*
1101 * Hand off to libzfs.
1102 */
1103 if (enable_all_pool_feat) {
1104 spa_feature_t i;
1105 for (i = 0; i < SPA_FEATURES; i++) {
1106 char propname[MAXPATHLEN];
1107 zfeature_info_t *feat = &spa_feature_table[i];
1108
1109 (void) snprintf(propname, sizeof (propname),
1110 "feature@%s", feat->fi_uname);
1111
1112 /*
1113 * Skip feature if user specified it manually
1114 * on the command line.
1115 */
1116 if (nvlist_exists(props, propname))
1117 continue;
1118
1119 ret = add_prop_list(propname,
1120 ZFS_FEATURE_ENABLED, &props, B_TRUE);
1121 if (ret != 0)
1122 goto errout;
1123 }
1124 }
1125
1126 ret = 1;
1127 if (zpool_create(g_zfs, poolname,
1128 nvroot, props, fsprops) == 0) {
1129 zfs_handle_t *pool = zfs_open(g_zfs, poolname,
1130 ZFS_TYPE_FILESYSTEM);
1131 if (pool != NULL) {
1132 if (zfs_mount(pool, NULL, 0) == 0)
1133 ret = zfs_shareall(pool);
1134 zfs_close(pool);
1135 }
1136 } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) {
1137 (void) fprintf(stderr, gettext("pool name may have "
1138 "been omitted\n"));
1139 }
1140 }
1141
1142 errout:
1143 nvlist_free(nvroot);
1144 nvlist_free(fsprops);
1145 nvlist_free(props);
1146 return (ret);
1147 badusage:
1148 nvlist_free(fsprops);
1149 nvlist_free(props);
1150 usage(B_FALSE);
1151 return (2);
1152 }
1153
1154 /*
1155 * zpool destroy <pool>
1156 *
1157 * -f Forcefully unmount any datasets
1158 *
1159 * Destroy the given pool. Automatically unmounts any datasets in the pool.
1160 */
1161 int
1162 zpool_do_destroy(int argc, char **argv)
1163 {
1164 boolean_t force = B_FALSE;
1165 int c;
1166 char *pool;
1167 zpool_handle_t *zhp;
1168 int ret;
1169
1170 /* check options */
1171 while ((c = getopt(argc, argv, "f")) != -1) {
1172 switch (c) {
1173 case 'f':
1174 force = B_TRUE;
1175 break;
1176 case '?':
1177 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1178 optopt);
1179 usage(B_FALSE);
1180 }
1181 }
1182
1183 argc -= optind;
1184 argv += optind;
1185
1186 /* check arguments */
1187 if (argc < 1) {
1188 (void) fprintf(stderr, gettext("missing pool argument\n"));
1189 usage(B_FALSE);
1190 }
1191 if (argc > 1) {
1192 (void) fprintf(stderr, gettext("too many arguments\n"));
1193 usage(B_FALSE);
1194 }
1195
1196 pool = argv[0];
1197
1198 if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) {
1199 /*
1200 * As a special case, check for use of '/' in the name, and
1201 * direct the user to use 'zfs destroy' instead.
1202 */
1203 if (strchr(pool, '/') != NULL)
1204 (void) fprintf(stderr, gettext("use 'zfs destroy' to "
1205 "destroy a dataset\n"));
1206 return (1);
1207 }
1208
1209 if (zpool_disable_datasets(zhp, force) != 0) {
1210 (void) fprintf(stderr, gettext("could not destroy '%s': "
1211 "could not unmount datasets\n"), zpool_get_name(zhp));
1212 return (1);
1213 }
1214
1215 /* The history must be logged as part of the export */
1216 log_history = B_FALSE;
1217
1218 ret = (zpool_destroy(zhp, history_str) != 0);
1219
1220 zpool_close(zhp);
1221
1222 return (ret);
1223 }
1224
1225 /*
1226 * zpool export [-f] <pool> ...
1227 *
1228 * -f Forcefully unmount datasets
1229 *
1230 * Export the given pools. By default, the command will attempt to cleanly
1231 * unmount any active datasets within the pool. If the '-f' flag is specified,
1232 * then the datasets will be forcefully unmounted.
1233 */
1234 int
1235 zpool_do_export(int argc, char **argv)
1236 {
1237 boolean_t force = B_FALSE;
1238 boolean_t hardforce = B_FALSE;
1239 int c;
1240 zpool_handle_t *zhp;
1241 int ret;
1242 int i;
1243
1244 /* check options */
1245 while ((c = getopt(argc, argv, "fF")) != -1) {
1246 switch (c) {
1247 case 'f':
1248 force = B_TRUE;
1249 break;
1250 case 'F':
1251 hardforce = B_TRUE;
1252 break;
1253 case '?':
1254 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1255 optopt);
1256 usage(B_FALSE);
1257 }
1258 }
1259
1260 argc -= optind;
1261 argv += optind;
1262
1263 /* check arguments */
1264 if (argc < 1) {
1265 (void) fprintf(stderr, gettext("missing pool argument\n"));
1266 usage(B_FALSE);
1267 }
1268
1269 ret = 0;
1270 for (i = 0; i < argc; i++) {
1271 if ((zhp = zpool_open_canfail(g_zfs, argv[i])) == NULL) {
1272 ret = 1;
1273 continue;
1274 }
1275
1276 if (zpool_disable_datasets(zhp, force) != 0) {
1277 ret = 1;
1278 zpool_close(zhp);
1279 continue;
1280 }
1281
1282 /* The history must be logged as part of the export */
1283 log_history = B_FALSE;
1284
1285 if (hardforce) {
1286 if (zpool_export_force(zhp, history_str) != 0)
1287 ret = 1;
1288 } else if (zpool_export(zhp, force, history_str) != 0) {
1289 ret = 1;
1290 }
1291
1292 zpool_close(zhp);
1293 }
1294
1295 return (ret);
1296 }
1297
1298 /*
1299 * Given a vdev configuration, determine the maximum width needed for the device
1300 * name column.
1301 */
1302 static int
1303 max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max)
1304 {
1305 char *name = zpool_vdev_name(g_zfs, zhp, nv, B_TRUE);
1306 nvlist_t **child;
1307 uint_t c, children;
1308 int ret;
1309
1310 if (strlen(name) + depth > max)
1311 max = strlen(name) + depth;
1312
1313 free(name);
1314
1315 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
1316 &child, &children) == 0) {
1317 for (c = 0; c < children; c++)
1318 if ((ret = max_width(zhp, child[c], depth + 2,
1319 max)) > max)
1320 max = ret;
1321 }
1322
1323 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
1324 &child, &children) == 0) {
1325 for (c = 0; c < children; c++)
1326 if ((ret = max_width(zhp, child[c], depth + 2,
1327 max)) > max)
1328 max = ret;
1329 }
1330
1331 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1332 &child, &children) == 0) {
1333 for (c = 0; c < children; c++)
1334 if ((ret = max_width(zhp, child[c], depth + 2,
1335 max)) > max)
1336 max = ret;
1337 }
1338
1339
1340 return (max);
1341 }
1342
1343 typedef struct spare_cbdata {
1344 uint64_t cb_guid;
1345 zpool_handle_t *cb_zhp;
1346 } spare_cbdata_t;
1347
1348 static boolean_t
1349 find_vdev(nvlist_t *nv, uint64_t search)
1350 {
1351 uint64_t guid;
1352 nvlist_t **child;
1353 uint_t c, children;
1354
1355 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 &&
1356 search == guid)
1357 return (B_TRUE);
1358
1359 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1360 &child, &children) == 0) {
1361 for (c = 0; c < children; c++)
1362 if (find_vdev(child[c], search))
1363 return (B_TRUE);
1364 }
1365
1366 return (B_FALSE);
1367 }
1368
1369 static int
1370 find_spare(zpool_handle_t *zhp, void *data)
1371 {
1372 spare_cbdata_t *cbp = data;
1373 nvlist_t *config, *nvroot;
1374
1375 config = zpool_get_config(zhp, NULL);
1376 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
1377 &nvroot) == 0);
1378
1379 if (find_vdev(nvroot, cbp->cb_guid)) {
1380 cbp->cb_zhp = zhp;
1381 return (1);
1382 }
1383
1384 zpool_close(zhp);
1385 return (0);
1386 }
1387
1388 /*
1389 * Print out configuration state as requested by status_callback.
1390 */
1391 void
1392 print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv,
1393 int namewidth, int depth, boolean_t isspare)
1394 {
1395 nvlist_t **child;
1396 uint_t c, children;
1397 pool_scan_stat_t *ps = NULL;
1398 vdev_stat_t *vs;
1399 char rbuf[6], wbuf[6], cbuf[6];
1400 char *vname;
1401 uint64_t notpresent;
1402 spare_cbdata_t cb;
1403 const char *state;
1404
1405 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1406 &child, &children) != 0)
1407 children = 0;
1408
1409 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
1410 (uint64_t **)&vs, &c) == 0);
1411
1412 state = zpool_state_to_name(vs->vs_state, vs->vs_aux);
1413 if (isspare) {
1414 /*
1415 * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for
1416 * online drives.
1417 */
1418 if (vs->vs_aux == VDEV_AUX_SPARED)
1419 state = "INUSE";
1420 else if (vs->vs_state == VDEV_STATE_HEALTHY)
1421 state = "AVAIL";
1422 }
1423
1424 (void) printf("\t%*s%-*s %-8s", depth, "", namewidth - depth,
1425 name, state);
1426
1427 if (!isspare) {
1428 zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf));
1429 zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf));
1430 zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf));
1431 (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf);
1432 }
1433
1434 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
1435 &notpresent) == 0) {
1436 char *path;
1437 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0);
1438 (void) printf(" was %s", path);
1439 } else if (vs->vs_aux != 0) {
1440 (void) printf(" ");
1441
1442 switch (vs->vs_aux) {
1443 case VDEV_AUX_OPEN_FAILED:
1444 (void) printf(gettext("cannot open"));
1445 break;
1446
1447 case VDEV_AUX_BAD_GUID_SUM:
1448 (void) printf(gettext("missing device"));
1449 break;
1450
1451 case VDEV_AUX_NO_REPLICAS:
1452 (void) printf(gettext("insufficient replicas"));
1453 break;
1454
1455 case VDEV_AUX_VERSION_NEWER:
1456 (void) printf(gettext("newer version"));
1457 break;
1458
1459 case VDEV_AUX_UNSUP_FEAT:
1460 (void) printf(gettext("unsupported feature(s)"));
1461 break;
1462
1463 case VDEV_AUX_SPARED:
1464 verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
1465 &cb.cb_guid) == 0);
1466 if (zpool_iter(g_zfs, find_spare, &cb) == 1) {
1467 if (strcmp(zpool_get_name(cb.cb_zhp),
1468 zpool_get_name(zhp)) == 0)
1469 (void) printf(gettext("currently in "
1470 "use"));
1471 else
1472 (void) printf(gettext("in use by "
1473 "pool '%s'"),
1474 zpool_get_name(cb.cb_zhp));
1475 zpool_close(cb.cb_zhp);
1476 } else {
1477 (void) printf(gettext("currently in use"));
1478 }
1479 break;
1480
1481 case VDEV_AUX_ERR_EXCEEDED:
1482 (void) printf(gettext("too many errors"));
1483 break;
1484
1485 case VDEV_AUX_IO_FAILURE:
1486 (void) printf(gettext("experienced I/O failures"));
1487 break;
1488
1489 case VDEV_AUX_BAD_LOG:
1490 (void) printf(gettext("bad intent log"));
1491 break;
1492
1493 case VDEV_AUX_EXTERNAL:
1494 (void) printf(gettext("external device fault"));
1495 break;
1496
1497 case VDEV_AUX_SPLIT_POOL:
1498 (void) printf(gettext("split into new pool"));
1499 break;
1500
1501 default:
1502 (void) printf(gettext("corrupted data"));
1503 break;
1504 }
1505 }
1506
1507 (void) nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_SCAN_STATS,
1508 (uint64_t **)&ps, &c);
1509
1510 if (ps && ps->pss_state == DSS_SCANNING &&
1511 vs->vs_scan_processed != 0 && children == 0) {
1512 (void) printf(gettext(" (%s)"),
1513 (ps->pss_func == POOL_SCAN_RESILVER) ?
1514 "resilvering" : "repairing");
1515 }
1516
1517 (void) printf("\n");
1518
1519 for (c = 0; c < children; c++) {
1520 uint64_t islog = B_FALSE, ishole = B_FALSE;
1521
1522 /* Don't print logs or holes here */
1523 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
1524 &islog);
1525 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
1526 &ishole);
1527 if (islog || ishole)
1528 continue;
1529 vname = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE);
1530 print_status_config(zhp, vname, child[c],
1531 namewidth, depth + 2, isspare);
1532 free(vname);
1533 }
1534 }
1535
1536
1537 /*
1538 * Print the configuration of an exported pool. Iterate over all vdevs in the
1539 * pool, printing out the name and status for each one.
1540 */
1541 void
1542 print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth)
1543 {
1544 nvlist_t **child;
1545 uint_t c, children;
1546 vdev_stat_t *vs;
1547 char *type, *vname;
1548
1549 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
1550 if (strcmp(type, VDEV_TYPE_MISSING) == 0 ||
1551 strcmp(type, VDEV_TYPE_HOLE) == 0)
1552 return;
1553
1554 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
1555 (uint64_t **)&vs, &c) == 0);
1556
1557 (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name);
1558 (void) printf(" %s", zpool_state_to_name(vs->vs_state, vs->vs_aux));
1559
1560 if (vs->vs_aux != 0) {
1561 (void) printf(" ");
1562
1563 switch (vs->vs_aux) {
1564 case VDEV_AUX_OPEN_FAILED:
1565 (void) printf(gettext("cannot open"));
1566 break;
1567
1568 case VDEV_AUX_BAD_GUID_SUM:
1569 (void) printf(gettext("missing device"));
1570 break;
1571
1572 case VDEV_AUX_NO_REPLICAS:
1573 (void) printf(gettext("insufficient replicas"));
1574 break;
1575
1576 case VDEV_AUX_VERSION_NEWER:
1577 (void) printf(gettext("newer version"));
1578 break;
1579
1580 case VDEV_AUX_UNSUP_FEAT:
1581 (void) printf(gettext("unsupported feature(s)"));
1582 break;
1583
1584 case VDEV_AUX_ERR_EXCEEDED:
1585 (void) printf(gettext("too many errors"));
1586 break;
1587
1588 default:
1589 (void) printf(gettext("corrupted data"));
1590 break;
1591 }
1592 }
1593 (void) printf("\n");
1594
1595 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1596 &child, &children) != 0)
1597 return;
1598
1599 for (c = 0; c < children; c++) {
1600 uint64_t is_log = B_FALSE;
1601
1602 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
1603 &is_log);
1604 if (is_log)
1605 continue;
1606
1607 vname = zpool_vdev_name(g_zfs, NULL, child[c], B_TRUE);
1608 print_import_config(vname, child[c], namewidth, depth + 2);
1609 free(vname);
1610 }
1611
1612 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
1613 &child, &children) == 0) {
1614 (void) printf(gettext("\tcache\n"));
1615 for (c = 0; c < children; c++) {
1616 vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE);
1617 (void) printf("\t %s\n", vname);
1618 free(vname);
1619 }
1620 }
1621
1622 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
1623 &child, &children) == 0) {
1624 (void) printf(gettext("\tspares\n"));
1625 for (c = 0; c < children; c++) {
1626 vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE);
1627 (void) printf("\t %s\n", vname);
1628 free(vname);
1629 }
1630 }
1631 }
1632
1633 /*
1634 * Print log vdevs.
1635 * Logs are recorded as top level vdevs in the main pool child array
1636 * but with "is_log" set to 1. We use either print_status_config() or
1637 * print_import_config() to print the top level logs then any log
1638 * children (eg mirrored slogs) are printed recursively - which
1639 * works because only the top level vdev is marked "is_log"
1640 */
1641 static void
1642 print_logs(zpool_handle_t *zhp, nvlist_t *nv, int namewidth, boolean_t verbose)
1643 {
1644 uint_t c, children;
1645 nvlist_t **child;
1646
1647 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child,
1648 &children) != 0)
1649 return;
1650
1651 (void) printf(gettext("\tlogs\n"));
1652
1653 for (c = 0; c < children; c++) {
1654 uint64_t is_log = B_FALSE;
1655 char *name;
1656
1657 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
1658 &is_log);
1659 if (!is_log)
1660 continue;
1661 name = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE);
1662 if (verbose)
1663 print_status_config(zhp, name, child[c], namewidth,
1664 2, B_FALSE);
1665 else
1666 print_import_config(name, child[c], namewidth, 2);
1667 free(name);
1668 }
1669 }
1670
1671 /*
1672 * Display the status for the given pool.
1673 */
1674 static void
1675 show_import(nvlist_t *config)
1676 {
1677 uint64_t pool_state;
1678 vdev_stat_t *vs;
1679 char *name;
1680 uint64_t guid;
1681 char *msgid;
1682 nvlist_t *nvroot;
1683 int reason;
1684 const char *health;
1685 uint_t vsc;
1686 int namewidth;
1687 char *comment;
1688
1689 verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
1690 &name) == 0);
1691 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
1692 &guid) == 0);
1693 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
1694 &pool_state) == 0);
1695 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
1696 &nvroot) == 0);
1697
1698 verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
1699 (uint64_t **)&vs, &vsc) == 0);
1700 health = zpool_state_to_name(vs->vs_state, vs->vs_aux);
1701
1702 reason = zpool_import_status(config, &msgid);
1703
1704 (void) printf(gettext(" pool: %s\n"), name);
1705 (void) printf(gettext(" id: %llu\n"), (u_longlong_t)guid);
1706 (void) printf(gettext(" state: %s"), health);
1707 if (pool_state == POOL_STATE_DESTROYED)
1708 (void) printf(gettext(" (DESTROYED)"));
1709 (void) printf("\n");
1710
1711 switch (reason) {
1712 case ZPOOL_STATUS_MISSING_DEV_R:
1713 case ZPOOL_STATUS_MISSING_DEV_NR:
1714 case ZPOOL_STATUS_BAD_GUID_SUM:
1715 (void) printf(gettext(" status: One or more devices are "
1716 "missing from the system.\n"));
1717 break;
1718
1719 case ZPOOL_STATUS_CORRUPT_LABEL_R:
1720 case ZPOOL_STATUS_CORRUPT_LABEL_NR:
1721 (void) printf(gettext(" status: One or more devices contains "
1722 "corrupted data.\n"));
1723 break;
1724
1725 case ZPOOL_STATUS_CORRUPT_DATA:
1726 (void) printf(
1727 gettext(" status: The pool data is corrupted.\n"));
1728 break;
1729
1730 case ZPOOL_STATUS_OFFLINE_DEV:
1731 (void) printf(gettext(" status: One or more devices "
1732 "are offlined.\n"));
1733 break;
1734
1735 case ZPOOL_STATUS_CORRUPT_POOL:
1736 (void) printf(gettext(" status: The pool metadata is "
1737 "corrupted.\n"));
1738 break;
1739
1740 case ZPOOL_STATUS_VERSION_OLDER:
1741 (void) printf(gettext(" status: The pool is formatted using a "
1742 "legacy on-disk version.\n"));
1743 break;
1744
1745 case ZPOOL_STATUS_VERSION_NEWER:
1746 (void) printf(gettext(" status: The pool is formatted using an "
1747 "incompatible version.\n"));
1748 break;
1749
1750 case ZPOOL_STATUS_FEAT_DISABLED:
1751 (void) printf(gettext(" status: Some supported features are "
1752 "not enabled on the pool.\n"));
1753 break;
1754
1755 case ZPOOL_STATUS_UNSUP_FEAT_READ:
1756 (void) printf(gettext("status: The pool uses the following "
1757 "feature(s) not supported on this sytem:\n"));
1758 zpool_print_unsup_feat(config);
1759 break;
1760
1761 case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
1762 (void) printf(gettext("status: The pool can only be accessed "
1763 "in read-only mode on this system. It\n\tcannot be "
1764 "accessed in read-write mode because it uses the "
1765 "following\n\tfeature(s) not supported on this system:\n"));
1766 zpool_print_unsup_feat(config);
1767 break;
1768
1769 case ZPOOL_STATUS_HOSTID_MISMATCH:
1770 (void) printf(gettext(" status: The pool was last accessed by "
1771 "another system.\n"));
1772 break;
1773
1774 case ZPOOL_STATUS_FAULTED_DEV_R:
1775 case ZPOOL_STATUS_FAULTED_DEV_NR:
1776 (void) printf(gettext(" status: One or more devices are "
1777 "faulted.\n"));
1778 break;
1779
1780 case ZPOOL_STATUS_BAD_LOG:
1781 (void) printf(gettext(" status: An intent log record cannot be "
1782 "read.\n"));
1783 break;
1784
1785 case ZPOOL_STATUS_RESILVERING:
1786 (void) printf(gettext(" status: One or more devices were being "
1787 "resilvered.\n"));
1788 break;
1789
1790 default:
1791 /*
1792 * No other status can be seen when importing pools.
1793 */
1794 assert(reason == ZPOOL_STATUS_OK);
1795 }
1796
1797 /*
1798 * Print out an action according to the overall state of the pool.
1799 */
1800 if (vs->vs_state == VDEV_STATE_HEALTHY) {
1801 if (reason == ZPOOL_STATUS_VERSION_OLDER ||
1802 reason == ZPOOL_STATUS_FEAT_DISABLED) {
1803 (void) printf(gettext(" action: The pool can be "
1804 "imported using its name or numeric identifier, "
1805 "though\n\tsome features will not be available "
1806 "without an explicit 'zpool upgrade'.\n"));
1807 } else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) {
1808 (void) printf(gettext(" action: The pool can be "
1809 "imported using its name or numeric "
1810 "identifier and\n\tthe '-f' flag.\n"));
1811 } else {
1812 (void) printf(gettext(" action: The pool can be "
1813 "imported using its name or numeric "
1814 "identifier.\n"));
1815 }
1816 } else if (vs->vs_state == VDEV_STATE_DEGRADED) {
1817 (void) printf(gettext(" action: The pool can be imported "
1818 "despite missing or damaged devices. The\n\tfault "
1819 "tolerance of the pool may be compromised if imported.\n"));
1820 } else {
1821 switch (reason) {
1822 case ZPOOL_STATUS_VERSION_NEWER:
1823 (void) printf(gettext(" action: The pool cannot be "
1824 "imported. Access the pool on a system running "
1825 "newer\n\tsoftware, or recreate the pool from "
1826 "backup.\n"));
1827 break;
1828 case ZPOOL_STATUS_UNSUP_FEAT_READ:
1829 (void) printf(gettext("action: The pool cannot be "
1830 "imported. Access the pool on a system that "
1831 "supports\n\tthe required feature(s), or recreate "
1832 "the pool from backup.\n"));
1833 break;
1834 case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
1835 (void) printf(gettext("action: The pool cannot be "
1836 "imported in read-write mode. Import the pool "
1837 "with\n"
1838 "\t\"-o readonly=on\", access the pool on a system "
1839 "that supports the\n\trequired feature(s), or "
1840 "recreate the pool from backup.\n"));
1841 break;
1842 case ZPOOL_STATUS_MISSING_DEV_R:
1843 case ZPOOL_STATUS_MISSING_DEV_NR:
1844 case ZPOOL_STATUS_BAD_GUID_SUM:
1845 (void) printf(gettext(" action: The pool cannot be "
1846 "imported. Attach the missing\n\tdevices and try "
1847 "again.\n"));
1848 break;
1849 default:
1850 (void) printf(gettext(" action: The pool cannot be "
1851 "imported due to damaged devices or data.\n"));
1852 }
1853 }
1854
1855 /* Print the comment attached to the pool. */
1856 if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0)
1857 (void) printf(gettext("comment: %s\n"), comment);
1858
1859 /*
1860 * If the state is "closed" or "can't open", and the aux state
1861 * is "corrupt data":
1862 */
1863 if (((vs->vs_state == VDEV_STATE_CLOSED) ||
1864 (vs->vs_state == VDEV_STATE_CANT_OPEN)) &&
1865 (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) {
1866 if (pool_state == POOL_STATE_DESTROYED)
1867 (void) printf(gettext("\tThe pool was destroyed, "
1868 "but can be imported using the '-Df' flags.\n"));
1869 else if (pool_state != POOL_STATE_EXPORTED)
1870 (void) printf(gettext("\tThe pool may be active on "
1871 "another system, but can be imported using\n\t"
1872 "the '-f' flag.\n"));
1873 }
1874
1875 if (msgid != NULL)
1876 (void) printf(gettext(" see: http://illumos.org/msg/%s\n"),
1877 msgid);
1878
1879 (void) printf(gettext(" config:\n\n"));
1880
1881 namewidth = max_width(NULL, nvroot, 0, 0);
1882 if (namewidth < 10)
1883 namewidth = 10;
1884
1885 print_import_config(name, nvroot, namewidth, 0);
1886 if (num_logs(nvroot) > 0)
1887 print_logs(NULL, nvroot, namewidth, B_FALSE);
1888
1889 if (reason == ZPOOL_STATUS_BAD_GUID_SUM) {
1890 (void) printf(gettext("\n\tAdditional devices are known to "
1891 "be part of this pool, though their\n\texact "
1892 "configuration cannot be determined.\n"));
1893 }
1894 }
1895
1896 /*
1897 * Perform the import for the given configuration. This passes the heavy
1898 * lifting off to zpool_import_props(), and then mounts the datasets contained
1899 * within the pool.
1900 */
1901 static int
1902 do_import(nvlist_t *config, const char *newname, const char *mntopts,
1903 nvlist_t *props, int flags)
1904 {
1905 zpool_handle_t *zhp;
1906 char *name;
1907 uint64_t state;
1908 uint64_t version;
1909
1910 verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
1911 &name) == 0);
1912
1913 verify(nvlist_lookup_uint64(config,
1914 ZPOOL_CONFIG_POOL_STATE, &state) == 0);
1915 verify(nvlist_lookup_uint64(config,
1916 ZPOOL_CONFIG_VERSION, &version) == 0);
1917 if (!SPA_VERSION_IS_SUPPORTED(version)) {
1918 (void) fprintf(stderr, gettext("cannot import '%s': pool "
1919 "is formatted using an unsupported ZFS version\n"), name);
1920 return (1);
1921 } else if (state != POOL_STATE_EXPORTED &&
1922 !(flags & ZFS_IMPORT_ANY_HOST)) {
1923 uint64_t hostid;
1924
1925 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID,
1926 &hostid) == 0) {
1927 if ((unsigned long)hostid != gethostid()) {
1928 char *hostname;
1929 uint64_t timestamp;
1930 time_t t;
1931
1932 verify(nvlist_lookup_string(config,
1933 ZPOOL_CONFIG_HOSTNAME, &hostname) == 0);
1934 verify(nvlist_lookup_uint64(config,
1935 ZPOOL_CONFIG_TIMESTAMP, &timestamp) == 0);
1936 t = timestamp;
1937 (void) fprintf(stderr, gettext("cannot import "
1938 "'%s': pool may be in use from other "
1939 "system, it was last accessed by %s "
1940 "(hostid: 0x%lx) on %s"), name, hostname,
1941 (unsigned long)hostid,
1942 asctime(localtime(&t)));
1943 (void) fprintf(stderr, gettext("use '-f' to "
1944 "import anyway\n"));
1945 return (1);
1946 }
1947 } else {
1948 (void) fprintf(stderr, gettext("cannot import '%s': "
1949 "pool may be in use from other system\n"), name);
1950 (void) fprintf(stderr, gettext("use '-f' to import "
1951 "anyway\n"));
1952 return (1);
1953 }
1954 }
1955
1956 if (zpool_import_props(g_zfs, config, newname, props, flags) != 0)
1957 return (1);
1958
1959 if (newname != NULL)
1960 name = (char *)newname;
1961
1962 if ((zhp = zpool_open_canfail(g_zfs, name)) == NULL)
1963 return (1);
1964
1965 if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL &&
1966 !(flags & ZFS_IMPORT_ONLY) &&
1967 zpool_enable_datasets(zhp, mntopts, 0) != 0) {
1968 zpool_close(zhp);
1969 return (1);
1970 }
1971
1972 zpool_close(zhp);
1973 return (0);
1974 }
1975
1976 /*
1977 * zpool import [-d dir] [-D]
1978 * import [-o mntopts] [-o prop=value] ... [-R root] [-D]
1979 * [-d dir | -c cachefile] [-f] -a
1980 * import [-o mntopts] [-o prop=value] ... [-R root] [-D]
1981 * [-d dir | -c cachefile] [-f] [-n] [-F] <pool | id> [newpool]
1982 *
1983 * -c Read pool information from a cachefile instead of searching
1984 * devices.
1985 *
1986 * -d Scan in a specific directory, other than /dev/dsk. More than
1987 * one directory can be specified using multiple '-d' options.
1988 *
1989 * -D Scan for previously destroyed pools or import all or only
1990 * specified destroyed pools.
1991 *
1992 * -R Temporarily import the pool, with all mountpoints relative to
1993 * the given root. The pool will remain exported when the machine
1994 * is rebooted.
1995 *
1996 * -V Import even in the presence of faulted vdevs. This is an
1997 * intentionally undocumented option for testing purposes, and
1998 * treats the pool configuration as complete, leaving any bad
1999 * vdevs in the FAULTED state. In other words, it does verbatim
2000 * import.
2001 *
2002 * -f Force import, even if it appears that the pool is active.
2003 *
2004 * -F Attempt rewind if necessary.
2005 *
2006 * -n See if rewind would work, but don't actually rewind.
2007 *
2008 * -N Import the pool but don't mount datasets.
2009 *
2010 * -T Specify a starting txg to use for import. This option is
2011 * intentionally undocumented option for testing purposes.
2012 *
2013 * -a Import all pools found.
2014 *
2015 * -o Set property=value and/or temporary mount options (without '=').
2016 *
2017 * The import command scans for pools to import, and import pools based on pool
2018 * name and GUID. The pool can also be renamed as part of the import process.
2019 */
2020 int
2021 zpool_do_import(int argc, char **argv)
2022 {
2023 char **searchdirs = NULL;
2024 int nsearch = 0;
2025 int c;
2026 int err = 0;
2027 nvlist_t *pools = NULL;
2028 boolean_t do_all = B_FALSE;
2029 boolean_t do_destroyed = B_FALSE;
2030 char *mntopts = NULL;
2031 nvpair_t *elem;
2032 nvlist_t *config;
2033 uint64_t searchguid = 0;
2034 char *searchname = NULL;
2035 char *propval;
2036 nvlist_t *found_config;
2037 nvlist_t *policy = NULL;
2038 nvlist_t *props = NULL;
2039 boolean_t first;
2040 int flags = ZFS_IMPORT_NORMAL;
2041 uint32_t rewind_policy = ZPOOL_NO_REWIND;
2042 boolean_t dryrun = B_FALSE;
2043 boolean_t do_rewind = B_FALSE;
2044 boolean_t xtreme_rewind = B_FALSE;
2045 uint64_t pool_state, txg = -1ULL;
2046 char *cachefile = NULL;
2047 importargs_t idata = { 0 };
2048 char *endptr;
2049
2050 /* check options */
2051 while ((c = getopt(argc, argv, ":aCc:d:DEfFmnNo:rR:T:VX")) != -1) {
2052 switch (c) {
2053 case 'a':
2054 do_all = B_TRUE;
2055 break;
2056 case 'c':
2057 cachefile = optarg;
2058 break;
2059 case 'd':
2060 if (searchdirs == NULL) {
2061 searchdirs = safe_malloc(sizeof (char *));
2062 } else {
2063 char **tmp = safe_malloc((nsearch + 1) *
2064 sizeof (char *));
2065 bcopy(searchdirs, tmp, nsearch *
2066 sizeof (char *));
2067 free(searchdirs);
2068 searchdirs = tmp;
2069 }
2070 searchdirs[nsearch++] = optarg;
2071 break;
2072 case 'D':
2073 do_destroyed = B_TRUE;
2074 break;
2075 case 'f':
2076 flags |= ZFS_IMPORT_ANY_HOST;
2077 break;
2078 case 'F':
2079 do_rewind = B_TRUE;
2080 break;
2081 case 'm':
2082 flags |= ZFS_IMPORT_MISSING_LOG;
2083 break;
2084 case 'n':
2085 dryrun = B_TRUE;
2086 break;
2087 case 'N':
2088 flags |= ZFS_IMPORT_ONLY;
2089 break;
2090 case 'o':
2091 if ((propval = strchr(optarg, '=')) != NULL) {
2092 *propval = '\0';
2093 propval++;
2094 if (add_prop_list(optarg, propval,
2095 &props, B_TRUE))
2096 goto error;
2097 } else {
2098 mntopts = optarg;
2099 }
2100 break;
2101 case 'R':
2102 if (add_prop_list(zpool_prop_to_name(
2103 ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE))
2104 goto error;
2105 if (nvlist_lookup_string(props,
2106 zpool_prop_to_name(ZPOOL_PROP_CACHEFILE),
2107 &propval) == 0)
2108 break;
2109 if (add_prop_list(zpool_prop_to_name(
2110 ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
2111 goto error;
2112 break;
2113 case 'T':
2114 errno = 0;
2115 txg = strtoull(optarg, &endptr, 0);
2116 if (errno != 0 || *endptr != '\0') {
2117 (void) fprintf(stderr,
2118 gettext("invalid txg value\n"));
2119 usage(B_FALSE);
2120 }
2121 rewind_policy = ZPOOL_DO_REWIND | ZPOOL_EXTREME_REWIND;
2122 break;
2123 case 'V':
2124 flags |= ZFS_IMPORT_VERBATIM;
2125 break;
2126 case 'X':
2127 xtreme_rewind = B_TRUE;
2128 break;
2129 case ':':
2130 (void) fprintf(stderr, gettext("missing argument for "
2131 "'%c' option\n"), optopt);
2132 usage(B_FALSE);
2133 break;
2134 case '?':
2135 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2136 optopt);
2137 usage(B_FALSE);
2138 }
2139 }
2140
2141 argc -= optind;
2142 argv += optind;
2143
2144 if (cachefile && nsearch != 0) {
2145 (void) fprintf(stderr, gettext("-c is incompatible with -d\n"));
2146 usage(B_FALSE);
2147 }
2148
2149 if ((dryrun || xtreme_rewind) && !do_rewind) {
2150 (void) fprintf(stderr,
2151 gettext("-n or -X only meaningful with -F\n"));
2152 usage(B_FALSE);
2153 }
2154 if (dryrun)
2155 rewind_policy = ZPOOL_TRY_REWIND;
2156 else if (do_rewind)
2157 rewind_policy = ZPOOL_DO_REWIND;
2158 if (xtreme_rewind)
2159 rewind_policy |= ZPOOL_EXTREME_REWIND;
2160
2161 /* In the future, we can capture further policy and include it here */
2162 if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 ||
2163 nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, txg) != 0 ||
2164 nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0)
2165 goto error;
2166
2167 if (searchdirs == NULL) {
2168 searchdirs = safe_malloc(sizeof (char *));
2169 searchdirs[0] = ZFS_DISK_ROOT;
2170 nsearch = 1;
2171 }
2172
2173 /* check argument count */
2174 if (do_all) {
2175 if (argc != 0) {
2176 (void) fprintf(stderr, gettext("too many arguments\n"));
2177 usage(B_FALSE);
2178 }
2179 } else {
2180 if (argc > 2) {
2181 (void) fprintf(stderr, gettext("too many arguments\n"));
2182 usage(B_FALSE);
2183 }
2184
2185 /*
2186 * Check for the SYS_CONFIG privilege. We do this explicitly
2187 * here because otherwise any attempt to discover pools will
2188 * silently fail.
2189 */
2190 if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) {
2191 (void) fprintf(stderr, gettext("cannot "
2192 "discover pools: permission denied\n"));
2193 free(searchdirs);
2194 nvlist_free(policy);
2195 return (1);
2196 }
2197 }
2198
2199 /*
2200 * Depending on the arguments given, we do one of the following:
2201 *
2202 * <none> Iterate through all pools and display information about
2203 * each one.
2204 *
2205 * -a Iterate through all pools and try to import each one.
2206 *
2207 * <id> Find the pool that corresponds to the given GUID/pool
2208 * name and import that one.
2209 *
2210 * -D Above options applies only to destroyed pools.
2211 */
2212 if (argc != 0) {
2213 char *endptr;
2214
2215 errno = 0;
2216 searchguid = strtoull(argv[0], &endptr, 10);
2217 if (errno != 0 || *endptr != '\0') {
2218 searchname = argv[0];
2219 searchguid = 0;
2220 }
2221 found_config = NULL;
2222
2223 /*
2224 * User specified a name or guid. Ensure it's unique.
2225 */
2226 idata.unique = B_TRUE;
2227 }
2228
2229
2230 idata.path = searchdirs;
2231 idata.paths = nsearch;
2232 idata.poolname = searchname;
2233 idata.guid = searchguid;
2234 idata.cachefile = cachefile;
2235
2236 pools = zpool_search_import(g_zfs, &idata);
2237
2238 if (pools != NULL && idata.exists &&
2239 (argc == 1 || strcmp(argv[0], argv[1]) == 0)) {
2240 (void) fprintf(stderr, gettext("cannot import '%s': "
2241 "a pool with that name already exists\n"),
2242 argv[0]);
2243 (void) fprintf(stderr, gettext("use the form '%s "
2244 "<pool | id> <newpool>' to give it a new name\n"),
2245 "zpool import");
2246 err = 1;
2247 } else if (pools == NULL && idata.exists) {
2248 (void) fprintf(stderr, gettext("cannot import '%s': "
2249 "a pool with that name is already created/imported,\n"),
2250 argv[0]);
2251 (void) fprintf(stderr, gettext("and no additional pools "
2252 "with that name were found\n"));
2253 err = 1;
2254 } else if (pools == NULL) {
2255 if (argc != 0) {
2256 (void) fprintf(stderr, gettext("cannot import '%s': "
2257 "no such pool available\n"), argv[0]);
2258 }
2259 err = 1;
2260 }
2261
2262 if (err == 1) {
2263 free(searchdirs);
2264 nvlist_free(policy);
2265 return (1);
2266 }
2267
2268 /*
2269 * At this point we have a list of import candidate configs. Even if
2270 * we were searching by pool name or guid, we still need to
2271 * post-process the list to deal with pool state and possible
2272 * duplicate names.
2273 */
2274 err = 0;
2275 elem = NULL;
2276 first = B_TRUE;
2277 while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
2278
2279 verify(nvpair_value_nvlist(elem, &config) == 0);
2280
2281 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
2282 &pool_state) == 0);
2283 if (!do_destroyed && pool_state == POOL_STATE_DESTROYED)
2284 continue;
2285 if (do_destroyed && pool_state != POOL_STATE_DESTROYED)
2286 continue;
2287
2288 verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY,
2289 policy) == 0);
2290
2291 if (argc == 0) {
2292 if (first)
2293 first = B_FALSE;
2294 else if (!do_all)
2295 (void) printf("\n");
2296
2297 if (do_all) {
2298 err |= do_import(config, NULL, mntopts,
2299 props, flags);
2300 } else {
2301 show_import(config);
2302 }
2303 } else if (searchname != NULL) {
2304 char *name;
2305
2306 /*
2307 * We are searching for a pool based on name.
2308 */
2309 verify(nvlist_lookup_string(config,
2310 ZPOOL_CONFIG_POOL_NAME, &name) == 0);
2311
2312 if (strcmp(name, searchname) == 0) {
2313 if (found_config != NULL) {
2314 (void) fprintf(stderr, gettext(
2315 "cannot import '%s': more than "
2316 "one matching pool\n"), searchname);
2317 (void) fprintf(stderr, gettext(
2318 "import by numeric ID instead\n"));
2319 err = B_TRUE;
2320 }
2321 found_config = config;
2322 }
2323 } else {
2324 uint64_t guid;
2325
2326 /*
2327 * Search for a pool by guid.
2328 */
2329 verify(nvlist_lookup_uint64(config,
2330 ZPOOL_CONFIG_POOL_GUID, &guid) == 0);
2331
2332 if (guid == searchguid)
2333 found_config = config;
2334 }
2335 }
2336
2337 /*
2338 * If we were searching for a specific pool, verify that we found a
2339 * pool, and then do the import.
2340 */
2341 if (argc != 0 && err == 0) {
2342 if (found_config == NULL) {
2343 (void) fprintf(stderr, gettext("cannot import '%s': "
2344 "no such pool available\n"), argv[0]);
2345 err = B_TRUE;
2346 } else {
2347 err |= do_import(found_config, argc == 1 ? NULL :
2348 argv[1], mntopts, props, flags);
2349 }
2350 }
2351
2352 /*
2353 * If we were just looking for pools, report an error if none were
2354 * found.
2355 */
2356 if (argc == 0 && first)
2357 (void) fprintf(stderr,
2358 gettext("no pools available to import\n"));
2359
2360 error:
2361 nvlist_free(props);
2362 nvlist_free(pools);
2363 nvlist_free(policy);
2364 free(searchdirs);
2365
2366 return (err ? 1 : 0);
2367 }
2368
2369 typedef struct iostat_cbdata {
2370 boolean_t cb_verbose;
2371 int cb_namewidth;
2372 int cb_iteration;
2373 zpool_list_t *cb_list;
2374 } iostat_cbdata_t;
2375
2376 static void
2377 print_iostat_separator(iostat_cbdata_t *cb)
2378 {
2379 int i = 0;
2380
2381 for (i = 0; i < cb->cb_namewidth; i++)
2382 (void) printf("-");
2383 (void) printf(" ----- ----- ----- ----- ----- -----\n");
2384 }
2385
2386 static void
2387 print_iostat_header(iostat_cbdata_t *cb)
2388 {
2389 (void) printf("%*s capacity operations bandwidth\n",
2390 cb->cb_namewidth, "");
2391 (void) printf("%-*s alloc free read write read write\n",
2392 cb->cb_namewidth, "pool");
2393 print_iostat_separator(cb);
2394 }
2395
2396 /*
2397 * Display a single statistic.
2398 */
2399 static void
2400 print_one_stat(uint64_t value)
2401 {
2402 char buf[64];
2403
2404 zfs_nicenum(value, buf, sizeof (buf));
2405 (void) printf(" %5s", buf);
2406 }
2407
2408 /*
2409 * Print out all the statistics for the given vdev. This can either be the
2410 * toplevel configuration, or called recursively. If 'name' is NULL, then this
2411 * is a verbose output, and we don't want to display the toplevel pool stats.
2412 */
2413 void
2414 print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv,
2415 nvlist_t *newnv, iostat_cbdata_t *cb, int depth)
2416 {
2417 nvlist_t **oldchild, **newchild;
2418 uint_t c, children;
2419 vdev_stat_t *oldvs, *newvs;
2420 vdev_stat_t zerovs = { 0 };
2421 uint64_t tdelta;
2422 double scale;
2423 char *vname;
2424
2425 if (oldnv != NULL) {
2426 verify(nvlist_lookup_uint64_array(oldnv,
2427 ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&oldvs, &c) == 0);
2428 } else {
2429 oldvs = &zerovs;
2430 }
2431
2432 verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_VDEV_STATS,
2433 (uint64_t **)&newvs, &c) == 0);
2434
2435 if (strlen(name) + depth > cb->cb_namewidth)
2436 (void) printf("%*s%s", depth, "", name);
2437 else
2438 (void) printf("%*s%s%*s", depth, "", name,
2439 (int)(cb->cb_namewidth - strlen(name) - depth), "");
2440
2441 tdelta = newvs->vs_timestamp - oldvs->vs_timestamp;
2442
2443 if (tdelta == 0)
2444 scale = 1.0;
2445 else
2446 scale = (double)NANOSEC / tdelta;
2447
2448 /* only toplevel vdevs have capacity stats */
2449 if (newvs->vs_space == 0) {
2450 (void) printf(" - -");
2451 } else {
2452 print_one_stat(newvs->vs_alloc);
2453 print_one_stat(newvs->vs_space - newvs->vs_alloc);
2454 }
2455
2456 print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] -
2457 oldvs->vs_ops[ZIO_TYPE_READ])));
2458
2459 print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] -
2460 oldvs->vs_ops[ZIO_TYPE_WRITE])));
2461
2462 print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] -
2463 oldvs->vs_bytes[ZIO_TYPE_READ])));
2464
2465 print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] -
2466 oldvs->vs_bytes[ZIO_TYPE_WRITE])));
2467
2468 (void) printf("\n");
2469
2470 if (!cb->cb_verbose)
2471 return;
2472
2473 if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN,
2474 &newchild, &children) != 0)
2475 return;
2476
2477 if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN,
2478 &oldchild, &c) != 0)
2479 return;
2480
2481 for (c = 0; c < children; c++) {
2482 uint64_t ishole = B_FALSE, islog = B_FALSE;
2483
2484 (void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_HOLE,
2485 &ishole);
2486
2487 (void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_LOG,
2488 &islog);
2489
2490 if (ishole || islog)
2491 continue;
2492
2493 vname = zpool_vdev_name(g_zfs, zhp, newchild[c], B_FALSE);
2494 print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL,
2495 newchild[c], cb, depth + 2);
2496 free(vname);
2497 }
2498
2499 /*
2500 * Log device section
2501 */
2502
2503 if (num_logs(newnv) > 0) {
2504 (void) printf("%-*s - - - - - "
2505 "-\n", cb->cb_namewidth, "logs");
2506
2507 for (c = 0; c < children; c++) {
2508 uint64_t islog = B_FALSE;
2509 (void) nvlist_lookup_uint64(newchild[c],
2510 ZPOOL_CONFIG_IS_LOG, &islog);
2511
2512 if (islog) {
2513 vname = zpool_vdev_name(g_zfs, zhp, newchild[c],
2514 B_FALSE);
2515 print_vdev_stats(zhp, vname, oldnv ?
2516 oldchild[c] : NULL, newchild[c],
2517 cb, depth + 2);
2518 free(vname);
2519 }
2520 }
2521
2522 }
2523
2524 /*
2525 * Include level 2 ARC devices in iostat output
2526 */
2527 if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE,
2528 &newchild, &children) != 0)
2529 return;
2530
2531 if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE,
2532 &oldchild, &c) != 0)
2533 return;
2534
2535 if (children > 0) {
2536 (void) printf("%-*s - - - - - "
2537 "-\n", cb->cb_namewidth, "cache");
2538 for (c = 0; c < children; c++) {
2539 vname = zpool_vdev_name(g_zfs, zhp, newchild[c],
2540 B_FALSE);
2541 print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL,
2542 newchild[c], cb, depth + 2);
2543 free(vname);
2544 }
2545 }
2546 }
2547
2548 static int
2549 refresh_iostat(zpool_handle_t *zhp, void *data)
2550 {
2551 iostat_cbdata_t *cb = data;
2552 boolean_t missing;
2553
2554 /*
2555 * If the pool has disappeared, remove it from the list and continue.
2556 */
2557 if (zpool_refresh_stats(zhp, &missing) != 0)
2558 return (-1);
2559
2560 if (missing)
2561 pool_list_remove(cb->cb_list, zhp);
2562
2563 return (0);
2564 }
2565
2566 /*
2567 * Callback to print out the iostats for the given pool.
2568 */
2569 int
2570 print_iostat(zpool_handle_t *zhp, void *data)
2571 {
2572 iostat_cbdata_t *cb = data;
2573 nvlist_t *oldconfig, *newconfig;
2574 nvlist_t *oldnvroot, *newnvroot;
2575
2576 newconfig = zpool_get_config(zhp, &oldconfig);
2577
2578 if (cb->cb_iteration == 1)
2579 oldconfig = NULL;
2580
2581 verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE,
2582 &newnvroot) == 0);
2583
2584 if (oldconfig == NULL)
2585 oldnvroot = NULL;
2586 else
2587 verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE,
2588 &oldnvroot) == 0);
2589
2590 /*
2591 * Print out the statistics for the pool.
2592 */
2593 print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0);
2594
2595 if (cb->cb_verbose)
2596 print_iostat_separator(cb);
2597
2598 return (0);
2599 }
2600
2601 int
2602 get_namewidth(zpool_handle_t *zhp, void *data)
2603 {
2604 iostat_cbdata_t *cb = data;
2605 nvlist_t *config, *nvroot;
2606
2607 if ((config = zpool_get_config(zhp, NULL)) != NULL) {
2608 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
2609 &nvroot) == 0);
2610 if (!cb->cb_verbose)
2611 cb->cb_namewidth = strlen(zpool_get_name(zhp));
2612 else
2613 cb->cb_namewidth = max_width(zhp, nvroot, 0,
2614 cb->cb_namewidth);
2615 }
2616
2617 /*
2618 * The width must fall into the range [10,38]. The upper limit is the
2619 * maximum we can have and still fit in 80 columns.
2620 */
2621 if (cb->cb_namewidth < 10)
2622 cb->cb_namewidth = 10;
2623 if (cb->cb_namewidth > 38)
2624 cb->cb_namewidth = 38;
2625
2626 return (0);
2627 }
2628
2629 /*
2630 * Parse the input string, get the 'interval' and 'count' value if there is one.
2631 */
2632 static void
2633 get_interval_count(int *argcp, char **argv, unsigned long *iv,
2634 unsigned long *cnt)
2635 {
2636 unsigned long interval = 0, count = 0;
2637 int argc = *argcp, errno;
2638
2639 /*
2640 * Determine if the last argument is an integer or a pool name
2641 */
2642 if (argc > 0 && isdigit(argv[argc - 1][0])) {
2643 char *end;
2644
2645 errno = 0;
2646 interval = strtoul(argv[argc - 1], &end, 10);
2647
2648 if (*end == '\0' && errno == 0) {
2649 if (interval == 0) {
2650 (void) fprintf(stderr, gettext("interval "
2651 "cannot be zero\n"));
2652 usage(B_FALSE);
2653 }
2654 /*
2655 * Ignore the last parameter
2656 */
2657 argc--;
2658 } else {
2659 /*
2660 * If this is not a valid number, just plow on. The
2661 * user will get a more informative error message later
2662 * on.
2663 */
2664 interval = 0;
2665 }
2666 }
2667
2668 /*
2669 * If the last argument is also an integer, then we have both a count
2670 * and an interval.
2671 */
2672 if (argc > 0 && isdigit(argv[argc - 1][0])) {
2673 char *end;
2674
2675 errno = 0;
2676 count = interval;
2677 interval = strtoul(argv[argc - 1], &end, 10);
2678
2679 if (*end == '\0' && errno == 0) {
2680 if (interval == 0) {
2681 (void) fprintf(stderr, gettext("interval "
2682 "cannot be zero\n"));
2683 usage(B_FALSE);
2684 }
2685
2686 /*
2687 * Ignore the last parameter
2688 */
2689 argc--;
2690 } else {
2691 interval = 0;
2692 }
2693 }
2694
2695 *iv = interval;
2696 *cnt = count;
2697 *argcp = argc;
2698 }
2699
2700 static void
2701 get_timestamp_arg(char c)
2702 {
2703 if (c == 'u')
2704 timestamp_fmt = UDATE;
2705 else if (c == 'd')
2706 timestamp_fmt = DDATE;
2707 else
2708 usage(B_FALSE);
2709 }
2710
2711 /*
2712 * zpool iostat [-v] [-T d|u] [pool] ... [interval [count]]
2713 *
2714 * -v Display statistics for individual vdevs
2715 * -T Display a timestamp in date(1) or Unix format
2716 *
2717 * This command can be tricky because we want to be able to deal with pool
2718 * creation/destruction as well as vdev configuration changes. The bulk of this
2719 * processing is handled by the pool_list_* routines in zpool_iter.c. We rely
2720 * on pool_list_update() to detect the addition of new pools. Configuration
2721 * changes are all handled within libzfs.
2722 */
2723 int
2724 zpool_do_iostat(int argc, char **argv)
2725 {
2726 int c;
2727 int ret;
2728 int npools;
2729 unsigned long interval = 0, count = 0;
2730 zpool_list_t *list;
2731 boolean_t verbose = B_FALSE;
2732 iostat_cbdata_t cb;
2733
2734 /* check options */
2735 while ((c = getopt(argc, argv, "T:v")) != -1) {
2736 switch (c) {
2737 case 'T':
2738 get_timestamp_arg(*optarg);
2739 break;
2740 case 'v':
2741 verbose = B_TRUE;
2742 break;
2743 case '?':
2744 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2745 optopt);
2746 usage(B_FALSE);
2747 }
2748 }
2749
2750 argc -= optind;
2751 argv += optind;
2752
2753 get_interval_count(&argc, argv, &interval, &count);
2754
2755 /*
2756 * Construct the list of all interesting pools.
2757 */
2758 ret = 0;
2759 if ((list = pool_list_get(argc, argv, NULL, &ret)) == NULL)
2760 return (1);
2761
2762 if (pool_list_count(list) == 0 && argc != 0) {
2763 pool_list_free(list);
2764 return (1);
2765 }
2766
2767 if (pool_list_count(list) == 0 && interval == 0) {
2768 pool_list_free(list);
2769 (void) fprintf(stderr, gettext("no pools available\n"));
2770 return (1);
2771 }
2772
2773 /*
2774 * Enter the main iostat loop.
2775 */
2776 cb.cb_list = list;
2777 cb.cb_verbose = verbose;
2778 cb.cb_iteration = 0;
2779 cb.cb_namewidth = 0;
2780
2781 for (;;) {
2782 pool_list_update(list);
2783
2784 if ((npools = pool_list_count(list)) == 0)
2785 break;
2786
2787 /*
2788 * Refresh all statistics. This is done as an explicit step
2789 * before calculating the maximum name width, so that any
2790 * configuration changes are properly accounted for.
2791 */
2792 (void) pool_list_iter(list, B_FALSE, refresh_iostat, &cb);
2793
2794 /*
2795 * Iterate over all pools to determine the maximum width
2796 * for the pool / device name column across all pools.
2797 */
2798 cb.cb_namewidth = 0;
2799 (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb);
2800
2801 if (timestamp_fmt != NODATE)
2802 print_timestamp(timestamp_fmt);
2803
2804 /*
2805 * If it's the first time, or verbose mode, print the header.
2806 */
2807 if (++cb.cb_iteration == 1 || verbose)
2808 print_iostat_header(&cb);
2809
2810 (void) pool_list_iter(list, B_FALSE, print_iostat, &cb);
2811
2812 /*
2813 * If there's more than one pool, and we're not in verbose mode
2814 * (which prints a separator for us), then print a separator.
2815 */
2816 if (npools > 1 && !verbose)
2817 print_iostat_separator(&cb);
2818
2819 if (verbose)
2820 (void) printf("\n");
2821
2822 /*
2823 * Flush the output so that redirection to a file isn't buffered
2824 * indefinitely.
2825 */
2826 (void) fflush(stdout);
2827
2828 if (interval == 0)
2829 break;
2830
2831 if (count != 0 && --count == 0)
2832 break;
2833
2834 (void) sleep(interval);
2835 }
2836
2837 pool_list_free(list);
2838
2839 return (ret);
2840 }
2841
2842 typedef struct list_cbdata {
2843 boolean_t cb_verbose;
2844 int cb_namewidth;
2845 boolean_t cb_scripted;
2846 zprop_list_t *cb_proplist;
2847 boolean_t cb_literal;
2848 } list_cbdata_t;
2849
2850 /*
2851 * Given a list of columns to display, output appropriate headers for each one.
2852 */
2853 static void
2854 print_header(list_cbdata_t *cb)
2855 {
2856 zprop_list_t *pl = cb->cb_proplist;
2857 char headerbuf[ZPOOL_MAXPROPLEN];
2858 const char *header;
2859 boolean_t first = B_TRUE;
2860 boolean_t right_justify;
2861 size_t width = 0;
2862
2863 for (; pl != NULL; pl = pl->pl_next) {
2864 width = pl->pl_width;
2865 if (first && cb->cb_verbose) {
2866 /*
2867 * Reset the width to accommodate the verbose listing
2868 * of devices.
2869 */
2870 width = cb->cb_namewidth;
2871 }
2872
2873 if (!first)
2874 (void) printf(" ");
2875 else
2876 first = B_FALSE;
2877
2878 right_justify = B_FALSE;
2879 if (pl->pl_prop != ZPROP_INVAL) {
2880 header = zpool_prop_column_name(pl->pl_prop);
2881 right_justify = zpool_prop_align_right(pl->pl_prop);
2882 } else {
2883 int i;
2884
2885 for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
2886 headerbuf[i] = toupper(pl->pl_user_prop[i]);
2887 headerbuf[i] = '\0';
2888 header = headerbuf;
2889 }
2890
2891 if (pl->pl_next == NULL && !right_justify)
2892 (void) printf("%s", header);
2893 else if (right_justify)
2894 (void) printf("%*s", width, header);
2895 else
2896 (void) printf("%-*s", width, header);
2897
2898 }
2899
2900 (void) printf("\n");
2901 }
2902
2903 /*
2904 * Given a pool and a list of properties, print out all the properties according
2905 * to the described layout.
2906 */
2907 static void
2908 print_pool(zpool_handle_t *zhp, list_cbdata_t *cb)
2909 {
2910 zprop_list_t *pl = cb->cb_proplist;
2911 boolean_t first = B_TRUE;
2912 char property[ZPOOL_MAXPROPLEN];
2913 char *propstr;
2914 boolean_t right_justify;
2915 size_t width;
2916
2917 for (; pl != NULL; pl = pl->pl_next) {
2918
2919 width = pl->pl_width;
2920 if (first && cb->cb_verbose) {
2921 /*
2922 * Reset the width to accommodate the verbose listing
2923 * of devices.
2924 */
2925 width = cb->cb_namewidth;
2926 }
2927
2928 if (!first) {
2929 if (cb->cb_scripted)
2930 (void) printf("\t");
2931 else
2932 (void) printf(" ");
2933 } else {
2934 first = B_FALSE;
2935 }
2936
2937 right_justify = B_FALSE;
2938 if (pl->pl_prop != ZPROP_INVAL) {
2939 if (zpool_get_prop(zhp, pl->pl_prop, property,
2940 sizeof (property), NULL, cb->cb_literal) != 0)
2941 propstr = "-";
2942 else
2943 propstr = property;
2944
2945 right_justify = zpool_prop_align_right(pl->pl_prop);
2946 } else if ((zpool_prop_feature(pl->pl_user_prop) ||
2947 zpool_prop_unsupported(pl->pl_user_prop)) &&
2948 zpool_prop_get_feature(zhp, pl->pl_user_prop, property,
2949 sizeof (property)) == 0) {
2950 propstr = property;
2951 } else {
2952 propstr = "-";
2953 }
2954
2955
2956 /*
2957 * If this is being called in scripted mode, or if this is the
2958 * last column and it is left-justified, don't include a width
2959 * format specifier.
2960 */
2961 if (cb->cb_scripted || (pl->pl_next == NULL && !right_justify))
2962 (void) printf("%s", propstr);
2963 else if (right_justify)
2964 (void) printf("%*s", width, propstr);
2965 else
2966 (void) printf("%-*s", width, propstr);
2967 }
2968
2969 (void) printf("\n");
2970 }
2971
2972 static void
2973 print_one_column(zpool_prop_t prop, uint64_t value, boolean_t scripted,
2974 boolean_t valid)
2975 {
2976 char propval[64];
2977 boolean_t fixed;
2978 size_t width = zprop_width(prop, &fixed, ZFS_TYPE_POOL);
2979
2980 switch (prop) {
2981 case ZPOOL_PROP_EXPANDSZ:
2982 if (value == 0)
2983 (void) strlcpy(propval, "-", sizeof (propval));
2984 else
2985 zfs_nicenum(value, propval, sizeof (propval));
2986 break;
2987 case ZPOOL_PROP_FRAGMENTATION:
2988 if (value == ZFS_FRAG_INVALID) {
2989 (void) strlcpy(propval, "-", sizeof (propval));
2990 } else {
2991 (void) snprintf(propval, sizeof (propval), "%llu%%",
2992 value);
2993 }
2994 break;
2995 case ZPOOL_PROP_CAPACITY:
2996 (void) snprintf(propval, sizeof (propval), "%llu%%", value);
2997 break;
2998 default:
2999 zfs_nicenum(value, propval, sizeof (propval));
3000 }
3001
3002 if (!valid)
3003 (void) strlcpy(propval, "-", sizeof (propval));
3004
3005 if (scripted)
3006 (void) printf("\t%s", propval);
3007 else
3008 (void) printf(" %*s", width, propval);
3009 }
3010
3011 void
3012 print_list_stats(zpool_handle_t *zhp, const char *name, nvlist_t *nv,
3013 list_cbdata_t *cb, int depth)
3014 {
3015 nvlist_t **child;
3016 vdev_stat_t *vs;
3017 uint_t c, children;
3018 char *vname;
3019 boolean_t scripted = cb->cb_scripted;
3020 uint64_t islog = B_FALSE;
3021 boolean_t haslog = B_FALSE;
3022 char *dashes = "%-*s - - - - - -\n";
3023
3024 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
3025 (uint64_t **)&vs, &c) == 0);
3026
3027 if (name != NULL) {
3028 boolean_t toplevel = (vs->vs_space != 0);
3029 uint64_t cap;
3030
3031 if (scripted)
3032 (void) printf("\t%s", name);
3033 else if (strlen(name) + depth > cb->cb_namewidth)
3034 (void) printf("%*s%s", depth, "", name);
3035 else
3036 (void) printf("%*s%s%*s", depth, "", name,
3037 (int)(cb->cb_namewidth - strlen(name) - depth), "");
3038
3039 /*
3040 * Print the properties for the individual vdevs. Some
3041 * properties are only applicable to toplevel vdevs. The
3042 * 'toplevel' boolean value is passed to the print_one_column()
3043 * to indicate that the value is valid.
3044 */
3045 print_one_column(ZPOOL_PROP_SIZE, vs->vs_space, scripted,
3046 toplevel);
3047 print_one_column(ZPOOL_PROP_ALLOCATED, vs->vs_alloc, scripted,
3048 toplevel);
3049 print_one_column(ZPOOL_PROP_FREE, vs->vs_space - vs->vs_alloc,
3050 scripted, toplevel);
3051 print_one_column(ZPOOL_PROP_EXPANDSZ, vs->vs_esize, scripted,
3052 B_TRUE);
3053 print_one_column(ZPOOL_PROP_FRAGMENTATION,
3054 vs->vs_fragmentation, scripted,
3055 (vs->vs_fragmentation != ZFS_FRAG_INVALID && toplevel));
3056 cap = (vs->vs_space == 0) ? 0 :
3057 (vs->vs_alloc * 100 / vs->vs_space);
3058 print_one_column(ZPOOL_PROP_CAPACITY, cap, scripted, toplevel);
3059 (void) printf("\n");
3060 }
3061
3062 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
3063 &child, &children) != 0)
3064 return;
3065
3066 for (c = 0; c < children; c++) {
3067 uint64_t ishole = B_FALSE;
3068
3069 if (nvlist_lookup_uint64(child[c],
3070 ZPOOL_CONFIG_IS_HOLE, &ishole) == 0 && ishole)
3071 continue;
3072
3073 if (nvlist_lookup_uint64(child[c],
3074 ZPOOL_CONFIG_IS_LOG, &islog) == 0 && islog) {
3075 haslog = B_TRUE;
3076 continue;
3077 }
3078
3079 vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE);
3080 print_list_stats(zhp, vname, child[c], cb, depth + 2);
3081 free(vname);
3082 }
3083
3084 if (haslog == B_TRUE) {
3085 /* LINTED E_SEC_PRINTF_VAR_FMT */
3086 (void) printf(dashes, cb->cb_namewidth, "log");
3087 for (c = 0; c < children; c++) {
3088 if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
3089 &islog) != 0 || !islog)
3090 continue;
3091 vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE);
3092 print_list_stats(zhp, vname, child[c], cb, depth + 2);
3093 free(vname);
3094 }
3095 }
3096
3097 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
3098 &child, &children) == 0 && children > 0) {
3099 /* LINTED E_SEC_PRINTF_VAR_FMT */
3100 (void) printf(dashes, cb->cb_namewidth, "cache");
3101 for (c = 0; c < children; c++) {
3102 vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE);
3103 print_list_stats(zhp, vname, child[c], cb, depth + 2);
3104 free(vname);
3105 }
3106 }
3107
3108 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, &child,
3109 &children) == 0 && children > 0) {
3110 /* LINTED E_SEC_PRINTF_VAR_FMT */
3111 (void) printf(dashes, cb->cb_namewidth, "spare");
3112 for (c = 0; c < children; c++) {
3113 vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE);
3114 print_list_stats(zhp, vname, child[c], cb, depth + 2);
3115 free(vname);
3116 }
3117 }
3118 }
3119
3120
3121 /*
3122 * Generic callback function to list a pool.
3123 */
3124 int
3125 list_callback(zpool_handle_t *zhp, void *data)
3126 {
3127 list_cbdata_t *cbp = data;
3128 nvlist_t *config;
3129 nvlist_t *nvroot;
3130
3131 config = zpool_get_config(zhp, NULL);
3132
3133 print_pool(zhp, cbp);
3134 if (!cbp->cb_verbose)
3135 return (0);
3136
3137 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
3138 &nvroot) == 0);
3139 print_list_stats(zhp, NULL, nvroot, cbp, 0);
3140
3141 return (0);
3142 }
3143
3144 /*
3145 * zpool list [-Hp] [-o prop[,prop]*] [-T d|u] [pool] ... [interval [count]]
3146 *
3147 * -H Scripted mode. Don't display headers, and separate properties
3148 * by a single tab.
3149 * -o List of properties to display. Defaults to
3150 * "name,size,allocated,free,expandsize,fragmentation,capacity,"
3151 * "dedupratio,health,altroot"
3152 * -p Diplay values in parsable (exact) format.
3153 * -T Display a timestamp in date(1) or Unix format
3154 *
3155 * List all pools in the system, whether or not they're healthy. Output space
3156 * statistics for each one, as well as health status summary.
3157 */
3158 int
3159 zpool_do_list(int argc, char **argv)
3160 {
3161 int c;
3162 int ret;
3163 list_cbdata_t cb = { 0 };
3164 static char default_props[] =
3165 "name,size,allocated,free,expandsize,fragmentation,capacity,"
3166 "dedupratio,health,altroot";
3167 char *props = default_props;
3168 unsigned long interval = 0, count = 0;
3169 zpool_list_t *list;
3170 boolean_t first = B_TRUE;
3171
3172 /* check options */
3173 while ((c = getopt(argc, argv, ":Ho:pT:v")) != -1) {
3174 switch (c) {
3175 case 'H':
3176 cb.cb_scripted = B_TRUE;
3177 break;
3178 case 'o':
3179 props = optarg;
3180 break;
3181 case 'p':
3182 cb.cb_literal = B_TRUE;
3183 break;
3184 case 'T':
3185 get_timestamp_arg(*optarg);
3186 break;
3187 case 'v':
3188 cb.cb_verbose = B_TRUE;
3189 break;
3190 case ':':
3191 (void) fprintf(stderr, gettext("missing argument for "
3192 "'%c' option\n"), optopt);
3193 usage(B_FALSE);
3194 break;
3195 case '?':
3196 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3197 optopt);
3198 usage(B_FALSE);
3199 }
3200 }
3201
3202 argc -= optind;
3203 argv += optind;
3204
3205 get_interval_count(&argc, argv, &interval, &count);
3206
3207 if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0)
3208 usage(B_FALSE);
3209
3210 for (;;) {
3211 if ((list = pool_list_get(argc, argv, &cb.cb_proplist,
3212 &ret)) == NULL)
3213 return (1);
3214
3215 if (pool_list_count(list) == 0)
3216 break;
3217
3218 cb.cb_namewidth = 0;
3219 (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb);
3220
3221 if (timestamp_fmt != NODATE)
3222 print_timestamp(timestamp_fmt);
3223
3224 if (!cb.cb_scripted && (first || cb.cb_verbose)) {
3225 print_header(&cb);
3226 first = B_FALSE;
3227 }
3228 ret = pool_list_iter(list, B_TRUE, list_callback, &cb);
3229
3230 if (interval == 0)
3231 break;
3232
3233 if (count != 0 && --count == 0)
3234 break;
3235
3236 pool_list_free(list);
3237 (void) sleep(interval);
3238 }
3239
3240 if (argc == 0 && !cb.cb_scripted && pool_list_count(list) == 0) {
3241 (void) printf(gettext("no pools available\n"));
3242 ret = 0;
3243 }
3244
3245 pool_list_free(list);
3246 zprop_free_list(cb.cb_proplist);
3247 return (ret);
3248 }
3249
3250 static int
3251 zpool_do_attach_or_replace(int argc, char **argv, int replacing)
3252 {
3253 boolean_t force = B_FALSE;
3254 int c;
3255 nvlist_t *nvroot;
3256 char *poolname, *old_disk, *new_disk;
3257 zpool_handle_t *zhp;
3258 zpool_boot_label_t boot_type;
3259 uint64_t boot_size;
3260 int ret;
3261
3262 /* check options */
3263 while ((c = getopt(argc, argv, "f")) != -1) {
3264 switch (c) {
3265 case 'f':
3266 force = B_TRUE;
3267 break;
3268 case '?':
3269 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3270 optopt);
3271 usage(B_FALSE);
3272 }
3273 }
3274
3275 argc -= optind;
3276 argv += optind;
3277
3278 /* get pool name and check number of arguments */
3279 if (argc < 1) {
3280 (void) fprintf(stderr, gettext("missing pool name argument\n"));
3281 usage(B_FALSE);
3282 }
3283
3284 poolname = argv[0];
3285
3286 if (argc < 2) {
3287 (void) fprintf(stderr,
3288 gettext("missing <device> specification\n"));
3289 usage(B_FALSE);
3290 }
3291
3292 old_disk = argv[1];
3293
3294 if (argc < 3) {
3295 if (!replacing) {
3296 (void) fprintf(stderr,
3297 gettext("missing <new_device> specification\n"));
3298 usage(B_FALSE);
3299 }
3300 new_disk = old_disk;
3301 argc -= 1;
3302 argv += 1;
3303 } else {
3304 new_disk = argv[2];
3305 argc -= 2;
3306 argv += 2;
3307 }
3308
3309 if (argc > 1) {
3310 (void) fprintf(stderr, gettext("too many arguments\n"));
3311 usage(B_FALSE);
3312 }
3313
3314 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
3315 return (1);
3316
3317 if (zpool_get_config(zhp, NULL) == NULL) {
3318 (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),
3319 poolname);
3320 zpool_close(zhp);
3321 return (1);
3322 }
3323
3324 if (zpool_is_bootable(zhp))
3325 boot_type = ZPOOL_COPY_BOOT_LABEL;
3326 else
3327 boot_type = ZPOOL_NO_BOOT_LABEL;
3328
3329 boot_size = zpool_get_prop_int(zhp, ZPOOL_PROP_BOOTSIZE, NULL);
3330 nvroot = make_root_vdev(zhp, force, B_FALSE, replacing, B_FALSE,
3331 boot_type, boot_size, argc, argv);
3332 if (nvroot == NULL) {
3333 zpool_close(zhp);
3334 return (1);
3335 }
3336
3337 ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing);
3338
3339 nvlist_free(nvroot);
3340 zpool_close(zhp);
3341
3342 return (ret);
3343 }
3344
3345 /*
3346 * zpool replace [-f] <pool> <device> <new_device>
3347 *
3348 * -f Force attach, even if <new_device> appears to be in use.
3349 *
3350 * Replace <device> with <new_device>.
3351 */
3352 /* ARGSUSED */
3353 int
3354 zpool_do_replace(int argc, char **argv)
3355 {
3356 return (zpool_do_attach_or_replace(argc, argv, B_TRUE));
3357 }
3358
3359 /*
3360 * zpool attach [-f] <pool> <device> <new_device>
3361 *
3362 * -f Force attach, even if <new_device> appears to be in use.
3363 *
3364 * Attach <new_device> to the mirror containing <device>. If <device> is not
3365 * part of a mirror, then <device> will be transformed into a mirror of
3366 * <device> and <new_device>. In either case, <new_device> will begin life
3367 * with a DTL of [0, now], and will immediately begin to resilver itself.
3368 */
3369 int
3370 zpool_do_attach(int argc, char **argv)
3371 {
3372 return (zpool_do_attach_or_replace(argc, argv, B_FALSE));
3373 }
3374
3375 /*
3376 * zpool detach [-f] <pool> <device>
3377 *
3378 * -f Force detach of <device>, even if DTLs argue against it
3379 * (not supported yet)
3380 *
3381 * Detach a device from a mirror. The operation will be refused if <device>
3382 * is the last device in the mirror, or if the DTLs indicate that this device
3383 * has the only valid copy of some data.
3384 */
3385 /* ARGSUSED */
3386 int
3387 zpool_do_detach(int argc, char **argv)
3388 {
3389 int c;
3390 char *poolname, *path;
3391 zpool_handle_t *zhp;
3392 int ret;
3393
3394 /* check options */
3395 while ((c = getopt(argc, argv, "f")) != -1) {
3396 switch (c) {
3397 case 'f':
3398 case '?':
3399 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3400 optopt);
3401 usage(B_FALSE);
3402 }
3403 }
3404
3405 argc -= optind;
3406 argv += optind;
3407
3408 /* get pool name and check number of arguments */
3409 if (argc < 1) {
3410 (void) fprintf(stderr, gettext("missing pool name argument\n"));
3411 usage(B_FALSE);
3412 }
3413
3414 if (argc < 2) {
3415 (void) fprintf(stderr,
3416 gettext("missing <device> specification\n"));
3417 usage(B_FALSE);
3418 }
3419
3420 poolname = argv[0];
3421 path = argv[1];
3422
3423 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
3424 return (1);
3425
3426 ret = zpool_vdev_detach(zhp, path);
3427
3428 zpool_close(zhp);
3429
3430 return (ret);
3431 }
3432
3433 /*
3434 * zpool split [-n] [-o prop=val] ...
3435 * [-o mntopt] ...
3436 * [-R altroot] <pool> <newpool> [<device> ...]
3437 *
3438 * -n Do not split the pool, but display the resulting layout if
3439 * it were to be split.
3440 * -o Set property=value, or set mount options.
3441 * -R Mount the split-off pool under an alternate root.
3442 *
3443 * Splits the named pool and gives it the new pool name. Devices to be split
3444 * off may be listed, provided that no more than one device is specified
3445 * per top-level vdev mirror. The newly split pool is left in an exported
3446 * state unless -R is specified.
3447 *
3448 * Restrictions: the top-level of the pool pool must only be made up of
3449 * mirrors; all devices in the pool must be healthy; no device may be
3450 * undergoing a resilvering operation.
3451 */
3452 int
3453 zpool_do_split(int argc, char **argv)
3454 {
3455 char *srcpool, *newpool, *propval;
3456 char *mntopts = NULL;
3457 splitflags_t flags;
3458 int c, ret = 0;
3459 zpool_handle_t *zhp;
3460 nvlist_t *config, *props = NULL;
3461
3462 flags.dryrun = B_FALSE;
3463 flags.import = B_FALSE;
3464
3465 /* check options */
3466 while ((c = getopt(argc, argv, ":R:no:")) != -1) {
3467 switch (c) {
3468 case 'R':
3469 flags.import = B_TRUE;
3470 if (add_prop_list(
3471 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), optarg,
3472 &props, B_TRUE) != 0) {
3473 nvlist_free(props);
3474 usage(B_FALSE);
3475 }
3476 break;
3477 case 'n':
3478 flags.dryrun = B_TRUE;
3479 break;
3480 case 'o':
3481 if ((propval = strchr(optarg, '=')) != NULL) {
3482 *propval = '\0';
3483 propval++;
3484 if (add_prop_list(optarg, propval,
3485 &props, B_TRUE) != 0) {
3486 nvlist_free(props);
3487 usage(B_FALSE);
3488 }
3489 } else {
3490 mntopts = optarg;
3491 }
3492 break;
3493 case ':':
3494 (void) fprintf(stderr, gettext("missing argument for "
3495 "'%c' option\n"), optopt);
3496 usage(B_FALSE);
3497 break;
3498 case '?':
3499 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3500 optopt);
3501 usage(B_FALSE);
3502 break;
3503 }
3504 }
3505
3506 if (!flags.import && mntopts != NULL) {
3507 (void) fprintf(stderr, gettext("setting mntopts is only "
3508 "valid when importing the pool\n"));
3509 usage(B_FALSE);
3510 }
3511
3512 argc -= optind;
3513 argv += optind;
3514
3515 if (argc < 1) {
3516 (void) fprintf(stderr, gettext("Missing pool name\n"));
3517 usage(B_FALSE);
3518 }
3519 if (argc < 2) {
3520 (void) fprintf(stderr, gettext("Missing new pool name\n"));
3521 usage(B_FALSE);
3522 }
3523
3524 srcpool = argv[0];
3525 newpool = argv[1];
3526
3527 argc -= 2;
3528 argv += 2;
3529
3530 if ((zhp = zpool_open(g_zfs, srcpool)) == NULL)
3531 return (1);
3532
3533 config = split_mirror_vdev(zhp, newpool, props, flags, argc, argv);
3534 if (config == NULL) {
3535 ret = 1;
3536 } else {
3537 if (flags.dryrun) {
3538 (void) printf(gettext("would create '%s' with the "
3539 "following layout:\n\n"), newpool);
3540 print_vdev_tree(NULL, newpool, config, 0, B_FALSE);
3541 }
3542 nvlist_free(config);
3543 }
3544
3545 zpool_close(zhp);
3546
3547 if (ret != 0 || flags.dryrun || !flags.import)
3548 return (ret);
3549
3550 /*
3551 * The split was successful. Now we need to open the new
3552 * pool and import it.
3553 */
3554 if ((zhp = zpool_open_canfail(g_zfs, newpool)) == NULL)
3555 return (1);
3556 if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL &&
3557 zpool_enable_datasets(zhp, mntopts, 0) != 0) {
3558 ret = 1;
3559 (void) fprintf(stderr, gettext("Split was successful, but "
3560 "the datasets could not all be mounted\n"));
3561 (void) fprintf(stderr, gettext("Try doing '%s' with a "
3562 "different altroot\n"), "zpool import");
3563 }
3564 zpool_close(zhp);
3565
3566 return (ret);
3567 }
3568
3569
3570
3571 /*
3572 * zpool online <pool> <device> ...
3573 */
3574 int
3575 zpool_do_online(int argc, char **argv)
3576 {
3577 int c, i;
3578 char *poolname;
3579 zpool_handle_t *zhp;
3580 int ret = 0;
3581 vdev_state_t newstate;
3582 int flags = 0;
3583
3584 /* check options */
3585 while ((c = getopt(argc, argv, "et")) != -1) {
3586 switch (c) {
3587 case 'e':
3588 flags |= ZFS_ONLINE_EXPAND;
3589 break;
3590 case 't':
3591 case '?':
3592 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3593 optopt);
3594 usage(B_FALSE);
3595 }
3596 }
3597
3598 argc -= optind;
3599 argv += optind;
3600
3601 /* get pool name and check number of arguments */
3602 if (argc < 1) {
3603 (void) fprintf(stderr, gettext("missing pool name\n"));
3604 usage(B_FALSE);
3605 }
3606 if (argc < 2) {
3607 (void) fprintf(stderr, gettext("missing device name\n"));
3608 usage(B_FALSE);
3609 }
3610
3611 poolname = argv[0];
3612
3613 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
3614 return (1);
3615
3616 for (i = 1; i < argc; i++) {
3617 if (zpool_vdev_online(zhp, argv[i], flags, &newstate) == 0) {
3618 if (newstate != VDEV_STATE_HEALTHY) {
3619 (void) printf(gettext("warning: device '%s' "
3620 "onlined, but remains in faulted state\n"),
3621 argv[i]);
3622 if (newstate == VDEV_STATE_FAULTED)
3623 (void) printf(gettext("use 'zpool "
3624 "clear' to restore a faulted "
3625 "device\n"));
3626 else
3627 (void) printf(gettext("use 'zpool "
3628 "replace' to replace devices "
3629 "that are no longer present\n"));
3630 }
3631 } else {
3632 ret = 1;
3633 }
3634 }
3635
3636 zpool_close(zhp);
3637
3638 return (ret);
3639 }
3640
3641 /*
3642 * zpool offline [-ft] <pool> <device> ...
3643 *
3644 * -f Force the device into the offline state, even if doing
3645 * so would appear to compromise pool availability.
3646 * (not supported yet)
3647 *
3648 * -t Only take the device off-line temporarily. The offline
3649 * state will not be persistent across reboots.
3650 */
3651 /* ARGSUSED */
3652 int
3653 zpool_do_offline(int argc, char **argv)
3654 {
3655 int c, i;
3656 char *poolname;
3657 zpool_handle_t *zhp;
3658 int ret = 0;
3659 boolean_t istmp = B_FALSE;
3660
3661 /* check options */
3662 while ((c = getopt(argc, argv, "ft")) != -1) {
3663 switch (c) {
3664 case 't':
3665 istmp = B_TRUE;
3666 break;
3667 case 'f':
3668 case '?':
3669 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3670 optopt);
3671 usage(B_FALSE);
3672 }
3673 }
3674
3675 argc -= optind;
3676 argv += optind;
3677
3678 /* get pool name and check number of arguments */
3679 if (argc < 1) {
3680 (void) fprintf(stderr, gettext("missing pool name\n"));
3681 usage(B_FALSE);
3682 }
3683 if (argc < 2) {
3684 (void) fprintf(stderr, gettext("missing device name\n"));
3685 usage(B_FALSE);
3686 }
3687
3688 poolname = argv[0];
3689
3690 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
3691 return (1);
3692
3693 for (i = 1; i < argc; i++) {
3694 if (zpool_vdev_offline(zhp, argv[i], istmp) != 0)
3695 ret = 1;
3696 }
3697
3698 zpool_close(zhp);
3699
3700 return (ret);
3701 }
3702
3703 /*
3704 * zpool clear <pool> [device]
3705 *
3706 * Clear all errors associated with a pool or a particular device.
3707 */
3708 int
3709 zpool_do_clear(int argc, char **argv)
3710 {
3711 int c;
3712 int ret = 0;
3713 boolean_t dryrun = B_FALSE;
3714 boolean_t do_rewind = B_FALSE;
3715 boolean_t xtreme_rewind = B_FALSE;
3716 uint32_t rewind_policy = ZPOOL_NO_REWIND;
3717 nvlist_t *policy = NULL;
3718 zpool_handle_t *zhp;
3719 char *pool, *device;
3720
3721 /* check options */
3722 while ((c = getopt(argc, argv, "FnX")) != -1) {
3723 switch (c) {
3724 case 'F':
3725 do_rewind = B_TRUE;
3726 break;
3727 case 'n':
3728 dryrun = B_TRUE;
3729 break;
3730 case 'X':
3731 xtreme_rewind = B_TRUE;
3732 break;
3733 case '?':
3734 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3735 optopt);
3736 usage(B_FALSE);
3737 }
3738 }
3739
3740 argc -= optind;
3741 argv += optind;
3742
3743 if (argc < 1) {
3744 (void) fprintf(stderr, gettext("missing pool name\n"));
3745 usage(B_FALSE);
3746 }
3747
3748 if (argc > 2) {
3749 (void) fprintf(stderr, gettext("too many arguments\n"));
3750 usage(B_FALSE);
3751 }
3752
3753 if ((dryrun || xtreme_rewind) && !do_rewind) {
3754 (void) fprintf(stderr,
3755 gettext("-n or -X only meaningful with -F\n"));
3756 usage(B_FALSE);
3757 }
3758 if (dryrun)
3759 rewind_policy = ZPOOL_TRY_REWIND;
3760 else if (do_rewind)
3761 rewind_policy = ZPOOL_DO_REWIND;
3762 if (xtreme_rewind)
3763 rewind_policy |= ZPOOL_EXTREME_REWIND;
3764
3765 /* In future, further rewind policy choices can be passed along here */
3766 if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 ||
3767 nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0)
3768 return (1);
3769
3770 pool = argv[0];
3771 device = argc == 2 ? argv[1] : NULL;
3772
3773 if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) {
3774 nvlist_free(policy);
3775 return (1);
3776 }
3777
3778 if (zpool_clear(zhp, device, policy) != 0)
3779 ret = 1;
3780
3781 zpool_close(zhp);
3782
3783 nvlist_free(policy);
3784
3785 return (ret);
3786 }
3787
3788 /*
3789 * zpool reguid <pool>
3790 */
3791 int
3792 zpool_do_reguid(int argc, char **argv)
3793 {
3794 int c;
3795 char *poolname;
3796 zpool_handle_t *zhp;
3797 int ret = 0;
3798
3799 /* check options */
3800 while ((c = getopt(argc, argv, "")) != -1) {
3801 switch (c) {
3802 case '?':
3803 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3804 optopt);
3805 usage(B_FALSE);
3806 }
3807 }
3808
3809 argc -= optind;
3810 argv += optind;
3811
3812 /* get pool name and check number of arguments */
3813 if (argc < 1) {
3814 (void) fprintf(stderr, gettext("missing pool name\n"));
3815 usage(B_FALSE);
3816 }
3817
3818 if (argc > 1) {
3819 (void) fprintf(stderr, gettext("too many arguments\n"));
3820 usage(B_FALSE);
3821 }
3822
3823 poolname = argv[0];
3824 if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
3825 return (1);
3826
3827 ret = zpool_reguid(zhp);
3828
3829 zpool_close(zhp);
3830 return (ret);
3831 }
3832
3833
3834 /*
3835 * zpool reopen <pool>
3836 *
3837 * Reopen the pool so that the kernel can update the sizes of all vdevs.
3838 */
3839 int
3840 zpool_do_reopen(int argc, char **argv)
3841 {
3842 int c;
3843 int ret = 0;
3844 zpool_handle_t *zhp;
3845 char *pool;
3846
3847 /* check options */
3848 while ((c = getopt(argc, argv, "")) != -1) {
3849 switch (c) {
3850 case '?':
3851 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3852 optopt);
3853 usage(B_FALSE);
3854 }
3855 }
3856
3857 argc--;
3858 argv++;
3859
3860 if (argc < 1) {
3861 (void) fprintf(stderr, gettext("missing pool name\n"));
3862 usage(B_FALSE);
3863 }
3864
3865 if (argc > 1) {
3866 (void) fprintf(stderr, gettext("too many arguments\n"));
3867 usage(B_FALSE);
3868 }
3869
3870 pool = argv[0];
3871 if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL)
3872 return (1);
3873
3874 ret = zpool_reopen(zhp);
3875 zpool_close(zhp);
3876 return (ret);
3877 }
3878
3879 typedef struct scrub_cbdata {
3880 int cb_type;
3881 int cb_argc;
3882 char **cb_argv;
3883 pool_scrub_cmd_t cb_scrub_cmd;
3884 } scrub_cbdata_t;
3885
3886 int
3887 scrub_callback(zpool_handle_t *zhp, void *data)
3888 {
3889 scrub_cbdata_t *cb = data;
3890 int err;
3891
3892 /*
3893 * Ignore faulted pools.
3894 */
3895 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
3896 (void) fprintf(stderr, gettext("cannot scrub '%s': pool is "
3897 "currently unavailable\n"), zpool_get_name(zhp));
3898 return (1);
3899 }
3900
3901 err = zpool_scan(zhp, cb->cb_type, cb->cb_scrub_cmd);
3902
3903 return (err != 0);
3904 }
3905
3906 /*
3907 * zpool scrub [-s | -p] <pool> ...
3908 *
3909 * -s Stop. Stops any in-progress scrub.
3910 * -p Pause. Pause in-progress scrub.
3911 */
3912 int
3913 zpool_do_scrub(int argc, char **argv)
3914 {
3915 int c;
3916 scrub_cbdata_t cb;
3917
3918 cb.cb_type = POOL_SCAN_SCRUB;
3919 cb.cb_scrub_cmd = POOL_SCRUB_NORMAL;
3920
3921 /* check options */
3922 while ((c = getopt(argc, argv, "sp")) != -1) {
3923 switch (c) {
3924 case 's':
3925 cb.cb_type = POOL_SCAN_NONE;
3926 break;
3927 case 'p':
3928 cb.cb_scrub_cmd = POOL_SCRUB_PAUSE;
3929 break;
3930 case '?':
3931 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3932 optopt);
3933 usage(B_FALSE);
3934 }
3935 }
3936
3937 if (cb.cb_type == POOL_SCAN_NONE &&
3938 cb.cb_scrub_cmd == POOL_SCRUB_PAUSE) {
3939 (void) fprintf(stderr, gettext("invalid option combination: "
3940 "-s and -p are mutually exclusive\n"));
3941 usage(B_FALSE);
3942 }
3943
3944 cb.cb_argc = argc;
3945 cb.cb_argv = argv;
3946 argc -= optind;
3947 argv += optind;
3948
3949 if (argc < 1) {
3950 (void) fprintf(stderr, gettext("missing pool name argument\n"));
3951 usage(B_FALSE);
3952 }
3953
3954 return (for_each_pool(argc, argv, B_TRUE, NULL, scrub_callback, &cb));
3955 }
3956
3957 typedef struct status_cbdata {
3958 int cb_count;
3959 boolean_t cb_allpools;
3960 boolean_t cb_verbose;
3961 boolean_t cb_explain;
3962 boolean_t cb_first;
3963 boolean_t cb_dedup_stats;
3964 } status_cbdata_t;
3965
3966 /*
3967 * Print out detailed scrub status.
3968 */
3969 void
3970 print_scan_status(pool_scan_stat_t *ps)
3971 {
3972 time_t start, end, pause;
3973 uint64_t elapsed, mins_left, hours_left;
3974 uint64_t pass_exam, examined, total;
3975 uint_t rate;
3976 double fraction_done;
3977 char processed_buf[7], examined_buf[7], total_buf[7], rate_buf[7];
3978
3979 (void) printf(gettext(" scan: "));
3980
3981 /* If there's never been a scan, there's not much to say. */
3982 if (ps == NULL || ps->pss_func == POOL_SCAN_NONE ||
3983 ps->pss_func >= POOL_SCAN_FUNCS) {
3984 (void) printf(gettext("none requested\n"));
3985 return;
3986 }
3987
3988 start = ps->pss_start_time;
3989 end = ps->pss_end_time;
3990 pause = ps->pss_pass_scrub_pause;
3991 zfs_nicenum(ps->pss_processed, processed_buf, sizeof (processed_buf));
3992
3993 assert(ps->pss_func == POOL_SCAN_SCRUB ||
3994 ps->pss_func == POOL_SCAN_RESILVER);
3995 /*
3996 * Scan is finished or canceled.
3997 */
3998 if (ps->pss_state == DSS_FINISHED) {
3999 uint64_t minutes_taken = (end - start) / 60;
4000 char *fmt = NULL;
4001
4002 if (ps->pss_func == POOL_SCAN_SCRUB) {
4003 fmt = gettext("scrub repaired %s in %lluh%um with "
4004 "%llu errors on %s");
4005 } else if (ps->pss_func == POOL_SCAN_RESILVER) {
4006 fmt = gettext("resilvered %s in %lluh%um with "
4007 "%llu errors on %s");
4008 }
4009 /* LINTED */
4010 (void) printf(fmt, processed_buf,
4011 (u_longlong_t)(minutes_taken / 60),
4012 (uint_t)(minutes_taken % 60),
4013 (u_longlong_t)ps->pss_errors,
4014 ctime((time_t *)&end));
4015 return;
4016 } else if (ps->pss_state == DSS_CANCELED) {
4017 if (ps->pss_func == POOL_SCAN_SCRUB) {
4018 (void) printf(gettext("scrub canceled on %s"),
4019 ctime(&end));
4020 } else if (ps->pss_func == POOL_SCAN_RESILVER) {
4021 (void) printf(gettext("resilver canceled on %s"),
4022 ctime(&end));
4023 }
4024 return;
4025 }
4026
4027 assert(ps->pss_state == DSS_SCANNING);
4028
4029 /*
4030 * Scan is in progress.
4031 */
4032 if (ps->pss_func == POOL_SCAN_SCRUB) {
4033 if (pause == 0) {
4034 (void) printf(gettext("scrub in progress since %s"),
4035 ctime(&start));
4036 } else {
4037 char buf[32];
4038 struct tm *p = localtime(&pause);
4039 (void) strftime(buf, sizeof (buf), "%a %b %e %T %Y", p);
4040 (void) printf(gettext("scrub paused since %s\n"), buf);
4041 (void) printf(gettext("\tscrub started on %s"),
4042 ctime(&start));
4043 }
4044 } else if (ps->pss_func == POOL_SCAN_RESILVER) {
4045 (void) printf(gettext("resilver in progress since %s"),
4046 ctime(&start));
4047 }
4048
4049 examined = ps->pss_examined ? ps->pss_examined : 1;
4050 total = ps->pss_to_examine;
4051 fraction_done = (double)examined / total;
4052
4053 /* elapsed time for this pass */
4054 elapsed = time(NULL) - ps->pss_pass_start;
4055 elapsed -= ps->pss_pass_scrub_spent_paused;
4056 elapsed = elapsed ? elapsed : 1;
4057 pass_exam = ps->pss_pass_exam ? ps->pss_pass_exam : 1;
4058 rate = pass_exam / elapsed;
4059 rate = rate ? rate : 1;
4060 mins_left = ((total - examined) / rate) / 60;
4061 hours_left = mins_left / 60;
4062
4063 zfs_nicenum(examined, examined_buf, sizeof (examined_buf));
4064 zfs_nicenum(total, total_buf, sizeof (total_buf));
4065
4066 /*
4067 * do not print estimated time if hours_left is more than 30 days
4068 * or we have a paused scrub
4069 */
4070 if (pause == 0) {
4071 zfs_nicenum(rate, rate_buf, sizeof (rate_buf));
4072 (void) printf(gettext("\t%s scanned out of %s at %s/s"),
4073 examined_buf, total_buf, rate_buf);
4074 if (hours_left < (30 * 24)) {
4075 (void) printf(gettext(", %lluh%um to go\n"),
4076 (u_longlong_t)hours_left, (uint_t)(mins_left % 60));
4077 } else {
4078 (void) printf(gettext(
4079 ", (scan is slow, no estimated time)\n"));
4080 }
4081 } else {
4082 (void) printf(gettext("\t%s scanned out of %s\n"),
4083 examined_buf, total_buf);
4084 }
4085
4086 if (ps->pss_func == POOL_SCAN_RESILVER) {
4087 (void) printf(gettext(" %s resilvered, %.2f%% done\n"),
4088 processed_buf, 100 * fraction_done);
4089 } else if (ps->pss_func == POOL_SCAN_SCRUB) {
4090 (void) printf(gettext(" %s repaired, %.2f%% done\n"),
4091 processed_buf, 100 * fraction_done);
4092 }
4093 }
4094
4095 static void
4096 print_error_log(zpool_handle_t *zhp)
4097 {
4098 nvlist_t *nverrlist = NULL;
4099 nvpair_t *elem;
4100 char *pathname;
4101 size_t len = MAXPATHLEN * 2;
4102
4103 if (zpool_get_errlog(zhp, &nverrlist) != 0) {
4104 (void) printf("errors: List of errors unavailable "
4105 "(insufficient privileges)\n");
4106 return;
4107 }
4108
4109 (void) printf("errors: Permanent errors have been "
4110 "detected in the following files:\n\n");
4111
4112 pathname = safe_malloc(len);
4113 elem = NULL;
4114 while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) {
4115 nvlist_t *nv;
4116 uint64_t dsobj, obj;
4117
4118 verify(nvpair_value_nvlist(elem, &nv) == 0);
4119 verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET,
4120 &dsobj) == 0);
4121 verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT,
4122 &obj) == 0);
4123 zpool_obj_to_path(zhp, dsobj, obj, pathname, len);
4124 (void) printf("%7s %s\n", "", pathname);
4125 }
4126 free(pathname);
4127 nvlist_free(nverrlist);
4128 }
4129
4130 static void
4131 print_spares(zpool_handle_t *zhp, nvlist_t **spares, uint_t nspares,
4132 int namewidth)
4133 {
4134 uint_t i;
4135 char *name;
4136
4137 if (nspares == 0)
4138 return;
4139
4140 (void) printf(gettext("\tspares\n"));
4141
4142 for (i = 0; i < nspares; i++) {
4143 name = zpool_vdev_name(g_zfs, zhp, spares[i], B_FALSE);
4144 print_status_config(zhp, name, spares[i],
4145 namewidth, 2, B_TRUE);
4146 free(name);
4147 }
4148 }
4149
4150 static void
4151 print_l2cache(zpool_handle_t *zhp, nvlist_t **l2cache, uint_t nl2cache,
4152 int namewidth)
4153 {
4154 uint_t i;
4155 char *name;
4156
4157 if (nl2cache == 0)
4158 return;
4159
4160 (void) printf(gettext("\tcache\n"));
4161
4162 for (i = 0; i < nl2cache; i++) {
4163 name = zpool_vdev_name(g_zfs, zhp, l2cache[i], B_FALSE);
4164 print_status_config(zhp, name, l2cache[i],
4165 namewidth, 2, B_FALSE);
4166 free(name);
4167 }
4168 }
4169
4170 static void
4171 print_dedup_stats(nvlist_t *config)
4172 {
4173 ddt_histogram_t *ddh;
4174 ddt_stat_t *dds;
4175 ddt_object_t *ddo;
4176 uint_t c;
4177
4178 /*
4179 * If the pool was faulted then we may not have been able to
4180 * obtain the config. Otherwise, if we have anything in the dedup
4181 * table continue processing the stats.
4182 */
4183 if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_OBJ_STATS,
4184 (uint64_t **)&ddo, &c) != 0)
4185 return;
4186
4187 (void) printf("\n");
4188 (void) printf(gettext(" dedup: "));
4189 if (ddo->ddo_count == 0) {
4190 (void) printf(gettext("no DDT entries\n"));
4191 return;
4192 }
4193
4194 (void) printf("DDT entries %llu, size %llu on disk, %llu in core\n",
4195 (u_longlong_t)ddo->ddo_count,
4196 (u_longlong_t)ddo->ddo_dspace,
4197 (u_longlong_t)ddo->ddo_mspace);
4198
4199 verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS,
4200 (uint64_t **)&dds, &c) == 0);
4201 verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_HISTOGRAM,
4202 (uint64_t **)&ddh, &c) == 0);
4203 zpool_dump_ddt(dds, ddh);
4204 }
4205
4206 /*
4207 * Display a summary of pool status. Displays a summary such as:
4208 *
4209 * pool: tank
4210 * status: DEGRADED
4211 * reason: One or more devices ...
4212 * see: http://illumos.org/msg/ZFS-xxxx-01
4213 * config:
4214 * mirror DEGRADED
4215 * c1t0d0 OK
4216 * c2t0d0 UNAVAIL
4217 *
4218 * When given the '-v' option, we print out the complete config. If the '-e'
4219 * option is specified, then we print out error rate information as well.
4220 */
4221 int
4222 status_callback(zpool_handle_t *zhp, void *data)
4223 {
4224 status_cbdata_t *cbp = data;
4225 nvlist_t *config, *nvroot;
4226 char *msgid;
4227 int reason;
4228 const char *health;
4229 uint_t c;
4230 vdev_stat_t *vs;
4231
4232 config = zpool_get_config(zhp, NULL);
4233 reason = zpool_get_status(zhp, &msgid);
4234
4235 cbp->cb_count++;
4236
4237 /*
4238 * If we were given 'zpool status -x', only report those pools with
4239 * problems.
4240 */
4241 if (cbp->cb_explain &&
4242 (reason == ZPOOL_STATUS_OK ||
4243 reason == ZPOOL_STATUS_VERSION_OLDER ||
4244 reason == ZPOOL_STATUS_FEAT_DISABLED)) {
4245 if (!cbp->cb_allpools) {
4246 (void) printf(gettext("pool '%s' is healthy\n"),
4247 zpool_get_name(zhp));
4248 if (cbp->cb_first)
4249 cbp->cb_first = B_FALSE;
4250 }
4251 return (0);
4252 }
4253
4254 if (cbp->cb_first)
4255 cbp->cb_first = B_FALSE;
4256 else
4257 (void) printf("\n");
4258
4259 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
4260 &nvroot) == 0);
4261 verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
4262 (uint64_t **)&vs, &c) == 0);
4263 health = zpool_state_to_name(vs->vs_state, vs->vs_aux);
4264
4265 (void) printf(gettext(" pool: %s\n"), zpool_get_name(zhp));
4266 (void) printf(gettext(" state: %s\n"), health);
4267
4268 switch (reason) {
4269 case ZPOOL_STATUS_MISSING_DEV_R:
4270 (void) printf(gettext("status: One or more devices could not "
4271 "be opened. Sufficient replicas exist for\n\tthe pool to "
4272 "continue functioning in a degraded state.\n"));
4273 (void) printf(gettext("action: Attach the missing device and "
4274 "online it using 'zpool online'.\n"));
4275 break;
4276
4277 case ZPOOL_STATUS_MISSING_DEV_NR:
4278 (void) printf(gettext("status: One or more devices could not "
4279 "be opened. There are insufficient\n\treplicas for the "
4280 "pool to continue functioning.\n"));
4281 (void) printf(gettext("action: Attach the missing device and "
4282 "online it using 'zpool online'.\n"));
4283 break;
4284
4285 case ZPOOL_STATUS_CORRUPT_LABEL_R:
4286 (void) printf(gettext("status: One or more devices could not "
4287 "be used because the label is missing or\n\tinvalid. "
4288 "Sufficient replicas exist for the pool to continue\n\t"
4289 "functioning in a degraded state.\n"));
4290 (void) printf(gettext("action: Replace the device using "
4291 "'zpool replace'.\n"));
4292 break;
4293
4294 case ZPOOL_STATUS_CORRUPT_LABEL_NR:
4295 (void) printf(gettext("status: One or more devices could not "
4296 "be used because the label is missing \n\tor invalid. "
4297 "There are insufficient replicas for the pool to "
4298 "continue\n\tfunctioning.\n"));
4299 zpool_explain_recover(zpool_get_handle(zhp),
4300 zpool_get_name(zhp), reason, config);
4301 break;
4302
4303 case ZPOOL_STATUS_FAILING_DEV:
4304 (void) printf(gettext("status: One or more devices has "
4305 "experienced an unrecoverable error. An\n\tattempt was "
4306 "made to correct the error. Applications are "
4307 "unaffected.\n"));
4308 (void) printf(gettext("action: Determine if the device needs "
4309 "to be replaced, and clear the errors\n\tusing "
4310 "'zpool clear' or replace the device with 'zpool "
4311 "replace'.\n"));
4312 break;
4313
4314 case ZPOOL_STATUS_OFFLINE_DEV:
4315 (void) printf(gettext("status: One or more devices has "
4316 "been taken offline by the administrator.\n\tSufficient "
4317 "replicas exist for the pool to continue functioning in "
4318 "a\n\tdegraded state.\n"));
4319 (void) printf(gettext("action: Online the device using "
4320 "'zpool online' or replace the device with\n\t'zpool "
4321 "replace'.\n"));
4322 break;
4323
4324 case ZPOOL_STATUS_REMOVED_DEV:
4325 (void) printf(gettext("status: One or more devices has "
4326 "been removed by the administrator.\n\tSufficient "
4327 "replicas exist for the pool to continue functioning in "
4328 "a\n\tdegraded state.\n"));
4329 (void) printf(gettext("action: Online the device using "
4330 "'zpool online' or replace the device with\n\t'zpool "
4331 "replace'.\n"));
4332 break;
4333
4334 case ZPOOL_STATUS_RESILVERING:
4335 (void) printf(gettext("status: One or more devices is "
4336 "currently being resilvered. The pool will\n\tcontinue "
4337 "to function, possibly in a degraded state.\n"));
4338 (void) printf(gettext("action: Wait for the resilver to "
4339 "complete.\n"));
4340 break;
4341
4342 case ZPOOL_STATUS_CORRUPT_DATA:
4343 (void) printf(gettext("status: One or more devices has "
4344 "experienced an error resulting in data\n\tcorruption. "
4345 "Applications may be affected.\n"));
4346 (void) printf(gettext("action: Restore the file in question "
4347 "if possible. Otherwise restore the\n\tentire pool from "
4348 "backup.\n"));
4349 break;
4350
4351 case ZPOOL_STATUS_CORRUPT_POOL:
4352 (void) printf(gettext("status: The pool metadata is corrupted "
4353 "and the pool cannot be opened.\n"));
4354 zpool_explain_recover(zpool_get_handle(zhp),
4355 zpool_get_name(zhp), reason, config);
4356 break;
4357
4358 case ZPOOL_STATUS_VERSION_OLDER:
4359 (void) printf(gettext("status: The pool is formatted using a "
4360 "legacy on-disk format. The pool can\n\tstill be used, "
4361 "but some features are unavailable.\n"));
4362 (void) printf(gettext("action: Upgrade the pool using 'zpool "
4363 "upgrade'. Once this is done, the\n\tpool will no longer "
4364 "be accessible on software that does not support feature\n"
4365 "\tflags.\n"));
4366 break;
4367
4368 case ZPOOL_STATUS_VERSION_NEWER:
4369 (void) printf(gettext("status: The pool has been upgraded to a "
4370 "newer, incompatible on-disk version.\n\tThe pool cannot "
4371 "be accessed on this system.\n"));
4372 (void) printf(gettext("action: Access the pool from a system "
4373 "running more recent software, or\n\trestore the pool from "
4374 "backup.\n"));
4375 break;
4376
4377 case ZPOOL_STATUS_FEAT_DISABLED:
4378 (void) printf(gettext("status: Some supported features are not "
4379 "enabled on the pool. The pool can\n\tstill be used, but "
4380 "some features are unavailable.\n"));
4381 (void) printf(gettext("action: Enable all features using "
4382 "'zpool upgrade'. Once this is done,\n\tthe pool may no "
4383 "longer be accessible by software that does not support\n\t"
4384 "the features. See zpool-features(5) for details.\n"));
4385 break;
4386
4387 case ZPOOL_STATUS_UNSUP_FEAT_READ:
4388 (void) printf(gettext("status: The pool cannot be accessed on "
4389 "this system because it uses the\n\tfollowing feature(s) "
4390 "not supported on this system:\n"));
4391 zpool_print_unsup_feat(config);
4392 (void) printf("\n");
4393 (void) printf(gettext("action: Access the pool from a system "
4394 "that supports the required feature(s),\n\tor restore the "
4395 "pool from backup.\n"));
4396 break;
4397
4398 case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
4399 (void) printf(gettext("status: The pool can only be accessed "
4400 "in read-only mode on this system. It\n\tcannot be "
4401 "accessed in read-write mode because it uses the "
4402 "following\n\tfeature(s) not supported on this system:\n"));
4403 zpool_print_unsup_feat(config);
4404 (void) printf("\n");
4405 (void) printf(gettext("action: The pool cannot be accessed in "
4406 "read-write mode. Import the pool with\n"
4407 "\t\"-o readonly=on\", access the pool from a system that "
4408 "supports the\n\trequired feature(s), or restore the "
4409 "pool from backup.\n"));
4410 break;
4411
4412 case ZPOOL_STATUS_FAULTED_DEV_R:
4413 (void) printf(gettext("status: One or more devices are "
4414 "faulted in response to persistent errors.\n\tSufficient "
4415 "replicas exist for the pool to continue functioning "
4416 "in a\n\tdegraded state.\n"));
4417 (void) printf(gettext("action: Replace the faulted device, "
4418 "or use 'zpool clear' to mark the device\n\trepaired.\n"));
4419 break;
4420
4421 case ZPOOL_STATUS_FAULTED_DEV_NR:
4422 (void) printf(gettext("status: One or more devices are "
4423 "faulted in response to persistent errors. There are "
4424 "insufficient replicas for the pool to\n\tcontinue "
4425 "functioning.\n"));
4426 (void) printf(gettext("action: Destroy and re-create the pool "
4427 "from a backup source. Manually marking the device\n"
4428 "\trepaired using 'zpool clear' may allow some data "
4429 "to be recovered.\n"));
4430 break;
4431
4432 case ZPOOL_STATUS_IO_FAILURE_WAIT:
4433 case ZPOOL_STATUS_IO_FAILURE_CONTINUE:
4434 (void) printf(gettext("status: One or more devices are "
4435 "faulted in response to IO failures.\n"));
4436 (void) printf(gettext("action: Make sure the affected devices "
4437 "are connected, then run 'zpool clear'.\n"));
4438 break;
4439
4440 case ZPOOL_STATUS_BAD_LOG:
4441 (void) printf(gettext("status: An intent log record "
4442 "could not be read.\n"
4443 "\tWaiting for adminstrator intervention to fix the "
4444 "faulted pool.\n"));
4445 (void) printf(gettext("action: Either restore the affected "
4446 "device(s) and run 'zpool online',\n"
4447 "\tor ignore the intent log records by running "
4448 "'zpool clear'.\n"));
4449 break;
4450
4451 default:
4452 /*
4453 * The remaining errors can't actually be generated, yet.
4454 */
4455 assert(reason == ZPOOL_STATUS_OK);
4456 }
4457
4458 if (msgid != NULL)
4459 (void) printf(gettext(" see: http://illumos.org/msg/%s\n"),
4460 msgid);
4461
4462 if (config != NULL) {
4463 int namewidth;
4464 uint64_t nerr;
4465 nvlist_t **spares, **l2cache;
4466 uint_t nspares, nl2cache;
4467 pool_scan_stat_t *ps = NULL;
4468
4469 (void) nvlist_lookup_uint64_array(nvroot,
4470 ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &c);
4471 print_scan_status(ps);
4472
4473 namewidth = max_width(zhp, nvroot, 0, 0);
4474 if (namewidth < 10)
4475 namewidth = 10;
4476
4477 (void) printf(gettext("config:\n\n"));
4478 (void) printf(gettext("\t%-*s %-8s %5s %5s %5s\n"), namewidth,
4479 "NAME", "STATE", "READ", "WRITE", "CKSUM");
4480 print_status_config(zhp, zpool_get_name(zhp), nvroot,
4481 namewidth, 0, B_FALSE);
4482
4483 if (num_logs(nvroot) > 0)
4484 print_logs(zhp, nvroot, namewidth, B_TRUE);
4485 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
4486 &l2cache, &nl2cache) == 0)
4487 print_l2cache(zhp, l2cache, nl2cache, namewidth);
4488
4489 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
4490 &spares, &nspares) == 0)
4491 print_spares(zhp, spares, nspares, namewidth);
4492
4493 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
4494 &nerr) == 0) {
4495 nvlist_t *nverrlist = NULL;
4496
4497 /*
4498 * If the approximate error count is small, get a
4499 * precise count by fetching the entire log and
4500 * uniquifying the results.
4501 */
4502 if (nerr > 0 && nerr < 100 && !cbp->cb_verbose &&
4503 zpool_get_errlog(zhp, &nverrlist) == 0) {
4504 nvpair_t *elem;
4505
4506 elem = NULL;
4507 nerr = 0;
4508 while ((elem = nvlist_next_nvpair(nverrlist,
4509 elem)) != NULL) {
4510 nerr++;
4511 }
4512 }
4513 nvlist_free(nverrlist);
4514
4515 (void) printf("\n");
4516
4517 if (nerr == 0)
4518 (void) printf(gettext("errors: No known data "
4519 "errors\n"));
4520 else if (!cbp->cb_verbose)
4521 (void) printf(gettext("errors: %llu data "
4522 "errors, use '-v' for a list\n"),
4523 (u_longlong_t)nerr);
4524 else
4525 print_error_log(zhp);
4526 }
4527
4528 if (cbp->cb_dedup_stats)
4529 print_dedup_stats(config);
4530 } else {
4531 (void) printf(gettext("config: The configuration cannot be "
4532 "determined.\n"));
4533 }
4534
4535 return (0);
4536 }
4537
4538 /*
4539 * zpool status [-vx] [-T d|u] [pool] ... [interval [count]]
4540 *
4541 * -v Display complete error logs
4542 * -x Display only pools with potential problems
4543 * -D Display dedup status (undocumented)
4544 * -T Display a timestamp in date(1) or Unix format
4545 *
4546 * Describes the health status of all pools or some subset.
4547 */
4548 int
4549 zpool_do_status(int argc, char **argv)
4550 {
4551 int c;
4552 int ret;
4553 unsigned long interval = 0, count = 0;
4554 status_cbdata_t cb = { 0 };
4555
4556 /* check options */
4557 while ((c = getopt(argc, argv, "vxDT:")) != -1) {
4558 switch (c) {
4559 case 'v':
4560 cb.cb_verbose = B_TRUE;
4561 break;
4562 case 'x':
4563 cb.cb_explain = B_TRUE;
4564 break;
4565 case 'D':
4566 cb.cb_dedup_stats = B_TRUE;
4567 break;
4568 case 'T':
4569 get_timestamp_arg(*optarg);
4570 break;
4571 case '?':
4572 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
4573 optopt);
4574 usage(B_FALSE);
4575 }
4576 }
4577
4578 argc -= optind;
4579 argv += optind;
4580
4581 get_interval_count(&argc, argv, &interval, &count);
4582
4583 if (argc == 0)
4584 cb.cb_allpools = B_TRUE;
4585
4586 cb.cb_first = B_TRUE;
4587
4588 for (;;) {
4589 if (timestamp_fmt != NODATE)
4590 print_timestamp(timestamp_fmt);
4591
4592 ret = for_each_pool(argc, argv, B_TRUE, NULL,
4593 status_callback, &cb);
4594
4595 if (argc == 0 && cb.cb_count == 0)
4596 (void) printf(gettext("no pools available\n"));
4597 else if (cb.cb_explain && cb.cb_first && cb.cb_allpools)
4598 (void) printf(gettext("all pools are healthy\n"));
4599
4600 if (ret != 0)
4601 return (ret);
4602
4603 if (interval == 0)
4604 break;
4605
4606 if (count != 0 && --count == 0)
4607 break;
4608
4609 (void) sleep(interval);
4610 }
4611
4612 return (0);
4613 }
4614
4615 typedef struct upgrade_cbdata {
4616 int cb_first;
4617 int cb_argc;
4618 uint64_t cb_version;
4619 char **cb_argv;
4620 } upgrade_cbdata_t;
4621
4622 static int
4623 upgrade_version(zpool_handle_t *zhp, uint64_t version)
4624 {
4625 int ret;
4626 nvlist_t *config;
4627 uint64_t oldversion;
4628
4629 config = zpool_get_config(zhp, NULL);
4630 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
4631 &oldversion) == 0);
4632
4633 assert(SPA_VERSION_IS_SUPPORTED(oldversion));
4634 assert(oldversion < version);
4635
4636 ret = zpool_upgrade(zhp, version);
4637 if (ret != 0)
4638 return (ret);
4639
4640 if (version >= SPA_VERSION_FEATURES) {
4641 (void) printf(gettext("Successfully upgraded "
4642 "'%s' from version %llu to feature flags.\n"),
4643 zpool_get_name(zhp), oldversion);
4644 } else {
4645 (void) printf(gettext("Successfully upgraded "
4646 "'%s' from version %llu to version %llu.\n"),
4647 zpool_get_name(zhp), oldversion, version);
4648 }
4649
4650 return (0);
4651 }
4652
4653 static int
4654 upgrade_enable_all(zpool_handle_t *zhp, int *countp)
4655 {
4656 int i, ret, count;
4657 boolean_t firstff = B_TRUE;
4658 nvlist_t *enabled = zpool_get_features(zhp);
4659
4660 count = 0;
4661 for (i = 0; i < SPA_FEATURES; i++) {
4662 const char *fname = spa_feature_table[i].fi_uname;
4663 const char *fguid = spa_feature_table[i].fi_guid;
4664 if (!nvlist_exists(enabled, fguid)) {
4665 char *propname;
4666 verify(-1 != asprintf(&propname, "feature@%s", fname));
4667 ret = zpool_set_prop(zhp, propname,
4668 ZFS_FEATURE_ENABLED);
4669 if (ret != 0) {
4670 free(propname);
4671 return (ret);
4672 }
4673 count++;
4674
4675 if (firstff) {
4676 (void) printf(gettext("Enabled the "
4677 "following features on '%s':\n"),
4678 zpool_get_name(zhp));
4679 firstff = B_FALSE;
4680 }
4681 (void) printf(gettext(" %s\n"), fname);
4682 free(propname);
4683 }
4684 }
4685
4686 if (countp != NULL)
4687 *countp = count;
4688 return (0);
4689 }
4690
4691 static int
4692 upgrade_cb(zpool_handle_t *zhp, void *arg)
4693 {
4694 upgrade_cbdata_t *cbp = arg;
4695 nvlist_t *config;
4696 uint64_t version;
4697 boolean_t printnl = B_FALSE;
4698 int ret;
4699
4700 config = zpool_get_config(zhp, NULL);
4701 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
4702 &version) == 0);
4703
4704 assert(SPA_VERSION_IS_SUPPORTED(version));
4705
4706 if (version < cbp->cb_version) {
4707 cbp->cb_first = B_FALSE;
4708 ret = upgrade_version(zhp, cbp->cb_version);
4709 if (ret != 0)
4710 return (ret);
4711 printnl = B_TRUE;
4712
4713 /*
4714 * If they did "zpool upgrade -a", then we could
4715 * be doing ioctls to different pools. We need
4716 * to log this history once to each pool, and bypass
4717 * the normal history logging that happens in main().
4718 */
4719 (void) zpool_log_history(g_zfs, history_str);
4720 log_history = B_FALSE;
4721 }
4722
4723 if (cbp->cb_version >= SPA_VERSION_FEATURES) {
4724 int count;
4725 ret = upgrade_enable_all(zhp, &count);
4726 if (ret != 0)
4727 return (ret);
4728
4729 if (count > 0) {
4730 cbp->cb_first = B_FALSE;
4731 printnl = B_TRUE;
4732 }
4733 }
4734
4735 if (printnl) {
4736 (void) printf(gettext("\n"));
4737 }
4738
4739 return (0);
4740 }
4741
4742 static int
4743 upgrade_list_older_cb(zpool_handle_t *zhp, void *arg)
4744 {
4745 upgrade_cbdata_t *cbp = arg;
4746 nvlist_t *config;
4747 uint64_t version;
4748
4749 config = zpool_get_config(zhp, NULL);
4750 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
4751 &version) == 0);
4752
4753 assert(SPA_VERSION_IS_SUPPORTED(version));
4754
4755 if (version < SPA_VERSION_FEATURES) {
4756 if (cbp->cb_first) {
4757 (void) printf(gettext("The following pools are "
4758 "formatted with legacy version numbers and can\n"
4759 "be upgraded to use feature flags. After "
4760 "being upgraded, these pools\nwill no "
4761 "longer be accessible by software that does not "
4762 "support feature\nflags.\n\n"));
4763 (void) printf(gettext("VER POOL\n"));
4764 (void) printf(gettext("--- ------------\n"));
4765 cbp->cb_first = B_FALSE;
4766 }
4767
4768 (void) printf("%2llu %s\n", (u_longlong_t)version,
4769 zpool_get_name(zhp));
4770 }
4771
4772 return (0);
4773 }
4774
4775 static int
4776 upgrade_list_disabled_cb(zpool_handle_t *zhp, void *arg)
4777 {
4778 upgrade_cbdata_t *cbp = arg;
4779 nvlist_t *config;
4780 uint64_t version;
4781
4782 config = zpool_get_config(zhp, NULL);
4783 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
4784 &version) == 0);
4785
4786 if (version >= SPA_VERSION_FEATURES) {
4787 int i;
4788 boolean_t poolfirst = B_TRUE;
4789 nvlist_t *enabled = zpool_get_features(zhp);
4790
4791 for (i = 0; i < SPA_FEATURES; i++) {
4792 const char *fguid = spa_feature_table[i].fi_guid;
4793 const char *fname = spa_feature_table[i].fi_uname;
4794 if (!nvlist_exists(enabled, fguid)) {
4795 if (cbp->cb_first) {
4796 (void) printf(gettext("\nSome "
4797 "supported features are not "
4798 "enabled on the following pools. "
4799 "Once a\nfeature is enabled the "
4800 "pool may become incompatible with "
4801 "software\nthat does not support "
4802 "the feature. See "
4803 "zpool-features(5) for "
4804 "details.\n\n"));
4805 (void) printf(gettext("POOL "
4806 "FEATURE\n"));
4807 (void) printf(gettext("------"
4808 "---------\n"));
4809 cbp->cb_first = B_FALSE;
4810 }
4811
4812 if (poolfirst) {
4813 (void) printf(gettext("%s\n"),
4814 zpool_get_name(zhp));
4815 poolfirst = B_FALSE;
4816 }
4817
4818 (void) printf(gettext(" %s\n"), fname);
4819 }
4820 }
4821 }
4822
4823 return (0);
4824 }
4825
4826 /* ARGSUSED */
4827 static int
4828 upgrade_one(zpool_handle_t *zhp, void *data)
4829 {
4830 boolean_t printnl = B_FALSE;
4831 upgrade_cbdata_t *cbp = data;
4832 uint64_t cur_version;
4833 int ret;
4834
4835 if (strcmp("log", zpool_get_name(zhp)) == 0) {
4836 (void) printf(gettext("'log' is now a reserved word\n"
4837 "Pool 'log' must be renamed using export and import"
4838 " to upgrade.\n"));
4839 return (1);
4840 }
4841
4842 cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
4843 if (cur_version > cbp->cb_version) {
4844 (void) printf(gettext("Pool '%s' is already formatted "
4845 "using more current version '%llu'.\n\n"),
4846 zpool_get_name(zhp), cur_version);
4847 return (0);
4848 }
4849
4850 if (cbp->cb_version != SPA_VERSION && cur_version == cbp->cb_version) {
4851 (void) printf(gettext("Pool '%s' is already formatted "
4852 "using version %llu.\n\n"), zpool_get_name(zhp),
4853 cbp->cb_version);
4854 return (0);
4855 }
4856
4857 if (cur_version != cbp->cb_version) {
4858 printnl = B_TRUE;
4859 ret = upgrade_version(zhp, cbp->cb_version);
4860 if (ret != 0)
4861 return (ret);
4862 }
4863
4864 if (cbp->cb_version >= SPA_VERSION_FEATURES) {
4865 int count = 0;
4866 ret = upgrade_enable_all(zhp, &count);
4867 if (ret != 0)
4868 return (ret);
4869
4870 if (count != 0) {
4871 printnl = B_TRUE;
4872 } else if (cur_version == SPA_VERSION) {
4873 (void) printf(gettext("Pool '%s' already has all "
4874 "supported features enabled.\n"),
4875 zpool_get_name(zhp));
4876 }
4877 }
4878
4879 if (printnl) {
4880 (void) printf(gettext("\n"));
4881 }
4882
4883 return (0);
4884 }
4885
4886 /*
4887 * zpool upgrade
4888 * zpool upgrade -v
4889 * zpool upgrade [-V version] <-a | pool ...>
4890 *
4891 * With no arguments, display downrev'd ZFS pool available for upgrade.
4892 * Individual pools can be upgraded by specifying the pool, and '-a' will
4893 * upgrade all pools.
4894 */
4895 int
4896 zpool_do_upgrade(int argc, char **argv)
4897 {
4898 int c;
4899 upgrade_cbdata_t cb = { 0 };
4900 int ret = 0;
4901 boolean_t showversions = B_FALSE;
4902 boolean_t upgradeall = B_FALSE;
4903 char *end;
4904
4905
4906 /* check options */
4907 while ((c = getopt(argc, argv, ":avV:")) != -1) {
4908 switch (c) {
4909 case 'a':
4910 upgradeall = B_TRUE;
4911 break;
4912 case 'v':
4913 showversions = B_TRUE;
4914 break;
4915 case 'V':
4916 cb.cb_version = strtoll(optarg, &end, 10);
4917 if (*end != '\0' ||
4918 !SPA_VERSION_IS_SUPPORTED(cb.cb_version)) {
4919 (void) fprintf(stderr,
4920 gettext("invalid version '%s'\n"), optarg);
4921 usage(B_FALSE);
4922 }
4923 break;
4924 case ':':
4925 (void) fprintf(stderr, gettext("missing argument for "
4926 "'%c' option\n"), optopt);
4927 usage(B_FALSE);
4928 break;
4929 case '?':
4930 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
4931 optopt);
4932 usage(B_FALSE);
4933 }
4934 }
4935
4936 cb.cb_argc = argc;
4937 cb.cb_argv = argv;
4938 argc -= optind;
4939 argv += optind;
4940
4941 if (cb.cb_version == 0) {
4942 cb.cb_version = SPA_VERSION;
4943 } else if (!upgradeall && argc == 0) {
4944 (void) fprintf(stderr, gettext("-V option is "
4945 "incompatible with other arguments\n"));
4946 usage(B_FALSE);
4947 }
4948
4949 if (showversions) {
4950 if (upgradeall || argc != 0) {
4951 (void) fprintf(stderr, gettext("-v option is "
4952 "incompatible with other arguments\n"));
4953 usage(B_FALSE);
4954 }
4955 } else if (upgradeall) {
4956 if (argc != 0) {
4957 (void) fprintf(stderr, gettext("-a option should not "
4958 "be used along with a pool name\n"));
4959 usage(B_FALSE);
4960 }
4961 }
4962
4963 (void) printf(gettext("This system supports ZFS pool feature "
4964 "flags.\n\n"));
4965 if (showversions) {
4966 int i;
4967
4968 (void) printf(gettext("The following features are "
4969 "supported:\n\n"));
4970 (void) printf(gettext("FEAT DESCRIPTION\n"));
4971 (void) printf("----------------------------------------------"
4972 "---------------\n");
4973 for (i = 0; i < SPA_FEATURES; i++) {
4974 zfeature_info_t *fi = &spa_feature_table[i];
4975 const char *ro =
4976 (fi->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ?
4977 " (read-only compatible)" : "";
4978
4979 (void) printf("%-37s%s\n", fi->fi_uname, ro);
4980 (void) printf(" %s\n", fi->fi_desc);
4981 }
4982 (void) printf("\n");
4983
4984 (void) printf(gettext("The following legacy versions are also "
4985 "supported:\n\n"));
4986 (void) printf(gettext("VER DESCRIPTION\n"));
4987 (void) printf("--- -----------------------------------------"
4988 "---------------\n");
4989 (void) printf(gettext(" 1 Initial ZFS version\n"));
4990 (void) printf(gettext(" 2 Ditto blocks "
4991 "(replicated metadata)\n"));
4992 (void) printf(gettext(" 3 Hot spares and double parity "
4993 "RAID-Z\n"));
4994 (void) printf(gettext(" 4 zpool history\n"));
4995 (void) printf(gettext(" 5 Compression using the gzip "
4996 "algorithm\n"));
4997 (void) printf(gettext(" 6 bootfs pool property\n"));
4998 (void) printf(gettext(" 7 Separate intent log devices\n"));
4999 (void) printf(gettext(" 8 Delegated administration\n"));
5000 (void) printf(gettext(" 9 refquota and refreservation "
5001 "properties\n"));
5002 (void) printf(gettext(" 10 Cache devices\n"));
5003 (void) printf(gettext(" 11 Improved scrub performance\n"));
5004 (void) printf(gettext(" 12 Snapshot properties\n"));
5005 (void) printf(gettext(" 13 snapused property\n"));
5006 (void) printf(gettext(" 14 passthrough-x aclinherit\n"));
5007 (void) printf(gettext(" 15 user/group space accounting\n"));
5008 (void) printf(gettext(" 16 stmf property support\n"));
5009 (void) printf(gettext(" 17 Triple-parity RAID-Z\n"));
5010 (void) printf(gettext(" 18 Snapshot user holds\n"));
5011 (void) printf(gettext(" 19 Log device removal\n"));
5012 (void) printf(gettext(" 20 Compression using zle "
5013 "(zero-length encoding)\n"));
5014 (void) printf(gettext(" 21 Deduplication\n"));
5015 (void) printf(gettext(" 22 Received properties\n"));
5016 (void) printf(gettext(" 23 Slim ZIL\n"));
5017 (void) printf(gettext(" 24 System attributes\n"));
5018 (void) printf(gettext(" 25 Improved scrub stats\n"));
5019 (void) printf(gettext(" 26 Improved snapshot deletion "
5020 "performance\n"));
5021 (void) printf(gettext(" 27 Improved snapshot creation "
5022 "performance\n"));
5023 (void) printf(gettext(" 28 Multiple vdev replacements\n"));
5024 (void) printf(gettext("\nFor more information on a particular "
5025 "version, including supported releases,\n"));
5026 (void) printf(gettext("see the ZFS Administration Guide.\n\n"));
5027 } else if (argc == 0 && upgradeall) {
5028 cb.cb_first = B_TRUE;
5029 ret = zpool_iter(g_zfs, upgrade_cb, &cb);
5030 if (ret == 0 && cb.cb_first) {
5031 if (cb.cb_version == SPA_VERSION) {
5032 (void) printf(gettext("All pools are already "
5033 "formatted using feature flags.\n\n"));
5034 (void) printf(gettext("Every feature flags "
5035 "pool already has all supported features "
5036 "enabled.\n"));
5037 } else {
5038 (void) printf(gettext("All pools are already "
5039 "formatted with version %llu or higher.\n"),
5040 cb.cb_version);
5041 }
5042 }
5043 } else if (argc == 0) {
5044 cb.cb_first = B_TRUE;
5045 ret = zpool_iter(g_zfs, upgrade_list_older_cb, &cb);
5046 assert(ret == 0);
5047
5048 if (cb.cb_first) {
5049 (void) printf(gettext("All pools are formatted "
5050 "using feature flags.\n\n"));
5051 } else {
5052 (void) printf(gettext("\nUse 'zpool upgrade -v' "
5053 "for a list of available legacy versions.\n"));
5054 }
5055
5056 cb.cb_first = B_TRUE;
5057 ret = zpool_iter(g_zfs, upgrade_list_disabled_cb, &cb);
5058 assert(ret == 0);
5059
5060 if (cb.cb_first) {
5061 (void) printf(gettext("Every feature flags pool has "
5062 "all supported features enabled.\n"));
5063 } else {
5064 (void) printf(gettext("\n"));
5065 }
5066 } else {
5067 ret = for_each_pool(argc, argv, B_FALSE, NULL,
5068 upgrade_one, &cb);
5069 }
5070
5071 return (ret);
5072 }
5073
5074 typedef struct hist_cbdata {
5075 boolean_t first;
5076 boolean_t longfmt;
5077 boolean_t internal;
5078 } hist_cbdata_t;
5079
5080 /*
5081 * Print out the command history for a specific pool.
5082 */
5083 static int
5084 get_history_one(zpool_handle_t *zhp, void *data)
5085 {
5086 nvlist_t *nvhis;
5087 nvlist_t **records;
5088 uint_t numrecords;
5089 int ret, i;
5090 hist_cbdata_t *cb = (hist_cbdata_t *)data;
5091
5092 cb->first = B_FALSE;
5093
5094 (void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp));
5095
5096 if ((ret = zpool_get_history(zhp, &nvhis)) != 0)
5097 return (ret);
5098
5099 verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD,
5100 &records, &numrecords) == 0);
5101 for (i = 0; i < numrecords; i++) {
5102 nvlist_t *rec = records[i];
5103 char tbuf[30] = "";
5104
5105 if (nvlist_exists(rec, ZPOOL_HIST_TIME)) {
5106 time_t tsec;
5107 struct tm t;
5108
5109 tsec = fnvlist_lookup_uint64(records[i],
5110 ZPOOL_HIST_TIME);
5111 (void) localtime_r(&tsec, &t);
5112 (void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
5113 }
5114
5115 if (nvlist_exists(rec, ZPOOL_HIST_CMD)) {
5116 (void) printf("%s %s", tbuf,
5117 fnvlist_lookup_string(rec, ZPOOL_HIST_CMD));
5118 } else if (nvlist_exists(rec, ZPOOL_HIST_INT_EVENT)) {
5119 int ievent =
5120 fnvlist_lookup_uint64(rec, ZPOOL_HIST_INT_EVENT);
5121 if (!cb->internal)
5122 continue;
5123 if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS) {
5124 (void) printf("%s unrecognized record:\n",
5125 tbuf);
5126 dump_nvlist(rec, 4);
5127 continue;
5128 }
5129 (void) printf("%s [internal %s txg:%lld] %s", tbuf,
5130 zfs_history_event_names[ievent],
5131 fnvlist_lookup_uint64(rec, ZPOOL_HIST_TXG),
5132 fnvlist_lookup_string(rec, ZPOOL_HIST_INT_STR));
5133 } else if (nvlist_exists(rec, ZPOOL_HIST_INT_NAME)) {
5134 if (!cb->internal)
5135 continue;
5136 (void) printf("%s [txg:%lld] %s", tbuf,
5137 fnvlist_lookup_uint64(rec, ZPOOL_HIST_TXG),
5138 fnvlist_lookup_string(rec, ZPOOL_HIST_INT_NAME));
5139 if (nvlist_exists(rec, ZPOOL_HIST_DSNAME)) {
5140 (void) printf(" %s (%llu)",
5141 fnvlist_lookup_string(rec,
5142 ZPOOL_HIST_DSNAME),
5143 fnvlist_lookup_uint64(rec,
5144 ZPOOL_HIST_DSID));
5145 }
5146 (void) printf(" %s", fnvlist_lookup_string(rec,
5147 ZPOOL_HIST_INT_STR));
5148 } else if (nvlist_exists(rec, ZPOOL_HIST_IOCTL)) {
5149 if (!cb->internal)
5150 continue;
5151 (void) printf("%s ioctl %s\n", tbuf,
5152 fnvlist_lookup_string(rec, ZPOOL_HIST_IOCTL));
5153 if (nvlist_exists(rec, ZPOOL_HIST_INPUT_NVL)) {
5154 (void) printf(" input:\n");
5155 dump_nvlist(fnvlist_lookup_nvlist(rec,
5156 ZPOOL_HIST_INPUT_NVL), 8);
5157 }
5158 if (nvlist_exists(rec, ZPOOL_HIST_OUTPUT_NVL)) {
5159 (void) printf(" output:\n");
5160 dump_nvlist(fnvlist_lookup_nvlist(rec,
5161 ZPOOL_HIST_OUTPUT_NVL), 8);
5162 }
5163 if (nvlist_exists(rec, ZPOOL_HIST_ERRNO)) {
5164 (void) printf(" errno: %lld\n",
5165 fnvlist_lookup_int64(rec,
5166 ZPOOL_HIST_ERRNO));
5167 }
5168 } else {
5169 if (!cb->internal)
5170 continue;
5171 (void) printf("%s unrecognized record:\n", tbuf);
5172 dump_nvlist(rec, 4);
5173 }
5174
5175 if (!cb->longfmt) {
5176 (void) printf("\n");
5177 continue;
5178 }
5179 (void) printf(" [");
5180 if (nvlist_exists(rec, ZPOOL_HIST_WHO)) {
5181 uid_t who = fnvlist_lookup_uint64(rec, ZPOOL_HIST_WHO);
5182 struct passwd *pwd = getpwuid(who);
5183 (void) printf("user %d ", (int)who);
5184 if (pwd != NULL)
5185 (void) printf("(%s) ", pwd->pw_name);
5186 }
5187 if (nvlist_exists(rec, ZPOOL_HIST_HOST)) {
5188 (void) printf("on %s",
5189 fnvlist_lookup_string(rec, ZPOOL_HIST_HOST));
5190 }
5191 if (nvlist_exists(rec, ZPOOL_HIST_ZONE)) {
5192 (void) printf(":%s",
5193 fnvlist_lookup_string(rec, ZPOOL_HIST_ZONE));
5194 }
5195 (void) printf("]");
5196 (void) printf("\n");
5197 }
5198 (void) printf("\n");
5199 nvlist_free(nvhis);
5200
5201 return (ret);
5202 }
5203
5204 /*
5205 * zpool history <pool>
5206 *
5207 * Displays the history of commands that modified pools.
5208 */
5209 int
5210 zpool_do_history(int argc, char **argv)
5211 {
5212 hist_cbdata_t cbdata = { 0 };
5213 int ret;
5214 int c;
5215
5216 cbdata.first = B_TRUE;
5217 /* check options */
5218 while ((c = getopt(argc, argv, "li")) != -1) {
5219 switch (c) {
5220 case 'l':
5221 cbdata.longfmt = B_TRUE;
5222 break;
5223 case 'i':
5224 cbdata.internal = B_TRUE;
5225 break;
5226 case '?':
5227 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
5228 optopt);
5229 usage(B_FALSE);
5230 }
5231 }
5232 argc -= optind;
5233 argv += optind;
5234
5235 ret = for_each_pool(argc, argv, B_FALSE, NULL, get_history_one,
5236 &cbdata);
5237
5238 if (argc == 0 && cbdata.first == B_TRUE) {
5239 (void) printf(gettext("no pools available\n"));
5240 return (0);
5241 }
5242
5243 return (ret);
5244 }
5245
5246 static int
5247 get_callback(zpool_handle_t *zhp, void *data)
5248 {
5249 zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data;
5250 char value[MAXNAMELEN];
5251 zprop_source_t srctype;
5252 zprop_list_t *pl;
5253
5254 for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) {
5255
5256 /*
5257 * Skip the special fake placeholder. This will also skip
5258 * over the name property when 'all' is specified.
5259 */
5260 if (pl->pl_prop == ZPOOL_PROP_NAME &&
5261 pl == cbp->cb_proplist)
5262 continue;
5263
5264 if (pl->pl_prop == ZPROP_INVAL &&
5265 (zpool_prop_feature(pl->pl_user_prop) ||
5266 zpool_prop_unsupported(pl->pl_user_prop))) {
5267 srctype = ZPROP_SRC_LOCAL;
5268
5269 if (zpool_prop_get_feature(zhp, pl->pl_user_prop,
5270 value, sizeof (value)) == 0) {
5271 zprop_print_one_property(zpool_get_name(zhp),
5272 cbp, pl->pl_user_prop, value, srctype,
5273 NULL, NULL);
5274 }
5275 } else {
5276 if (zpool_get_prop(zhp, pl->pl_prop, value,
5277 sizeof (value), &srctype, cbp->cb_literal) != 0)
5278 continue;
5279
5280 zprop_print_one_property(zpool_get_name(zhp), cbp,
5281 zpool_prop_to_name(pl->pl_prop), value, srctype,
5282 NULL, NULL);
5283 }
5284 }
5285 return (0);
5286 }
5287
5288 /*
5289 * zpool get [-Hp] [-o "all" | field[,...]] <"all" | property[,...]> <pool> ...
5290 *
5291 * -H Scripted mode. Don't display headers, and separate properties
5292 * by a single tab.
5293 * -o List of columns to display. Defaults to
5294 * "name,property,value,source".
5295 * -p Diplay values in parsable (exact) format.
5296 *
5297 * Get properties of pools in the system. Output space statistics
5298 * for each one as well as other attributes.
5299 */
5300 int
5301 zpool_do_get(int argc, char **argv)
5302 {
5303 zprop_get_cbdata_t cb = { 0 };
5304 zprop_list_t fake_name = { 0 };
5305 int ret;
5306 int c, i;
5307 char *value;
5308
5309 cb.cb_first = B_TRUE;
5310
5311 /*
5312 * Set up default columns and sources.
5313 */
5314 cb.cb_sources = ZPROP_SRC_ALL;
5315 cb.cb_columns[0] = GET_COL_NAME;
5316 cb.cb_columns[1] = GET_COL_PROPERTY;
5317 cb.cb_columns[2] = GET_COL_VALUE;
5318 cb.cb_columns[3] = GET_COL_SOURCE;
5319 cb.cb_type = ZFS_TYPE_POOL;
5320
5321 /* check options */
5322 while ((c = getopt(argc, argv, ":Hpo:")) != -1) {
5323 switch (c) {
5324 case 'p':
5325 cb.cb_literal = B_TRUE;
5326 break;
5327 case 'H':
5328 cb.cb_scripted = B_TRUE;
5329 break;
5330 case 'o':
5331 bzero(&cb.cb_columns, sizeof (cb.cb_columns));
5332 i = 0;
5333 while (*optarg != '\0') {
5334 static char *col_subopts[] =
5335 { "name", "property", "value", "source",
5336 "all", NULL };
5337
5338 if (i == ZFS_GET_NCOLS) {
5339 (void) fprintf(stderr, gettext("too "
5340 "many fields given to -o "
5341 "option\n"));
5342 usage(B_FALSE);
5343 }
5344
5345 switch (getsubopt(&optarg, col_subopts,
5346 &value)) {
5347 case 0:
5348 cb.cb_columns[i++] = GET_COL_NAME;
5349 break;
5350 case 1:
5351 cb.cb_columns[i++] = GET_COL_PROPERTY;
5352 break;
5353 case 2:
5354 cb.cb_columns[i++] = GET_COL_VALUE;
5355 break;
5356 case 3:
5357 cb.cb_columns[i++] = GET_COL_SOURCE;
5358 break;
5359 case 4:
5360 if (i > 0) {
5361 (void) fprintf(stderr,
5362 gettext("\"all\" conflicts "
5363 "with specific fields "
5364 "given to -o option\n"));
5365 usage(B_FALSE);
5366 }
5367 cb.cb_columns[0] = GET_COL_NAME;
5368 cb.cb_columns[1] = GET_COL_PROPERTY;
5369 cb.cb_columns[2] = GET_COL_VALUE;
5370 cb.cb_columns[3] = GET_COL_SOURCE;
5371 i = ZFS_GET_NCOLS;
5372 break;
5373 default:
5374 (void) fprintf(stderr,
5375 gettext("invalid column name "
5376 "'%s'\n"), value);
5377 usage(B_FALSE);
5378 }
5379 }
5380 break;
5381 case '?':
5382 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
5383 optopt);
5384 usage(B_FALSE);
5385 }
5386 }
5387
5388 argc -= optind;
5389 argv += optind;
5390
5391 if (argc < 1) {
5392 (void) fprintf(stderr, gettext("missing property "
5393 "argument\n"));
5394 usage(B_FALSE);
5395 }
5396
5397 if (zprop_get_list(g_zfs, argv[0], &cb.cb_proplist,
5398 ZFS_TYPE_POOL) != 0)
5399 usage(B_FALSE);
5400
5401 argc--;
5402 argv++;
5403
5404 if (cb.cb_proplist != NULL) {
5405 fake_name.pl_prop = ZPOOL_PROP_NAME;
5406 fake_name.pl_width = strlen(gettext("NAME"));
5407 fake_name.pl_next = cb.cb_proplist;
5408 cb.cb_proplist = &fake_name;
5409 }
5410
5411 ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist,
5412 get_callback, &cb);
5413
5414 if (cb.cb_proplist == &fake_name)
5415 zprop_free_list(fake_name.pl_next);
5416 else
5417 zprop_free_list(cb.cb_proplist);
5418
5419 return (ret);
5420 }
5421
5422 typedef struct set_cbdata {
5423 char *cb_propname;
5424 char *cb_value;
5425 boolean_t cb_any_successful;
5426 } set_cbdata_t;
5427
5428 int
5429 set_callback(zpool_handle_t *zhp, void *data)
5430 {
5431 int error;
5432 set_cbdata_t *cb = (set_cbdata_t *)data;
5433
5434 error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value);
5435
5436 if (!error)
5437 cb->cb_any_successful = B_TRUE;
5438
5439 return (error);
5440 }
5441
5442 int
5443 zpool_do_set(int argc, char **argv)
5444 {
5445 set_cbdata_t cb = { 0 };
5446 int error;
5447
5448 if (argc > 1 && argv[1][0] == '-') {
5449 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
5450 argv[1][1]);
5451 usage(B_FALSE);
5452 }
5453
5454 if (argc < 2) {
5455 (void) fprintf(stderr, gettext("missing property=value "
5456 "argument\n"));
5457 usage(B_FALSE);
5458 }
5459
5460 if (argc < 3) {
5461 (void) fprintf(stderr, gettext("missing pool name\n"));
5462 usage(B_FALSE);
5463 }
5464
5465 if (argc > 3) {
5466 (void) fprintf(stderr, gettext("too many pool names\n"));
5467 usage(B_FALSE);
5468 }
5469
5470 cb.cb_propname = argv[1];
5471 cb.cb_value = strchr(cb.cb_propname, '=');
5472 if (cb.cb_value == NULL) {
5473 (void) fprintf(stderr, gettext("missing value in "
5474 "property=value argument\n"));
5475 usage(B_FALSE);
5476 }
5477
5478 *(cb.cb_value) = '\0';
5479 cb.cb_value++;
5480
5481 error = for_each_pool(argc - 2, argv + 2, B_TRUE, NULL,
5482 set_callback, &cb);
5483
5484 return (error);
5485 }
5486
5487 static int
5488 find_command_idx(char *command, int *idx)
5489 {
5490 int i;
5491
5492 for (i = 0; i < NCOMMAND; i++) {
5493 if (command_table[i].name == NULL)
5494 continue;
5495
5496 if (strcmp(command, command_table[i].name) == 0) {
5497 *idx = i;
5498 return (0);
5499 }
5500 }
5501 return (1);
5502 }
5503
5504 int
5505 main(int argc, char **argv)
5506 {
5507 int ret = 0;
5508 int i;
5509 char *cmdname;
5510
5511 (void) setlocale(LC_ALL, "");
5512 (void) textdomain(TEXT_DOMAIN);
5513
5514 if ((g_zfs = libzfs_init()) == NULL) {
5515 (void) fprintf(stderr, gettext("internal error: failed to "
5516 "initialize ZFS library\n"));
5517 return (1);
5518 }
5519
5520 libzfs_print_on_error(g_zfs, B_TRUE);
5521
5522 opterr = 0;
5523
5524 /*
5525 * Make sure the user has specified some command.
5526 */
5527 if (argc < 2) {
5528 (void) fprintf(stderr, gettext("missing command\n"));
5529 usage(B_FALSE);
5530 }
5531
5532 cmdname = argv[1];
5533
5534 /*
5535 * Special case '-?'
5536 */
5537 if (strcmp(cmdname, "-?") == 0)
5538 usage(B_TRUE);
5539
5540 zfs_save_arguments(argc, argv, history_str, sizeof (history_str));
5541
5542 /*
5543 * Run the appropriate command.
5544 */
5545 if (find_command_idx(cmdname, &i) == 0) {
5546 current_command = &command_table[i];
5547 ret = command_table[i].func(argc - 1, argv + 1);
5548 } else if (strchr(cmdname, '=')) {
5549 verify(find_command_idx("set", &i) == 0);
5550 current_command = &command_table[i];
5551 ret = command_table[i].func(argc, argv);
5552 } else if (strcmp(cmdname, "freeze") == 0 && argc == 3) {
5553 /*
5554 * 'freeze' is a vile debugging abomination, so we treat
5555 * it as such.
5556 */
5557 char buf[16384];
5558 int fd = open(ZFS_DEV, O_RDWR);
5559 (void) strcpy((void *)buf, argv[2]);
5560 return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf));
5561 } else {
5562 (void) fprintf(stderr, gettext("unrecognized "
5563 "command '%s'\n"), cmdname);
5564 usage(B_FALSE);
5565 }
5566
5567 if (ret == 0 && log_history)
5568 (void) zpool_log_history(g_zfs, history_str);
5569
5570 libzfs_fini(g_zfs);
5571
5572 /*
5573 * The 'ZFS_ABORT' environment variable causes us to dump core on exit
5574 * for the purposes of running ::findleaks.
5575 */
5576 if (getenv("ZFS_ABORT") != NULL) {
5577 (void) printf("dumping core by request\n");
5578 abort();
5579 }
5580
5581 return (ret);
5582 }
Unleashed OS