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