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