1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5441d80aaSlling * Common Development and Distribution License (the "License"). 6441d80aaSlling * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 2199653d4eSeschrock 22fa9e4066Sahrens /* 23c67d9675Seschrock * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 24fa9e4066Sahrens * Use is subject to license terms. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 28fa9e4066Sahrens 29fa9e4066Sahrens #include <assert.h> 30fa9e4066Sahrens #include <ctype.h> 31fa9e4066Sahrens #include <dirent.h> 32fa9e4066Sahrens #include <errno.h> 33fa9e4066Sahrens #include <fcntl.h> 34fa9e4066Sahrens #include <libgen.h> 35fa9e4066Sahrens #include <libintl.h> 36fa9e4066Sahrens #include <libuutil.h> 37fa9e4066Sahrens #include <locale.h> 38fa9e4066Sahrens #include <stdio.h> 39fa9e4066Sahrens #include <stdlib.h> 40fa9e4066Sahrens #include <string.h> 41fa9e4066Sahrens #include <strings.h> 42fa9e4066Sahrens #include <unistd.h> 43fa9e4066Sahrens #include <priv.h> 44fa9e4066Sahrens 45fa9e4066Sahrens #include <sys/stat.h> 46fa9e4066Sahrens 47fa9e4066Sahrens #include <libzfs.h> 48fa9e4066Sahrens 49fa9e4066Sahrens #include "zpool_util.h" 50fa9e4066Sahrens 51fa9e4066Sahrens static int zpool_do_create(int, char **); 52fa9e4066Sahrens static int zpool_do_destroy(int, char **); 53fa9e4066Sahrens 54fa9e4066Sahrens static int zpool_do_add(int, char **); 5599653d4eSeschrock static int zpool_do_remove(int, char **); 56fa9e4066Sahrens 57fa9e4066Sahrens static int zpool_do_list(int, char **); 58fa9e4066Sahrens static int zpool_do_iostat(int, char **); 59fa9e4066Sahrens static int zpool_do_status(int, char **); 60fa9e4066Sahrens 61fa9e4066Sahrens static int zpool_do_online(int, char **); 62fa9e4066Sahrens static int zpool_do_offline(int, char **); 63ea8dc4b6Seschrock static int zpool_do_clear(int, char **); 64fa9e4066Sahrens 65fa9e4066Sahrens static int zpool_do_attach(int, char **); 66fa9e4066Sahrens static int zpool_do_detach(int, char **); 67fa9e4066Sahrens static int zpool_do_replace(int, char **); 68fa9e4066Sahrens 69fa9e4066Sahrens static int zpool_do_scrub(int, char **); 70fa9e4066Sahrens 71fa9e4066Sahrens static int zpool_do_import(int, char **); 72fa9e4066Sahrens static int zpool_do_export(int, char **); 73fa9e4066Sahrens 74eaca9bbdSeschrock static int zpool_do_upgrade(int, char **); 75eaca9bbdSeschrock 76fa9e4066Sahrens /* 77fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 78fa9e4066Sahrens * debugging facilities. 79fa9e4066Sahrens */ 80fa9e4066Sahrens const char * 8199653d4eSeschrock _umem_debug_init(void) 82fa9e4066Sahrens { 83fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 84fa9e4066Sahrens } 85fa9e4066Sahrens 86fa9e4066Sahrens const char * 87fa9e4066Sahrens _umem_logging_init(void) 88fa9e4066Sahrens { 89fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 90fa9e4066Sahrens } 91fa9e4066Sahrens 9265cd9f28Seschrock typedef enum { 9365cd9f28Seschrock HELP_ADD, 9465cd9f28Seschrock HELP_ATTACH, 95ea8dc4b6Seschrock HELP_CLEAR, 9665cd9f28Seschrock HELP_CREATE, 9765cd9f28Seschrock HELP_DESTROY, 9865cd9f28Seschrock HELP_DETACH, 9965cd9f28Seschrock HELP_EXPORT, 10065cd9f28Seschrock HELP_IMPORT, 10165cd9f28Seschrock HELP_IOSTAT, 10265cd9f28Seschrock HELP_LIST, 10365cd9f28Seschrock HELP_OFFLINE, 10465cd9f28Seschrock HELP_ONLINE, 10565cd9f28Seschrock HELP_REPLACE, 10699653d4eSeschrock HELP_REMOVE, 10765cd9f28Seschrock HELP_SCRUB, 108eaca9bbdSeschrock HELP_STATUS, 109eaca9bbdSeschrock HELP_UPGRADE 11065cd9f28Seschrock } zpool_help_t; 11165cd9f28Seschrock 11265cd9f28Seschrock 113fa9e4066Sahrens typedef struct zpool_command { 114fa9e4066Sahrens const char *name; 115fa9e4066Sahrens int (*func)(int, char **); 11665cd9f28Seschrock zpool_help_t usage; 117fa9e4066Sahrens } zpool_command_t; 118fa9e4066Sahrens 119fa9e4066Sahrens /* 120fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and 121ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have 122ea8dc4b6Seschrock * to have a function to return the usage message based on a command index. 12365cd9f28Seschrock * 12465cd9f28Seschrock * These commands are organized according to how they are displayed in the usage 12565cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in 12665cd9f28Seschrock * the generic usage message. 127fa9e4066Sahrens */ 128fa9e4066Sahrens static zpool_command_t command_table[] = { 12965cd9f28Seschrock { "create", zpool_do_create, HELP_CREATE }, 13065cd9f28Seschrock { "destroy", zpool_do_destroy, HELP_DESTROY }, 131fa9e4066Sahrens { NULL }, 13265cd9f28Seschrock { "add", zpool_do_add, HELP_ADD }, 13399653d4eSeschrock { "remove", zpool_do_remove, HELP_REMOVE }, 134fa9e4066Sahrens { NULL }, 13565cd9f28Seschrock { "list", zpool_do_list, HELP_LIST }, 13665cd9f28Seschrock { "iostat", zpool_do_iostat, HELP_IOSTAT }, 13765cd9f28Seschrock { "status", zpool_do_status, HELP_STATUS }, 138fa9e4066Sahrens { NULL }, 13965cd9f28Seschrock { "online", zpool_do_online, HELP_ONLINE }, 14065cd9f28Seschrock { "offline", zpool_do_offline, HELP_OFFLINE }, 141ea8dc4b6Seschrock { "clear", zpool_do_clear, HELP_CLEAR }, 142fa9e4066Sahrens { NULL }, 14365cd9f28Seschrock { "attach", zpool_do_attach, HELP_ATTACH }, 14465cd9f28Seschrock { "detach", zpool_do_detach, HELP_DETACH }, 14565cd9f28Seschrock { "replace", zpool_do_replace, HELP_REPLACE }, 146fa9e4066Sahrens { NULL }, 14765cd9f28Seschrock { "scrub", zpool_do_scrub, HELP_SCRUB }, 148fa9e4066Sahrens { NULL }, 14965cd9f28Seschrock { "import", zpool_do_import, HELP_IMPORT }, 15065cd9f28Seschrock { "export", zpool_do_export, HELP_EXPORT }, 151eaca9bbdSeschrock { "upgrade", zpool_do_upgrade, HELP_UPGRADE } 152fa9e4066Sahrens }; 153fa9e4066Sahrens 154fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0])) 155fa9e4066Sahrens 156fa9e4066Sahrens zpool_command_t *current_command; 157fa9e4066Sahrens 15865cd9f28Seschrock static const char * 15965cd9f28Seschrock get_usage(zpool_help_t idx) { 16065cd9f28Seschrock switch (idx) { 16165cd9f28Seschrock case HELP_ADD: 16265cd9f28Seschrock return (gettext("\tadd [-fn] <pool> <vdev> ...\n")); 16365cd9f28Seschrock case HELP_ATTACH: 16465cd9f28Seschrock return (gettext("\tattach [-f] <pool> <device> " 16565cd9f28Seschrock "<new_device>\n")); 166ea8dc4b6Seschrock case HELP_CLEAR: 167ea8dc4b6Seschrock return (gettext("\tclear <pool> [device]\n")); 16865cd9f28Seschrock case HELP_CREATE: 16965cd9f28Seschrock return (gettext("\tcreate [-fn] [-R root] [-m mountpoint] " 17065cd9f28Seschrock "<pool> <vdev> ...\n")); 17165cd9f28Seschrock case HELP_DESTROY: 17265cd9f28Seschrock return (gettext("\tdestroy [-f] <pool>\n")); 17365cd9f28Seschrock case HELP_DETACH: 17465cd9f28Seschrock return (gettext("\tdetach <pool> <device>\n")); 17565cd9f28Seschrock case HELP_EXPORT: 17665cd9f28Seschrock return (gettext("\texport [-f] <pool> ...\n")); 17765cd9f28Seschrock case HELP_IMPORT: 1784c58d714Sdarrenm return (gettext("\timport [-d dir] [-D]\n" 1794c58d714Sdarrenm "\timport [-d dir] [-D] [-f] [-o opts] [-R root] -a\n" 1804c58d714Sdarrenm "\timport [-d dir] [-D] [-f] [-o opts] [-R root ]" 1814c58d714Sdarrenm " <pool | id> [newpool]\n")); 18265cd9f28Seschrock case HELP_IOSTAT: 18365cd9f28Seschrock return (gettext("\tiostat [-v] [pool] ... [interval " 18465cd9f28Seschrock "[count]]\n")); 18565cd9f28Seschrock case HELP_LIST: 18665cd9f28Seschrock return (gettext("\tlist [-H] [-o field[,field]*] " 18765cd9f28Seschrock "[pool] ...\n")); 18865cd9f28Seschrock case HELP_OFFLINE: 189441d80aaSlling return (gettext("\toffline [-t] <pool> <device> ...\n")); 19065cd9f28Seschrock case HELP_ONLINE: 191441d80aaSlling return (gettext("\tonline <pool> <device> ...\n")); 19265cd9f28Seschrock case HELP_REPLACE: 19365cd9f28Seschrock return (gettext("\treplace [-f] <pool> <device> " 19465cd9f28Seschrock "[new_device]\n")); 19599653d4eSeschrock case HELP_REMOVE: 19699653d4eSeschrock return (gettext("\tremove <pool> <device>\n")); 19765cd9f28Seschrock case HELP_SCRUB: 19865cd9f28Seschrock return (gettext("\tscrub [-s] <pool> ...\n")); 19965cd9f28Seschrock case HELP_STATUS: 20065cd9f28Seschrock return (gettext("\tstatus [-vx] [pool] ...\n")); 201eaca9bbdSeschrock case HELP_UPGRADE: 202eaca9bbdSeschrock return (gettext("\tupgrade\n" 203eaca9bbdSeschrock "\tupgrade -v\n" 204eaca9bbdSeschrock "\tupgrade <-a | pool>\n")); 20565cd9f28Seschrock } 20665cd9f28Seschrock 20765cd9f28Seschrock abort(); 20865cd9f28Seschrock /* NOTREACHED */ 20965cd9f28Seschrock } 21065cd9f28Seschrock 211fa9e4066Sahrens /* 212fa9e4066Sahrens * Fields available for 'zpool list'. 213fa9e4066Sahrens */ 214fa9e4066Sahrens typedef enum { 215fa9e4066Sahrens ZPOOL_FIELD_NAME, 216fa9e4066Sahrens ZPOOL_FIELD_SIZE, 217fa9e4066Sahrens ZPOOL_FIELD_USED, 218fa9e4066Sahrens ZPOOL_FIELD_AVAILABLE, 219fa9e4066Sahrens ZPOOL_FIELD_CAPACITY, 220fa9e4066Sahrens ZPOOL_FIELD_HEALTH, 221fa9e4066Sahrens ZPOOL_FIELD_ROOT 222fa9e4066Sahrens } zpool_field_t; 223fa9e4066Sahrens 224fa9e4066Sahrens #define MAX_FIELDS 10 225fa9e4066Sahrens 226fa9e4066Sahrens typedef struct column_def { 227fa9e4066Sahrens const char *cd_title; 228fa9e4066Sahrens size_t cd_width; 229fa9e4066Sahrens enum { 230fa9e4066Sahrens left_justify, 231fa9e4066Sahrens right_justify 232fa9e4066Sahrens } cd_justify; 233fa9e4066Sahrens } column_def_t; 234fa9e4066Sahrens 235fa9e4066Sahrens static column_def_t column_table[] = { 236fa9e4066Sahrens { "NAME", 20, left_justify }, 237fa9e4066Sahrens { "SIZE", 6, right_justify }, 238fa9e4066Sahrens { "USED", 6, right_justify }, 239fa9e4066Sahrens { "AVAIL", 6, right_justify }, 240fa9e4066Sahrens { "CAP", 5, right_justify }, 241fa9e4066Sahrens { "HEALTH", 9, left_justify }, 242fa9e4066Sahrens { "ALTROOT", 15, left_justify } 243fa9e4066Sahrens }; 244fa9e4066Sahrens 245fa9e4066Sahrens static char *column_subopts[] = { 246fa9e4066Sahrens "name", 247fa9e4066Sahrens "size", 248fa9e4066Sahrens "used", 249fa9e4066Sahrens "available", 250fa9e4066Sahrens "capacity", 251fa9e4066Sahrens "health", 252fa9e4066Sahrens "root", 253fa9e4066Sahrens NULL 254fa9e4066Sahrens }; 255fa9e4066Sahrens 256fa9e4066Sahrens /* 257fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 258fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 259fa9e4066Sahrens * a complete usage message. 260fa9e4066Sahrens */ 261fa9e4066Sahrens void 26299653d4eSeschrock usage(boolean_t requested) 263fa9e4066Sahrens { 264fa9e4066Sahrens int i; 265fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 266fa9e4066Sahrens 267fa9e4066Sahrens if (current_command == NULL) { 268fa9e4066Sahrens int i; 269fa9e4066Sahrens 270fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zpool command args ...\n")); 271fa9e4066Sahrens (void) fprintf(fp, 272fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 273fa9e4066Sahrens 274fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 275fa9e4066Sahrens if (command_table[i].name == NULL) 276fa9e4066Sahrens (void) fprintf(fp, "\n"); 277fa9e4066Sahrens else 278fa9e4066Sahrens (void) fprintf(fp, "%s", 27965cd9f28Seschrock get_usage(command_table[i].usage)); 280fa9e4066Sahrens } 281fa9e4066Sahrens } else { 282fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 28365cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 284fa9e4066Sahrens 285fa9e4066Sahrens if (strcmp(current_command->name, "list") == 0) { 286fa9e4066Sahrens (void) fprintf(fp, gettext("\nwhere 'field' is one " 287fa9e4066Sahrens "of the following:\n\n")); 288fa9e4066Sahrens 289fa9e4066Sahrens for (i = 0; column_subopts[i] != NULL; i++) 290fa9e4066Sahrens (void) fprintf(fp, "\t%s\n", column_subopts[i]); 291fa9e4066Sahrens } 292fa9e4066Sahrens } 293fa9e4066Sahrens 294*e9dbad6fSeschrock /* 295*e9dbad6fSeschrock * See comments at end of main(). 296*e9dbad6fSeschrock */ 297*e9dbad6fSeschrock if (getenv("ZFS_ABORT") != NULL) { 298*e9dbad6fSeschrock (void) printf("dumping core by request\n"); 299*e9dbad6fSeschrock abort(); 300*e9dbad6fSeschrock } 301*e9dbad6fSeschrock 302fa9e4066Sahrens exit(requested ? 0 : 2); 303fa9e4066Sahrens } 304fa9e4066Sahrens 305fa9e4066Sahrens const char * 306ea8dc4b6Seschrock state_to_name(vdev_stat_t *vs) 307fa9e4066Sahrens { 308ea8dc4b6Seschrock switch (vs->vs_state) { 309fa9e4066Sahrens case VDEV_STATE_CLOSED: 310fa9e4066Sahrens case VDEV_STATE_CANT_OPEN: 311ea8dc4b6Seschrock if (vs->vs_aux == VDEV_AUX_CORRUPT_DATA) 312ea8dc4b6Seschrock return (gettext("FAULTED")); 313ea8dc4b6Seschrock else 314ea8dc4b6Seschrock return (gettext("UNAVAIL")); 315fa9e4066Sahrens case VDEV_STATE_OFFLINE: 316fa9e4066Sahrens return (gettext("OFFLINE")); 317fa9e4066Sahrens case VDEV_STATE_DEGRADED: 318fa9e4066Sahrens return (gettext("DEGRADED")); 319fa9e4066Sahrens case VDEV_STATE_HEALTHY: 320fa9e4066Sahrens return (gettext("ONLINE")); 321fa9e4066Sahrens } 322fa9e4066Sahrens 323fa9e4066Sahrens return (gettext("UNKNOWN")); 324fa9e4066Sahrens } 325fa9e4066Sahrens 326fa9e4066Sahrens void 327c67d9675Seschrock print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent) 328fa9e4066Sahrens { 329fa9e4066Sahrens nvlist_t **child; 330fa9e4066Sahrens uint_t c, children; 331afefbcddSeschrock char *vname; 332fa9e4066Sahrens 333fa9e4066Sahrens if (name != NULL) 334fa9e4066Sahrens (void) printf("\t%*s%s\n", indent, "", name); 335fa9e4066Sahrens 336fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 337fa9e4066Sahrens &child, &children) != 0) 338fa9e4066Sahrens return; 339fa9e4066Sahrens 340afefbcddSeschrock for (c = 0; c < children; c++) { 34199653d4eSeschrock vname = zpool_vdev_name(g_zfs, zhp, child[c]); 342c67d9675Seschrock print_vdev_tree(zhp, vname, child[c], indent + 2); 343afefbcddSeschrock free(vname); 344afefbcddSeschrock } 345fa9e4066Sahrens } 346fa9e4066Sahrens 347fa9e4066Sahrens /* 348fa9e4066Sahrens * zpool add [-fn] <pool> <vdev> ... 349fa9e4066Sahrens * 350fa9e4066Sahrens * -f Force addition of devices, even if they appear in use 351fa9e4066Sahrens * -n Do not add the devices, but display the resulting layout if 352fa9e4066Sahrens * they were to be added. 353fa9e4066Sahrens * 354fa9e4066Sahrens * Adds the given vdevs to 'pool'. As with create, the bulk of this work is 355fa9e4066Sahrens * handled by get_vdev_spec(), which constructs the nvlist needed to pass to 356fa9e4066Sahrens * libzfs. 357fa9e4066Sahrens */ 358fa9e4066Sahrens int 359fa9e4066Sahrens zpool_do_add(int argc, char **argv) 360fa9e4066Sahrens { 36199653d4eSeschrock boolean_t force = B_FALSE; 36299653d4eSeschrock boolean_t dryrun = B_FALSE; 363fa9e4066Sahrens int c; 364fa9e4066Sahrens nvlist_t *nvroot; 365fa9e4066Sahrens char *poolname; 366fa9e4066Sahrens int ret; 367fa9e4066Sahrens zpool_handle_t *zhp; 368fa9e4066Sahrens nvlist_t *config; 369fa9e4066Sahrens 370fa9e4066Sahrens /* check options */ 371fa9e4066Sahrens while ((c = getopt(argc, argv, "fn")) != -1) { 372fa9e4066Sahrens switch (c) { 373fa9e4066Sahrens case 'f': 37499653d4eSeschrock force = B_TRUE; 375fa9e4066Sahrens break; 376fa9e4066Sahrens case 'n': 37799653d4eSeschrock dryrun = B_TRUE; 378fa9e4066Sahrens break; 379fa9e4066Sahrens case '?': 380fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 381fa9e4066Sahrens optopt); 38299653d4eSeschrock usage(B_FALSE); 383fa9e4066Sahrens } 384fa9e4066Sahrens } 385fa9e4066Sahrens 386fa9e4066Sahrens argc -= optind; 387fa9e4066Sahrens argv += optind; 388fa9e4066Sahrens 389fa9e4066Sahrens /* get pool name and check number of arguments */ 390fa9e4066Sahrens if (argc < 1) { 391fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 39299653d4eSeschrock usage(B_FALSE); 393fa9e4066Sahrens } 394fa9e4066Sahrens if (argc < 2) { 395fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 39699653d4eSeschrock usage(B_FALSE); 397fa9e4066Sahrens } 398fa9e4066Sahrens 399fa9e4066Sahrens poolname = argv[0]; 400fa9e4066Sahrens 401fa9e4066Sahrens argc--; 402fa9e4066Sahrens argv++; 403fa9e4066Sahrens 40499653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 405fa9e4066Sahrens return (1); 406fa9e4066Sahrens 407088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 408fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 409fa9e4066Sahrens poolname); 410fa9e4066Sahrens zpool_close(zhp); 411fa9e4066Sahrens return (1); 412fa9e4066Sahrens } 413fa9e4066Sahrens 414fa9e4066Sahrens /* pass off to get_vdev_spec for processing */ 41599653d4eSeschrock nvroot = make_root_vdev(config, force, !force, B_FALSE, argc, argv); 416fa9e4066Sahrens if (nvroot == NULL) { 417fa9e4066Sahrens zpool_close(zhp); 418fa9e4066Sahrens return (1); 419fa9e4066Sahrens } 420fa9e4066Sahrens 421fa9e4066Sahrens if (dryrun) { 422fa9e4066Sahrens nvlist_t *poolnvroot; 423fa9e4066Sahrens 424fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 425fa9e4066Sahrens &poolnvroot) == 0); 426fa9e4066Sahrens 427fa9e4066Sahrens (void) printf(gettext("would update '%s' to the following " 428fa9e4066Sahrens "configuration:\n"), zpool_get_name(zhp)); 429fa9e4066Sahrens 430c67d9675Seschrock print_vdev_tree(zhp, poolname, poolnvroot, 0); 431c67d9675Seschrock print_vdev_tree(zhp, NULL, nvroot, 0); 432fa9e4066Sahrens 433fa9e4066Sahrens ret = 0; 434fa9e4066Sahrens } else { 435fa9e4066Sahrens ret = (zpool_add(zhp, nvroot) != 0); 436fa9e4066Sahrens } 437fa9e4066Sahrens 43899653d4eSeschrock nvlist_free(nvroot); 43999653d4eSeschrock zpool_close(zhp); 44099653d4eSeschrock 44199653d4eSeschrock return (ret); 44299653d4eSeschrock } 44399653d4eSeschrock 44499653d4eSeschrock /* 44599653d4eSeschrock * zpool remove <pool> <vdev> 44699653d4eSeschrock * 44799653d4eSeschrock * Removes the given vdev from the pool. Currently, this only supports removing 44899653d4eSeschrock * spares from the pool. Eventually, we'll want to support removing leaf vdevs 44999653d4eSeschrock * (as an alias for 'detach') as well as toplevel vdevs. 45099653d4eSeschrock */ 45199653d4eSeschrock int 45299653d4eSeschrock zpool_do_remove(int argc, char **argv) 45399653d4eSeschrock { 45499653d4eSeschrock char *poolname; 45599653d4eSeschrock int ret; 45699653d4eSeschrock zpool_handle_t *zhp; 45799653d4eSeschrock 45899653d4eSeschrock argc--; 45999653d4eSeschrock argv++; 46099653d4eSeschrock 46199653d4eSeschrock /* get pool name and check number of arguments */ 46299653d4eSeschrock if (argc < 1) { 46399653d4eSeschrock (void) fprintf(stderr, gettext("missing pool name argument\n")); 46499653d4eSeschrock usage(B_FALSE); 46599653d4eSeschrock } 46699653d4eSeschrock if (argc < 2) { 46799653d4eSeschrock (void) fprintf(stderr, gettext("missing device\n")); 46899653d4eSeschrock usage(B_FALSE); 46999653d4eSeschrock } 47099653d4eSeschrock 47199653d4eSeschrock poolname = argv[0]; 47299653d4eSeschrock 47399653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 47499653d4eSeschrock return (1); 47599653d4eSeschrock 47699653d4eSeschrock ret = (zpool_vdev_remove(zhp, argv[1]) != 0); 47799653d4eSeschrock 478fa9e4066Sahrens return (ret); 479fa9e4066Sahrens } 480fa9e4066Sahrens 481fa9e4066Sahrens /* 482fa9e4066Sahrens * zpool create [-fn] [-R root] [-m mountpoint] <pool> <dev> ... 483fa9e4066Sahrens * 484fa9e4066Sahrens * -f Force creation, even if devices appear in use 485fa9e4066Sahrens * -n Do not create the pool, but display the resulting layout if it 486fa9e4066Sahrens * were to be created. 487fa9e4066Sahrens * -R Create a pool under an alternate root 488fa9e4066Sahrens * -m Set default mountpoint for the root dataset. By default it's 489fa9e4066Sahrens * '/<pool>' 490fa9e4066Sahrens * 491fa9e4066Sahrens * Creates the the named pool according to the given vdev specification. The 492fa9e4066Sahrens * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once 493fa9e4066Sahrens * we get the nvlist back from get_vdev_spec(), we either print out the contents 494fa9e4066Sahrens * (if '-n' was specified), or pass it to libzfs to do the creation. 495fa9e4066Sahrens */ 496fa9e4066Sahrens int 497fa9e4066Sahrens zpool_do_create(int argc, char **argv) 498fa9e4066Sahrens { 49999653d4eSeschrock boolean_t force = B_FALSE; 50099653d4eSeschrock boolean_t dryrun = B_FALSE; 501fa9e4066Sahrens int c; 502fa9e4066Sahrens nvlist_t *nvroot; 503fa9e4066Sahrens char *poolname; 504fa9e4066Sahrens int ret; 505fa9e4066Sahrens char *altroot = NULL; 506fa9e4066Sahrens char *mountpoint = NULL; 50799653d4eSeschrock nvlist_t **child; 50899653d4eSeschrock uint_t children; 509fa9e4066Sahrens 510fa9e4066Sahrens /* check options */ 511fa9e4066Sahrens while ((c = getopt(argc, argv, ":fnR:m:")) != -1) { 512fa9e4066Sahrens switch (c) { 513fa9e4066Sahrens case 'f': 51499653d4eSeschrock force = B_TRUE; 515fa9e4066Sahrens break; 516fa9e4066Sahrens case 'n': 51799653d4eSeschrock dryrun = B_TRUE; 518fa9e4066Sahrens break; 519fa9e4066Sahrens case 'R': 520fa9e4066Sahrens altroot = optarg; 521fa9e4066Sahrens break; 522fa9e4066Sahrens case 'm': 523fa9e4066Sahrens mountpoint = optarg; 524fa9e4066Sahrens break; 525fa9e4066Sahrens case ':': 526fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 527fa9e4066Sahrens "'%c' option\n"), optopt); 52899653d4eSeschrock usage(B_FALSE); 529fa9e4066Sahrens break; 530fa9e4066Sahrens case '?': 531fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 532fa9e4066Sahrens optopt); 53399653d4eSeschrock usage(B_FALSE); 534fa9e4066Sahrens } 535fa9e4066Sahrens } 536fa9e4066Sahrens 537fa9e4066Sahrens argc -= optind; 538fa9e4066Sahrens argv += optind; 539fa9e4066Sahrens 540fa9e4066Sahrens /* get pool name and check number of arguments */ 541fa9e4066Sahrens if (argc < 1) { 542fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 54399653d4eSeschrock usage(B_FALSE); 544fa9e4066Sahrens } 545fa9e4066Sahrens if (argc < 2) { 546fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 54799653d4eSeschrock usage(B_FALSE); 548fa9e4066Sahrens } 549fa9e4066Sahrens 550fa9e4066Sahrens poolname = argv[0]; 551fa9e4066Sahrens 552fa9e4066Sahrens /* 553fa9e4066Sahrens * As a special case, check for use of '/' in the name, and direct the 554fa9e4066Sahrens * user to use 'zfs create' instead. 555fa9e4066Sahrens */ 556fa9e4066Sahrens if (strchr(poolname, '/') != NULL) { 557fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot create '%s': invalid " 558fa9e4066Sahrens "character '/' in pool name\n"), poolname); 559fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs create' to " 560fa9e4066Sahrens "create a dataset\n")); 561fa9e4066Sahrens return (1); 562fa9e4066Sahrens } 563fa9e4066Sahrens 564fa9e4066Sahrens /* pass off to get_vdev_spec for bulk processing */ 56599653d4eSeschrock nvroot = make_root_vdev(NULL, force, !force, B_FALSE, argc - 1, 56699653d4eSeschrock argv + 1); 567fa9e4066Sahrens if (nvroot == NULL) 568fa9e4066Sahrens return (1); 569fa9e4066Sahrens 57099653d4eSeschrock /* make_root_vdev() allows 0 toplevel children if there are spares */ 57199653d4eSeschrock verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 57299653d4eSeschrock &child, &children) == 0); 57399653d4eSeschrock if (children == 0) { 57499653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev " 57599653d4eSeschrock "specification: at least one toplevel vdev must be " 57699653d4eSeschrock "specified\n")); 57799653d4eSeschrock return (1); 57899653d4eSeschrock } 57999653d4eSeschrock 58099653d4eSeschrock 581fa9e4066Sahrens if (altroot != NULL && altroot[0] != '/') { 582fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid alternate root '%s': " 583*e9dbad6fSeschrock "must be an absolute path\n"), altroot); 58499653d4eSeschrock nvlist_free(nvroot); 585fa9e4066Sahrens return (1); 586fa9e4066Sahrens } 587fa9e4066Sahrens 588fa9e4066Sahrens /* 589fa9e4066Sahrens * Check the validity of the mountpoint and direct the user to use the 590fa9e4066Sahrens * '-m' mountpoint option if it looks like its in use. 591fa9e4066Sahrens */ 592fa9e4066Sahrens if (mountpoint == NULL || 593fa9e4066Sahrens (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 && 594fa9e4066Sahrens strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) { 595fa9e4066Sahrens char buf[MAXPATHLEN]; 596fa9e4066Sahrens struct stat64 statbuf; 597fa9e4066Sahrens 598fa9e4066Sahrens if (mountpoint && mountpoint[0] != '/') { 599fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid mountpoint " 600fa9e4066Sahrens "'%s': must be an absolute path, 'legacy', or " 601fa9e4066Sahrens "'none'\n"), mountpoint); 60299653d4eSeschrock nvlist_free(nvroot); 603fa9e4066Sahrens return (1); 604fa9e4066Sahrens } 605fa9e4066Sahrens 606fa9e4066Sahrens if (mountpoint == NULL) { 607fa9e4066Sahrens if (altroot != NULL) 608fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s/%s", 609fa9e4066Sahrens altroot, poolname); 610fa9e4066Sahrens else 611fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "/%s", 612fa9e4066Sahrens poolname); 613fa9e4066Sahrens } else { 614fa9e4066Sahrens if (altroot != NULL) 615fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s%s", 616fa9e4066Sahrens altroot, mountpoint); 617fa9e4066Sahrens else 618fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s", 619fa9e4066Sahrens mountpoint); 620fa9e4066Sahrens } 621fa9e4066Sahrens 622fa9e4066Sahrens if (stat64(buf, &statbuf) == 0 && 623fa9e4066Sahrens statbuf.st_nlink != 2) { 624fa9e4066Sahrens if (mountpoint == NULL) 625fa9e4066Sahrens (void) fprintf(stderr, gettext("default " 626fa9e4066Sahrens "mountpoint '%s' exists and is not " 627fa9e4066Sahrens "empty\n"), buf); 628fa9e4066Sahrens else 629fa9e4066Sahrens (void) fprintf(stderr, gettext("mountpoint " 630fa9e4066Sahrens "'%s' exists and is not empty\n"), buf); 631fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-m' " 632fa9e4066Sahrens "option to provide a different default\n")); 63399653d4eSeschrock nvlist_free(nvroot); 634fa9e4066Sahrens return (1); 635fa9e4066Sahrens } 636fa9e4066Sahrens } 637fa9e4066Sahrens 638fa9e4066Sahrens 639fa9e4066Sahrens if (dryrun) { 640fa9e4066Sahrens /* 641fa9e4066Sahrens * For a dry run invocation, print out a basic message and run 642fa9e4066Sahrens * through all the vdevs in the list and print out in an 643fa9e4066Sahrens * appropriate hierarchy. 644fa9e4066Sahrens */ 645fa9e4066Sahrens (void) printf(gettext("would create '%s' with the " 646fa9e4066Sahrens "following layout:\n\n"), poolname); 647fa9e4066Sahrens 648c67d9675Seschrock print_vdev_tree(NULL, poolname, nvroot, 0); 649fa9e4066Sahrens 650fa9e4066Sahrens ret = 0; 651fa9e4066Sahrens } else { 652fa9e4066Sahrens ret = 1; 653fa9e4066Sahrens /* 654fa9e4066Sahrens * Hand off to libzfs. 655fa9e4066Sahrens */ 65699653d4eSeschrock if (zpool_create(g_zfs, poolname, nvroot, altroot) == 0) { 65799653d4eSeschrock zfs_handle_t *pool = zfs_open(g_zfs, poolname, 658fa9e4066Sahrens ZFS_TYPE_FILESYSTEM); 659fa9e4066Sahrens if (pool != NULL) { 660fa9e4066Sahrens if (mountpoint != NULL) 661fa9e4066Sahrens verify(zfs_prop_set(pool, 662*e9dbad6fSeschrock zfs_prop_to_name( 663*e9dbad6fSeschrock ZFS_PROP_MOUNTPOINT), 664fa9e4066Sahrens mountpoint) == 0); 665fa9e4066Sahrens if (zfs_mount(pool, NULL, 0) == 0) 666fa9e4066Sahrens ret = zfs_share(pool); 667fa9e4066Sahrens zfs_close(pool); 668fa9e4066Sahrens } 66999653d4eSeschrock } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) { 67099653d4eSeschrock (void) fprintf(stderr, gettext("pool name may have " 67199653d4eSeschrock "been omitted\n")); 672fa9e4066Sahrens } 673fa9e4066Sahrens } 674fa9e4066Sahrens 675fa9e4066Sahrens nvlist_free(nvroot); 676fa9e4066Sahrens 677fa9e4066Sahrens return (ret); 678fa9e4066Sahrens } 679fa9e4066Sahrens 680fa9e4066Sahrens /* 681fa9e4066Sahrens * zpool destroy <pool> 682fa9e4066Sahrens * 683fa9e4066Sahrens * -f Forcefully unmount any datasets 684fa9e4066Sahrens * 685fa9e4066Sahrens * Destroy the given pool. Automatically unmounts any datasets in the pool. 686fa9e4066Sahrens */ 687fa9e4066Sahrens int 688fa9e4066Sahrens zpool_do_destroy(int argc, char **argv) 689fa9e4066Sahrens { 69099653d4eSeschrock boolean_t force = B_FALSE; 691fa9e4066Sahrens int c; 692fa9e4066Sahrens char *pool; 693fa9e4066Sahrens zpool_handle_t *zhp; 694fa9e4066Sahrens int ret; 695fa9e4066Sahrens 696fa9e4066Sahrens /* check options */ 697fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 698fa9e4066Sahrens switch (c) { 699fa9e4066Sahrens case 'f': 70099653d4eSeschrock force = B_TRUE; 701fa9e4066Sahrens break; 702fa9e4066Sahrens case '?': 703fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 704fa9e4066Sahrens optopt); 70599653d4eSeschrock usage(B_FALSE); 706fa9e4066Sahrens } 707fa9e4066Sahrens } 708fa9e4066Sahrens 709fa9e4066Sahrens argc -= optind; 710fa9e4066Sahrens argv += optind; 711fa9e4066Sahrens 712fa9e4066Sahrens /* check arguments */ 713fa9e4066Sahrens if (argc < 1) { 714fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 71599653d4eSeschrock usage(B_FALSE); 716fa9e4066Sahrens } 717fa9e4066Sahrens if (argc > 1) { 718fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 71999653d4eSeschrock usage(B_FALSE); 720fa9e4066Sahrens } 721fa9e4066Sahrens 722fa9e4066Sahrens pool = argv[0]; 723fa9e4066Sahrens 72499653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 725fa9e4066Sahrens /* 726fa9e4066Sahrens * As a special case, check for use of '/' in the name, and 727fa9e4066Sahrens * direct the user to use 'zfs destroy' instead. 728fa9e4066Sahrens */ 729fa9e4066Sahrens if (strchr(pool, '/') != NULL) 730fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy' to " 731fa9e4066Sahrens "destroy a dataset\n")); 732fa9e4066Sahrens return (1); 733fa9e4066Sahrens } 734fa9e4066Sahrens 7353bb79becSeschrock if (zpool_unmount_datasets(zhp, force) != 0) { 736fa9e4066Sahrens (void) fprintf(stderr, gettext("could not destroy '%s': " 737fa9e4066Sahrens "could not unmount datasets\n"), zpool_get_name(zhp)); 738fa9e4066Sahrens return (1); 739fa9e4066Sahrens } 740fa9e4066Sahrens 741fa9e4066Sahrens ret = (zpool_destroy(zhp) != 0); 742fa9e4066Sahrens 743fa9e4066Sahrens zpool_close(zhp); 744fa9e4066Sahrens 745fa9e4066Sahrens return (ret); 746fa9e4066Sahrens } 747fa9e4066Sahrens 748fa9e4066Sahrens /* 749fa9e4066Sahrens * zpool export [-f] <pool> ... 750fa9e4066Sahrens * 751fa9e4066Sahrens * -f Forcefully unmount datasets 752fa9e4066Sahrens * 753fa9e4066Sahrens * Export the the given pools. By default, the command will attempt to cleanly 754fa9e4066Sahrens * unmount any active datasets within the pool. If the '-f' flag is specified, 755fa9e4066Sahrens * then the datasets will be forcefully unmounted. 756fa9e4066Sahrens */ 757fa9e4066Sahrens int 758fa9e4066Sahrens zpool_do_export(int argc, char **argv) 759fa9e4066Sahrens { 76099653d4eSeschrock boolean_t force = B_FALSE; 761fa9e4066Sahrens int c; 762fa9e4066Sahrens zpool_handle_t *zhp; 763fa9e4066Sahrens int ret; 764fa9e4066Sahrens int i; 765fa9e4066Sahrens 766fa9e4066Sahrens /* check options */ 767fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 768fa9e4066Sahrens switch (c) { 769fa9e4066Sahrens case 'f': 77099653d4eSeschrock force = B_TRUE; 771fa9e4066Sahrens break; 772fa9e4066Sahrens case '?': 773fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 774fa9e4066Sahrens optopt); 77599653d4eSeschrock usage(B_FALSE); 776fa9e4066Sahrens } 777fa9e4066Sahrens } 778fa9e4066Sahrens 779fa9e4066Sahrens argc -= optind; 780fa9e4066Sahrens argv += optind; 781fa9e4066Sahrens 782fa9e4066Sahrens /* check arguments */ 783fa9e4066Sahrens if (argc < 1) { 784fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 78599653d4eSeschrock usage(B_FALSE); 786fa9e4066Sahrens } 787fa9e4066Sahrens 788fa9e4066Sahrens ret = 0; 789fa9e4066Sahrens for (i = 0; i < argc; i++) { 79099653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, argv[i])) == NULL) { 791fa9e4066Sahrens ret = 1; 792fa9e4066Sahrens continue; 793fa9e4066Sahrens } 794fa9e4066Sahrens 7953bb79becSeschrock if (zpool_unmount_datasets(zhp, force) != 0) { 796fa9e4066Sahrens ret = 1; 797fa9e4066Sahrens zpool_close(zhp); 798fa9e4066Sahrens continue; 799fa9e4066Sahrens } 800fa9e4066Sahrens 801fa9e4066Sahrens if (zpool_export(zhp) != 0) 802fa9e4066Sahrens ret = 1; 803fa9e4066Sahrens 804fa9e4066Sahrens zpool_close(zhp); 805fa9e4066Sahrens } 806fa9e4066Sahrens 807fa9e4066Sahrens return (ret); 808fa9e4066Sahrens } 809fa9e4066Sahrens 810fa9e4066Sahrens /* 811fa9e4066Sahrens * Given a vdev configuration, determine the maximum width needed for the device 812fa9e4066Sahrens * name column. 813fa9e4066Sahrens */ 814fa9e4066Sahrens static int 815c67d9675Seschrock max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max) 816fa9e4066Sahrens { 81799653d4eSeschrock char *name = zpool_vdev_name(g_zfs, zhp, nv); 818fa9e4066Sahrens nvlist_t **child; 819fa9e4066Sahrens uint_t c, children; 820fa9e4066Sahrens int ret; 821fa9e4066Sahrens 822fa9e4066Sahrens if (strlen(name) + depth > max) 823fa9e4066Sahrens max = strlen(name) + depth; 824fa9e4066Sahrens 825afefbcddSeschrock free(name); 826afefbcddSeschrock 82799653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 82899653d4eSeschrock &child, &children) == 0) { 82999653d4eSeschrock for (c = 0; c < children; c++) 83099653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 83199653d4eSeschrock max)) > max) 83299653d4eSeschrock max = ret; 83399653d4eSeschrock } 83499653d4eSeschrock 835fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 83699653d4eSeschrock &child, &children) == 0) { 83799653d4eSeschrock for (c = 0; c < children; c++) 83899653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 83999653d4eSeschrock max)) > max) 84099653d4eSeschrock max = ret; 84199653d4eSeschrock } 842fa9e4066Sahrens 843fa9e4066Sahrens 844fa9e4066Sahrens return (max); 845fa9e4066Sahrens } 846fa9e4066Sahrens 847fa9e4066Sahrens 848fa9e4066Sahrens /* 849fa9e4066Sahrens * Print the configuration of an exported pool. Iterate over all vdevs in the 850fa9e4066Sahrens * pool, printing out the name and status for each one. 851fa9e4066Sahrens */ 852fa9e4066Sahrens void 853fa9e4066Sahrens print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth) 854fa9e4066Sahrens { 855fa9e4066Sahrens nvlist_t **child; 856fa9e4066Sahrens uint_t c, children; 857fa9e4066Sahrens vdev_stat_t *vs; 858afefbcddSeschrock char *type, *vname; 859fa9e4066Sahrens 860fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 861fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_MISSING) == 0) 862fa9e4066Sahrens return; 863fa9e4066Sahrens 864fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS, 865fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 866fa9e4066Sahrens 867fa9e4066Sahrens (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name); 868fa9e4066Sahrens 869fa9e4066Sahrens if (vs->vs_aux != 0) { 870ea8dc4b6Seschrock (void) printf(" %-8s ", state_to_name(vs)); 871fa9e4066Sahrens 872fa9e4066Sahrens switch (vs->vs_aux) { 873fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 874fa9e4066Sahrens (void) printf(gettext("cannot open")); 875fa9e4066Sahrens break; 876fa9e4066Sahrens 877fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 878fa9e4066Sahrens (void) printf(gettext("missing device")); 879fa9e4066Sahrens break; 880fa9e4066Sahrens 881fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 882fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 883fa9e4066Sahrens break; 884fa9e4066Sahrens 885eaca9bbdSeschrock case VDEV_AUX_VERSION_NEWER: 886eaca9bbdSeschrock (void) printf(gettext("newer version")); 887eaca9bbdSeschrock break; 888eaca9bbdSeschrock 889fa9e4066Sahrens default: 890fa9e4066Sahrens (void) printf(gettext("corrupted data")); 891fa9e4066Sahrens break; 892fa9e4066Sahrens } 893fa9e4066Sahrens } else { 894ea8dc4b6Seschrock (void) printf(" %s", state_to_name(vs)); 895fa9e4066Sahrens } 896fa9e4066Sahrens (void) printf("\n"); 897fa9e4066Sahrens 898fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 899fa9e4066Sahrens &child, &children) != 0) 900fa9e4066Sahrens return; 901fa9e4066Sahrens 902afefbcddSeschrock for (c = 0; c < children; c++) { 90399653d4eSeschrock vname = zpool_vdev_name(g_zfs, NULL, child[c]); 904afefbcddSeschrock print_import_config(vname, child[c], 905fa9e4066Sahrens namewidth, depth + 2); 906afefbcddSeschrock free(vname); 907afefbcddSeschrock } 90899653d4eSeschrock 90999653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 91099653d4eSeschrock &child, &children) != 0) 91199653d4eSeschrock return; 91299653d4eSeschrock 91399653d4eSeschrock (void) printf(gettext("\tspares\n")); 91499653d4eSeschrock for (c = 0; c < children; c++) { 91599653d4eSeschrock vname = zpool_vdev_name(g_zfs, NULL, child[c]); 91699653d4eSeschrock (void) printf("\t %s\n", vname); 91799653d4eSeschrock free(vname); 91899653d4eSeschrock } 919fa9e4066Sahrens } 920fa9e4066Sahrens 921fa9e4066Sahrens /* 922fa9e4066Sahrens * Display the status for the given pool. 923fa9e4066Sahrens */ 924fa9e4066Sahrens static void 925fa9e4066Sahrens show_import(nvlist_t *config) 926fa9e4066Sahrens { 927fa9e4066Sahrens uint64_t pool_state; 928fa9e4066Sahrens vdev_stat_t *vs; 929fa9e4066Sahrens char *name; 930fa9e4066Sahrens uint64_t guid; 931fa9e4066Sahrens char *msgid; 932fa9e4066Sahrens nvlist_t *nvroot; 933fa9e4066Sahrens int reason; 934fa9e4066Sahrens char *health; 935fa9e4066Sahrens uint_t vsc; 936fa9e4066Sahrens int namewidth; 937fa9e4066Sahrens 938fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 939fa9e4066Sahrens &name) == 0); 940fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 941fa9e4066Sahrens &guid) == 0); 942fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 943fa9e4066Sahrens &pool_state) == 0); 944fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_HEALTH, 945fa9e4066Sahrens &health) == 0); 946fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 947fa9e4066Sahrens &nvroot) == 0); 948fa9e4066Sahrens 949fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 950fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 951fa9e4066Sahrens 952fa9e4066Sahrens reason = zpool_import_status(config, &msgid); 953fa9e4066Sahrens 954fa9e4066Sahrens (void) printf(" pool: %s\n", name); 955fa9e4066Sahrens (void) printf(" id: %llu\n", guid); 9564c58d714Sdarrenm (void) printf(" state: %s", health); 9574c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 9584c58d714Sdarrenm (void) printf(" (DESTROYED)"); 9594c58d714Sdarrenm (void) printf("\n"); 960fa9e4066Sahrens 961fa9e4066Sahrens switch (reason) { 962fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 963fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 964fa9e4066Sahrens case ZPOOL_STATUS_BAD_GUID_SUM: 965fa9e4066Sahrens (void) printf(gettext("status: One or more devices are missing " 966fa9e4066Sahrens "from the system.\n")); 967fa9e4066Sahrens break; 968fa9e4066Sahrens 969fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 970fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 971fa9e4066Sahrens (void) printf(gettext("status: One or more devices contains " 972fa9e4066Sahrens "corrupted data.\n")); 973fa9e4066Sahrens break; 974fa9e4066Sahrens 975fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_DATA: 976fa9e4066Sahrens (void) printf(gettext("status: The pool data is corrupted.\n")); 977fa9e4066Sahrens break; 978fa9e4066Sahrens 979441d80aaSlling case ZPOOL_STATUS_OFFLINE_DEV: 980441d80aaSlling (void) printf(gettext("status: One or more devices " 981441d80aaSlling "are offlined.\n")); 982441d80aaSlling break; 983441d80aaSlling 984ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 985ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is " 986ea8dc4b6Seschrock "corrupted.\n")); 987ea8dc4b6Seschrock break; 988ea8dc4b6Seschrock 989eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 990eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 991eaca9bbdSeschrock "older on-disk version.\n")); 992eaca9bbdSeschrock break; 993eaca9bbdSeschrock 994eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 995eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 996eaca9bbdSeschrock "incompatible version.\n")); 997eaca9bbdSeschrock break; 998eaca9bbdSeschrock 999fa9e4066Sahrens default: 1000fa9e4066Sahrens /* 1001fa9e4066Sahrens * No other status can be seen when importing pools. 1002fa9e4066Sahrens */ 1003fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 1004fa9e4066Sahrens } 1005fa9e4066Sahrens 1006fa9e4066Sahrens /* 1007fa9e4066Sahrens * Print out an action according to the overall state of the pool. 1008fa9e4066Sahrens */ 1009fa9e4066Sahrens if (strcmp(health, gettext("ONLINE")) == 0) { 1010eaca9bbdSeschrock if (reason == ZPOOL_STATUS_VERSION_OLDER) 1011eaca9bbdSeschrock (void) printf(gettext("action: The pool can be " 1012eaca9bbdSeschrock "imported using its name or numeric identifier, " 1013eaca9bbdSeschrock "though\n\tsome features will not be available " 1014eaca9bbdSeschrock "without an explicit 'zpool upgrade'.\n")); 1015fa9e4066Sahrens else 1016eaca9bbdSeschrock (void) printf(gettext("action: The pool can be " 1017eaca9bbdSeschrock "imported using its name or numeric " 1018eaca9bbdSeschrock "identifier.\n")); 1019fa9e4066Sahrens } else if (strcmp(health, gettext("DEGRADED")) == 0) { 1020fa9e4066Sahrens (void) printf(gettext("action: The pool can be imported " 1021fa9e4066Sahrens "despite missing or damaged devices. The\n\tfault " 1022eaca9bbdSeschrock "tolerance of the pool may be compromised if imported.\n")); 1023fa9e4066Sahrens } else { 1024eaca9bbdSeschrock switch (reason) { 1025eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 1026eaca9bbdSeschrock (void) printf(gettext("action: The pool cannot be " 1027eaca9bbdSeschrock "imported. Access the pool on a system running " 1028eaca9bbdSeschrock "newer\n\tsoftware, or recreate the pool from " 1029eaca9bbdSeschrock "backup.\n")); 1030eaca9bbdSeschrock break; 1031eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_R: 1032eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_NR: 1033eaca9bbdSeschrock case ZPOOL_STATUS_BAD_GUID_SUM: 1034fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 1035fa9e4066Sahrens "imported. Attach the missing\n\tdevices and try " 1036fa9e4066Sahrens "again.\n")); 1037eaca9bbdSeschrock break; 1038eaca9bbdSeschrock default: 1039fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 1040fa9e4066Sahrens "imported due to damaged devices or data.\n")); 1041eaca9bbdSeschrock } 1042eaca9bbdSeschrock } 1043eaca9bbdSeschrock 1044eaca9bbdSeschrock if (strcmp(health, gettext("FAULTED")) != 0) { 1045eaca9bbdSeschrock if (pool_state == POOL_STATE_DESTROYED) 1046eaca9bbdSeschrock (void) printf(gettext("\tThe pool was destroyed, " 1047eaca9bbdSeschrock "but can be imported using the '-Df' flags.\n")); 1048eaca9bbdSeschrock else if (pool_state != POOL_STATE_EXPORTED) 1049eaca9bbdSeschrock (void) printf(gettext("\tThe pool may be active on " 1050eaca9bbdSeschrock "on another system, but can be imported using\n\t" 1051eaca9bbdSeschrock "the '-f' flag.\n")); 1052fa9e4066Sahrens } 1053fa9e4066Sahrens 1054fa9e4066Sahrens if (msgid != NULL) 1055fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 1056fa9e4066Sahrens msgid); 1057fa9e4066Sahrens 1058fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 1059fa9e4066Sahrens 1060c67d9675Seschrock namewidth = max_width(NULL, nvroot, 0, 0); 1061fa9e4066Sahrens if (namewidth < 10) 1062fa9e4066Sahrens namewidth = 10; 1063fa9e4066Sahrens print_import_config(name, nvroot, namewidth, 0); 1064fa9e4066Sahrens 1065fa9e4066Sahrens if (reason == ZPOOL_STATUS_BAD_GUID_SUM) { 1066fa9e4066Sahrens (void) printf("\n\tAdditional devices are known to " 1067fa9e4066Sahrens "be part of this pool, though their\n\texact " 1068fa9e4066Sahrens "configuration cannot be determined.\n"); 1069fa9e4066Sahrens } 1070fa9e4066Sahrens } 1071fa9e4066Sahrens 1072fa9e4066Sahrens /* 1073fa9e4066Sahrens * Perform the import for the given configuration. This passes the heavy 1074fa9e4066Sahrens * lifting off to zpool_import(), and then mounts the datasets contained within 1075fa9e4066Sahrens * the pool. 1076fa9e4066Sahrens */ 1077fa9e4066Sahrens static int 1078fa9e4066Sahrens do_import(nvlist_t *config, const char *newname, const char *mntopts, 1079fa9e4066Sahrens const char *altroot, int force) 1080fa9e4066Sahrens { 1081fa9e4066Sahrens zpool_handle_t *zhp; 1082fa9e4066Sahrens char *name; 1083fa9e4066Sahrens uint64_t state; 1084eaca9bbdSeschrock uint64_t version; 1085fa9e4066Sahrens 1086fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1087fa9e4066Sahrens &name) == 0); 1088fa9e4066Sahrens 1089fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1090fa9e4066Sahrens ZPOOL_CONFIG_POOL_STATE, &state) == 0); 1091eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, 1092eaca9bbdSeschrock ZPOOL_CONFIG_VERSION, &version) == 0); 1093eaca9bbdSeschrock if (version > ZFS_VERSION) { 1094eaca9bbdSeschrock (void) fprintf(stderr, gettext("cannot import '%s': pool " 1095eaca9bbdSeschrock "is formatted using a newer ZFS version\n"), name); 1096eaca9bbdSeschrock return (1); 1097eaca9bbdSeschrock } else if (state != POOL_STATE_EXPORTED && !force) { 1098fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': pool " 1099fa9e4066Sahrens "may be in use from other system\n"), name); 1100fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-f' to import anyway\n")); 1101fa9e4066Sahrens return (1); 1102fa9e4066Sahrens } 1103fa9e4066Sahrens 110499653d4eSeschrock if (zpool_import(g_zfs, config, newname, altroot) != 0) 1105fa9e4066Sahrens return (1); 1106fa9e4066Sahrens 1107fa9e4066Sahrens if (newname != NULL) 1108fa9e4066Sahrens name = (char *)newname; 1109fa9e4066Sahrens 111099653d4eSeschrock verify((zhp = zpool_open(g_zfs, name)) != NULL); 1111fa9e4066Sahrens 1112c08432ebSeschrock if (zpool_mount_datasets(zhp, mntopts, 0) != 0) { 1113fa9e4066Sahrens zpool_close(zhp); 1114fa9e4066Sahrens return (1); 1115fa9e4066Sahrens } 1116fa9e4066Sahrens 1117fa9e4066Sahrens zpool_close(zhp); 1118fa9e4066Sahrens return (0); 1119fa9e4066Sahrens } 1120fa9e4066Sahrens 1121fa9e4066Sahrens /* 11224c58d714Sdarrenm * zpool import [-d dir] [-D] 11234c58d714Sdarrenm * import [-R root] [-D] [-d dir] [-f] -a 11244c58d714Sdarrenm * import [-R root] [-D] [-d dir] [-f] <pool | id> [newpool] 1125fa9e4066Sahrens * 1126fa9e4066Sahrens * -d Scan in a specific directory, other than /dev/dsk. More than 1127fa9e4066Sahrens * one directory can be specified using multiple '-d' options. 1128fa9e4066Sahrens * 11294c58d714Sdarrenm * -D Scan for previously destroyed pools or import all or only 11304c58d714Sdarrenm * specified destroyed pools. 11314c58d714Sdarrenm * 1132fa9e4066Sahrens * -R Temporarily import the pool, with all mountpoints relative to 1133fa9e4066Sahrens * the given root. The pool will remain exported when the machine 1134fa9e4066Sahrens * is rebooted. 1135fa9e4066Sahrens * 1136fa9e4066Sahrens * -f Force import, even if it appears that the pool is active. 1137fa9e4066Sahrens * 1138fa9e4066Sahrens * -a Import all pools found. 1139fa9e4066Sahrens * 1140fa9e4066Sahrens * The import command scans for pools to import, and import pools based on pool 1141fa9e4066Sahrens * name and GUID. The pool can also be renamed as part of the import process. 1142fa9e4066Sahrens */ 1143fa9e4066Sahrens int 1144fa9e4066Sahrens zpool_do_import(int argc, char **argv) 1145fa9e4066Sahrens { 1146fa9e4066Sahrens char **searchdirs = NULL; 1147fa9e4066Sahrens int nsearch = 0; 1148fa9e4066Sahrens int c; 1149fa9e4066Sahrens int err; 1150fa9e4066Sahrens nvlist_t *pools; 115199653d4eSeschrock boolean_t do_all = B_FALSE; 115299653d4eSeschrock boolean_t do_destroyed = B_FALSE; 1153fa9e4066Sahrens char *altroot = NULL; 1154fa9e4066Sahrens char *mntopts = NULL; 115599653d4eSeschrock boolean_t do_force = B_FALSE; 1156fa9e4066Sahrens nvpair_t *elem; 1157fa9e4066Sahrens nvlist_t *config; 1158fa9e4066Sahrens uint64_t searchguid; 1159fa9e4066Sahrens char *searchname; 1160fa9e4066Sahrens nvlist_t *found_config; 116199653d4eSeschrock boolean_t first; 11624c58d714Sdarrenm uint64_t pool_state; 1163fa9e4066Sahrens 1164fa9e4066Sahrens /* check options */ 11654c58d714Sdarrenm while ((c = getopt(argc, argv, ":Dfd:R:ao:")) != -1) { 1166fa9e4066Sahrens switch (c) { 1167fa9e4066Sahrens case 'a': 116899653d4eSeschrock do_all = B_TRUE; 1169fa9e4066Sahrens break; 1170fa9e4066Sahrens case 'd': 1171fa9e4066Sahrens if (searchdirs == NULL) { 1172fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1173fa9e4066Sahrens } else { 1174fa9e4066Sahrens char **tmp = safe_malloc((nsearch + 1) * 1175fa9e4066Sahrens sizeof (char *)); 1176fa9e4066Sahrens bcopy(searchdirs, tmp, nsearch * 1177fa9e4066Sahrens sizeof (char *)); 1178fa9e4066Sahrens free(searchdirs); 1179fa9e4066Sahrens searchdirs = tmp; 1180fa9e4066Sahrens } 1181fa9e4066Sahrens searchdirs[nsearch++] = optarg; 1182fa9e4066Sahrens break; 11834c58d714Sdarrenm case 'D': 118499653d4eSeschrock do_destroyed = B_TRUE; 11854c58d714Sdarrenm break; 1186fa9e4066Sahrens case 'f': 118799653d4eSeschrock do_force = B_TRUE; 1188fa9e4066Sahrens break; 1189fa9e4066Sahrens case 'o': 1190fa9e4066Sahrens mntopts = optarg; 1191fa9e4066Sahrens break; 1192fa9e4066Sahrens case 'R': 1193fa9e4066Sahrens altroot = optarg; 1194fa9e4066Sahrens break; 1195fa9e4066Sahrens case ':': 1196fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1197fa9e4066Sahrens "'%c' option\n"), optopt); 119899653d4eSeschrock usage(B_FALSE); 1199fa9e4066Sahrens break; 1200fa9e4066Sahrens case '?': 1201fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1202fa9e4066Sahrens optopt); 120399653d4eSeschrock usage(B_FALSE); 1204fa9e4066Sahrens } 1205fa9e4066Sahrens } 1206fa9e4066Sahrens 1207fa9e4066Sahrens argc -= optind; 1208fa9e4066Sahrens argv += optind; 1209fa9e4066Sahrens 1210fa9e4066Sahrens if (searchdirs == NULL) { 1211fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1212fa9e4066Sahrens searchdirs[0] = "/dev/dsk"; 1213fa9e4066Sahrens nsearch = 1; 1214fa9e4066Sahrens } 1215fa9e4066Sahrens 1216fa9e4066Sahrens /* check argument count */ 1217fa9e4066Sahrens if (do_all) { 1218fa9e4066Sahrens if (argc != 0) { 1219fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 122099653d4eSeschrock usage(B_FALSE); 1221fa9e4066Sahrens } 1222fa9e4066Sahrens } else { 1223fa9e4066Sahrens if (argc > 2) { 1224fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 122599653d4eSeschrock usage(B_FALSE); 1226fa9e4066Sahrens } 1227fa9e4066Sahrens 1228fa9e4066Sahrens /* 1229fa9e4066Sahrens * Check for the SYS_CONFIG privilege. We do this explicitly 1230fa9e4066Sahrens * here because otherwise any attempt to discover pools will 1231fa9e4066Sahrens * silently fail. 1232fa9e4066Sahrens */ 1233fa9e4066Sahrens if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) { 1234fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1235fa9e4066Sahrens "discover pools: permission denied\n")); 123699653d4eSeschrock free(searchdirs); 1237fa9e4066Sahrens return (1); 1238fa9e4066Sahrens } 1239fa9e4066Sahrens } 1240fa9e4066Sahrens 124199653d4eSeschrock if ((pools = zpool_find_import(g_zfs, nsearch, searchdirs)) == NULL) { 124299653d4eSeschrock free(searchdirs); 1243fa9e4066Sahrens return (1); 124499653d4eSeschrock } 1245fa9e4066Sahrens 1246fa9e4066Sahrens /* 1247fa9e4066Sahrens * We now have a list of all available pools in the given directories. 1248fa9e4066Sahrens * Depending on the arguments given, we do one of the following: 1249fa9e4066Sahrens * 1250fa9e4066Sahrens * <none> Iterate through all pools and display information about 1251fa9e4066Sahrens * each one. 1252fa9e4066Sahrens * 1253fa9e4066Sahrens * -a Iterate through all pools and try to import each one. 1254fa9e4066Sahrens * 1255fa9e4066Sahrens * <id> Find the pool that corresponds to the given GUID/pool 1256fa9e4066Sahrens * name and import that one. 12574c58d714Sdarrenm * 12584c58d714Sdarrenm * -D Above options applies only to destroyed pools. 1259fa9e4066Sahrens */ 1260fa9e4066Sahrens if (argc != 0) { 1261fa9e4066Sahrens char *endptr; 1262fa9e4066Sahrens 1263fa9e4066Sahrens errno = 0; 1264fa9e4066Sahrens searchguid = strtoull(argv[0], &endptr, 10); 1265fa9e4066Sahrens if (errno != 0 || *endptr != '\0') 1266fa9e4066Sahrens searchname = argv[0]; 1267fa9e4066Sahrens else 1268fa9e4066Sahrens searchname = NULL; 1269fa9e4066Sahrens found_config = NULL; 1270fa9e4066Sahrens } 1271fa9e4066Sahrens 1272fa9e4066Sahrens err = 0; 1273fa9e4066Sahrens elem = NULL; 127499653d4eSeschrock first = B_TRUE; 1275fa9e4066Sahrens while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { 1276fa9e4066Sahrens 1277fa9e4066Sahrens verify(nvpair_value_nvlist(elem, &config) == 0); 1278fa9e4066Sahrens 12794c58d714Sdarrenm verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 12804c58d714Sdarrenm &pool_state) == 0); 12814c58d714Sdarrenm if (!do_destroyed && pool_state == POOL_STATE_DESTROYED) 12824c58d714Sdarrenm continue; 12834c58d714Sdarrenm if (do_destroyed && pool_state != POOL_STATE_DESTROYED) 12844c58d714Sdarrenm continue; 12854c58d714Sdarrenm 1286fa9e4066Sahrens if (argc == 0) { 1287fa9e4066Sahrens if (first) 128899653d4eSeschrock first = B_FALSE; 12893bb79becSeschrock else if (!do_all) 1290fa9e4066Sahrens (void) printf("\n"); 1291fa9e4066Sahrens 1292fa9e4066Sahrens if (do_all) 1293fa9e4066Sahrens err |= do_import(config, NULL, mntopts, 1294fa9e4066Sahrens altroot, do_force); 1295fa9e4066Sahrens else 1296fa9e4066Sahrens show_import(config); 1297fa9e4066Sahrens } else if (searchname != NULL) { 1298fa9e4066Sahrens char *name; 1299fa9e4066Sahrens 1300fa9e4066Sahrens /* 1301fa9e4066Sahrens * We are searching for a pool based on name. 1302fa9e4066Sahrens */ 1303fa9e4066Sahrens verify(nvlist_lookup_string(config, 1304fa9e4066Sahrens ZPOOL_CONFIG_POOL_NAME, &name) == 0); 1305fa9e4066Sahrens 1306fa9e4066Sahrens if (strcmp(name, searchname) == 0) { 1307fa9e4066Sahrens if (found_config != NULL) { 1308fa9e4066Sahrens (void) fprintf(stderr, gettext( 1309fa9e4066Sahrens "cannot import '%s': more than " 1310fa9e4066Sahrens "one matching pool\n"), searchname); 1311fa9e4066Sahrens (void) fprintf(stderr, gettext( 1312fa9e4066Sahrens "import by numeric ID instead\n")); 131399653d4eSeschrock err = B_TRUE; 1314fa9e4066Sahrens } 1315fa9e4066Sahrens found_config = config; 1316fa9e4066Sahrens } 1317fa9e4066Sahrens } else { 1318fa9e4066Sahrens uint64_t guid; 1319fa9e4066Sahrens 1320fa9e4066Sahrens /* 1321fa9e4066Sahrens * Search for a pool by guid. 1322fa9e4066Sahrens */ 1323fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1324fa9e4066Sahrens ZPOOL_CONFIG_POOL_GUID, &guid) == 0); 1325fa9e4066Sahrens 1326fa9e4066Sahrens if (guid == searchguid) 1327fa9e4066Sahrens found_config = config; 1328fa9e4066Sahrens } 1329fa9e4066Sahrens } 1330fa9e4066Sahrens 1331fa9e4066Sahrens /* 1332fa9e4066Sahrens * If we were searching for a specific pool, verify that we found a 1333fa9e4066Sahrens * pool, and then do the import. 1334fa9e4066Sahrens */ 1335fa9e4066Sahrens if (argc != 0 && err == 0) { 1336fa9e4066Sahrens if (found_config == NULL) { 1337fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': " 1338fa9e4066Sahrens "no such pool available\n"), argv[0]); 133999653d4eSeschrock err = B_TRUE; 1340fa9e4066Sahrens } else { 1341fa9e4066Sahrens err |= do_import(found_config, argc == 1 ? NULL : 1342fa9e4066Sahrens argv[1], mntopts, altroot, do_force); 1343fa9e4066Sahrens } 1344fa9e4066Sahrens } 1345fa9e4066Sahrens 1346fa9e4066Sahrens /* 1347fa9e4066Sahrens * If we were just looking for pools, report an error if none were 1348fa9e4066Sahrens * found. 1349fa9e4066Sahrens */ 1350fa9e4066Sahrens if (argc == 0 && first) 1351fa9e4066Sahrens (void) fprintf(stderr, 1352fa9e4066Sahrens gettext("no pools available to import\n")); 1353fa9e4066Sahrens 1354fa9e4066Sahrens nvlist_free(pools); 135599653d4eSeschrock free(searchdirs); 1356fa9e4066Sahrens 1357fa9e4066Sahrens return (err ? 1 : 0); 1358fa9e4066Sahrens } 1359fa9e4066Sahrens 1360fa9e4066Sahrens typedef struct iostat_cbdata { 1361fa9e4066Sahrens zpool_list_t *cb_list; 1362fa9e4066Sahrens int cb_verbose; 1363fa9e4066Sahrens int cb_iteration; 1364fa9e4066Sahrens int cb_namewidth; 1365fa9e4066Sahrens } iostat_cbdata_t; 1366fa9e4066Sahrens 1367fa9e4066Sahrens static void 1368fa9e4066Sahrens print_iostat_separator(iostat_cbdata_t *cb) 1369fa9e4066Sahrens { 1370fa9e4066Sahrens int i = 0; 1371fa9e4066Sahrens 1372fa9e4066Sahrens for (i = 0; i < cb->cb_namewidth; i++) 1373fa9e4066Sahrens (void) printf("-"); 1374fa9e4066Sahrens (void) printf(" ----- ----- ----- ----- ----- -----\n"); 1375fa9e4066Sahrens } 1376fa9e4066Sahrens 1377fa9e4066Sahrens static void 1378fa9e4066Sahrens print_iostat_header(iostat_cbdata_t *cb) 1379fa9e4066Sahrens { 1380fa9e4066Sahrens (void) printf("%*s capacity operations bandwidth\n", 1381fa9e4066Sahrens cb->cb_namewidth, ""); 1382fa9e4066Sahrens (void) printf("%-*s used avail read write read write\n", 1383fa9e4066Sahrens cb->cb_namewidth, "pool"); 1384fa9e4066Sahrens print_iostat_separator(cb); 1385fa9e4066Sahrens } 1386fa9e4066Sahrens 1387fa9e4066Sahrens /* 1388fa9e4066Sahrens * Display a single statistic. 1389fa9e4066Sahrens */ 1390fa9e4066Sahrens void 1391fa9e4066Sahrens print_one_stat(uint64_t value) 1392fa9e4066Sahrens { 1393fa9e4066Sahrens char buf[64]; 1394fa9e4066Sahrens 1395fa9e4066Sahrens zfs_nicenum(value, buf, sizeof (buf)); 1396fa9e4066Sahrens (void) printf(" %5s", buf); 1397fa9e4066Sahrens } 1398fa9e4066Sahrens 1399fa9e4066Sahrens /* 1400fa9e4066Sahrens * Print out all the statistics for the given vdev. This can either be the 1401fa9e4066Sahrens * toplevel configuration, or called recursively. If 'name' is NULL, then this 1402fa9e4066Sahrens * is a verbose output, and we don't want to display the toplevel pool stats. 1403fa9e4066Sahrens */ 1404fa9e4066Sahrens void 1405c67d9675Seschrock print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, 1406c67d9675Seschrock nvlist_t *newnv, iostat_cbdata_t *cb, int depth) 1407fa9e4066Sahrens { 1408fa9e4066Sahrens nvlist_t **oldchild, **newchild; 1409fa9e4066Sahrens uint_t c, children; 1410fa9e4066Sahrens vdev_stat_t *oldvs, *newvs; 1411fa9e4066Sahrens vdev_stat_t zerovs = { 0 }; 1412fa9e4066Sahrens uint64_t tdelta; 1413fa9e4066Sahrens double scale; 1414afefbcddSeschrock char *vname; 1415fa9e4066Sahrens 1416fa9e4066Sahrens if (oldnv != NULL) { 1417fa9e4066Sahrens verify(nvlist_lookup_uint64_array(oldnv, ZPOOL_CONFIG_STATS, 1418fa9e4066Sahrens (uint64_t **)&oldvs, &c) == 0); 1419fa9e4066Sahrens } else { 1420fa9e4066Sahrens oldvs = &zerovs; 1421fa9e4066Sahrens } 1422fa9e4066Sahrens 1423fa9e4066Sahrens verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_STATS, 1424fa9e4066Sahrens (uint64_t **)&newvs, &c) == 0); 1425fa9e4066Sahrens 1426fa9e4066Sahrens if (strlen(name) + depth > cb->cb_namewidth) 1427fa9e4066Sahrens (void) printf("%*s%s", depth, "", name); 1428fa9e4066Sahrens else 1429fa9e4066Sahrens (void) printf("%*s%s%*s", depth, "", name, 1430fa9e4066Sahrens (int)(cb->cb_namewidth - strlen(name) - depth), ""); 1431fa9e4066Sahrens 1432fa9e4066Sahrens tdelta = newvs->vs_timestamp - oldvs->vs_timestamp; 1433fa9e4066Sahrens 1434fa9e4066Sahrens if (tdelta == 0) 1435fa9e4066Sahrens scale = 1.0; 1436fa9e4066Sahrens else 1437fa9e4066Sahrens scale = (double)NANOSEC / tdelta; 1438fa9e4066Sahrens 1439fa9e4066Sahrens /* only toplevel vdevs have capacity stats */ 1440fa9e4066Sahrens if (newvs->vs_space == 0) { 1441fa9e4066Sahrens (void) printf(" - -"); 1442fa9e4066Sahrens } else { 1443fa9e4066Sahrens print_one_stat(newvs->vs_alloc); 1444fa9e4066Sahrens print_one_stat(newvs->vs_space - newvs->vs_alloc); 1445fa9e4066Sahrens } 1446fa9e4066Sahrens 1447fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] - 1448fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_READ]))); 1449fa9e4066Sahrens 1450fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] - 1451fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_WRITE]))); 1452fa9e4066Sahrens 1453fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] - 1454fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_READ]))); 1455fa9e4066Sahrens 1456fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] - 1457fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_WRITE]))); 1458fa9e4066Sahrens 1459fa9e4066Sahrens (void) printf("\n"); 1460fa9e4066Sahrens 1461fa9e4066Sahrens if (!cb->cb_verbose) 1462fa9e4066Sahrens return; 1463fa9e4066Sahrens 1464fa9e4066Sahrens if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN, 1465fa9e4066Sahrens &newchild, &children) != 0) 1466fa9e4066Sahrens return; 1467fa9e4066Sahrens 1468fa9e4066Sahrens if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN, 1469fa9e4066Sahrens &oldchild, &c) != 0) 1470fa9e4066Sahrens return; 1471fa9e4066Sahrens 1472afefbcddSeschrock for (c = 0; c < children; c++) { 147399653d4eSeschrock vname = zpool_vdev_name(g_zfs, zhp, newchild[c]); 1474c67d9675Seschrock print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 1475afefbcddSeschrock newchild[c], cb, depth + 2); 1476afefbcddSeschrock free(vname); 1477afefbcddSeschrock } 1478fa9e4066Sahrens } 1479fa9e4066Sahrens 1480088e9d47Seschrock static int 1481088e9d47Seschrock refresh_iostat(zpool_handle_t *zhp, void *data) 1482088e9d47Seschrock { 1483088e9d47Seschrock iostat_cbdata_t *cb = data; 148494de1d4cSeschrock boolean_t missing; 1485088e9d47Seschrock 1486088e9d47Seschrock /* 1487088e9d47Seschrock * If the pool has disappeared, remove it from the list and continue. 1488088e9d47Seschrock */ 148994de1d4cSeschrock if (zpool_refresh_stats(zhp, &missing) != 0) 149094de1d4cSeschrock return (-1); 149194de1d4cSeschrock 149294de1d4cSeschrock if (missing) 1493088e9d47Seschrock pool_list_remove(cb->cb_list, zhp); 1494088e9d47Seschrock 1495088e9d47Seschrock return (0); 1496088e9d47Seschrock } 1497088e9d47Seschrock 1498fa9e4066Sahrens /* 1499fa9e4066Sahrens * Callback to print out the iostats for the given pool. 1500fa9e4066Sahrens */ 1501fa9e4066Sahrens int 1502fa9e4066Sahrens print_iostat(zpool_handle_t *zhp, void *data) 1503fa9e4066Sahrens { 1504fa9e4066Sahrens iostat_cbdata_t *cb = data; 1505fa9e4066Sahrens nvlist_t *oldconfig, *newconfig; 1506fa9e4066Sahrens nvlist_t *oldnvroot, *newnvroot; 1507fa9e4066Sahrens 1508088e9d47Seschrock newconfig = zpool_get_config(zhp, &oldconfig); 1509fa9e4066Sahrens 1510088e9d47Seschrock if (cb->cb_iteration == 1) 1511fa9e4066Sahrens oldconfig = NULL; 1512fa9e4066Sahrens 1513fa9e4066Sahrens verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE, 1514fa9e4066Sahrens &newnvroot) == 0); 1515fa9e4066Sahrens 1516088e9d47Seschrock if (oldconfig == NULL) 1517fa9e4066Sahrens oldnvroot = NULL; 1518088e9d47Seschrock else 1519088e9d47Seschrock verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE, 1520088e9d47Seschrock &oldnvroot) == 0); 1521fa9e4066Sahrens 1522fa9e4066Sahrens /* 1523fa9e4066Sahrens * Print out the statistics for the pool. 1524fa9e4066Sahrens */ 1525c67d9675Seschrock print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0); 1526fa9e4066Sahrens 1527fa9e4066Sahrens if (cb->cb_verbose) 1528fa9e4066Sahrens print_iostat_separator(cb); 1529fa9e4066Sahrens 1530fa9e4066Sahrens return (0); 1531fa9e4066Sahrens } 1532fa9e4066Sahrens 1533fa9e4066Sahrens int 1534fa9e4066Sahrens get_namewidth(zpool_handle_t *zhp, void *data) 1535fa9e4066Sahrens { 1536fa9e4066Sahrens iostat_cbdata_t *cb = data; 1537fa9e4066Sahrens nvlist_t *config, *nvroot; 1538fa9e4066Sahrens 1539088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) != NULL) { 1540fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1541fa9e4066Sahrens &nvroot) == 0); 1542fa9e4066Sahrens if (!cb->cb_verbose) 1543fa9e4066Sahrens cb->cb_namewidth = strlen(zpool_get_name(zhp)); 1544fa9e4066Sahrens else 1545c67d9675Seschrock cb->cb_namewidth = max_width(zhp, nvroot, 0, 0); 1546fa9e4066Sahrens } 1547fa9e4066Sahrens 1548fa9e4066Sahrens /* 1549fa9e4066Sahrens * The width must fall into the range [10,38]. The upper limit is the 1550fa9e4066Sahrens * maximum we can have and still fit in 80 columns. 1551fa9e4066Sahrens */ 1552fa9e4066Sahrens if (cb->cb_namewidth < 10) 1553fa9e4066Sahrens cb->cb_namewidth = 10; 1554fa9e4066Sahrens if (cb->cb_namewidth > 38) 1555fa9e4066Sahrens cb->cb_namewidth = 38; 1556fa9e4066Sahrens 1557fa9e4066Sahrens return (0); 1558fa9e4066Sahrens } 1559fa9e4066Sahrens 1560fa9e4066Sahrens /* 1561fa9e4066Sahrens * zpool iostat [-v] [pool] ... [interval [count]] 1562fa9e4066Sahrens * 1563fa9e4066Sahrens * -v Display statistics for individual vdevs 1564fa9e4066Sahrens * 1565fa9e4066Sahrens * This command can be tricky because we want to be able to deal with pool 1566fa9e4066Sahrens * creation/destruction as well as vdev configuration changes. The bulk of this 1567fa9e4066Sahrens * processing is handled by the pool_list_* routines in zpool_iter.c. We rely 1568fa9e4066Sahrens * on pool_list_update() to detect the addition of new pools. Configuration 1569fa9e4066Sahrens * changes are all handled within libzfs. 1570fa9e4066Sahrens */ 1571fa9e4066Sahrens int 1572fa9e4066Sahrens zpool_do_iostat(int argc, char **argv) 1573fa9e4066Sahrens { 1574fa9e4066Sahrens int c; 1575fa9e4066Sahrens int ret; 1576fa9e4066Sahrens int npools; 1577fa9e4066Sahrens unsigned long interval = 0, count = 0; 1578fa9e4066Sahrens zpool_list_t *list; 157999653d4eSeschrock boolean_t verbose = B_FALSE; 1580fa9e4066Sahrens iostat_cbdata_t cb; 1581fa9e4066Sahrens 1582fa9e4066Sahrens /* check options */ 1583fa9e4066Sahrens while ((c = getopt(argc, argv, "v")) != -1) { 1584fa9e4066Sahrens switch (c) { 1585fa9e4066Sahrens case 'v': 158699653d4eSeschrock verbose = B_TRUE; 1587fa9e4066Sahrens break; 1588fa9e4066Sahrens case '?': 1589fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1590fa9e4066Sahrens optopt); 159199653d4eSeschrock usage(B_FALSE); 1592fa9e4066Sahrens } 1593fa9e4066Sahrens } 1594fa9e4066Sahrens 1595fa9e4066Sahrens argc -= optind; 1596fa9e4066Sahrens argv += optind; 1597fa9e4066Sahrens 1598fa9e4066Sahrens /* 1599fa9e4066Sahrens * Determine if the last argument is an integer or a pool name 1600fa9e4066Sahrens */ 1601fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 1602fa9e4066Sahrens char *end; 1603fa9e4066Sahrens 1604fa9e4066Sahrens errno = 0; 1605fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 1606fa9e4066Sahrens 1607fa9e4066Sahrens if (*end == '\0' && errno == 0) { 1608fa9e4066Sahrens if (interval == 0) { 1609fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 1610fa9e4066Sahrens "cannot be zero\n")); 161199653d4eSeschrock usage(B_FALSE); 1612fa9e4066Sahrens } 1613fa9e4066Sahrens 1614fa9e4066Sahrens /* 1615fa9e4066Sahrens * Ignore the last parameter 1616fa9e4066Sahrens */ 1617fa9e4066Sahrens argc--; 1618fa9e4066Sahrens } else { 1619fa9e4066Sahrens /* 1620fa9e4066Sahrens * If this is not a valid number, just plow on. The 1621fa9e4066Sahrens * user will get a more informative error message later 1622fa9e4066Sahrens * on. 1623fa9e4066Sahrens */ 1624fa9e4066Sahrens interval = 0; 1625fa9e4066Sahrens } 1626fa9e4066Sahrens } 1627fa9e4066Sahrens 1628fa9e4066Sahrens /* 1629fa9e4066Sahrens * If the last argument is also an integer, then we have both a count 1630fa9e4066Sahrens * and an integer. 1631fa9e4066Sahrens */ 1632fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 1633fa9e4066Sahrens char *end; 1634fa9e4066Sahrens 1635fa9e4066Sahrens errno = 0; 1636fa9e4066Sahrens count = interval; 1637fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 1638fa9e4066Sahrens 1639fa9e4066Sahrens if (*end == '\0' && errno == 0) { 1640fa9e4066Sahrens if (interval == 0) { 1641fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 1642fa9e4066Sahrens "cannot be zero\n")); 164399653d4eSeschrock usage(B_FALSE); 1644fa9e4066Sahrens } 1645fa9e4066Sahrens 1646fa9e4066Sahrens /* 1647fa9e4066Sahrens * Ignore the last parameter 1648fa9e4066Sahrens */ 1649fa9e4066Sahrens argc--; 1650fa9e4066Sahrens } else { 1651fa9e4066Sahrens interval = 0; 1652fa9e4066Sahrens } 1653fa9e4066Sahrens } 1654fa9e4066Sahrens 1655fa9e4066Sahrens /* 1656fa9e4066Sahrens * Construct the list of all interesting pools. 1657fa9e4066Sahrens */ 1658fa9e4066Sahrens ret = 0; 1659fa9e4066Sahrens if ((list = pool_list_get(argc, argv, &ret)) == NULL) 1660fa9e4066Sahrens return (1); 1661fa9e4066Sahrens 166299653d4eSeschrock if (pool_list_count(list) == 0 && argc != 0) { 166399653d4eSeschrock pool_list_free(list); 1664fa9e4066Sahrens return (1); 166599653d4eSeschrock } 1666fa9e4066Sahrens 1667fa9e4066Sahrens if (pool_list_count(list) == 0 && interval == 0) { 166899653d4eSeschrock pool_list_free(list); 1669fa9e4066Sahrens (void) fprintf(stderr, gettext("no pools available\n")); 1670fa9e4066Sahrens return (1); 1671fa9e4066Sahrens } 1672fa9e4066Sahrens 1673fa9e4066Sahrens /* 1674fa9e4066Sahrens * Enter the main iostat loop. 1675fa9e4066Sahrens */ 1676fa9e4066Sahrens cb.cb_list = list; 1677fa9e4066Sahrens cb.cb_verbose = verbose; 1678fa9e4066Sahrens cb.cb_iteration = 0; 1679fa9e4066Sahrens cb.cb_namewidth = 0; 1680fa9e4066Sahrens 1681fa9e4066Sahrens for (;;) { 1682fa9e4066Sahrens pool_list_update(list); 1683fa9e4066Sahrens 1684fa9e4066Sahrens if ((npools = pool_list_count(list)) == 0) 1685fa9e4066Sahrens break; 1686fa9e4066Sahrens 1687088e9d47Seschrock /* 1688088e9d47Seschrock * Refresh all statistics. This is done as an explicit step 1689088e9d47Seschrock * before calculating the maximum name width, so that any 1690088e9d47Seschrock * configuration changes are properly accounted for. 1691088e9d47Seschrock */ 169299653d4eSeschrock (void) pool_list_iter(list, B_FALSE, refresh_iostat, &cb); 1693088e9d47Seschrock 1694fa9e4066Sahrens /* 1695fa9e4066Sahrens * Iterate over all pools to determine the maximum width 1696fa9e4066Sahrens * for the pool / device name column across all pools. 1697fa9e4066Sahrens */ 1698fa9e4066Sahrens cb.cb_namewidth = 0; 169999653d4eSeschrock (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb); 1700fa9e4066Sahrens 1701fa9e4066Sahrens /* 1702fa9e4066Sahrens * If it's the first time, or verbose mode, print the header. 1703fa9e4066Sahrens */ 1704fa9e4066Sahrens if (++cb.cb_iteration == 1 || verbose) 1705fa9e4066Sahrens print_iostat_header(&cb); 1706fa9e4066Sahrens 170799653d4eSeschrock (void) pool_list_iter(list, B_FALSE, print_iostat, &cb); 1708fa9e4066Sahrens 1709fa9e4066Sahrens /* 1710fa9e4066Sahrens * If there's more than one pool, and we're not in verbose mode 1711fa9e4066Sahrens * (which prints a separator for us), then print a separator. 1712fa9e4066Sahrens */ 1713fa9e4066Sahrens if (npools > 1 && !verbose) 1714fa9e4066Sahrens print_iostat_separator(&cb); 1715fa9e4066Sahrens 1716fa9e4066Sahrens if (verbose) 1717fa9e4066Sahrens (void) printf("\n"); 1718fa9e4066Sahrens 1719fa9e4066Sahrens if (interval == 0) 1720fa9e4066Sahrens break; 1721fa9e4066Sahrens 1722fa9e4066Sahrens if (count != 0 && --count == 0) 1723fa9e4066Sahrens break; 1724fa9e4066Sahrens 1725fa9e4066Sahrens (void) sleep(interval); 1726fa9e4066Sahrens } 1727fa9e4066Sahrens 1728fa9e4066Sahrens pool_list_free(list); 1729fa9e4066Sahrens 1730fa9e4066Sahrens return (ret); 1731fa9e4066Sahrens } 1732fa9e4066Sahrens 1733fa9e4066Sahrens typedef struct list_cbdata { 173499653d4eSeschrock boolean_t cb_scripted; 173599653d4eSeschrock boolean_t cb_first; 173699653d4eSeschrock int cb_fields[MAX_FIELDS]; 173799653d4eSeschrock int cb_fieldcount; 1738fa9e4066Sahrens } list_cbdata_t; 1739fa9e4066Sahrens 1740fa9e4066Sahrens /* 1741fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 1742fa9e4066Sahrens */ 1743fa9e4066Sahrens void 1744fa9e4066Sahrens print_header(int *fields, size_t count) 1745fa9e4066Sahrens { 1746fa9e4066Sahrens int i; 1747fa9e4066Sahrens column_def_t *col; 1748fa9e4066Sahrens const char *fmt; 1749fa9e4066Sahrens 1750fa9e4066Sahrens for (i = 0; i < count; i++) { 1751fa9e4066Sahrens col = &column_table[fields[i]]; 1752fa9e4066Sahrens if (i != 0) 1753fa9e4066Sahrens (void) printf(" "); 1754fa9e4066Sahrens if (col->cd_justify == left_justify) 1755fa9e4066Sahrens fmt = "%-*s"; 1756fa9e4066Sahrens else 1757fa9e4066Sahrens fmt = "%*s"; 1758fa9e4066Sahrens 1759fa9e4066Sahrens (void) printf(fmt, i == count - 1 ? strlen(col->cd_title) : 1760fa9e4066Sahrens col->cd_width, col->cd_title); 1761fa9e4066Sahrens } 1762fa9e4066Sahrens 1763fa9e4066Sahrens (void) printf("\n"); 1764fa9e4066Sahrens } 1765fa9e4066Sahrens 1766fa9e4066Sahrens int 1767fa9e4066Sahrens list_callback(zpool_handle_t *zhp, void *data) 1768fa9e4066Sahrens { 1769fa9e4066Sahrens list_cbdata_t *cbp = data; 1770fa9e4066Sahrens nvlist_t *config; 1771fa9e4066Sahrens int i; 1772fa9e4066Sahrens char buf[ZPOOL_MAXNAMELEN]; 1773fa9e4066Sahrens uint64_t total; 1774fa9e4066Sahrens uint64_t used; 1775fa9e4066Sahrens const char *fmt; 1776fa9e4066Sahrens column_def_t *col; 1777fa9e4066Sahrens 1778fa9e4066Sahrens if (cbp->cb_first) { 1779fa9e4066Sahrens if (!cbp->cb_scripted) 1780fa9e4066Sahrens print_header(cbp->cb_fields, cbp->cb_fieldcount); 178199653d4eSeschrock cbp->cb_first = B_FALSE; 1782fa9e4066Sahrens } 1783fa9e4066Sahrens 1784fa9e4066Sahrens if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 1785fa9e4066Sahrens config = NULL; 1786fa9e4066Sahrens } else { 1787088e9d47Seschrock config = zpool_get_config(zhp, NULL); 1788fa9e4066Sahrens total = zpool_get_space_total(zhp); 1789fa9e4066Sahrens used = zpool_get_space_used(zhp); 1790fa9e4066Sahrens } 1791fa9e4066Sahrens 1792fa9e4066Sahrens for (i = 0; i < cbp->cb_fieldcount; i++) { 1793fa9e4066Sahrens if (i != 0) { 1794fa9e4066Sahrens if (cbp->cb_scripted) 1795fa9e4066Sahrens (void) printf("\t"); 1796fa9e4066Sahrens else 1797fa9e4066Sahrens (void) printf(" "); 1798fa9e4066Sahrens } 1799fa9e4066Sahrens 1800fa9e4066Sahrens col = &column_table[cbp->cb_fields[i]]; 1801fa9e4066Sahrens 1802fa9e4066Sahrens switch (cbp->cb_fields[i]) { 1803fa9e4066Sahrens case ZPOOL_FIELD_NAME: 1804fa9e4066Sahrens (void) strlcpy(buf, zpool_get_name(zhp), sizeof (buf)); 1805fa9e4066Sahrens break; 1806fa9e4066Sahrens 1807fa9e4066Sahrens case ZPOOL_FIELD_SIZE: 1808fa9e4066Sahrens if (config == NULL) 1809fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1810fa9e4066Sahrens else 1811fa9e4066Sahrens zfs_nicenum(total, buf, sizeof (buf)); 1812fa9e4066Sahrens break; 1813fa9e4066Sahrens 1814fa9e4066Sahrens case ZPOOL_FIELD_USED: 1815fa9e4066Sahrens if (config == NULL) 1816fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1817fa9e4066Sahrens else 1818fa9e4066Sahrens zfs_nicenum(used, buf, sizeof (buf)); 1819fa9e4066Sahrens break; 1820fa9e4066Sahrens 1821fa9e4066Sahrens case ZPOOL_FIELD_AVAILABLE: 1822fa9e4066Sahrens if (config == NULL) 1823fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1824fa9e4066Sahrens else 1825fa9e4066Sahrens zfs_nicenum(total - used, buf, sizeof (buf)); 1826fa9e4066Sahrens break; 1827fa9e4066Sahrens 1828fa9e4066Sahrens case ZPOOL_FIELD_CAPACITY: 1829fa9e4066Sahrens if (config == NULL) { 1830fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1831fa9e4066Sahrens } else { 1832fa9e4066Sahrens uint64_t capacity = (total == 0 ? 0 : 1833fa9e4066Sahrens (used * 100 / total)); 1834fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%llu%%", 1835fa9e4066Sahrens capacity); 1836fa9e4066Sahrens } 1837fa9e4066Sahrens break; 1838fa9e4066Sahrens 1839fa9e4066Sahrens case ZPOOL_FIELD_HEALTH: 1840fa9e4066Sahrens if (config == NULL) { 1841fa9e4066Sahrens (void) strlcpy(buf, "FAULTED", sizeof (buf)); 1842fa9e4066Sahrens } else { 1843fa9e4066Sahrens nvlist_t *nvroot; 1844fa9e4066Sahrens vdev_stat_t *vs; 1845fa9e4066Sahrens uint_t vsc; 1846fa9e4066Sahrens 1847fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, 1848fa9e4066Sahrens ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 1849fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, 1850fa9e4066Sahrens ZPOOL_CONFIG_STATS, (uint64_t **)&vs, 1851fa9e4066Sahrens &vsc) == 0); 1852ea8dc4b6Seschrock (void) strlcpy(buf, state_to_name(vs), 1853fa9e4066Sahrens sizeof (buf)); 1854fa9e4066Sahrens } 1855fa9e4066Sahrens break; 1856fa9e4066Sahrens 1857fa9e4066Sahrens case ZPOOL_FIELD_ROOT: 1858fa9e4066Sahrens if (config == NULL) 1859fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1860fa9e4066Sahrens else if (zpool_get_root(zhp, buf, sizeof (buf)) != 0) 1861fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1862fa9e4066Sahrens break; 1863fa9e4066Sahrens } 1864fa9e4066Sahrens 1865fa9e4066Sahrens if (cbp->cb_scripted) 1866fa9e4066Sahrens (void) printf("%s", buf); 1867fa9e4066Sahrens else { 1868fa9e4066Sahrens if (col->cd_justify == left_justify) 1869fa9e4066Sahrens fmt = "%-*s"; 1870fa9e4066Sahrens else 1871fa9e4066Sahrens fmt = "%*s"; 1872fa9e4066Sahrens 1873fa9e4066Sahrens (void) printf(fmt, i == cbp->cb_fieldcount - 1 ? 1874fa9e4066Sahrens strlen(buf) : col->cd_width, buf); 1875fa9e4066Sahrens } 1876fa9e4066Sahrens } 1877fa9e4066Sahrens 1878fa9e4066Sahrens (void) printf("\n"); 1879fa9e4066Sahrens 1880fa9e4066Sahrens return (0); 1881fa9e4066Sahrens } 1882fa9e4066Sahrens 1883fa9e4066Sahrens /* 1884fa9e4066Sahrens * zpool list [-H] [-o field[,field]*] [pool] ... 1885fa9e4066Sahrens * 1886fa9e4066Sahrens * -H Scripted mode. Don't display headers, and separate fields by 1887fa9e4066Sahrens * a single tab. 1888fa9e4066Sahrens * -o List of fields to display. Defaults to all fields, or 1889fa9e4066Sahrens * "name,size,used,available,capacity,health,root" 1890fa9e4066Sahrens * 1891fa9e4066Sahrens * List all pools in the system, whether or not they're healthy. Output space 1892fa9e4066Sahrens * statistics for each one, as well as health status summary. 1893fa9e4066Sahrens */ 1894fa9e4066Sahrens int 1895fa9e4066Sahrens zpool_do_list(int argc, char **argv) 1896fa9e4066Sahrens { 1897fa9e4066Sahrens int c; 1898fa9e4066Sahrens int ret; 1899fa9e4066Sahrens list_cbdata_t cb = { 0 }; 1900fa9e4066Sahrens static char default_fields[] = 1901fa9e4066Sahrens "name,size,used,available,capacity,health,root"; 1902fa9e4066Sahrens char *fields = default_fields; 1903fa9e4066Sahrens char *value; 1904fa9e4066Sahrens 1905fa9e4066Sahrens /* check options */ 1906fa9e4066Sahrens while ((c = getopt(argc, argv, ":Ho:")) != -1) { 1907fa9e4066Sahrens switch (c) { 1908fa9e4066Sahrens case 'H': 190999653d4eSeschrock cb.cb_scripted = B_TRUE; 1910fa9e4066Sahrens break; 1911fa9e4066Sahrens case 'o': 1912fa9e4066Sahrens fields = optarg; 1913fa9e4066Sahrens break; 1914fa9e4066Sahrens case ':': 1915fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1916fa9e4066Sahrens "'%c' option\n"), optopt); 191799653d4eSeschrock usage(B_FALSE); 1918fa9e4066Sahrens break; 1919fa9e4066Sahrens case '?': 1920fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1921fa9e4066Sahrens optopt); 192299653d4eSeschrock usage(B_FALSE); 1923fa9e4066Sahrens } 1924fa9e4066Sahrens } 1925fa9e4066Sahrens 1926fa9e4066Sahrens argc -= optind; 1927fa9e4066Sahrens argv += optind; 1928fa9e4066Sahrens 1929fa9e4066Sahrens while (*fields != '\0') { 1930fa9e4066Sahrens if (cb.cb_fieldcount == MAX_FIELDS) { 1931fa9e4066Sahrens (void) fprintf(stderr, gettext("too many " 1932fa9e4066Sahrens "properties given to -o option\n")); 193399653d4eSeschrock usage(B_FALSE); 1934fa9e4066Sahrens } 1935fa9e4066Sahrens 1936fa9e4066Sahrens if ((cb.cb_fields[cb.cb_fieldcount] = getsubopt(&fields, 1937fa9e4066Sahrens column_subopts, &value)) == -1) { 1938fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid property " 1939fa9e4066Sahrens "'%s'\n"), value); 194099653d4eSeschrock usage(B_FALSE); 1941fa9e4066Sahrens } 1942fa9e4066Sahrens 1943fa9e4066Sahrens cb.cb_fieldcount++; 1944fa9e4066Sahrens } 1945fa9e4066Sahrens 1946fa9e4066Sahrens 194799653d4eSeschrock cb.cb_first = B_TRUE; 1948fa9e4066Sahrens 194999653d4eSeschrock ret = for_each_pool(argc, argv, B_TRUE, list_callback, &cb); 1950fa9e4066Sahrens 1951fa9e4066Sahrens if (argc == 0 && cb.cb_first) { 1952fa9e4066Sahrens (void) printf(gettext("no pools available\n")); 1953fa9e4066Sahrens return (0); 1954fa9e4066Sahrens } 1955fa9e4066Sahrens 1956fa9e4066Sahrens return (ret); 1957fa9e4066Sahrens } 1958fa9e4066Sahrens 1959fa9e4066Sahrens static nvlist_t * 1960fa9e4066Sahrens zpool_get_vdev_by_name(nvlist_t *nv, char *name) 1961fa9e4066Sahrens { 1962fa9e4066Sahrens nvlist_t **child; 1963fa9e4066Sahrens uint_t c, children; 1964fa9e4066Sahrens nvlist_t *match; 1965fa9e4066Sahrens char *path; 1966fa9e4066Sahrens 1967fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1968fa9e4066Sahrens &child, &children) != 0) { 1969fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1970fa9e4066Sahrens if (strncmp(name, "/dev/dsk/", 9) == 0) 1971fa9e4066Sahrens name += 9; 1972fa9e4066Sahrens if (strncmp(path, "/dev/dsk/", 9) == 0) 1973fa9e4066Sahrens path += 9; 1974fa9e4066Sahrens if (strcmp(name, path) == 0) 1975fa9e4066Sahrens return (nv); 1976fa9e4066Sahrens return (NULL); 1977fa9e4066Sahrens } 1978fa9e4066Sahrens 1979fa9e4066Sahrens for (c = 0; c < children; c++) 1980fa9e4066Sahrens if ((match = zpool_get_vdev_by_name(child[c], name)) != NULL) 1981fa9e4066Sahrens return (match); 1982fa9e4066Sahrens 1983fa9e4066Sahrens return (NULL); 1984fa9e4066Sahrens } 1985fa9e4066Sahrens 1986fa9e4066Sahrens static int 1987fa9e4066Sahrens zpool_do_attach_or_replace(int argc, char **argv, int replacing) 1988fa9e4066Sahrens { 198999653d4eSeschrock boolean_t force = B_FALSE; 1990fa9e4066Sahrens int c; 1991fa9e4066Sahrens nvlist_t *nvroot; 1992fa9e4066Sahrens char *poolname, *old_disk, *new_disk; 1993fa9e4066Sahrens zpool_handle_t *zhp; 1994fa9e4066Sahrens nvlist_t *config; 199599653d4eSeschrock int ret; 1996fa9e4066Sahrens 1997fa9e4066Sahrens /* check options */ 1998fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 1999fa9e4066Sahrens switch (c) { 2000fa9e4066Sahrens case 'f': 200199653d4eSeschrock force = B_TRUE; 2002fa9e4066Sahrens break; 2003fa9e4066Sahrens case '?': 2004fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2005fa9e4066Sahrens optopt); 200699653d4eSeschrock usage(B_FALSE); 2007fa9e4066Sahrens } 2008fa9e4066Sahrens } 2009fa9e4066Sahrens 2010fa9e4066Sahrens argc -= optind; 2011fa9e4066Sahrens argv += optind; 2012fa9e4066Sahrens 2013fa9e4066Sahrens /* get pool name and check number of arguments */ 2014fa9e4066Sahrens if (argc < 1) { 2015fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 201699653d4eSeschrock usage(B_FALSE); 2017fa9e4066Sahrens } 2018fa9e4066Sahrens 2019fa9e4066Sahrens poolname = argv[0]; 2020fa9e4066Sahrens 2021fa9e4066Sahrens if (argc < 2) { 2022fa9e4066Sahrens (void) fprintf(stderr, 2023fa9e4066Sahrens gettext("missing <device> specification\n")); 202499653d4eSeschrock usage(B_FALSE); 2025fa9e4066Sahrens } 2026fa9e4066Sahrens 2027fa9e4066Sahrens old_disk = argv[1]; 2028fa9e4066Sahrens 2029fa9e4066Sahrens if (argc < 3) { 2030fa9e4066Sahrens if (!replacing) { 2031fa9e4066Sahrens (void) fprintf(stderr, 2032fa9e4066Sahrens gettext("missing <new_device> specification\n")); 203399653d4eSeschrock usage(B_FALSE); 2034fa9e4066Sahrens } 2035fa9e4066Sahrens new_disk = old_disk; 2036fa9e4066Sahrens argc -= 1; 2037fa9e4066Sahrens argv += 1; 2038fa9e4066Sahrens } else { 2039fa9e4066Sahrens new_disk = argv[2]; 2040fa9e4066Sahrens argc -= 2; 2041fa9e4066Sahrens argv += 2; 2042fa9e4066Sahrens } 2043fa9e4066Sahrens 2044fa9e4066Sahrens if (argc > 1) { 2045fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 204699653d4eSeschrock usage(B_FALSE); 2047fa9e4066Sahrens } 2048fa9e4066Sahrens 204999653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2050fa9e4066Sahrens return (1); 2051fa9e4066Sahrens 2052088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 2053fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 2054fa9e4066Sahrens poolname); 2055fa9e4066Sahrens zpool_close(zhp); 2056fa9e4066Sahrens return (1); 2057fa9e4066Sahrens } 2058fa9e4066Sahrens 205999653d4eSeschrock nvroot = make_root_vdev(config, force, B_FALSE, replacing, argc, argv); 2060fa9e4066Sahrens if (nvroot == NULL) { 2061fa9e4066Sahrens zpool_close(zhp); 2062fa9e4066Sahrens return (1); 2063fa9e4066Sahrens } 2064fa9e4066Sahrens 206599653d4eSeschrock ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing); 206699653d4eSeschrock 206799653d4eSeschrock nvlist_free(nvroot); 206899653d4eSeschrock zpool_close(zhp); 206999653d4eSeschrock 207099653d4eSeschrock return (ret); 2071fa9e4066Sahrens } 2072fa9e4066Sahrens 2073fa9e4066Sahrens /* 2074fa9e4066Sahrens * zpool replace [-f] <pool> <device> <new_device> 2075fa9e4066Sahrens * 2076fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 2077fa9e4066Sahrens * 2078fa9e4066Sahrens * Replace <device> with <new_device>. 2079fa9e4066Sahrens */ 2080fa9e4066Sahrens /* ARGSUSED */ 2081fa9e4066Sahrens int 2082fa9e4066Sahrens zpool_do_replace(int argc, char **argv) 2083fa9e4066Sahrens { 2084fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_TRUE)); 2085fa9e4066Sahrens } 2086fa9e4066Sahrens 2087fa9e4066Sahrens /* 2088fa9e4066Sahrens * zpool attach [-f] <pool> <device> <new_device> 2089fa9e4066Sahrens * 2090fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 2091fa9e4066Sahrens * 2092fa9e4066Sahrens * Attach <new_device> to the mirror containing <device>. If <device> is not 2093fa9e4066Sahrens * part of a mirror, then <device> will be transformed into a mirror of 2094fa9e4066Sahrens * <device> and <new_device>. In either case, <new_device> will begin life 2095fa9e4066Sahrens * with a DTL of [0, now], and will immediately begin to resilver itself. 2096fa9e4066Sahrens */ 2097fa9e4066Sahrens int 2098fa9e4066Sahrens zpool_do_attach(int argc, char **argv) 2099fa9e4066Sahrens { 2100fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_FALSE)); 2101fa9e4066Sahrens } 2102fa9e4066Sahrens 2103fa9e4066Sahrens /* 2104fa9e4066Sahrens * zpool detach [-f] <pool> <device> 2105fa9e4066Sahrens * 2106fa9e4066Sahrens * -f Force detach of <device>, even if DTLs argue against it 2107fa9e4066Sahrens * (not supported yet) 2108fa9e4066Sahrens * 2109fa9e4066Sahrens * Detach a device from a mirror. The operation will be refused if <device> 2110fa9e4066Sahrens * is the last device in the mirror, or if the DTLs indicate that this device 2111fa9e4066Sahrens * has the only valid copy of some data. 2112fa9e4066Sahrens */ 2113fa9e4066Sahrens /* ARGSUSED */ 2114fa9e4066Sahrens int 2115fa9e4066Sahrens zpool_do_detach(int argc, char **argv) 2116fa9e4066Sahrens { 2117fa9e4066Sahrens int c; 2118fa9e4066Sahrens char *poolname, *path; 2119fa9e4066Sahrens zpool_handle_t *zhp; 212099653d4eSeschrock int ret; 2121fa9e4066Sahrens 2122fa9e4066Sahrens /* check options */ 2123fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2124fa9e4066Sahrens switch (c) { 2125fa9e4066Sahrens case 'f': 2126fa9e4066Sahrens case '?': 2127fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2128fa9e4066Sahrens optopt); 212999653d4eSeschrock usage(B_FALSE); 2130fa9e4066Sahrens } 2131fa9e4066Sahrens } 2132fa9e4066Sahrens 2133fa9e4066Sahrens argc -= optind; 2134fa9e4066Sahrens argv += optind; 2135fa9e4066Sahrens 2136fa9e4066Sahrens /* get pool name and check number of arguments */ 2137fa9e4066Sahrens if (argc < 1) { 2138fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 213999653d4eSeschrock usage(B_FALSE); 2140fa9e4066Sahrens } 2141fa9e4066Sahrens 2142fa9e4066Sahrens if (argc < 2) { 2143fa9e4066Sahrens (void) fprintf(stderr, 2144fa9e4066Sahrens gettext("missing <device> specification\n")); 214599653d4eSeschrock usage(B_FALSE); 2146fa9e4066Sahrens } 2147fa9e4066Sahrens 2148fa9e4066Sahrens poolname = argv[0]; 2149fa9e4066Sahrens path = argv[1]; 2150fa9e4066Sahrens 215199653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2152fa9e4066Sahrens return (1); 2153fa9e4066Sahrens 215499653d4eSeschrock ret = zpool_vdev_detach(zhp, path); 215599653d4eSeschrock 215699653d4eSeschrock zpool_close(zhp); 215799653d4eSeschrock 215899653d4eSeschrock return (ret); 2159fa9e4066Sahrens } 2160fa9e4066Sahrens 2161fa9e4066Sahrens /* 2162441d80aaSlling * zpool online <pool> <device> ... 2163fa9e4066Sahrens */ 2164fa9e4066Sahrens /* ARGSUSED */ 2165fa9e4066Sahrens int 2166fa9e4066Sahrens zpool_do_online(int argc, char **argv) 2167fa9e4066Sahrens { 2168fa9e4066Sahrens int c, i; 2169fa9e4066Sahrens char *poolname; 2170fa9e4066Sahrens zpool_handle_t *zhp; 2171fa9e4066Sahrens int ret = 0; 2172fa9e4066Sahrens 2173fa9e4066Sahrens /* check options */ 2174fa9e4066Sahrens while ((c = getopt(argc, argv, "t")) != -1) { 2175fa9e4066Sahrens switch (c) { 2176fa9e4066Sahrens case 't': 2177fa9e4066Sahrens case '?': 2178fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2179fa9e4066Sahrens optopt); 218099653d4eSeschrock usage(B_FALSE); 2181fa9e4066Sahrens } 2182fa9e4066Sahrens } 2183fa9e4066Sahrens 2184fa9e4066Sahrens argc -= optind; 2185fa9e4066Sahrens argv += optind; 2186fa9e4066Sahrens 2187fa9e4066Sahrens /* get pool name and check number of arguments */ 2188fa9e4066Sahrens if (argc < 1) { 2189fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 219099653d4eSeschrock usage(B_FALSE); 2191fa9e4066Sahrens } 2192fa9e4066Sahrens if (argc < 2) { 2193fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 219499653d4eSeschrock usage(B_FALSE); 2195fa9e4066Sahrens } 2196fa9e4066Sahrens 2197fa9e4066Sahrens poolname = argv[0]; 2198fa9e4066Sahrens 219999653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2200fa9e4066Sahrens return (1); 2201fa9e4066Sahrens 2202fa9e4066Sahrens for (i = 1; i < argc; i++) 2203fa9e4066Sahrens if (zpool_vdev_online(zhp, argv[i]) == 0) 2204fa9e4066Sahrens (void) printf(gettext("Bringing device %s online\n"), 2205fa9e4066Sahrens argv[i]); 2206fa9e4066Sahrens else 2207fa9e4066Sahrens ret = 1; 2208fa9e4066Sahrens 220999653d4eSeschrock zpool_close(zhp); 221099653d4eSeschrock 2211fa9e4066Sahrens return (ret); 2212fa9e4066Sahrens } 2213fa9e4066Sahrens 2214fa9e4066Sahrens /* 2215441d80aaSlling * zpool offline [-ft] <pool> <device> ... 2216fa9e4066Sahrens * 2217fa9e4066Sahrens * -f Force the device into the offline state, even if doing 2218fa9e4066Sahrens * so would appear to compromise pool availability. 2219fa9e4066Sahrens * (not supported yet) 2220fa9e4066Sahrens * 2221fa9e4066Sahrens * -t Only take the device off-line temporarily. The offline 2222fa9e4066Sahrens * state will not be persistent across reboots. 2223fa9e4066Sahrens */ 2224fa9e4066Sahrens /* ARGSUSED */ 2225fa9e4066Sahrens int 2226fa9e4066Sahrens zpool_do_offline(int argc, char **argv) 2227fa9e4066Sahrens { 2228fa9e4066Sahrens int c, i; 2229fa9e4066Sahrens char *poolname; 2230fa9e4066Sahrens zpool_handle_t *zhp; 223199653d4eSeschrock int ret = 0; 223299653d4eSeschrock boolean_t istmp = B_FALSE; 2233fa9e4066Sahrens 2234fa9e4066Sahrens /* check options */ 2235fa9e4066Sahrens while ((c = getopt(argc, argv, "ft")) != -1) { 2236fa9e4066Sahrens switch (c) { 2237fa9e4066Sahrens case 't': 223899653d4eSeschrock istmp = B_TRUE; 2239441d80aaSlling break; 2240441d80aaSlling case 'f': 2241fa9e4066Sahrens case '?': 2242fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2243fa9e4066Sahrens optopt); 224499653d4eSeschrock usage(B_FALSE); 2245fa9e4066Sahrens } 2246fa9e4066Sahrens } 2247fa9e4066Sahrens 2248fa9e4066Sahrens argc -= optind; 2249fa9e4066Sahrens argv += optind; 2250fa9e4066Sahrens 2251fa9e4066Sahrens /* get pool name and check number of arguments */ 2252fa9e4066Sahrens if (argc < 1) { 2253fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 225499653d4eSeschrock usage(B_FALSE); 2255fa9e4066Sahrens } 2256fa9e4066Sahrens if (argc < 2) { 2257fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 225899653d4eSeschrock usage(B_FALSE); 2259fa9e4066Sahrens } 2260fa9e4066Sahrens 2261fa9e4066Sahrens poolname = argv[0]; 2262fa9e4066Sahrens 226399653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2264fa9e4066Sahrens return (1); 2265fa9e4066Sahrens 2266fa9e4066Sahrens for (i = 1; i < argc; i++) 2267441d80aaSlling if (zpool_vdev_offline(zhp, argv[i], istmp) == 0) 2268fa9e4066Sahrens (void) printf(gettext("Bringing device %s offline\n"), 2269fa9e4066Sahrens argv[i]); 2270fa9e4066Sahrens else 2271fa9e4066Sahrens ret = 1; 2272fa9e4066Sahrens 227399653d4eSeschrock zpool_close(zhp); 227499653d4eSeschrock 2275fa9e4066Sahrens return (ret); 2276fa9e4066Sahrens } 2277fa9e4066Sahrens 2278ea8dc4b6Seschrock /* 2279ea8dc4b6Seschrock * zpool clear <pool> [device] 2280ea8dc4b6Seschrock * 2281ea8dc4b6Seschrock * Clear all errors associated with a pool or a particular device. 2282ea8dc4b6Seschrock */ 2283ea8dc4b6Seschrock int 2284ea8dc4b6Seschrock zpool_do_clear(int argc, char **argv) 2285ea8dc4b6Seschrock { 2286ea8dc4b6Seschrock int ret = 0; 2287ea8dc4b6Seschrock zpool_handle_t *zhp; 2288ea8dc4b6Seschrock char *pool, *device; 2289ea8dc4b6Seschrock 2290ea8dc4b6Seschrock if (argc < 2) { 2291ea8dc4b6Seschrock (void) fprintf(stderr, gettext("missing pool name\n")); 229299653d4eSeschrock usage(B_FALSE); 2293ea8dc4b6Seschrock } 2294ea8dc4b6Seschrock 2295ea8dc4b6Seschrock if (argc > 3) { 2296ea8dc4b6Seschrock (void) fprintf(stderr, gettext("too many arguments\n")); 229799653d4eSeschrock usage(B_FALSE); 2298ea8dc4b6Seschrock } 2299ea8dc4b6Seschrock 2300ea8dc4b6Seschrock pool = argv[1]; 2301ea8dc4b6Seschrock device = argc == 3 ? argv[2] : NULL; 2302ea8dc4b6Seschrock 230399653d4eSeschrock if ((zhp = zpool_open(g_zfs, pool)) == NULL) 2304ea8dc4b6Seschrock return (1); 2305ea8dc4b6Seschrock 2306ea8dc4b6Seschrock if (zpool_clear(zhp, device) != 0) 2307ea8dc4b6Seschrock ret = 1; 2308ea8dc4b6Seschrock 2309ea8dc4b6Seschrock zpool_close(zhp); 2310ea8dc4b6Seschrock 2311ea8dc4b6Seschrock return (ret); 2312ea8dc4b6Seschrock } 2313ea8dc4b6Seschrock 2314fa9e4066Sahrens typedef struct scrub_cbdata { 2315fa9e4066Sahrens int cb_type; 2316fa9e4066Sahrens } scrub_cbdata_t; 2317fa9e4066Sahrens 2318fa9e4066Sahrens int 2319fa9e4066Sahrens scrub_callback(zpool_handle_t *zhp, void *data) 2320fa9e4066Sahrens { 2321fa9e4066Sahrens scrub_cbdata_t *cb = data; 2322fa9e4066Sahrens 2323ea8dc4b6Seschrock /* 2324ea8dc4b6Seschrock * Ignore faulted pools. 2325ea8dc4b6Seschrock */ 2326ea8dc4b6Seschrock if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 2327ea8dc4b6Seschrock (void) fprintf(stderr, gettext("cannot scrub '%s': pool is " 2328ea8dc4b6Seschrock "currently unavailable\n"), zpool_get_name(zhp)); 2329ea8dc4b6Seschrock return (1); 2330ea8dc4b6Seschrock } 2331ea8dc4b6Seschrock 2332fa9e4066Sahrens return (zpool_scrub(zhp, cb->cb_type) != 0); 2333fa9e4066Sahrens } 2334fa9e4066Sahrens 2335fa9e4066Sahrens /* 2336fa9e4066Sahrens * zpool scrub [-s] <pool> ... 2337fa9e4066Sahrens * 2338fa9e4066Sahrens * -s Stop. Stops any in-progress scrub. 2339fa9e4066Sahrens */ 2340fa9e4066Sahrens int 2341fa9e4066Sahrens zpool_do_scrub(int argc, char **argv) 2342fa9e4066Sahrens { 2343fa9e4066Sahrens int c; 2344fa9e4066Sahrens scrub_cbdata_t cb; 2345fa9e4066Sahrens 2346fa9e4066Sahrens cb.cb_type = POOL_SCRUB_EVERYTHING; 2347fa9e4066Sahrens 2348fa9e4066Sahrens /* check options */ 2349fa9e4066Sahrens while ((c = getopt(argc, argv, "s")) != -1) { 2350fa9e4066Sahrens switch (c) { 2351fa9e4066Sahrens case 's': 2352fa9e4066Sahrens cb.cb_type = POOL_SCRUB_NONE; 2353fa9e4066Sahrens break; 2354fa9e4066Sahrens case '?': 2355fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2356fa9e4066Sahrens optopt); 235799653d4eSeschrock usage(B_FALSE); 2358fa9e4066Sahrens } 2359fa9e4066Sahrens } 2360fa9e4066Sahrens 2361fa9e4066Sahrens argc -= optind; 2362fa9e4066Sahrens argv += optind; 2363fa9e4066Sahrens 2364fa9e4066Sahrens if (argc < 1) { 2365fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 236699653d4eSeschrock usage(B_FALSE); 2367fa9e4066Sahrens } 2368fa9e4066Sahrens 236999653d4eSeschrock return (for_each_pool(argc, argv, B_TRUE, scrub_callback, &cb)); 2370fa9e4066Sahrens } 2371fa9e4066Sahrens 2372fa9e4066Sahrens typedef struct status_cbdata { 237399653d4eSeschrock int cb_count; 2374*e9dbad6fSeschrock boolean_t cb_allpools; 237599653d4eSeschrock boolean_t cb_verbose; 237699653d4eSeschrock boolean_t cb_explain; 237799653d4eSeschrock boolean_t cb_first; 2378fa9e4066Sahrens } status_cbdata_t; 2379fa9e4066Sahrens 2380fa9e4066Sahrens /* 2381fa9e4066Sahrens * Print out detailed scrub status. 2382fa9e4066Sahrens */ 2383fa9e4066Sahrens void 2384fa9e4066Sahrens print_scrub_status(nvlist_t *nvroot) 2385fa9e4066Sahrens { 2386fa9e4066Sahrens vdev_stat_t *vs; 2387fa9e4066Sahrens uint_t vsc; 2388fa9e4066Sahrens time_t start, end, now; 2389fa9e4066Sahrens double fraction_done; 2390fa9e4066Sahrens uint64_t examined, total, minutes_left; 2391fa9e4066Sahrens char *scrub_type; 2392fa9e4066Sahrens 2393fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 2394fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 2395fa9e4066Sahrens 2396fa9e4066Sahrens /* 2397fa9e4066Sahrens * If there's never been a scrub, there's not much to say. 2398fa9e4066Sahrens */ 2399fa9e4066Sahrens if (vs->vs_scrub_end == 0 && vs->vs_scrub_type == POOL_SCRUB_NONE) { 2400fa9e4066Sahrens (void) printf(gettext("none requested\n")); 2401fa9e4066Sahrens return; 2402fa9e4066Sahrens } 2403fa9e4066Sahrens 2404fa9e4066Sahrens scrub_type = (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ? 2405fa9e4066Sahrens "resilver" : "scrub"; 2406fa9e4066Sahrens 2407fa9e4066Sahrens start = vs->vs_scrub_start; 2408fa9e4066Sahrens end = vs->vs_scrub_end; 2409fa9e4066Sahrens now = time(NULL); 2410fa9e4066Sahrens examined = vs->vs_scrub_examined; 2411fa9e4066Sahrens total = vs->vs_alloc; 2412fa9e4066Sahrens 2413fa9e4066Sahrens if (end != 0) { 2414fa9e4066Sahrens (void) printf(gettext("%s %s with %llu errors on %s"), 2415fa9e4066Sahrens scrub_type, vs->vs_scrub_complete ? "completed" : "stopped", 2416fa9e4066Sahrens (u_longlong_t)vs->vs_scrub_errors, ctime(&end)); 2417fa9e4066Sahrens return; 2418fa9e4066Sahrens } 2419fa9e4066Sahrens 2420fa9e4066Sahrens if (examined == 0) 2421fa9e4066Sahrens examined = 1; 2422fa9e4066Sahrens if (examined > total) 2423fa9e4066Sahrens total = examined; 2424fa9e4066Sahrens 2425fa9e4066Sahrens fraction_done = (double)examined / total; 2426fa9e4066Sahrens minutes_left = (uint64_t)((now - start) * 2427fa9e4066Sahrens (1 - fraction_done) / fraction_done / 60); 2428fa9e4066Sahrens 2429fa9e4066Sahrens (void) printf(gettext("%s in progress, %.2f%% done, %lluh%um to go\n"), 2430fa9e4066Sahrens scrub_type, 100 * fraction_done, 2431fa9e4066Sahrens (u_longlong_t)(minutes_left / 60), (uint_t)(minutes_left % 60)); 2432fa9e4066Sahrens } 2433fa9e4066Sahrens 243499653d4eSeschrock typedef struct spare_cbdata { 243599653d4eSeschrock uint64_t cb_guid; 243699653d4eSeschrock zpool_handle_t *cb_zhp; 243799653d4eSeschrock } spare_cbdata_t; 243899653d4eSeschrock 243999653d4eSeschrock static boolean_t 244099653d4eSeschrock find_vdev(nvlist_t *nv, uint64_t search) 244199653d4eSeschrock { 244299653d4eSeschrock uint64_t guid; 244399653d4eSeschrock nvlist_t **child; 244499653d4eSeschrock uint_t c, children; 244599653d4eSeschrock 244699653d4eSeschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 && 244799653d4eSeschrock search == guid) 244899653d4eSeschrock return (B_TRUE); 244999653d4eSeschrock 245099653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 245199653d4eSeschrock &child, &children) == 0) { 245299653d4eSeschrock for (c = 0; c < children; c++) 245399653d4eSeschrock if (find_vdev(child[c], search)) 245499653d4eSeschrock return (B_TRUE); 245599653d4eSeschrock } 245699653d4eSeschrock 245799653d4eSeschrock return (B_FALSE); 245899653d4eSeschrock } 245999653d4eSeschrock 246099653d4eSeschrock static int 246199653d4eSeschrock find_spare(zpool_handle_t *zhp, void *data) 246299653d4eSeschrock { 246399653d4eSeschrock spare_cbdata_t *cbp = data; 246499653d4eSeschrock nvlist_t *config, *nvroot; 246599653d4eSeschrock 246699653d4eSeschrock config = zpool_get_config(zhp, NULL); 246799653d4eSeschrock verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 246899653d4eSeschrock &nvroot) == 0); 246999653d4eSeschrock 247099653d4eSeschrock if (find_vdev(nvroot, cbp->cb_guid)) { 247199653d4eSeschrock cbp->cb_zhp = zhp; 247299653d4eSeschrock return (1); 247399653d4eSeschrock } 247499653d4eSeschrock 247599653d4eSeschrock zpool_close(zhp); 247699653d4eSeschrock return (0); 247799653d4eSeschrock } 247899653d4eSeschrock 2479fa9e4066Sahrens /* 2480fa9e4066Sahrens * Print out configuration state as requested by status_callback. 2481fa9e4066Sahrens */ 2482fa9e4066Sahrens void 2483c67d9675Seschrock print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 248499653d4eSeschrock int namewidth, int depth, boolean_t isspare) 2485fa9e4066Sahrens { 2486fa9e4066Sahrens nvlist_t **child; 2487fa9e4066Sahrens uint_t c, children; 2488fa9e4066Sahrens vdev_stat_t *vs; 2489ea8dc4b6Seschrock char rbuf[6], wbuf[6], cbuf[6], repaired[7]; 2490afefbcddSeschrock char *vname; 2491ea8dc4b6Seschrock uint64_t notpresent; 249299653d4eSeschrock spare_cbdata_t cb; 249399653d4eSeschrock const char *state; 2494fa9e4066Sahrens 2495fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS, 2496fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 2497fa9e4066Sahrens 2498fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2499fa9e4066Sahrens &child, &children) != 0) 2500fa9e4066Sahrens children = 0; 2501fa9e4066Sahrens 250299653d4eSeschrock state = state_to_name(vs); 250399653d4eSeschrock if (isspare) { 250499653d4eSeschrock /* 250599653d4eSeschrock * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for 250699653d4eSeschrock * online drives. 250799653d4eSeschrock */ 250899653d4eSeschrock if (vs->vs_aux == VDEV_AUX_SPARED) 250999653d4eSeschrock state = "INUSE"; 251099653d4eSeschrock else if (vs->vs_state == VDEV_STATE_HEALTHY) 251199653d4eSeschrock state = "AVAIL"; 251299653d4eSeschrock } 251399653d4eSeschrock 2514fa9e4066Sahrens (void) printf("\t%*s%-*s %-8s", depth, "", namewidth - depth, 251599653d4eSeschrock name, state); 2516fa9e4066Sahrens 251799653d4eSeschrock if (!isspare) { 251899653d4eSeschrock zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf)); 251999653d4eSeschrock zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf)); 252099653d4eSeschrock zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf)); 252199653d4eSeschrock (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf); 252299653d4eSeschrock } 2523fa9e4066Sahrens 2524ea8dc4b6Seschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 2525ea8dc4b6Seschrock ¬present) == 0) { 2526ea8dc4b6Seschrock char *path; 2527ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 25280917b783Seschrock (void) printf(" was %s", path); 2529ea8dc4b6Seschrock } else if (vs->vs_aux != 0) { 2530fa9e4066Sahrens (void) printf(" "); 2531fa9e4066Sahrens 2532fa9e4066Sahrens switch (vs->vs_aux) { 2533fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 2534fa9e4066Sahrens (void) printf(gettext("cannot open")); 2535fa9e4066Sahrens break; 2536fa9e4066Sahrens 2537fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 2538fa9e4066Sahrens (void) printf(gettext("missing device")); 2539fa9e4066Sahrens break; 2540fa9e4066Sahrens 2541fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 2542fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 2543fa9e4066Sahrens break; 2544fa9e4066Sahrens 2545eaca9bbdSeschrock case VDEV_AUX_VERSION_NEWER: 2546eaca9bbdSeschrock (void) printf(gettext("newer version")); 2547eaca9bbdSeschrock break; 2548eaca9bbdSeschrock 254999653d4eSeschrock case VDEV_AUX_SPARED: 255099653d4eSeschrock verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, 255199653d4eSeschrock &cb.cb_guid) == 0); 255299653d4eSeschrock if (zpool_iter(g_zfs, find_spare, &cb) == 1) { 255399653d4eSeschrock if (strcmp(zpool_get_name(cb.cb_zhp), 255499653d4eSeschrock zpool_get_name(zhp)) == 0) 255599653d4eSeschrock (void) printf(gettext("currently in " 255699653d4eSeschrock "use")); 255799653d4eSeschrock else 255899653d4eSeschrock (void) printf(gettext("in use by " 255999653d4eSeschrock "pool '%s'"), 256099653d4eSeschrock zpool_get_name(cb.cb_zhp)); 256199653d4eSeschrock zpool_close(cb.cb_zhp); 256299653d4eSeschrock } else { 256399653d4eSeschrock (void) printf(gettext("currently in use")); 256499653d4eSeschrock } 256599653d4eSeschrock break; 256699653d4eSeschrock 2567fa9e4066Sahrens default: 2568fa9e4066Sahrens (void) printf(gettext("corrupted data")); 2569fa9e4066Sahrens break; 2570fa9e4066Sahrens } 2571fa9e4066Sahrens } else if (vs->vs_scrub_repaired != 0 && children == 0) { 2572fa9e4066Sahrens /* 2573fa9e4066Sahrens * Report bytes resilvered/repaired on leaf devices. 2574fa9e4066Sahrens */ 2575fa9e4066Sahrens zfs_nicenum(vs->vs_scrub_repaired, repaired, sizeof (repaired)); 2576fa9e4066Sahrens (void) printf(gettext(" %s %s"), repaired, 2577fa9e4066Sahrens (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ? 2578fa9e4066Sahrens "resilvered" : "repaired"); 2579fa9e4066Sahrens } 2580fa9e4066Sahrens 2581fa9e4066Sahrens (void) printf("\n"); 2582fa9e4066Sahrens 2583afefbcddSeschrock for (c = 0; c < children; c++) { 258499653d4eSeschrock vname = zpool_vdev_name(g_zfs, zhp, child[c]); 2585c67d9675Seschrock print_status_config(zhp, vname, child[c], 258699653d4eSeschrock namewidth, depth + 2, isspare); 2587afefbcddSeschrock free(vname); 2588afefbcddSeschrock } 2589fa9e4066Sahrens } 2590fa9e4066Sahrens 2591ea8dc4b6Seschrock static void 2592ea8dc4b6Seschrock print_error_log(zpool_handle_t *zhp) 2593ea8dc4b6Seschrock { 2594ea8dc4b6Seschrock nvlist_t **log; 2595ea8dc4b6Seschrock size_t nelem; 2596ea8dc4b6Seschrock size_t maxdsname = sizeof ("DATASET") - 1; 2597ea8dc4b6Seschrock size_t maxobjname = sizeof ("OBJECT") - 1; 2598ea8dc4b6Seschrock int i; 2599ea8dc4b6Seschrock nvlist_t *nv; 2600ea8dc4b6Seschrock size_t len; 2601ea8dc4b6Seschrock char *dsname, *objname, *range; 2602ea8dc4b6Seschrock 2603ea8dc4b6Seschrock if (zpool_get_errlog(zhp, &log, &nelem) != 0) { 2604ea8dc4b6Seschrock (void) printf("errors: List of errors unavailable " 2605ea8dc4b6Seschrock "(insufficient privileges)\n"); 2606ea8dc4b6Seschrock return; 2607ea8dc4b6Seschrock } 2608ea8dc4b6Seschrock 2609ea8dc4b6Seschrock for (i = 0; i < nelem; i++) { 2610ea8dc4b6Seschrock nv = log[i]; 2611ea8dc4b6Seschrock 2612ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_DATASET, 2613ea8dc4b6Seschrock &dsname) == 0); 2614ea8dc4b6Seschrock len = strlen(dsname); 2615ea8dc4b6Seschrock if (len > maxdsname) 2616ea8dc4b6Seschrock maxdsname = len; 2617ea8dc4b6Seschrock 2618ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_OBJECT, 2619ea8dc4b6Seschrock &objname) == 0); 2620ea8dc4b6Seschrock len = strlen(objname); 2621ea8dc4b6Seschrock if (len > maxobjname) 2622ea8dc4b6Seschrock maxobjname = len; 2623ea8dc4b6Seschrock } 2624ea8dc4b6Seschrock 2625ea8dc4b6Seschrock (void) printf("errors: The following persistent errors have been " 2626ea8dc4b6Seschrock "detected:\n\n"); 2627ea8dc4b6Seschrock (void) printf("%8s %-*s %-*s %s\n", "", maxdsname, "DATASET", 2628ea8dc4b6Seschrock maxobjname, "OBJECT", "RANGE"); 2629ea8dc4b6Seschrock 2630ea8dc4b6Seschrock for (i = 0; i < nelem; i++) { 2631ea8dc4b6Seschrock nv = log[i]; 2632ea8dc4b6Seschrock 2633ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_DATASET, 2634ea8dc4b6Seschrock &dsname) == 0); 2635ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_OBJECT, 2636ea8dc4b6Seschrock &objname) == 0); 2637ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_RANGE, 2638ea8dc4b6Seschrock &range) == 0); 2639ea8dc4b6Seschrock 2640ea8dc4b6Seschrock (void) printf("%8s %-*s %-*s %s\n", "", maxdsname, 2641ea8dc4b6Seschrock dsname, maxobjname, objname, range); 2642ea8dc4b6Seschrock } 2643ea8dc4b6Seschrock } 2644ea8dc4b6Seschrock 264599653d4eSeschrock static void 264699653d4eSeschrock print_spares(zpool_handle_t *zhp, nvlist_t **spares, uint_t nspares, 264799653d4eSeschrock int namewidth) 264899653d4eSeschrock { 264999653d4eSeschrock uint_t i; 265099653d4eSeschrock char *name; 265199653d4eSeschrock 265299653d4eSeschrock if (nspares == 0) 265399653d4eSeschrock return; 265499653d4eSeschrock 265599653d4eSeschrock (void) printf(gettext("\tspares\n")); 265699653d4eSeschrock 265799653d4eSeschrock for (i = 0; i < nspares; i++) { 265899653d4eSeschrock name = zpool_vdev_name(g_zfs, zhp, spares[i]); 265999653d4eSeschrock print_status_config(zhp, name, spares[i], 266099653d4eSeschrock namewidth, 2, B_TRUE); 266199653d4eSeschrock free(name); 266299653d4eSeschrock } 266399653d4eSeschrock } 266499653d4eSeschrock 2665fa9e4066Sahrens /* 2666fa9e4066Sahrens * Display a summary of pool status. Displays a summary such as: 2667fa9e4066Sahrens * 2668fa9e4066Sahrens * pool: tank 2669fa9e4066Sahrens * status: DEGRADED 2670fa9e4066Sahrens * reason: One or more devices ... 2671fa9e4066Sahrens * see: http://www.sun.com/msg/ZFS-xxxx-01 2672fa9e4066Sahrens * config: 2673fa9e4066Sahrens * mirror DEGRADED 2674fa9e4066Sahrens * c1t0d0 OK 2675ea8dc4b6Seschrock * c2t0d0 UNAVAIL 2676fa9e4066Sahrens * 2677fa9e4066Sahrens * When given the '-v' option, we print out the complete config. If the '-e' 2678fa9e4066Sahrens * option is specified, then we print out error rate information as well. 2679fa9e4066Sahrens */ 2680fa9e4066Sahrens int 2681fa9e4066Sahrens status_callback(zpool_handle_t *zhp, void *data) 2682fa9e4066Sahrens { 2683fa9e4066Sahrens status_cbdata_t *cbp = data; 2684fa9e4066Sahrens nvlist_t *config, *nvroot; 2685fa9e4066Sahrens char *msgid; 2686fa9e4066Sahrens int reason; 2687fa9e4066Sahrens char *health; 2688fa9e4066Sahrens 2689088e9d47Seschrock config = zpool_get_config(zhp, NULL); 2690fa9e4066Sahrens reason = zpool_get_status(zhp, &msgid); 2691fa9e4066Sahrens 2692fa9e4066Sahrens cbp->cb_count++; 2693fa9e4066Sahrens 2694fa9e4066Sahrens /* 2695fa9e4066Sahrens * If we were given 'zpool status -x', only report those pools with 2696fa9e4066Sahrens * problems. 2697fa9e4066Sahrens */ 2698*e9dbad6fSeschrock if (reason == ZPOOL_STATUS_OK && cbp->cb_explain) { 2699*e9dbad6fSeschrock if (!cbp->cb_allpools) { 2700*e9dbad6fSeschrock (void) printf(gettext("pool '%s' is healthy\n"), 2701*e9dbad6fSeschrock zpool_get_name(zhp)); 2702*e9dbad6fSeschrock if (cbp->cb_first) 2703*e9dbad6fSeschrock cbp->cb_first = B_FALSE; 2704*e9dbad6fSeschrock } 2705fa9e4066Sahrens return (0); 2706*e9dbad6fSeschrock } 2707fa9e4066Sahrens 2708fa9e4066Sahrens if (cbp->cb_first) 270999653d4eSeschrock cbp->cb_first = B_FALSE; 2710fa9e4066Sahrens else 2711fa9e4066Sahrens (void) printf("\n"); 2712fa9e4066Sahrens 2713fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_HEALTH, 2714fa9e4066Sahrens &health) == 0); 2715fa9e4066Sahrens 2716fa9e4066Sahrens (void) printf(gettext(" pool: %s\n"), zpool_get_name(zhp)); 2717fa9e4066Sahrens (void) printf(gettext(" state: %s\n"), health); 2718fa9e4066Sahrens 2719fa9e4066Sahrens switch (reason) { 2720fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 2721fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2722fa9e4066Sahrens "be opened. Sufficient replicas exist for\n\tthe pool to " 2723fa9e4066Sahrens "continue functioning in a degraded state.\n")); 2724fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 2725fa9e4066Sahrens "online it using 'zpool online'.\n")); 2726fa9e4066Sahrens break; 2727fa9e4066Sahrens 2728fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 2729fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2730fa9e4066Sahrens "be opened. There are insufficient\n\treplicas for the " 2731fa9e4066Sahrens "pool to continue functioning.\n")); 2732fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 2733fa9e4066Sahrens "online it using 'zpool online'.\n")); 2734fa9e4066Sahrens break; 2735fa9e4066Sahrens 2736fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 2737fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2738fa9e4066Sahrens "be used because the label is missing or\n\tinvalid. " 2739fa9e4066Sahrens "Sufficient replicas exist for the pool to continue\n\t" 2740fa9e4066Sahrens "functioning in a degraded state.\n")); 2741fa9e4066Sahrens (void) printf(gettext("action: Replace the device using " 2742fa9e4066Sahrens "'zpool replace'.\n")); 2743fa9e4066Sahrens break; 2744fa9e4066Sahrens 2745fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 2746fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2747fa9e4066Sahrens "be used because the the label is missing \n\tor invalid. " 2748fa9e4066Sahrens "There are insufficient replicas for the pool to " 2749fa9e4066Sahrens "continue\n\tfunctioning.\n")); 2750fa9e4066Sahrens (void) printf(gettext("action: Destroy and re-create the pool " 2751fa9e4066Sahrens "from a backup source.\n")); 2752fa9e4066Sahrens break; 2753fa9e4066Sahrens 2754fa9e4066Sahrens case ZPOOL_STATUS_FAILING_DEV: 2755fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 2756fa9e4066Sahrens "experienced an unrecoverable error. An\n\tattempt was " 2757fa9e4066Sahrens "made to correct the error. Applications are " 2758fa9e4066Sahrens "unaffected.\n")); 2759fa9e4066Sahrens (void) printf(gettext("action: Determine if the device needs " 2760fa9e4066Sahrens "to be replaced, and clear the errors\n\tusing " 2761ea8dc4b6Seschrock "'zpool clear' or replace the device with 'zpool " 2762fa9e4066Sahrens "replace'.\n")); 2763fa9e4066Sahrens break; 2764fa9e4066Sahrens 2765fa9e4066Sahrens case ZPOOL_STATUS_OFFLINE_DEV: 2766fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 2767fa9e4066Sahrens "been taken offline by the adminstrator.\n\tSufficient " 2768fa9e4066Sahrens "replicas exist for the pool to continue functioning in " 2769fa9e4066Sahrens "a\n\tdegraded state.\n")); 2770fa9e4066Sahrens (void) printf(gettext("action: Online the device using " 2771fa9e4066Sahrens "'zpool online' or replace the device with\n\t'zpool " 2772fa9e4066Sahrens "replace'.\n")); 2773fa9e4066Sahrens break; 2774fa9e4066Sahrens 2775fa9e4066Sahrens case ZPOOL_STATUS_RESILVERING: 2776fa9e4066Sahrens (void) printf(gettext("status: One or more devices is " 2777fa9e4066Sahrens "currently being resilvered. The pool will\n\tcontinue " 2778fa9e4066Sahrens "to function, possibly in a degraded state.\n")); 2779fa9e4066Sahrens (void) printf(gettext("action: Wait for the resilver to " 2780fa9e4066Sahrens "complete.\n")); 2781fa9e4066Sahrens break; 2782fa9e4066Sahrens 2783ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_DATA: 2784ea8dc4b6Seschrock (void) printf(gettext("status: One or more devices has " 2785ea8dc4b6Seschrock "experienced an error resulting in data\n\tcorruption. " 2786ea8dc4b6Seschrock "Applications may be affected.\n")); 2787ea8dc4b6Seschrock (void) printf(gettext("action: Restore the file in question " 2788ea8dc4b6Seschrock "if possible. Otherwise restore the\n\tentire pool from " 2789ea8dc4b6Seschrock "backup.\n")); 2790ea8dc4b6Seschrock break; 2791ea8dc4b6Seschrock 2792ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 2793ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is corrupted " 2794ea8dc4b6Seschrock "and the pool cannot be opened.\n")); 2795ea8dc4b6Seschrock (void) printf(gettext("action: Destroy and re-create the pool " 2796ea8dc4b6Seschrock "from a backup source.\n")); 2797ea8dc4b6Seschrock break; 2798ea8dc4b6Seschrock 2799eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 2800eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 2801eaca9bbdSeschrock "older on-disk format. The pool can\n\tstill be used, but " 2802eaca9bbdSeschrock "some features are unavailable.\n")); 2803eaca9bbdSeschrock (void) printf(gettext("action: Upgrade the pool using 'zpool " 2804eaca9bbdSeschrock "upgrade'. Once this is done, the\n\tpool will no longer " 2805eaca9bbdSeschrock "be accessible on older software versions.\n")); 2806eaca9bbdSeschrock break; 2807eaca9bbdSeschrock 2808eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 2809eaca9bbdSeschrock (void) printf(gettext("status: The pool has been upgraded to a " 2810eaca9bbdSeschrock "newer, incompatible on-disk version.\n\tThe pool cannot " 2811eaca9bbdSeschrock "be accessed on this system.\n")); 2812eaca9bbdSeschrock (void) printf(gettext("action: Access the pool from a system " 2813eaca9bbdSeschrock "running more recent software, or\n\trestore the pool from " 2814eaca9bbdSeschrock "backup.\n")); 2815eaca9bbdSeschrock break; 2816eaca9bbdSeschrock 2817fa9e4066Sahrens default: 2818fa9e4066Sahrens /* 2819fa9e4066Sahrens * The remaining errors can't actually be generated, yet. 2820fa9e4066Sahrens */ 2821fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 2822fa9e4066Sahrens } 2823fa9e4066Sahrens 2824fa9e4066Sahrens if (msgid != NULL) 2825fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 2826fa9e4066Sahrens msgid); 2827fa9e4066Sahrens 2828fa9e4066Sahrens if (config != NULL) { 2829fa9e4066Sahrens int namewidth; 2830ea8dc4b6Seschrock uint64_t nerr; 2831ea8dc4b6Seschrock size_t realerr; 283299653d4eSeschrock nvlist_t **spares; 283399653d4eSeschrock uint_t nspares; 2834fa9e4066Sahrens 2835fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2836fa9e4066Sahrens &nvroot) == 0); 2837fa9e4066Sahrens 2838fa9e4066Sahrens (void) printf(gettext(" scrub: ")); 2839fa9e4066Sahrens print_scrub_status(nvroot); 2840fa9e4066Sahrens 2841c67d9675Seschrock namewidth = max_width(zhp, nvroot, 0, 0); 2842fa9e4066Sahrens if (namewidth < 10) 2843fa9e4066Sahrens namewidth = 10; 2844fa9e4066Sahrens 2845fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 2846fa9e4066Sahrens (void) printf(gettext("\t%-*s %-8s %5s %5s %5s\n"), namewidth, 2847fa9e4066Sahrens "NAME", "STATE", "READ", "WRITE", "CKSUM"); 2848c67d9675Seschrock print_status_config(zhp, zpool_get_name(zhp), nvroot, 284999653d4eSeschrock namewidth, 0, B_FALSE); 285099653d4eSeschrock 285199653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 285299653d4eSeschrock &spares, &nspares) == 0) 285399653d4eSeschrock print_spares(zhp, spares, nspares, namewidth); 2854ea8dc4b6Seschrock 2855ea8dc4b6Seschrock if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT, 2856ea8dc4b6Seschrock &nerr) == 0) { 2857ea8dc4b6Seschrock /* 2858ea8dc4b6Seschrock * If the approximate error count is small, get a 2859ea8dc4b6Seschrock * precise count by fetching the entire log and 2860ea8dc4b6Seschrock * uniquifying the results. 2861ea8dc4b6Seschrock */ 2862ea8dc4b6Seschrock if (nerr < 100 && !cbp->cb_verbose && 2863ea8dc4b6Seschrock zpool_get_errlog(zhp, NULL, &realerr) == 0) 2864ea8dc4b6Seschrock nerr = realerr; 2865ea8dc4b6Seschrock 2866ea8dc4b6Seschrock (void) printf("\n"); 286799653d4eSeschrock 2868ea8dc4b6Seschrock if (nerr == 0) 2869ea8dc4b6Seschrock (void) printf(gettext("errors: No known data " 2870ea8dc4b6Seschrock "errors\n")); 2871ea8dc4b6Seschrock else if (!cbp->cb_verbose) 2872*e9dbad6fSeschrock (void) printf(gettext("errors: %llu data " 2873*e9dbad6fSeschrock "errors, use '-v' for a list\n"), nerr); 2874ea8dc4b6Seschrock else 2875ea8dc4b6Seschrock print_error_log(zhp); 2876ea8dc4b6Seschrock } 2877fa9e4066Sahrens } else { 2878fa9e4066Sahrens (void) printf(gettext("config: The configuration cannot be " 2879fa9e4066Sahrens "determined.\n")); 2880fa9e4066Sahrens } 2881fa9e4066Sahrens 2882fa9e4066Sahrens return (0); 2883fa9e4066Sahrens } 2884fa9e4066Sahrens 2885fa9e4066Sahrens /* 2886fa9e4066Sahrens * zpool status [-vx] [pool] ... 2887fa9e4066Sahrens * 2888fa9e4066Sahrens * -v Display complete error logs 2889fa9e4066Sahrens * -x Display only pools with potential problems 2890fa9e4066Sahrens * 2891fa9e4066Sahrens * Describes the health status of all pools or some subset. 2892fa9e4066Sahrens */ 2893fa9e4066Sahrens int 2894fa9e4066Sahrens zpool_do_status(int argc, char **argv) 2895fa9e4066Sahrens { 2896fa9e4066Sahrens int c; 2897fa9e4066Sahrens int ret; 2898fa9e4066Sahrens status_cbdata_t cb = { 0 }; 2899fa9e4066Sahrens 2900fa9e4066Sahrens /* check options */ 2901fa9e4066Sahrens while ((c = getopt(argc, argv, "vx")) != -1) { 2902fa9e4066Sahrens switch (c) { 2903fa9e4066Sahrens case 'v': 290499653d4eSeschrock cb.cb_verbose = B_TRUE; 2905fa9e4066Sahrens break; 2906fa9e4066Sahrens case 'x': 290799653d4eSeschrock cb.cb_explain = B_TRUE; 2908fa9e4066Sahrens break; 2909fa9e4066Sahrens case '?': 2910fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2911fa9e4066Sahrens optopt); 291299653d4eSeschrock usage(B_FALSE); 2913fa9e4066Sahrens } 2914fa9e4066Sahrens } 2915fa9e4066Sahrens 2916fa9e4066Sahrens argc -= optind; 2917fa9e4066Sahrens argv += optind; 2918fa9e4066Sahrens 291999653d4eSeschrock cb.cb_first = B_TRUE; 2920fa9e4066Sahrens 2921*e9dbad6fSeschrock if (argc == 0) 2922*e9dbad6fSeschrock cb.cb_allpools = B_TRUE; 2923*e9dbad6fSeschrock 292499653d4eSeschrock ret = for_each_pool(argc, argv, B_TRUE, status_callback, &cb); 2925fa9e4066Sahrens 2926fa9e4066Sahrens if (argc == 0 && cb.cb_count == 0) 2927fa9e4066Sahrens (void) printf(gettext("no pools available\n")); 2928*e9dbad6fSeschrock else if (cb.cb_explain && cb.cb_first && cb.cb_allpools) 2929*e9dbad6fSeschrock (void) printf(gettext("all pools are healthy\n")); 2930fa9e4066Sahrens 2931fa9e4066Sahrens return (ret); 2932fa9e4066Sahrens } 2933fa9e4066Sahrens 2934eaca9bbdSeschrock typedef struct upgrade_cbdata { 2935eaca9bbdSeschrock int cb_all; 2936eaca9bbdSeschrock int cb_first; 2937eaca9bbdSeschrock int cb_newer; 2938eaca9bbdSeschrock } upgrade_cbdata_t; 2939eaca9bbdSeschrock 2940eaca9bbdSeschrock static int 2941eaca9bbdSeschrock upgrade_cb(zpool_handle_t *zhp, void *arg) 2942eaca9bbdSeschrock { 2943eaca9bbdSeschrock upgrade_cbdata_t *cbp = arg; 2944eaca9bbdSeschrock nvlist_t *config; 2945eaca9bbdSeschrock uint64_t version; 2946eaca9bbdSeschrock int ret = 0; 2947eaca9bbdSeschrock 2948eaca9bbdSeschrock config = zpool_get_config(zhp, NULL); 2949eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 2950eaca9bbdSeschrock &version) == 0); 2951eaca9bbdSeschrock 2952eaca9bbdSeschrock if (!cbp->cb_newer && version < ZFS_VERSION) { 2953eaca9bbdSeschrock if (!cbp->cb_all) { 2954eaca9bbdSeschrock if (cbp->cb_first) { 2955eaca9bbdSeschrock (void) printf(gettext("The following pools are " 2956eaca9bbdSeschrock "out of date, and can be upgraded. After " 2957eaca9bbdSeschrock "being\nupgraded, these pools will no " 2958eaca9bbdSeschrock "longer be accessible by older software " 2959eaca9bbdSeschrock "versions.\n\n")); 2960eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 2961eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 296299653d4eSeschrock cbp->cb_first = B_FALSE; 2963eaca9bbdSeschrock } 2964eaca9bbdSeschrock 2965eaca9bbdSeschrock (void) printf("%2llu %s\n", version, 2966eaca9bbdSeschrock zpool_get_name(zhp)); 2967eaca9bbdSeschrock } else { 296899653d4eSeschrock cbp->cb_first = B_FALSE; 2969eaca9bbdSeschrock ret = zpool_upgrade(zhp); 2970eaca9bbdSeschrock if (ret == 0) 2971eaca9bbdSeschrock (void) printf(gettext("Successfully upgraded " 2972eaca9bbdSeschrock "'%s'\n"), zpool_get_name(zhp)); 2973eaca9bbdSeschrock } 2974eaca9bbdSeschrock } else if (cbp->cb_newer && version > ZFS_VERSION) { 2975eaca9bbdSeschrock assert(!cbp->cb_all); 2976eaca9bbdSeschrock 2977eaca9bbdSeschrock if (cbp->cb_first) { 2978eaca9bbdSeschrock (void) printf(gettext("The following pools are " 2979eaca9bbdSeschrock "formatted using a newer software version and\n" 2980eaca9bbdSeschrock "cannot be accessed on the current system.\n\n")); 2981eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 2982eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 298399653d4eSeschrock cbp->cb_first = B_FALSE; 2984eaca9bbdSeschrock } 2985eaca9bbdSeschrock 2986eaca9bbdSeschrock (void) printf("%2llu %s\n", version, 2987eaca9bbdSeschrock zpool_get_name(zhp)); 2988eaca9bbdSeschrock } 2989eaca9bbdSeschrock 2990eaca9bbdSeschrock zpool_close(zhp); 2991eaca9bbdSeschrock return (ret); 2992eaca9bbdSeschrock } 2993eaca9bbdSeschrock 2994eaca9bbdSeschrock /* ARGSUSED */ 2995eaca9bbdSeschrock static int 2996eaca9bbdSeschrock upgrade_one(zpool_handle_t *zhp, void *unused) 2997eaca9bbdSeschrock { 2998eaca9bbdSeschrock nvlist_t *config; 2999eaca9bbdSeschrock uint64_t version; 3000eaca9bbdSeschrock int ret; 3001eaca9bbdSeschrock 3002eaca9bbdSeschrock config = zpool_get_config(zhp, NULL); 3003eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 3004eaca9bbdSeschrock &version) == 0); 3005eaca9bbdSeschrock 3006eaca9bbdSeschrock if (version == ZFS_VERSION) { 3007eaca9bbdSeschrock (void) printf(gettext("Pool '%s' is already formatted " 3008eaca9bbdSeschrock "using the current version.\n"), zpool_get_name(zhp)); 3009eaca9bbdSeschrock return (0); 3010eaca9bbdSeschrock } 3011eaca9bbdSeschrock 3012eaca9bbdSeschrock ret = zpool_upgrade(zhp); 3013eaca9bbdSeschrock if (ret == 0) 301444cd46caSbillm (void) printf(gettext("Successfully upgraded '%s' " 301544cd46caSbillm "from version %llu to version %llu\n"), zpool_get_name(zhp), 301644cd46caSbillm (u_longlong_t)version, (u_longlong_t)ZFS_VERSION); 3017eaca9bbdSeschrock 3018eaca9bbdSeschrock return (ret != 0); 3019eaca9bbdSeschrock } 3020eaca9bbdSeschrock 3021eaca9bbdSeschrock /* 3022eaca9bbdSeschrock * zpool upgrade 3023eaca9bbdSeschrock * zpool upgrade -v 3024eaca9bbdSeschrock * zpool upgrade <-a | pool> 3025eaca9bbdSeschrock * 3026eaca9bbdSeschrock * With no arguments, display downrev'd ZFS pool available for upgrade. 3027eaca9bbdSeschrock * Individual pools can be upgraded by specifying the pool, and '-a' will 3028eaca9bbdSeschrock * upgrade all pools. 3029eaca9bbdSeschrock */ 3030eaca9bbdSeschrock int 3031eaca9bbdSeschrock zpool_do_upgrade(int argc, char **argv) 3032eaca9bbdSeschrock { 3033eaca9bbdSeschrock int c; 3034eaca9bbdSeschrock upgrade_cbdata_t cb = { 0 }; 3035eaca9bbdSeschrock int ret = 0; 3036eaca9bbdSeschrock boolean_t showversions = B_FALSE; 3037eaca9bbdSeschrock 3038eaca9bbdSeschrock /* check options */ 3039eaca9bbdSeschrock while ((c = getopt(argc, argv, "av")) != -1) { 3040eaca9bbdSeschrock switch (c) { 3041eaca9bbdSeschrock case 'a': 304299653d4eSeschrock cb.cb_all = B_TRUE; 3043eaca9bbdSeschrock break; 3044eaca9bbdSeschrock case 'v': 3045eaca9bbdSeschrock showversions = B_TRUE; 3046eaca9bbdSeschrock break; 3047eaca9bbdSeschrock case '?': 3048eaca9bbdSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3049eaca9bbdSeschrock optopt); 305099653d4eSeschrock usage(B_FALSE); 3051eaca9bbdSeschrock } 3052eaca9bbdSeschrock } 3053eaca9bbdSeschrock 3054eaca9bbdSeschrock argc -= optind; 3055eaca9bbdSeschrock argv += optind; 3056eaca9bbdSeschrock 3057eaca9bbdSeschrock if (showversions) { 3058eaca9bbdSeschrock if (cb.cb_all || argc != 0) { 3059eaca9bbdSeschrock (void) fprintf(stderr, gettext("-v option is " 3060eaca9bbdSeschrock "incompatible with other arguments\n")); 306199653d4eSeschrock usage(B_FALSE); 3062eaca9bbdSeschrock } 3063eaca9bbdSeschrock } else if (cb.cb_all) { 3064eaca9bbdSeschrock if (argc != 0) { 3065eaca9bbdSeschrock (void) fprintf(stderr, gettext("-a option is " 3066eaca9bbdSeschrock "incompatible with other arguments\n")); 306799653d4eSeschrock usage(B_FALSE); 3068eaca9bbdSeschrock } 3069eaca9bbdSeschrock } 3070eaca9bbdSeschrock 3071eaca9bbdSeschrock (void) printf(gettext("This system is currently running ZFS version " 3072eaca9bbdSeschrock "%llu.\n\n"), ZFS_VERSION); 307399653d4eSeschrock cb.cb_first = B_TRUE; 3074eaca9bbdSeschrock if (showversions) { 3075eaca9bbdSeschrock (void) printf(gettext("The following versions are " 3076eaca9bbdSeschrock "suppored:\n\n")); 3077eaca9bbdSeschrock (void) printf(gettext("VER DESCRIPTION\n")); 3078eaca9bbdSeschrock (void) printf("--- -----------------------------------------" 3079eaca9bbdSeschrock "---------------\n"); 308099653d4eSeschrock (void) printf(gettext(" 1 Initial ZFS version\n")); 308144cd46caSbillm (void) printf(gettext(" 2 Ditto blocks " 308244cd46caSbillm "(replicated metadata)\n")); 308399653d4eSeschrock (void) printf(gettext(" 3 Hot spares and double parity " 308499653d4eSeschrock "RAID-Z\n")); 308544cd46caSbillm (void) printf(gettext("\nFor more information on a particular " 3086eaca9bbdSeschrock "version, including supported releases, see:\n\n")); 3087eaca9bbdSeschrock (void) printf("http://www.opensolaris.org/os/community/zfs/" 3088eaca9bbdSeschrock "version/N\n\n"); 3089eaca9bbdSeschrock (void) printf(gettext("Where 'N' is the version number.\n")); 3090eaca9bbdSeschrock } else if (argc == 0) { 3091eaca9bbdSeschrock int notfound; 3092eaca9bbdSeschrock 309399653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 3094eaca9bbdSeschrock notfound = cb.cb_first; 3095eaca9bbdSeschrock 3096eaca9bbdSeschrock if (!cb.cb_all && ret == 0) { 3097eaca9bbdSeschrock if (!cb.cb_first) 3098eaca9bbdSeschrock (void) printf("\n"); 3099eaca9bbdSeschrock cb.cb_first = B_TRUE; 3100eaca9bbdSeschrock cb.cb_newer = B_TRUE; 310199653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 3102eaca9bbdSeschrock if (!cb.cb_first) { 3103eaca9bbdSeschrock notfound = B_FALSE; 3104eaca9bbdSeschrock (void) printf("\n"); 3105eaca9bbdSeschrock } 3106eaca9bbdSeschrock } 3107eaca9bbdSeschrock 3108eaca9bbdSeschrock if (ret == 0) { 3109eaca9bbdSeschrock if (notfound) 3110eaca9bbdSeschrock (void) printf(gettext("All pools are formatted " 3111eaca9bbdSeschrock "using this version.\n")); 3112eaca9bbdSeschrock else if (!cb.cb_all) 3113eaca9bbdSeschrock (void) printf(gettext("Use 'zpool upgrade -v' " 3114eaca9bbdSeschrock "for a list of available versions and " 3115eaca9bbdSeschrock "their associated\nfeatures.\n")); 3116eaca9bbdSeschrock } 3117eaca9bbdSeschrock } else { 311899653d4eSeschrock ret = for_each_pool(argc, argv, B_FALSE, upgrade_one, NULL); 3119eaca9bbdSeschrock } 3120eaca9bbdSeschrock 3121eaca9bbdSeschrock return (ret); 3122eaca9bbdSeschrock } 3123eaca9bbdSeschrock 3124fa9e4066Sahrens int 3125fa9e4066Sahrens main(int argc, char **argv) 3126fa9e4066Sahrens { 3127fa9e4066Sahrens int ret; 3128fa9e4066Sahrens int i; 3129fa9e4066Sahrens char *cmdname; 3130fa9e4066Sahrens 3131fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 3132fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 3133fa9e4066Sahrens 313499653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 313599653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to " 313699653d4eSeschrock "initialize ZFS library")); 313799653d4eSeschrock return (1); 313899653d4eSeschrock } 313999653d4eSeschrock 314099653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE); 314199653d4eSeschrock 3142fa9e4066Sahrens opterr = 0; 3143fa9e4066Sahrens 3144fa9e4066Sahrens /* 3145fa9e4066Sahrens * Make sure the user has specified some command. 3146fa9e4066Sahrens */ 3147fa9e4066Sahrens if (argc < 2) { 3148fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 314999653d4eSeschrock usage(B_FALSE); 3150fa9e4066Sahrens } 3151fa9e4066Sahrens 3152fa9e4066Sahrens cmdname = argv[1]; 3153fa9e4066Sahrens 3154fa9e4066Sahrens /* 3155fa9e4066Sahrens * Special case '-?' 3156fa9e4066Sahrens */ 3157fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 315899653d4eSeschrock usage(B_TRUE); 3159fa9e4066Sahrens 3160fa9e4066Sahrens /* 3161fa9e4066Sahrens * Run the appropriate command. 3162fa9e4066Sahrens */ 3163fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 3164fa9e4066Sahrens if (command_table[i].name == NULL) 3165fa9e4066Sahrens continue; 3166fa9e4066Sahrens 3167fa9e4066Sahrens if (strcmp(cmdname, command_table[i].name) == 0) { 3168fa9e4066Sahrens current_command = &command_table[i]; 3169fa9e4066Sahrens ret = command_table[i].func(argc - 1, argv + 1); 3170fa9e4066Sahrens break; 3171fa9e4066Sahrens } 3172fa9e4066Sahrens } 3173fa9e4066Sahrens 3174fa9e4066Sahrens /* 3175fa9e4066Sahrens * 'freeze' is a vile debugging abomination, so we treat it as such. 3176fa9e4066Sahrens */ 3177fa9e4066Sahrens if (strcmp(cmdname, "freeze") == 0 && argc == 3) { 3178ea8dc4b6Seschrock char buf[16384]; 3179ea8dc4b6Seschrock int fd = open(ZFS_DEV, O_RDWR); 3180fa9e4066Sahrens (void) strcpy((void *)buf, argv[2]); 3181fa9e4066Sahrens return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf)); 3182fa9e4066Sahrens } 3183fa9e4066Sahrens 3184fa9e4066Sahrens if (i == NCOMMAND) { 3185fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 3186fa9e4066Sahrens "command '%s'\n"), cmdname); 318799653d4eSeschrock usage(B_FALSE); 3188fa9e4066Sahrens } 3189fa9e4066Sahrens 319099653d4eSeschrock libzfs_fini(g_zfs); 319199653d4eSeschrock 3192fa9e4066Sahrens /* 3193fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 3194fa9e4066Sahrens * for the purposes of running ::findleaks. 3195fa9e4066Sahrens */ 3196fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 3197fa9e4066Sahrens (void) printf("dumping core by request\n"); 3198fa9e4066Sahrens abort(); 3199fa9e4066Sahrens } 3200fa9e4066Sahrens 3201fa9e4066Sahrens return (ret); 3202fa9e4066Sahrens } 3203