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 */ 21fa9e4066Sahrens /* 22c67d9675Seschrock * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23fa9e4066Sahrens * Use is subject to license terms. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 27fa9e4066Sahrens 28fa9e4066Sahrens #include <assert.h> 29fa9e4066Sahrens #include <ctype.h> 30fa9e4066Sahrens #include <dirent.h> 31fa9e4066Sahrens #include <errno.h> 32fa9e4066Sahrens #include <fcntl.h> 33fa9e4066Sahrens #include <libgen.h> 34fa9e4066Sahrens #include <libintl.h> 35fa9e4066Sahrens #include <libuutil.h> 36fa9e4066Sahrens #include <locale.h> 37fa9e4066Sahrens #include <stdio.h> 38fa9e4066Sahrens #include <stdlib.h> 39fa9e4066Sahrens #include <string.h> 40fa9e4066Sahrens #include <strings.h> 41fa9e4066Sahrens #include <unistd.h> 42fa9e4066Sahrens #include <priv.h> 43fa9e4066Sahrens 44fa9e4066Sahrens #include <sys/stat.h> 45fa9e4066Sahrens 46fa9e4066Sahrens #include <libzfs.h> 47fa9e4066Sahrens 48fa9e4066Sahrens #include "zpool_util.h" 49fa9e4066Sahrens 50fa9e4066Sahrens static int zpool_do_create(int, char **); 51fa9e4066Sahrens static int zpool_do_destroy(int, char **); 52fa9e4066Sahrens 53fa9e4066Sahrens static int zpool_do_add(int, char **); 54fa9e4066Sahrens 55fa9e4066Sahrens static int zpool_do_list(int, char **); 56fa9e4066Sahrens static int zpool_do_iostat(int, char **); 57fa9e4066Sahrens static int zpool_do_status(int, char **); 58fa9e4066Sahrens 59fa9e4066Sahrens static int zpool_do_online(int, char **); 60fa9e4066Sahrens static int zpool_do_offline(int, char **); 61ea8dc4b6Seschrock static int zpool_do_clear(int, char **); 62fa9e4066Sahrens 63fa9e4066Sahrens static int zpool_do_attach(int, char **); 64fa9e4066Sahrens static int zpool_do_detach(int, char **); 65fa9e4066Sahrens static int zpool_do_replace(int, char **); 66fa9e4066Sahrens 67fa9e4066Sahrens static int zpool_do_scrub(int, char **); 68fa9e4066Sahrens 69fa9e4066Sahrens static int zpool_do_import(int, char **); 70fa9e4066Sahrens static int zpool_do_export(int, char **); 71fa9e4066Sahrens 72fa9e4066Sahrens /* 73fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 74fa9e4066Sahrens * debugging facilities. 75fa9e4066Sahrens */ 76fa9e4066Sahrens const char * 77fa9e4066Sahrens _umem_debug_init() 78fa9e4066Sahrens { 79fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 80fa9e4066Sahrens } 81fa9e4066Sahrens 82fa9e4066Sahrens const char * 83fa9e4066Sahrens _umem_logging_init(void) 84fa9e4066Sahrens { 85fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 86fa9e4066Sahrens } 87fa9e4066Sahrens 8865cd9f28Seschrock typedef enum { 8965cd9f28Seschrock HELP_ADD, 9065cd9f28Seschrock HELP_ATTACH, 91ea8dc4b6Seschrock HELP_CLEAR, 9265cd9f28Seschrock HELP_CREATE, 9365cd9f28Seschrock HELP_DESTROY, 9465cd9f28Seschrock HELP_DETACH, 9565cd9f28Seschrock HELP_EXPORT, 9665cd9f28Seschrock HELP_IMPORT, 9765cd9f28Seschrock HELP_IOSTAT, 9865cd9f28Seschrock HELP_LIST, 9965cd9f28Seschrock HELP_OFFLINE, 10065cd9f28Seschrock HELP_ONLINE, 10165cd9f28Seschrock HELP_REPLACE, 10265cd9f28Seschrock HELP_SCRUB, 10365cd9f28Seschrock HELP_STATUS 10465cd9f28Seschrock } zpool_help_t; 10565cd9f28Seschrock 10665cd9f28Seschrock 107fa9e4066Sahrens typedef struct zpool_command { 108fa9e4066Sahrens const char *name; 109fa9e4066Sahrens int (*func)(int, char **); 11065cd9f28Seschrock zpool_help_t usage; 111fa9e4066Sahrens } zpool_command_t; 112fa9e4066Sahrens 113fa9e4066Sahrens /* 114fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and 115ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have 116ea8dc4b6Seschrock * to have a function to return the usage message based on a command index. 11765cd9f28Seschrock * 11865cd9f28Seschrock * These commands are organized according to how they are displayed in the usage 11965cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in 12065cd9f28Seschrock * the generic usage message. 121fa9e4066Sahrens */ 122fa9e4066Sahrens static zpool_command_t command_table[] = { 12365cd9f28Seschrock { "create", zpool_do_create, HELP_CREATE }, 12465cd9f28Seschrock { "destroy", zpool_do_destroy, HELP_DESTROY }, 125fa9e4066Sahrens { NULL }, 12665cd9f28Seschrock { "add", zpool_do_add, HELP_ADD }, 127fa9e4066Sahrens { NULL }, 12865cd9f28Seschrock { "list", zpool_do_list, HELP_LIST }, 12965cd9f28Seschrock { "iostat", zpool_do_iostat, HELP_IOSTAT }, 13065cd9f28Seschrock { "status", zpool_do_status, HELP_STATUS }, 131fa9e4066Sahrens { NULL }, 13265cd9f28Seschrock { "online", zpool_do_online, HELP_ONLINE }, 13365cd9f28Seschrock { "offline", zpool_do_offline, HELP_OFFLINE }, 134ea8dc4b6Seschrock { "clear", zpool_do_clear, HELP_CLEAR }, 135fa9e4066Sahrens { NULL }, 13665cd9f28Seschrock { "attach", zpool_do_attach, HELP_ATTACH }, 13765cd9f28Seschrock { "detach", zpool_do_detach, HELP_DETACH }, 13865cd9f28Seschrock { "replace", zpool_do_replace, HELP_REPLACE }, 139fa9e4066Sahrens { NULL }, 14065cd9f28Seschrock { "scrub", zpool_do_scrub, HELP_SCRUB }, 141fa9e4066Sahrens { NULL }, 14265cd9f28Seschrock { "import", zpool_do_import, HELP_IMPORT }, 14365cd9f28Seschrock { "export", zpool_do_export, HELP_EXPORT }, 144fa9e4066Sahrens }; 145fa9e4066Sahrens 146fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0])) 147fa9e4066Sahrens 148fa9e4066Sahrens zpool_command_t *current_command; 149fa9e4066Sahrens 15065cd9f28Seschrock static const char * 15165cd9f28Seschrock get_usage(zpool_help_t idx) { 15265cd9f28Seschrock switch (idx) { 15365cd9f28Seschrock case HELP_ADD: 15465cd9f28Seschrock return (gettext("\tadd [-fn] <pool> <vdev> ...\n")); 15565cd9f28Seschrock case HELP_ATTACH: 15665cd9f28Seschrock return (gettext("\tattach [-f] <pool> <device> " 15765cd9f28Seschrock "<new_device>\n")); 158ea8dc4b6Seschrock case HELP_CLEAR: 159ea8dc4b6Seschrock return (gettext("\tclear <pool> [device]\n")); 16065cd9f28Seschrock case HELP_CREATE: 16165cd9f28Seschrock return (gettext("\tcreate [-fn] [-R root] [-m mountpoint] " 16265cd9f28Seschrock "<pool> <vdev> ...\n")); 16365cd9f28Seschrock case HELP_DESTROY: 16465cd9f28Seschrock return (gettext("\tdestroy [-f] <pool>\n")); 16565cd9f28Seschrock case HELP_DETACH: 16665cd9f28Seschrock return (gettext("\tdetach <pool> <device>\n")); 16765cd9f28Seschrock case HELP_EXPORT: 16865cd9f28Seschrock return (gettext("\texport [-f] <pool> ...\n")); 16965cd9f28Seschrock case HELP_IMPORT: 170*4c58d714Sdarrenm return (gettext("\timport [-d dir] [-D]\n" 171*4c58d714Sdarrenm "\timport [-d dir] [-D] [-f] [-o opts] [-R root] -a\n" 172*4c58d714Sdarrenm "\timport [-d dir] [-D] [-f] [-o opts] [-R root ]" 173*4c58d714Sdarrenm " <pool | id> [newpool]\n")); 17465cd9f28Seschrock case HELP_IOSTAT: 17565cd9f28Seschrock return (gettext("\tiostat [-v] [pool] ... [interval " 17665cd9f28Seschrock "[count]]\n")); 17765cd9f28Seschrock case HELP_LIST: 17865cd9f28Seschrock return (gettext("\tlist [-H] [-o field[,field]*] " 17965cd9f28Seschrock "[pool] ...\n")); 18065cd9f28Seschrock case HELP_OFFLINE: 181441d80aaSlling return (gettext("\toffline [-t] <pool> <device> ...\n")); 18265cd9f28Seschrock case HELP_ONLINE: 183441d80aaSlling return (gettext("\tonline <pool> <device> ...\n")); 18465cd9f28Seschrock case HELP_REPLACE: 18565cd9f28Seschrock return (gettext("\treplace [-f] <pool> <device> " 18665cd9f28Seschrock "[new_device]\n")); 18765cd9f28Seschrock case HELP_SCRUB: 18865cd9f28Seschrock return (gettext("\tscrub [-s] <pool> ...\n")); 18965cd9f28Seschrock case HELP_STATUS: 19065cd9f28Seschrock return (gettext("\tstatus [-vx] [pool] ...\n")); 19165cd9f28Seschrock } 19265cd9f28Seschrock 19365cd9f28Seschrock abort(); 19465cd9f28Seschrock /* NOTREACHED */ 19565cd9f28Seschrock } 19665cd9f28Seschrock 197fa9e4066Sahrens /* 198fa9e4066Sahrens * Fields available for 'zpool list'. 199fa9e4066Sahrens */ 200fa9e4066Sahrens typedef enum { 201fa9e4066Sahrens ZPOOL_FIELD_NAME, 202fa9e4066Sahrens ZPOOL_FIELD_SIZE, 203fa9e4066Sahrens ZPOOL_FIELD_USED, 204fa9e4066Sahrens ZPOOL_FIELD_AVAILABLE, 205fa9e4066Sahrens ZPOOL_FIELD_CAPACITY, 206fa9e4066Sahrens ZPOOL_FIELD_HEALTH, 207fa9e4066Sahrens ZPOOL_FIELD_ROOT 208fa9e4066Sahrens } zpool_field_t; 209fa9e4066Sahrens 210fa9e4066Sahrens #define MAX_FIELDS 10 211fa9e4066Sahrens 212fa9e4066Sahrens typedef struct column_def { 213fa9e4066Sahrens const char *cd_title; 214fa9e4066Sahrens size_t cd_width; 215fa9e4066Sahrens enum { 216fa9e4066Sahrens left_justify, 217fa9e4066Sahrens right_justify 218fa9e4066Sahrens } cd_justify; 219fa9e4066Sahrens } column_def_t; 220fa9e4066Sahrens 221fa9e4066Sahrens static column_def_t column_table[] = { 222fa9e4066Sahrens { "NAME", 20, left_justify }, 223fa9e4066Sahrens { "SIZE", 6, right_justify }, 224fa9e4066Sahrens { "USED", 6, right_justify }, 225fa9e4066Sahrens { "AVAIL", 6, right_justify }, 226fa9e4066Sahrens { "CAP", 5, right_justify }, 227fa9e4066Sahrens { "HEALTH", 9, left_justify }, 228fa9e4066Sahrens { "ALTROOT", 15, left_justify } 229fa9e4066Sahrens }; 230fa9e4066Sahrens 231fa9e4066Sahrens static char *column_subopts[] = { 232fa9e4066Sahrens "name", 233fa9e4066Sahrens "size", 234fa9e4066Sahrens "used", 235fa9e4066Sahrens "available", 236fa9e4066Sahrens "capacity", 237fa9e4066Sahrens "health", 238fa9e4066Sahrens "root", 239fa9e4066Sahrens NULL 240fa9e4066Sahrens }; 241fa9e4066Sahrens 242fa9e4066Sahrens /* 243fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 244fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 245fa9e4066Sahrens * a complete usage message. 246fa9e4066Sahrens */ 247fa9e4066Sahrens void 248fa9e4066Sahrens usage(int requested) 249fa9e4066Sahrens { 250fa9e4066Sahrens int i; 251fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 252fa9e4066Sahrens 253fa9e4066Sahrens if (current_command == NULL) { 254fa9e4066Sahrens int i; 255fa9e4066Sahrens 256fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zpool command args ...\n")); 257fa9e4066Sahrens (void) fprintf(fp, 258fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 259fa9e4066Sahrens 260fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 261fa9e4066Sahrens if (command_table[i].name == NULL) 262fa9e4066Sahrens (void) fprintf(fp, "\n"); 263fa9e4066Sahrens else 264fa9e4066Sahrens (void) fprintf(fp, "%s", 26565cd9f28Seschrock get_usage(command_table[i].usage)); 266fa9e4066Sahrens } 267fa9e4066Sahrens } else { 268fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 26965cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 270fa9e4066Sahrens 271fa9e4066Sahrens if (strcmp(current_command->name, "list") == 0) { 272fa9e4066Sahrens (void) fprintf(fp, gettext("\nwhere 'field' is one " 273fa9e4066Sahrens "of the following:\n\n")); 274fa9e4066Sahrens 275fa9e4066Sahrens for (i = 0; column_subopts[i] != NULL; i++) 276fa9e4066Sahrens (void) fprintf(fp, "\t%s\n", column_subopts[i]); 277fa9e4066Sahrens } 278fa9e4066Sahrens } 279fa9e4066Sahrens 280fa9e4066Sahrens exit(requested ? 0 : 2); 281fa9e4066Sahrens } 282fa9e4066Sahrens 283fa9e4066Sahrens const char * 284ea8dc4b6Seschrock state_to_name(vdev_stat_t *vs) 285fa9e4066Sahrens { 286ea8dc4b6Seschrock switch (vs->vs_state) { 287fa9e4066Sahrens case VDEV_STATE_CLOSED: 288fa9e4066Sahrens case VDEV_STATE_CANT_OPEN: 289ea8dc4b6Seschrock if (vs->vs_aux == VDEV_AUX_CORRUPT_DATA) 290ea8dc4b6Seschrock return (gettext("FAULTED")); 291ea8dc4b6Seschrock else 292ea8dc4b6Seschrock return (gettext("UNAVAIL")); 293fa9e4066Sahrens case VDEV_STATE_OFFLINE: 294fa9e4066Sahrens return (gettext("OFFLINE")); 295fa9e4066Sahrens case VDEV_STATE_DEGRADED: 296fa9e4066Sahrens return (gettext("DEGRADED")); 297fa9e4066Sahrens case VDEV_STATE_HEALTHY: 298fa9e4066Sahrens return (gettext("ONLINE")); 299fa9e4066Sahrens } 300fa9e4066Sahrens 301fa9e4066Sahrens return (gettext("UNKNOWN")); 302fa9e4066Sahrens } 303fa9e4066Sahrens 304fa9e4066Sahrens void 305c67d9675Seschrock print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent) 306fa9e4066Sahrens { 307fa9e4066Sahrens nvlist_t **child; 308fa9e4066Sahrens uint_t c, children; 309afefbcddSeschrock char *vname; 310fa9e4066Sahrens 311fa9e4066Sahrens if (name != NULL) 312fa9e4066Sahrens (void) printf("\t%*s%s\n", indent, "", name); 313fa9e4066Sahrens 314fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 315fa9e4066Sahrens &child, &children) != 0) 316fa9e4066Sahrens return; 317fa9e4066Sahrens 318afefbcddSeschrock for (c = 0; c < children; c++) { 319c67d9675Seschrock vname = zpool_vdev_name(zhp, child[c]); 320c67d9675Seschrock print_vdev_tree(zhp, vname, child[c], indent + 2); 321afefbcddSeschrock free(vname); 322afefbcddSeschrock } 323fa9e4066Sahrens } 324fa9e4066Sahrens 325fa9e4066Sahrens /* 326fa9e4066Sahrens * zpool add [-fn] <pool> <vdev> ... 327fa9e4066Sahrens * 328fa9e4066Sahrens * -f Force addition of devices, even if they appear in use 329fa9e4066Sahrens * -n Do not add the devices, but display the resulting layout if 330fa9e4066Sahrens * they were to be added. 331fa9e4066Sahrens * 332fa9e4066Sahrens * Adds the given vdevs to 'pool'. As with create, the bulk of this work is 333fa9e4066Sahrens * handled by get_vdev_spec(), which constructs the nvlist needed to pass to 334fa9e4066Sahrens * libzfs. 335fa9e4066Sahrens */ 336fa9e4066Sahrens int 337fa9e4066Sahrens zpool_do_add(int argc, char **argv) 338fa9e4066Sahrens { 339fa9e4066Sahrens int force = FALSE; 340fa9e4066Sahrens int dryrun = FALSE; 341fa9e4066Sahrens int c; 342fa9e4066Sahrens nvlist_t *nvroot; 343fa9e4066Sahrens char *poolname; 344fa9e4066Sahrens int ret; 345fa9e4066Sahrens zpool_handle_t *zhp; 346fa9e4066Sahrens nvlist_t *config; 347fa9e4066Sahrens 348fa9e4066Sahrens /* check options */ 349fa9e4066Sahrens while ((c = getopt(argc, argv, "fn")) != -1) { 350fa9e4066Sahrens switch (c) { 351fa9e4066Sahrens case 'f': 352fa9e4066Sahrens force = TRUE; 353fa9e4066Sahrens break; 354fa9e4066Sahrens case 'n': 355fa9e4066Sahrens dryrun = TRUE; 356fa9e4066Sahrens break; 357fa9e4066Sahrens case '?': 358fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 359fa9e4066Sahrens optopt); 360fa9e4066Sahrens usage(FALSE); 361fa9e4066Sahrens } 362fa9e4066Sahrens } 363fa9e4066Sahrens 364fa9e4066Sahrens argc -= optind; 365fa9e4066Sahrens argv += optind; 366fa9e4066Sahrens 367fa9e4066Sahrens /* get pool name and check number of arguments */ 368fa9e4066Sahrens if (argc < 1) { 369fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 370fa9e4066Sahrens usage(FALSE); 371fa9e4066Sahrens } 372fa9e4066Sahrens if (argc < 2) { 373fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 374fa9e4066Sahrens usage(FALSE); 375fa9e4066Sahrens } 376fa9e4066Sahrens 377fa9e4066Sahrens poolname = argv[0]; 378fa9e4066Sahrens 379fa9e4066Sahrens argc--; 380fa9e4066Sahrens argv++; 381fa9e4066Sahrens 382fa9e4066Sahrens if ((zhp = zpool_open(poolname)) == NULL) 383fa9e4066Sahrens return (1); 384fa9e4066Sahrens 385088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 386fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 387fa9e4066Sahrens poolname); 388fa9e4066Sahrens zpool_close(zhp); 389fa9e4066Sahrens return (1); 390fa9e4066Sahrens } 391fa9e4066Sahrens 392fa9e4066Sahrens /* pass off to get_vdev_spec for processing */ 393fa9e4066Sahrens nvroot = make_root_vdev(config, force, !force, argc, argv); 394fa9e4066Sahrens if (nvroot == NULL) { 395fa9e4066Sahrens zpool_close(zhp); 396fa9e4066Sahrens return (1); 397fa9e4066Sahrens } 398fa9e4066Sahrens 399fa9e4066Sahrens if (dryrun) { 400fa9e4066Sahrens nvlist_t *poolnvroot; 401fa9e4066Sahrens 402fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 403fa9e4066Sahrens &poolnvroot) == 0); 404fa9e4066Sahrens 405fa9e4066Sahrens (void) printf(gettext("would update '%s' to the following " 406fa9e4066Sahrens "configuration:\n"), zpool_get_name(zhp)); 407fa9e4066Sahrens 408c67d9675Seschrock print_vdev_tree(zhp, poolname, poolnvroot, 0); 409c67d9675Seschrock print_vdev_tree(zhp, NULL, nvroot, 0); 410fa9e4066Sahrens 411fa9e4066Sahrens ret = 0; 412fa9e4066Sahrens } else { 413fa9e4066Sahrens ret = (zpool_add(zhp, nvroot) != 0); 414fa9e4066Sahrens } 415fa9e4066Sahrens 416fa9e4066Sahrens return (ret); 417fa9e4066Sahrens } 418fa9e4066Sahrens 419fa9e4066Sahrens /* 420fa9e4066Sahrens * zpool create [-fn] [-R root] [-m mountpoint] <pool> <dev> ... 421fa9e4066Sahrens * 422fa9e4066Sahrens * -f Force creation, even if devices appear in use 423fa9e4066Sahrens * -n Do not create the pool, but display the resulting layout if it 424fa9e4066Sahrens * were to be created. 425fa9e4066Sahrens * -R Create a pool under an alternate root 426fa9e4066Sahrens * -m Set default mountpoint for the root dataset. By default it's 427fa9e4066Sahrens * '/<pool>' 428fa9e4066Sahrens * 429fa9e4066Sahrens * Creates the the named pool according to the given vdev specification. The 430fa9e4066Sahrens * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once 431fa9e4066Sahrens * we get the nvlist back from get_vdev_spec(), we either print out the contents 432fa9e4066Sahrens * (if '-n' was specified), or pass it to libzfs to do the creation. 433fa9e4066Sahrens */ 434fa9e4066Sahrens int 435fa9e4066Sahrens zpool_do_create(int argc, char **argv) 436fa9e4066Sahrens { 437fa9e4066Sahrens int force = FALSE; 438fa9e4066Sahrens int dryrun = FALSE; 439fa9e4066Sahrens int c; 440fa9e4066Sahrens nvlist_t *nvroot; 441fa9e4066Sahrens char *poolname; 442fa9e4066Sahrens int ret; 443fa9e4066Sahrens char *altroot = NULL; 444fa9e4066Sahrens char *mountpoint = NULL; 445fa9e4066Sahrens 446fa9e4066Sahrens /* check options */ 447fa9e4066Sahrens while ((c = getopt(argc, argv, ":fnR:m:")) != -1) { 448fa9e4066Sahrens switch (c) { 449fa9e4066Sahrens case 'f': 450fa9e4066Sahrens force = TRUE; 451fa9e4066Sahrens break; 452fa9e4066Sahrens case 'n': 453fa9e4066Sahrens dryrun = TRUE; 454fa9e4066Sahrens break; 455fa9e4066Sahrens case 'R': 456fa9e4066Sahrens altroot = optarg; 457fa9e4066Sahrens break; 458fa9e4066Sahrens case 'm': 459fa9e4066Sahrens mountpoint = optarg; 460fa9e4066Sahrens break; 461fa9e4066Sahrens case ':': 462fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 463fa9e4066Sahrens "'%c' option\n"), optopt); 464fa9e4066Sahrens usage(FALSE); 465fa9e4066Sahrens break; 466fa9e4066Sahrens case '?': 467fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 468fa9e4066Sahrens optopt); 469fa9e4066Sahrens usage(FALSE); 470fa9e4066Sahrens } 471fa9e4066Sahrens } 472fa9e4066Sahrens 473fa9e4066Sahrens argc -= optind; 474fa9e4066Sahrens argv += optind; 475fa9e4066Sahrens 476fa9e4066Sahrens /* get pool name and check number of arguments */ 477fa9e4066Sahrens if (argc < 1) { 478fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 479fa9e4066Sahrens usage(FALSE); 480fa9e4066Sahrens } 481fa9e4066Sahrens if (argc < 2) { 482fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 483fa9e4066Sahrens usage(FALSE); 484fa9e4066Sahrens } 485fa9e4066Sahrens 486fa9e4066Sahrens poolname = argv[0]; 487fa9e4066Sahrens 488fa9e4066Sahrens /* 489fa9e4066Sahrens * As a special case, check for use of '/' in the name, and direct the 490fa9e4066Sahrens * user to use 'zfs create' instead. 491fa9e4066Sahrens */ 492fa9e4066Sahrens if (strchr(poolname, '/') != NULL) { 493fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot create '%s': invalid " 494fa9e4066Sahrens "character '/' in pool name\n"), poolname); 495fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs create' to " 496fa9e4066Sahrens "create a dataset\n")); 497fa9e4066Sahrens return (1); 498fa9e4066Sahrens } 499fa9e4066Sahrens 500fa9e4066Sahrens /* pass off to get_vdev_spec for bulk processing */ 501fa9e4066Sahrens nvroot = make_root_vdev(NULL, force, !force, argc - 1, argv + 1); 502fa9e4066Sahrens if (nvroot == NULL) 503fa9e4066Sahrens return (1); 504fa9e4066Sahrens 505fa9e4066Sahrens if (altroot != NULL && altroot[0] != '/') { 506fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid alternate root '%s': " 507fa9e4066Sahrens "must be an absolute path\n")); 508fa9e4066Sahrens return (1); 509fa9e4066Sahrens } 510fa9e4066Sahrens 511fa9e4066Sahrens /* 512fa9e4066Sahrens * Check the validity of the mountpoint and direct the user to use the 513fa9e4066Sahrens * '-m' mountpoint option if it looks like its in use. 514fa9e4066Sahrens */ 515fa9e4066Sahrens if (mountpoint == NULL || 516fa9e4066Sahrens (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 && 517fa9e4066Sahrens strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) { 518fa9e4066Sahrens char buf[MAXPATHLEN]; 519fa9e4066Sahrens struct stat64 statbuf; 520fa9e4066Sahrens 521fa9e4066Sahrens if (mountpoint && mountpoint[0] != '/') { 522fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid mountpoint " 523fa9e4066Sahrens "'%s': must be an absolute path, 'legacy', or " 524fa9e4066Sahrens "'none'\n"), mountpoint); 525fa9e4066Sahrens return (1); 526fa9e4066Sahrens } 527fa9e4066Sahrens 528fa9e4066Sahrens if (mountpoint == NULL) { 529fa9e4066Sahrens if (altroot != NULL) 530fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s/%s", 531fa9e4066Sahrens altroot, poolname); 532fa9e4066Sahrens else 533fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "/%s", 534fa9e4066Sahrens poolname); 535fa9e4066Sahrens } else { 536fa9e4066Sahrens if (altroot != NULL) 537fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s%s", 538fa9e4066Sahrens altroot, mountpoint); 539fa9e4066Sahrens else 540fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s", 541fa9e4066Sahrens mountpoint); 542fa9e4066Sahrens } 543fa9e4066Sahrens 544fa9e4066Sahrens if (stat64(buf, &statbuf) == 0 && 545fa9e4066Sahrens statbuf.st_nlink != 2) { 546fa9e4066Sahrens if (mountpoint == NULL) 547fa9e4066Sahrens (void) fprintf(stderr, gettext("default " 548fa9e4066Sahrens "mountpoint '%s' exists and is not " 549fa9e4066Sahrens "empty\n"), buf); 550fa9e4066Sahrens else 551fa9e4066Sahrens (void) fprintf(stderr, gettext("mountpoint " 552fa9e4066Sahrens "'%s' exists and is not empty\n"), buf); 553fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-m' " 554fa9e4066Sahrens "option to provide a different default\n")); 555fa9e4066Sahrens return (1); 556fa9e4066Sahrens } 557fa9e4066Sahrens } 558fa9e4066Sahrens 559fa9e4066Sahrens 560fa9e4066Sahrens if (dryrun) { 561fa9e4066Sahrens /* 562fa9e4066Sahrens * For a dry run invocation, print out a basic message and run 563fa9e4066Sahrens * through all the vdevs in the list and print out in an 564fa9e4066Sahrens * appropriate hierarchy. 565fa9e4066Sahrens * 566fa9e4066Sahrens * XXZFS find out of we can create the pool? 567fa9e4066Sahrens */ 568fa9e4066Sahrens (void) printf(gettext("would create '%s' with the " 569fa9e4066Sahrens "following layout:\n\n"), poolname); 570fa9e4066Sahrens 571c67d9675Seschrock print_vdev_tree(NULL, poolname, nvroot, 0); 572fa9e4066Sahrens 573fa9e4066Sahrens ret = 0; 574fa9e4066Sahrens } else { 575fa9e4066Sahrens ret = 1; 576fa9e4066Sahrens /* 577fa9e4066Sahrens * Hand off to libzfs. 578fa9e4066Sahrens */ 579fa9e4066Sahrens if (zpool_create(poolname, nvroot, altroot) == 0) { 580fa9e4066Sahrens zfs_handle_t *pool = zfs_open(poolname, 581fa9e4066Sahrens ZFS_TYPE_FILESYSTEM); 582fa9e4066Sahrens if (pool != NULL) { 583fa9e4066Sahrens if (mountpoint != NULL) 584fa9e4066Sahrens verify(zfs_prop_set(pool, 585fa9e4066Sahrens ZFS_PROP_MOUNTPOINT, 586fa9e4066Sahrens mountpoint) == 0); 587fa9e4066Sahrens if (zfs_mount(pool, NULL, 0) == 0) 588fa9e4066Sahrens ret = zfs_share(pool); 589fa9e4066Sahrens zfs_close(pool); 590fa9e4066Sahrens } 591fa9e4066Sahrens } 592fa9e4066Sahrens 593fa9e4066Sahrens } 594fa9e4066Sahrens 595fa9e4066Sahrens nvlist_free(nvroot); 596fa9e4066Sahrens 597fa9e4066Sahrens return (ret); 598fa9e4066Sahrens } 599fa9e4066Sahrens 600fa9e4066Sahrens /* 601fa9e4066Sahrens * zpool destroy <pool> 602fa9e4066Sahrens * 603fa9e4066Sahrens * -f Forcefully unmount any datasets 604fa9e4066Sahrens * 605fa9e4066Sahrens * Destroy the given pool. Automatically unmounts any datasets in the pool. 606fa9e4066Sahrens */ 607fa9e4066Sahrens int 608fa9e4066Sahrens zpool_do_destroy(int argc, char **argv) 609fa9e4066Sahrens { 610fa9e4066Sahrens int force = FALSE; 611fa9e4066Sahrens int c; 612fa9e4066Sahrens char *pool; 613fa9e4066Sahrens zpool_handle_t *zhp; 614fa9e4066Sahrens int ret; 615fa9e4066Sahrens 616fa9e4066Sahrens /* check options */ 617fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 618fa9e4066Sahrens switch (c) { 619fa9e4066Sahrens case 'f': 620fa9e4066Sahrens force = TRUE; 621fa9e4066Sahrens break; 622fa9e4066Sahrens case '?': 623fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 624fa9e4066Sahrens optopt); 625fa9e4066Sahrens usage(FALSE); 626fa9e4066Sahrens } 627fa9e4066Sahrens } 628fa9e4066Sahrens 629fa9e4066Sahrens argc -= optind; 630fa9e4066Sahrens argv += optind; 631fa9e4066Sahrens 632fa9e4066Sahrens /* check arguments */ 633fa9e4066Sahrens if (argc < 1) { 634fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 635fa9e4066Sahrens usage(FALSE); 636fa9e4066Sahrens } 637fa9e4066Sahrens if (argc > 1) { 638fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 639fa9e4066Sahrens usage(FALSE); 640fa9e4066Sahrens } 641fa9e4066Sahrens 642fa9e4066Sahrens pool = argv[0]; 643fa9e4066Sahrens 644fa9e4066Sahrens if ((zhp = zpool_open_canfail(pool)) == NULL) { 645fa9e4066Sahrens /* 646fa9e4066Sahrens * As a special case, check for use of '/' in the name, and 647fa9e4066Sahrens * direct the user to use 'zfs destroy' instead. 648fa9e4066Sahrens */ 649fa9e4066Sahrens if (strchr(pool, '/') != NULL) 650fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy' to " 651fa9e4066Sahrens "destroy a dataset\n")); 652fa9e4066Sahrens return (1); 653fa9e4066Sahrens } 654fa9e4066Sahrens 655fa9e4066Sahrens if (unmount_datasets(zhp, force) != 0) { 656fa9e4066Sahrens (void) fprintf(stderr, gettext("could not destroy '%s': " 657fa9e4066Sahrens "could not unmount datasets\n"), zpool_get_name(zhp)); 658fa9e4066Sahrens return (1); 659fa9e4066Sahrens } 660fa9e4066Sahrens 661fa9e4066Sahrens ret = (zpool_destroy(zhp) != 0); 662fa9e4066Sahrens 663fa9e4066Sahrens zpool_close(zhp); 664fa9e4066Sahrens 665fa9e4066Sahrens return (ret); 666fa9e4066Sahrens } 667fa9e4066Sahrens 668fa9e4066Sahrens /* 669fa9e4066Sahrens * zpool export [-f] <pool> ... 670fa9e4066Sahrens * 671fa9e4066Sahrens * -f Forcefully unmount datasets 672fa9e4066Sahrens * 673fa9e4066Sahrens * Export the the given pools. By default, the command will attempt to cleanly 674fa9e4066Sahrens * unmount any active datasets within the pool. If the '-f' flag is specified, 675fa9e4066Sahrens * then the datasets will be forcefully unmounted. 676fa9e4066Sahrens */ 677fa9e4066Sahrens int 678fa9e4066Sahrens zpool_do_export(int argc, char **argv) 679fa9e4066Sahrens { 680fa9e4066Sahrens int force = FALSE; 681fa9e4066Sahrens int c; 682fa9e4066Sahrens zpool_handle_t *zhp; 683fa9e4066Sahrens int ret; 684fa9e4066Sahrens int i; 685fa9e4066Sahrens 686fa9e4066Sahrens /* check options */ 687fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 688fa9e4066Sahrens switch (c) { 689fa9e4066Sahrens case 'f': 690fa9e4066Sahrens force = TRUE; 691fa9e4066Sahrens break; 692fa9e4066Sahrens case '?': 693fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 694fa9e4066Sahrens optopt); 695fa9e4066Sahrens usage(FALSE); 696fa9e4066Sahrens } 697fa9e4066Sahrens } 698fa9e4066Sahrens 699fa9e4066Sahrens argc -= optind; 700fa9e4066Sahrens argv += optind; 701fa9e4066Sahrens 702fa9e4066Sahrens /* check arguments */ 703fa9e4066Sahrens if (argc < 1) { 704fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 705fa9e4066Sahrens usage(FALSE); 706fa9e4066Sahrens } 707fa9e4066Sahrens 708fa9e4066Sahrens ret = 0; 709fa9e4066Sahrens for (i = 0; i < argc; i++) { 710fa9e4066Sahrens if ((zhp = zpool_open_canfail(argv[i])) == NULL) { 711fa9e4066Sahrens ret = 1; 712fa9e4066Sahrens continue; 713fa9e4066Sahrens } 714fa9e4066Sahrens 715fa9e4066Sahrens if (unmount_datasets(zhp, force) != 0) { 716fa9e4066Sahrens ret = 1; 717fa9e4066Sahrens zpool_close(zhp); 718fa9e4066Sahrens continue; 719fa9e4066Sahrens } 720fa9e4066Sahrens 721fa9e4066Sahrens if (zpool_export(zhp) != 0) 722fa9e4066Sahrens ret = 1; 723fa9e4066Sahrens 724fa9e4066Sahrens zpool_close(zhp); 725fa9e4066Sahrens } 726fa9e4066Sahrens 727fa9e4066Sahrens return (ret); 728fa9e4066Sahrens } 729fa9e4066Sahrens 730fa9e4066Sahrens /* 731fa9e4066Sahrens * Given a vdev configuration, determine the maximum width needed for the device 732fa9e4066Sahrens * name column. 733fa9e4066Sahrens */ 734fa9e4066Sahrens static int 735c67d9675Seschrock max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max) 736fa9e4066Sahrens { 737c67d9675Seschrock char *name = zpool_vdev_name(zhp, nv); 738fa9e4066Sahrens nvlist_t **child; 739fa9e4066Sahrens uint_t c, children; 740fa9e4066Sahrens int ret; 741fa9e4066Sahrens 742fa9e4066Sahrens if (strlen(name) + depth > max) 743fa9e4066Sahrens max = strlen(name) + depth; 744fa9e4066Sahrens 745afefbcddSeschrock free(name); 746afefbcddSeschrock 747fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 748fa9e4066Sahrens &child, &children) != 0) 749fa9e4066Sahrens return (max); 750fa9e4066Sahrens 751fa9e4066Sahrens for (c = 0; c < children; c++) 752c67d9675Seschrock if ((ret = max_width(zhp, child[c], depth + 2, max)) > max) 753fa9e4066Sahrens max = ret; 754fa9e4066Sahrens 755fa9e4066Sahrens return (max); 756fa9e4066Sahrens } 757fa9e4066Sahrens 758fa9e4066Sahrens 759fa9e4066Sahrens /* 760fa9e4066Sahrens * Print the configuration of an exported pool. Iterate over all vdevs in the 761fa9e4066Sahrens * pool, printing out the name and status for each one. 762fa9e4066Sahrens */ 763fa9e4066Sahrens void 764fa9e4066Sahrens print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth) 765fa9e4066Sahrens { 766fa9e4066Sahrens nvlist_t **child; 767fa9e4066Sahrens uint_t c, children; 768fa9e4066Sahrens vdev_stat_t *vs; 769afefbcddSeschrock char *type, *vname; 770fa9e4066Sahrens 771fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 772fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_MISSING) == 0) 773fa9e4066Sahrens return; 774fa9e4066Sahrens 775fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS, 776fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 777fa9e4066Sahrens 778fa9e4066Sahrens (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name); 779fa9e4066Sahrens 780fa9e4066Sahrens if (vs->vs_aux != 0) { 781ea8dc4b6Seschrock (void) printf(" %-8s ", state_to_name(vs)); 782fa9e4066Sahrens 783fa9e4066Sahrens switch (vs->vs_aux) { 784fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 785fa9e4066Sahrens (void) printf(gettext("cannot open")); 786fa9e4066Sahrens break; 787fa9e4066Sahrens 788fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 789fa9e4066Sahrens (void) printf(gettext("missing device")); 790fa9e4066Sahrens break; 791fa9e4066Sahrens 792fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 793fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 794fa9e4066Sahrens break; 795fa9e4066Sahrens 796fa9e4066Sahrens default: 797fa9e4066Sahrens (void) printf(gettext("corrupted data")); 798fa9e4066Sahrens break; 799fa9e4066Sahrens } 800fa9e4066Sahrens } else { 801ea8dc4b6Seschrock (void) printf(" %s", state_to_name(vs)); 802fa9e4066Sahrens } 803fa9e4066Sahrens (void) printf("\n"); 804fa9e4066Sahrens 805fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 806fa9e4066Sahrens &child, &children) != 0) 807fa9e4066Sahrens return; 808fa9e4066Sahrens 809afefbcddSeschrock for (c = 0; c < children; c++) { 810c67d9675Seschrock vname = zpool_vdev_name(NULL, child[c]); 811afefbcddSeschrock print_import_config(vname, child[c], 812fa9e4066Sahrens namewidth, depth + 2); 813afefbcddSeschrock free(vname); 814afefbcddSeschrock } 815fa9e4066Sahrens } 816fa9e4066Sahrens 817fa9e4066Sahrens /* 818fa9e4066Sahrens * Display the status for the given pool. 819fa9e4066Sahrens */ 820fa9e4066Sahrens static void 821fa9e4066Sahrens show_import(nvlist_t *config) 822fa9e4066Sahrens { 823fa9e4066Sahrens uint64_t pool_state; 824fa9e4066Sahrens vdev_stat_t *vs; 825fa9e4066Sahrens char *name; 826fa9e4066Sahrens uint64_t guid; 827fa9e4066Sahrens char *msgid; 828fa9e4066Sahrens nvlist_t *nvroot; 829fa9e4066Sahrens int reason; 830fa9e4066Sahrens char *health; 831fa9e4066Sahrens uint_t vsc; 832fa9e4066Sahrens int namewidth; 833fa9e4066Sahrens 834fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 835fa9e4066Sahrens &name) == 0); 836fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 837fa9e4066Sahrens &guid) == 0); 838fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 839fa9e4066Sahrens &pool_state) == 0); 840fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_HEALTH, 841fa9e4066Sahrens &health) == 0); 842fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 843fa9e4066Sahrens &nvroot) == 0); 844fa9e4066Sahrens 845fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 846fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 847fa9e4066Sahrens 848fa9e4066Sahrens reason = zpool_import_status(config, &msgid); 849fa9e4066Sahrens 850fa9e4066Sahrens (void) printf(" pool: %s\n", name); 851fa9e4066Sahrens (void) printf(" id: %llu\n", guid); 852*4c58d714Sdarrenm (void) printf(" state: %s", health); 853*4c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 854*4c58d714Sdarrenm (void) printf(" (DESTROYED)"); 855*4c58d714Sdarrenm (void) printf("\n"); 856fa9e4066Sahrens 857fa9e4066Sahrens switch (reason) { 858fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 859fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 860fa9e4066Sahrens case ZPOOL_STATUS_BAD_GUID_SUM: 861fa9e4066Sahrens (void) printf(gettext("status: One or more devices are missing " 862fa9e4066Sahrens "from the system.\n")); 863fa9e4066Sahrens break; 864fa9e4066Sahrens 865fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 866fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 867fa9e4066Sahrens (void) printf(gettext("status: One or more devices contains " 868fa9e4066Sahrens "corrupted data.\n")); 869fa9e4066Sahrens break; 870fa9e4066Sahrens 871fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_DATA: 872fa9e4066Sahrens (void) printf(gettext("status: The pool data is corrupted.\n")); 873fa9e4066Sahrens break; 874fa9e4066Sahrens 875441d80aaSlling case ZPOOL_STATUS_OFFLINE_DEV: 876441d80aaSlling (void) printf(gettext("status: One or more devices " 877441d80aaSlling "are offlined.\n")); 878441d80aaSlling break; 879441d80aaSlling 880ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 881ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is " 882ea8dc4b6Seschrock "corrupted.\n")); 883ea8dc4b6Seschrock break; 884ea8dc4b6Seschrock 885fa9e4066Sahrens default: 886fa9e4066Sahrens /* 887fa9e4066Sahrens * No other status can be seen when importing pools. 888fa9e4066Sahrens */ 889fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 890fa9e4066Sahrens } 891fa9e4066Sahrens 892fa9e4066Sahrens /* 893fa9e4066Sahrens * Print out an action according to the overall state of the pool. 894fa9e4066Sahrens */ 895fa9e4066Sahrens if (strcmp(health, gettext("ONLINE")) == 0) { 896fa9e4066Sahrens (void) printf(gettext("action: The pool can be imported" 897fa9e4066Sahrens " using its name or numeric identifier.")); 898*4c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 899*4c58d714Sdarrenm (void) printf(gettext(" The\n\tpool was destroyed, " 900*4c58d714Sdarrenm "but can be imported using the '-Df' flags.\n")); 901*4c58d714Sdarrenm else if (pool_state != POOL_STATE_EXPORTED) 902fa9e4066Sahrens (void) printf(gettext(" The\n\tpool may be active on " 903fa9e4066Sahrens "on another system, but can be imported using\n\t" 904fa9e4066Sahrens "the '-f' flag.\n")); 905fa9e4066Sahrens else 906fa9e4066Sahrens (void) printf("\n"); 907fa9e4066Sahrens } else if (strcmp(health, gettext("DEGRADED")) == 0) { 908fa9e4066Sahrens (void) printf(gettext("action: The pool can be imported " 909fa9e4066Sahrens "despite missing or damaged devices. The\n\tfault " 910fa9e4066Sahrens "tolerance of the pool may be compromised if imported.")); 911*4c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 912*4c58d714Sdarrenm (void) printf(gettext(" The\n\tpool was destroyed, " 913*4c58d714Sdarrenm "but can be imported using the '-Df' flags.\n")); 914*4c58d714Sdarrenm else if (pool_state != POOL_STATE_EXPORTED) 915fa9e4066Sahrens (void) printf(gettext(" The\n\tpool may be active on " 916fa9e4066Sahrens "on another system, but can be imported using\n\t" 917fa9e4066Sahrens "the '-f' flag.\n")); 918fa9e4066Sahrens else 919fa9e4066Sahrens (void) printf("\n"); 920fa9e4066Sahrens } else { 921fa9e4066Sahrens if (reason == ZPOOL_STATUS_MISSING_DEV_R || 922fa9e4066Sahrens reason == ZPOOL_STATUS_MISSING_DEV_NR || 923fa9e4066Sahrens reason == ZPOOL_STATUS_BAD_GUID_SUM) 924fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 925fa9e4066Sahrens "imported. Attach the missing\n\tdevices and try " 926fa9e4066Sahrens "again.\n")); 927fa9e4066Sahrens else 928fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 929fa9e4066Sahrens "imported due to damaged devices or data.\n")); 930fa9e4066Sahrens } 931fa9e4066Sahrens 932fa9e4066Sahrens if (msgid != NULL) 933fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 934fa9e4066Sahrens msgid); 935fa9e4066Sahrens 936fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 937fa9e4066Sahrens 938c67d9675Seschrock namewidth = max_width(NULL, nvroot, 0, 0); 939fa9e4066Sahrens if (namewidth < 10) 940fa9e4066Sahrens namewidth = 10; 941fa9e4066Sahrens print_import_config(name, nvroot, namewidth, 0); 942fa9e4066Sahrens 943fa9e4066Sahrens if (reason == ZPOOL_STATUS_BAD_GUID_SUM) { 944fa9e4066Sahrens (void) printf("\n\tAdditional devices are known to " 945fa9e4066Sahrens "be part of this pool, though their\n\texact " 946fa9e4066Sahrens "configuration cannot be determined.\n"); 947fa9e4066Sahrens } 948fa9e4066Sahrens } 949fa9e4066Sahrens 950fa9e4066Sahrens /* 951fa9e4066Sahrens * Perform the import for the given configuration. This passes the heavy 952fa9e4066Sahrens * lifting off to zpool_import(), and then mounts the datasets contained within 953fa9e4066Sahrens * the pool. 954fa9e4066Sahrens */ 955fa9e4066Sahrens static int 956fa9e4066Sahrens do_import(nvlist_t *config, const char *newname, const char *mntopts, 957fa9e4066Sahrens const char *altroot, int force) 958fa9e4066Sahrens { 959fa9e4066Sahrens zpool_handle_t *zhp; 960fa9e4066Sahrens char *name; 961fa9e4066Sahrens uint64_t state; 962fa9e4066Sahrens 963fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 964fa9e4066Sahrens &name) == 0); 965fa9e4066Sahrens 966fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 967fa9e4066Sahrens ZPOOL_CONFIG_POOL_STATE, &state) == 0); 968fa9e4066Sahrens if (state != POOL_STATE_EXPORTED && !force) { 969fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': pool " 970fa9e4066Sahrens "may be in use from other system\n"), name); 971fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-f' to import anyway\n")); 972fa9e4066Sahrens return (1); 973fa9e4066Sahrens } 974fa9e4066Sahrens 975fa9e4066Sahrens if (zpool_import(config, newname, altroot) != 0) 976fa9e4066Sahrens return (1); 977fa9e4066Sahrens 978fa9e4066Sahrens if (newname != NULL) 979fa9e4066Sahrens name = (char *)newname; 980fa9e4066Sahrens 981fa9e4066Sahrens verify((zhp = zpool_open(name)) != NULL); 982fa9e4066Sahrens 983cbcb6089Slling if (mount_share_datasets(zhp, mntopts) != 0) { 984fa9e4066Sahrens zpool_close(zhp); 985fa9e4066Sahrens return (1); 986fa9e4066Sahrens } 987fa9e4066Sahrens 988fa9e4066Sahrens zpool_close(zhp); 989fa9e4066Sahrens return (0); 990fa9e4066Sahrens } 991fa9e4066Sahrens 992fa9e4066Sahrens /* 993*4c58d714Sdarrenm * zpool import [-d dir] [-D] 994*4c58d714Sdarrenm * import [-R root] [-D] [-d dir] [-f] -a 995*4c58d714Sdarrenm * import [-R root] [-D] [-d dir] [-f] <pool | id> [newpool] 996fa9e4066Sahrens * 997fa9e4066Sahrens * -d Scan in a specific directory, other than /dev/dsk. More than 998fa9e4066Sahrens * one directory can be specified using multiple '-d' options. 999fa9e4066Sahrens * 1000*4c58d714Sdarrenm * -D Scan for previously destroyed pools or import all or only 1001*4c58d714Sdarrenm * specified destroyed pools. 1002*4c58d714Sdarrenm * 1003fa9e4066Sahrens * -R Temporarily import the pool, with all mountpoints relative to 1004fa9e4066Sahrens * the given root. The pool will remain exported when the machine 1005fa9e4066Sahrens * is rebooted. 1006fa9e4066Sahrens * 1007fa9e4066Sahrens * -f Force import, even if it appears that the pool is active. 1008fa9e4066Sahrens * 1009fa9e4066Sahrens * -a Import all pools found. 1010fa9e4066Sahrens * 1011fa9e4066Sahrens * The import command scans for pools to import, and import pools based on pool 1012fa9e4066Sahrens * name and GUID. The pool can also be renamed as part of the import process. 1013fa9e4066Sahrens */ 1014fa9e4066Sahrens int 1015fa9e4066Sahrens zpool_do_import(int argc, char **argv) 1016fa9e4066Sahrens { 1017fa9e4066Sahrens char **searchdirs = NULL; 1018fa9e4066Sahrens int nsearch = 0; 1019fa9e4066Sahrens int c; 1020fa9e4066Sahrens int err; 1021fa9e4066Sahrens nvlist_t *pools; 1022fa9e4066Sahrens int do_all = FALSE; 1023*4c58d714Sdarrenm int do_destroyed = FALSE; 1024fa9e4066Sahrens char *altroot = NULL; 1025fa9e4066Sahrens char *mntopts = NULL; 1026fa9e4066Sahrens int do_force = FALSE; 1027fa9e4066Sahrens nvpair_t *elem; 1028fa9e4066Sahrens nvlist_t *config; 1029fa9e4066Sahrens uint64_t searchguid; 1030fa9e4066Sahrens char *searchname; 1031fa9e4066Sahrens nvlist_t *found_config; 1032fa9e4066Sahrens int first; 1033*4c58d714Sdarrenm uint64_t pool_state; 1034fa9e4066Sahrens 1035fa9e4066Sahrens /* check options */ 1036*4c58d714Sdarrenm while ((c = getopt(argc, argv, ":Dfd:R:ao:")) != -1) { 1037fa9e4066Sahrens switch (c) { 1038fa9e4066Sahrens case 'a': 1039fa9e4066Sahrens do_all = TRUE; 1040fa9e4066Sahrens break; 1041fa9e4066Sahrens case 'd': 1042fa9e4066Sahrens if (searchdirs == NULL) { 1043fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1044fa9e4066Sahrens } else { 1045fa9e4066Sahrens char **tmp = safe_malloc((nsearch + 1) * 1046fa9e4066Sahrens sizeof (char *)); 1047fa9e4066Sahrens bcopy(searchdirs, tmp, nsearch * 1048fa9e4066Sahrens sizeof (char *)); 1049fa9e4066Sahrens free(searchdirs); 1050fa9e4066Sahrens searchdirs = tmp; 1051fa9e4066Sahrens } 1052fa9e4066Sahrens searchdirs[nsearch++] = optarg; 1053fa9e4066Sahrens break; 1054*4c58d714Sdarrenm case 'D': 1055*4c58d714Sdarrenm do_destroyed = TRUE; 1056*4c58d714Sdarrenm break; 1057fa9e4066Sahrens case 'f': 1058fa9e4066Sahrens do_force = TRUE; 1059fa9e4066Sahrens break; 1060fa9e4066Sahrens case 'o': 1061fa9e4066Sahrens mntopts = optarg; 1062fa9e4066Sahrens break; 1063fa9e4066Sahrens case 'R': 1064fa9e4066Sahrens altroot = optarg; 1065fa9e4066Sahrens break; 1066fa9e4066Sahrens case ':': 1067fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1068fa9e4066Sahrens "'%c' option\n"), optopt); 1069fa9e4066Sahrens usage(FALSE); 1070fa9e4066Sahrens break; 1071fa9e4066Sahrens case '?': 1072fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1073fa9e4066Sahrens optopt); 1074fa9e4066Sahrens usage(FALSE); 1075fa9e4066Sahrens } 1076fa9e4066Sahrens } 1077fa9e4066Sahrens 1078fa9e4066Sahrens argc -= optind; 1079fa9e4066Sahrens argv += optind; 1080fa9e4066Sahrens 1081fa9e4066Sahrens if (searchdirs == NULL) { 1082fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1083fa9e4066Sahrens searchdirs[0] = "/dev/dsk"; 1084fa9e4066Sahrens nsearch = 1; 1085fa9e4066Sahrens } 1086fa9e4066Sahrens 1087fa9e4066Sahrens /* check argument count */ 1088fa9e4066Sahrens if (do_all) { 1089fa9e4066Sahrens if (argc != 0) { 1090fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1091fa9e4066Sahrens usage(FALSE); 1092fa9e4066Sahrens } 1093fa9e4066Sahrens } else { 1094fa9e4066Sahrens if (argc > 2) { 1095fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1096fa9e4066Sahrens usage(FALSE); 1097fa9e4066Sahrens } 1098fa9e4066Sahrens 1099fa9e4066Sahrens /* 1100fa9e4066Sahrens * Check for the SYS_CONFIG privilege. We do this explicitly 1101fa9e4066Sahrens * here because otherwise any attempt to discover pools will 1102fa9e4066Sahrens * silently fail. 1103fa9e4066Sahrens */ 1104fa9e4066Sahrens if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) { 1105fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1106fa9e4066Sahrens "discover pools: permission denied\n")); 1107fa9e4066Sahrens return (1); 1108fa9e4066Sahrens } 1109fa9e4066Sahrens } 1110fa9e4066Sahrens 1111fa9e4066Sahrens if ((pools = zpool_find_import(nsearch, searchdirs)) == NULL) 1112fa9e4066Sahrens return (1); 1113fa9e4066Sahrens 1114fa9e4066Sahrens /* 1115fa9e4066Sahrens * We now have a list of all available pools in the given directories. 1116fa9e4066Sahrens * Depending on the arguments given, we do one of the following: 1117fa9e4066Sahrens * 1118fa9e4066Sahrens * <none> Iterate through all pools and display information about 1119fa9e4066Sahrens * each one. 1120fa9e4066Sahrens * 1121fa9e4066Sahrens * -a Iterate through all pools and try to import each one. 1122fa9e4066Sahrens * 1123fa9e4066Sahrens * <id> Find the pool that corresponds to the given GUID/pool 1124fa9e4066Sahrens * name and import that one. 1125*4c58d714Sdarrenm * 1126*4c58d714Sdarrenm * -D Above options applies only to destroyed pools. 1127fa9e4066Sahrens */ 1128fa9e4066Sahrens if (argc != 0) { 1129fa9e4066Sahrens char *endptr; 1130fa9e4066Sahrens 1131fa9e4066Sahrens errno = 0; 1132fa9e4066Sahrens searchguid = strtoull(argv[0], &endptr, 10); 1133fa9e4066Sahrens if (errno != 0 || *endptr != '\0') 1134fa9e4066Sahrens searchname = argv[0]; 1135fa9e4066Sahrens else 1136fa9e4066Sahrens searchname = NULL; 1137fa9e4066Sahrens found_config = NULL; 1138fa9e4066Sahrens } 1139fa9e4066Sahrens 1140fa9e4066Sahrens err = 0; 1141fa9e4066Sahrens elem = NULL; 1142fa9e4066Sahrens first = TRUE; 1143fa9e4066Sahrens while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { 1144fa9e4066Sahrens 1145fa9e4066Sahrens verify(nvpair_value_nvlist(elem, &config) == 0); 1146fa9e4066Sahrens 1147*4c58d714Sdarrenm verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 1148*4c58d714Sdarrenm &pool_state) == 0); 1149*4c58d714Sdarrenm if (!do_destroyed && pool_state == POOL_STATE_DESTROYED) 1150*4c58d714Sdarrenm continue; 1151*4c58d714Sdarrenm if (do_destroyed && pool_state != POOL_STATE_DESTROYED) 1152*4c58d714Sdarrenm continue; 1153*4c58d714Sdarrenm 1154fa9e4066Sahrens if (argc == 0) { 1155fa9e4066Sahrens if (first) 1156fa9e4066Sahrens first = FALSE; 1157fa9e4066Sahrens else 1158fa9e4066Sahrens (void) printf("\n"); 1159fa9e4066Sahrens 1160fa9e4066Sahrens if (do_all) 1161fa9e4066Sahrens err |= do_import(config, NULL, mntopts, 1162fa9e4066Sahrens altroot, do_force); 1163fa9e4066Sahrens else 1164fa9e4066Sahrens show_import(config); 1165fa9e4066Sahrens } else if (searchname != NULL) { 1166fa9e4066Sahrens char *name; 1167fa9e4066Sahrens 1168fa9e4066Sahrens /* 1169fa9e4066Sahrens * We are searching for a pool based on name. 1170fa9e4066Sahrens */ 1171fa9e4066Sahrens verify(nvlist_lookup_string(config, 1172fa9e4066Sahrens ZPOOL_CONFIG_POOL_NAME, &name) == 0); 1173fa9e4066Sahrens 1174fa9e4066Sahrens if (strcmp(name, searchname) == 0) { 1175fa9e4066Sahrens if (found_config != NULL) { 1176fa9e4066Sahrens (void) fprintf(stderr, gettext( 1177fa9e4066Sahrens "cannot import '%s': more than " 1178fa9e4066Sahrens "one matching pool\n"), searchname); 1179fa9e4066Sahrens (void) fprintf(stderr, gettext( 1180fa9e4066Sahrens "import by numeric ID instead\n")); 1181fa9e4066Sahrens err = TRUE; 1182fa9e4066Sahrens } 1183fa9e4066Sahrens found_config = config; 1184fa9e4066Sahrens } 1185fa9e4066Sahrens } else { 1186fa9e4066Sahrens uint64_t guid; 1187fa9e4066Sahrens 1188fa9e4066Sahrens /* 1189fa9e4066Sahrens * Search for a pool by guid. 1190fa9e4066Sahrens */ 1191fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1192fa9e4066Sahrens ZPOOL_CONFIG_POOL_GUID, &guid) == 0); 1193fa9e4066Sahrens 1194fa9e4066Sahrens if (guid == searchguid) 1195fa9e4066Sahrens found_config = config; 1196fa9e4066Sahrens } 1197fa9e4066Sahrens } 1198fa9e4066Sahrens 1199fa9e4066Sahrens /* 1200fa9e4066Sahrens * If we were searching for a specific pool, verify that we found a 1201fa9e4066Sahrens * pool, and then do the import. 1202fa9e4066Sahrens */ 1203fa9e4066Sahrens if (argc != 0 && err == 0) { 1204fa9e4066Sahrens if (found_config == NULL) { 1205fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': " 1206fa9e4066Sahrens "no such pool available\n"), argv[0]); 1207fa9e4066Sahrens err = TRUE; 1208fa9e4066Sahrens } else { 1209fa9e4066Sahrens err |= do_import(found_config, argc == 1 ? NULL : 1210fa9e4066Sahrens argv[1], mntopts, altroot, do_force); 1211fa9e4066Sahrens } 1212fa9e4066Sahrens } 1213fa9e4066Sahrens 1214fa9e4066Sahrens /* 1215fa9e4066Sahrens * If we were just looking for pools, report an error if none were 1216fa9e4066Sahrens * found. 1217fa9e4066Sahrens */ 1218fa9e4066Sahrens if (argc == 0 && first) 1219fa9e4066Sahrens (void) fprintf(stderr, 1220fa9e4066Sahrens gettext("no pools available to import\n")); 1221fa9e4066Sahrens 1222fa9e4066Sahrens nvlist_free(pools); 1223fa9e4066Sahrens 1224fa9e4066Sahrens return (err ? 1 : 0); 1225fa9e4066Sahrens } 1226fa9e4066Sahrens 1227fa9e4066Sahrens typedef struct iostat_cbdata { 1228fa9e4066Sahrens zpool_list_t *cb_list; 1229fa9e4066Sahrens int cb_verbose; 1230fa9e4066Sahrens int cb_iteration; 1231fa9e4066Sahrens int cb_namewidth; 1232fa9e4066Sahrens } iostat_cbdata_t; 1233fa9e4066Sahrens 1234fa9e4066Sahrens static void 1235fa9e4066Sahrens print_iostat_separator(iostat_cbdata_t *cb) 1236fa9e4066Sahrens { 1237fa9e4066Sahrens int i = 0; 1238fa9e4066Sahrens 1239fa9e4066Sahrens for (i = 0; i < cb->cb_namewidth; i++) 1240fa9e4066Sahrens (void) printf("-"); 1241fa9e4066Sahrens (void) printf(" ----- ----- ----- ----- ----- -----\n"); 1242fa9e4066Sahrens } 1243fa9e4066Sahrens 1244fa9e4066Sahrens static void 1245fa9e4066Sahrens print_iostat_header(iostat_cbdata_t *cb) 1246fa9e4066Sahrens { 1247fa9e4066Sahrens (void) printf("%*s capacity operations bandwidth\n", 1248fa9e4066Sahrens cb->cb_namewidth, ""); 1249fa9e4066Sahrens (void) printf("%-*s used avail read write read write\n", 1250fa9e4066Sahrens cb->cb_namewidth, "pool"); 1251fa9e4066Sahrens print_iostat_separator(cb); 1252fa9e4066Sahrens } 1253fa9e4066Sahrens 1254fa9e4066Sahrens /* 1255fa9e4066Sahrens * Display a single statistic. 1256fa9e4066Sahrens */ 1257fa9e4066Sahrens void 1258fa9e4066Sahrens print_one_stat(uint64_t value) 1259fa9e4066Sahrens { 1260fa9e4066Sahrens char buf[64]; 1261fa9e4066Sahrens 1262fa9e4066Sahrens zfs_nicenum(value, buf, sizeof (buf)); 1263fa9e4066Sahrens (void) printf(" %5s", buf); 1264fa9e4066Sahrens } 1265fa9e4066Sahrens 1266fa9e4066Sahrens /* 1267fa9e4066Sahrens * Print out all the statistics for the given vdev. This can either be the 1268fa9e4066Sahrens * toplevel configuration, or called recursively. If 'name' is NULL, then this 1269fa9e4066Sahrens * is a verbose output, and we don't want to display the toplevel pool stats. 1270fa9e4066Sahrens */ 1271fa9e4066Sahrens void 1272c67d9675Seschrock print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, 1273c67d9675Seschrock nvlist_t *newnv, iostat_cbdata_t *cb, int depth) 1274fa9e4066Sahrens { 1275fa9e4066Sahrens nvlist_t **oldchild, **newchild; 1276fa9e4066Sahrens uint_t c, children; 1277fa9e4066Sahrens vdev_stat_t *oldvs, *newvs; 1278fa9e4066Sahrens vdev_stat_t zerovs = { 0 }; 1279fa9e4066Sahrens uint64_t tdelta; 1280fa9e4066Sahrens double scale; 1281afefbcddSeschrock char *vname; 1282fa9e4066Sahrens 1283fa9e4066Sahrens if (oldnv != NULL) { 1284fa9e4066Sahrens verify(nvlist_lookup_uint64_array(oldnv, ZPOOL_CONFIG_STATS, 1285fa9e4066Sahrens (uint64_t **)&oldvs, &c) == 0); 1286fa9e4066Sahrens } else { 1287fa9e4066Sahrens oldvs = &zerovs; 1288fa9e4066Sahrens } 1289fa9e4066Sahrens 1290fa9e4066Sahrens verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_STATS, 1291fa9e4066Sahrens (uint64_t **)&newvs, &c) == 0); 1292fa9e4066Sahrens 1293fa9e4066Sahrens if (strlen(name) + depth > cb->cb_namewidth) 1294fa9e4066Sahrens (void) printf("%*s%s", depth, "", name); 1295fa9e4066Sahrens else 1296fa9e4066Sahrens (void) printf("%*s%s%*s", depth, "", name, 1297fa9e4066Sahrens (int)(cb->cb_namewidth - strlen(name) - depth), ""); 1298fa9e4066Sahrens 1299fa9e4066Sahrens tdelta = newvs->vs_timestamp - oldvs->vs_timestamp; 1300fa9e4066Sahrens 1301fa9e4066Sahrens if (tdelta == 0) 1302fa9e4066Sahrens scale = 1.0; 1303fa9e4066Sahrens else 1304fa9e4066Sahrens scale = (double)NANOSEC / tdelta; 1305fa9e4066Sahrens 1306fa9e4066Sahrens /* only toplevel vdevs have capacity stats */ 1307fa9e4066Sahrens if (newvs->vs_space == 0) { 1308fa9e4066Sahrens (void) printf(" - -"); 1309fa9e4066Sahrens } else { 1310fa9e4066Sahrens print_one_stat(newvs->vs_alloc); 1311fa9e4066Sahrens print_one_stat(newvs->vs_space - newvs->vs_alloc); 1312fa9e4066Sahrens } 1313fa9e4066Sahrens 1314fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] - 1315fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_READ]))); 1316fa9e4066Sahrens 1317fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] - 1318fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_WRITE]))); 1319fa9e4066Sahrens 1320fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] - 1321fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_READ]))); 1322fa9e4066Sahrens 1323fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] - 1324fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_WRITE]))); 1325fa9e4066Sahrens 1326fa9e4066Sahrens (void) printf("\n"); 1327fa9e4066Sahrens 1328fa9e4066Sahrens if (!cb->cb_verbose) 1329fa9e4066Sahrens return; 1330fa9e4066Sahrens 1331fa9e4066Sahrens if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN, 1332fa9e4066Sahrens &newchild, &children) != 0) 1333fa9e4066Sahrens return; 1334fa9e4066Sahrens 1335fa9e4066Sahrens if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN, 1336fa9e4066Sahrens &oldchild, &c) != 0) 1337fa9e4066Sahrens return; 1338fa9e4066Sahrens 1339afefbcddSeschrock for (c = 0; c < children; c++) { 1340c67d9675Seschrock vname = zpool_vdev_name(zhp, newchild[c]); 1341c67d9675Seschrock print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 1342afefbcddSeschrock newchild[c], cb, depth + 2); 1343afefbcddSeschrock free(vname); 1344afefbcddSeschrock } 1345fa9e4066Sahrens } 1346fa9e4066Sahrens 1347088e9d47Seschrock static int 1348088e9d47Seschrock refresh_iostat(zpool_handle_t *zhp, void *data) 1349088e9d47Seschrock { 1350088e9d47Seschrock iostat_cbdata_t *cb = data; 1351088e9d47Seschrock 1352088e9d47Seschrock /* 1353088e9d47Seschrock * If the pool has disappeared, remove it from the list and continue. 1354088e9d47Seschrock */ 1355088e9d47Seschrock if (zpool_refresh_stats(zhp) != 0) 1356088e9d47Seschrock pool_list_remove(cb->cb_list, zhp); 1357088e9d47Seschrock 1358088e9d47Seschrock return (0); 1359088e9d47Seschrock } 1360088e9d47Seschrock 1361fa9e4066Sahrens /* 1362fa9e4066Sahrens * Callback to print out the iostats for the given pool. 1363fa9e4066Sahrens */ 1364fa9e4066Sahrens int 1365fa9e4066Sahrens print_iostat(zpool_handle_t *zhp, void *data) 1366fa9e4066Sahrens { 1367fa9e4066Sahrens iostat_cbdata_t *cb = data; 1368fa9e4066Sahrens nvlist_t *oldconfig, *newconfig; 1369fa9e4066Sahrens nvlist_t *oldnvroot, *newnvroot; 1370fa9e4066Sahrens 1371088e9d47Seschrock newconfig = zpool_get_config(zhp, &oldconfig); 1372fa9e4066Sahrens 1373088e9d47Seschrock if (cb->cb_iteration == 1) 1374fa9e4066Sahrens oldconfig = NULL; 1375fa9e4066Sahrens 1376fa9e4066Sahrens verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE, 1377fa9e4066Sahrens &newnvroot) == 0); 1378fa9e4066Sahrens 1379088e9d47Seschrock if (oldconfig == NULL) 1380fa9e4066Sahrens oldnvroot = NULL; 1381088e9d47Seschrock else 1382088e9d47Seschrock verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE, 1383088e9d47Seschrock &oldnvroot) == 0); 1384fa9e4066Sahrens 1385fa9e4066Sahrens /* 1386fa9e4066Sahrens * Print out the statistics for the pool. 1387fa9e4066Sahrens */ 1388c67d9675Seschrock print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0); 1389fa9e4066Sahrens 1390fa9e4066Sahrens if (cb->cb_verbose) 1391fa9e4066Sahrens print_iostat_separator(cb); 1392fa9e4066Sahrens 1393fa9e4066Sahrens return (0); 1394fa9e4066Sahrens } 1395fa9e4066Sahrens 1396fa9e4066Sahrens int 1397fa9e4066Sahrens get_namewidth(zpool_handle_t *zhp, void *data) 1398fa9e4066Sahrens { 1399fa9e4066Sahrens iostat_cbdata_t *cb = data; 1400fa9e4066Sahrens nvlist_t *config, *nvroot; 1401fa9e4066Sahrens 1402088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) != NULL) { 1403fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1404fa9e4066Sahrens &nvroot) == 0); 1405fa9e4066Sahrens if (!cb->cb_verbose) 1406fa9e4066Sahrens cb->cb_namewidth = strlen(zpool_get_name(zhp)); 1407fa9e4066Sahrens else 1408c67d9675Seschrock cb->cb_namewidth = max_width(zhp, nvroot, 0, 0); 1409fa9e4066Sahrens } 1410fa9e4066Sahrens 1411fa9e4066Sahrens /* 1412fa9e4066Sahrens * The width must fall into the range [10,38]. The upper limit is the 1413fa9e4066Sahrens * maximum we can have and still fit in 80 columns. 1414fa9e4066Sahrens */ 1415fa9e4066Sahrens if (cb->cb_namewidth < 10) 1416fa9e4066Sahrens cb->cb_namewidth = 10; 1417fa9e4066Sahrens if (cb->cb_namewidth > 38) 1418fa9e4066Sahrens cb->cb_namewidth = 38; 1419fa9e4066Sahrens 1420fa9e4066Sahrens return (0); 1421fa9e4066Sahrens } 1422fa9e4066Sahrens 1423fa9e4066Sahrens /* 1424fa9e4066Sahrens * zpool iostat [-v] [pool] ... [interval [count]] 1425fa9e4066Sahrens * 1426fa9e4066Sahrens * -v Display statistics for individual vdevs 1427fa9e4066Sahrens * 1428fa9e4066Sahrens * This command can be tricky because we want to be able to deal with pool 1429fa9e4066Sahrens * creation/destruction as well as vdev configuration changes. The bulk of this 1430fa9e4066Sahrens * processing is handled by the pool_list_* routines in zpool_iter.c. We rely 1431fa9e4066Sahrens * on pool_list_update() to detect the addition of new pools. Configuration 1432fa9e4066Sahrens * changes are all handled within libzfs. 1433fa9e4066Sahrens */ 1434fa9e4066Sahrens int 1435fa9e4066Sahrens zpool_do_iostat(int argc, char **argv) 1436fa9e4066Sahrens { 1437fa9e4066Sahrens int c; 1438fa9e4066Sahrens int ret; 1439fa9e4066Sahrens int npools; 1440fa9e4066Sahrens unsigned long interval = 0, count = 0; 1441fa9e4066Sahrens zpool_list_t *list; 1442fa9e4066Sahrens int verbose = FALSE; 1443fa9e4066Sahrens iostat_cbdata_t cb; 1444fa9e4066Sahrens 1445fa9e4066Sahrens /* check options */ 1446fa9e4066Sahrens while ((c = getopt(argc, argv, "v")) != -1) { 1447fa9e4066Sahrens switch (c) { 1448fa9e4066Sahrens case 'v': 1449fa9e4066Sahrens verbose = TRUE; 1450fa9e4066Sahrens break; 1451fa9e4066Sahrens case '?': 1452fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1453fa9e4066Sahrens optopt); 1454fa9e4066Sahrens usage(FALSE); 1455fa9e4066Sahrens } 1456fa9e4066Sahrens } 1457fa9e4066Sahrens 1458fa9e4066Sahrens argc -= optind; 1459fa9e4066Sahrens argv += optind; 1460fa9e4066Sahrens 1461fa9e4066Sahrens /* 1462fa9e4066Sahrens * Determine if the last argument is an integer or a pool name 1463fa9e4066Sahrens */ 1464fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 1465fa9e4066Sahrens char *end; 1466fa9e4066Sahrens 1467fa9e4066Sahrens errno = 0; 1468fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 1469fa9e4066Sahrens 1470fa9e4066Sahrens if (*end == '\0' && errno == 0) { 1471fa9e4066Sahrens if (interval == 0) { 1472fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 1473fa9e4066Sahrens "cannot be zero\n")); 1474fa9e4066Sahrens usage(FALSE); 1475fa9e4066Sahrens } 1476fa9e4066Sahrens 1477fa9e4066Sahrens /* 1478fa9e4066Sahrens * Ignore the last parameter 1479fa9e4066Sahrens */ 1480fa9e4066Sahrens argc--; 1481fa9e4066Sahrens } else { 1482fa9e4066Sahrens /* 1483fa9e4066Sahrens * If this is not a valid number, just plow on. The 1484fa9e4066Sahrens * user will get a more informative error message later 1485fa9e4066Sahrens * on. 1486fa9e4066Sahrens */ 1487fa9e4066Sahrens interval = 0; 1488fa9e4066Sahrens } 1489fa9e4066Sahrens } 1490fa9e4066Sahrens 1491fa9e4066Sahrens /* 1492fa9e4066Sahrens * If the last argument is also an integer, then we have both a count 1493fa9e4066Sahrens * and an integer. 1494fa9e4066Sahrens */ 1495fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 1496fa9e4066Sahrens char *end; 1497fa9e4066Sahrens 1498fa9e4066Sahrens errno = 0; 1499fa9e4066Sahrens count = interval; 1500fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 1501fa9e4066Sahrens 1502fa9e4066Sahrens if (*end == '\0' && errno == 0) { 1503fa9e4066Sahrens if (interval == 0) { 1504fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 1505fa9e4066Sahrens "cannot be zero\n")); 1506fa9e4066Sahrens usage(FALSE); 1507fa9e4066Sahrens } 1508fa9e4066Sahrens 1509fa9e4066Sahrens /* 1510fa9e4066Sahrens * Ignore the last parameter 1511fa9e4066Sahrens */ 1512fa9e4066Sahrens argc--; 1513fa9e4066Sahrens } else { 1514fa9e4066Sahrens interval = 0; 1515fa9e4066Sahrens } 1516fa9e4066Sahrens } 1517fa9e4066Sahrens 1518fa9e4066Sahrens /* 1519fa9e4066Sahrens * Construct the list of all interesting pools. 1520fa9e4066Sahrens */ 1521fa9e4066Sahrens ret = 0; 1522fa9e4066Sahrens if ((list = pool_list_get(argc, argv, &ret)) == NULL) 1523fa9e4066Sahrens return (1); 1524fa9e4066Sahrens 1525fa9e4066Sahrens if (pool_list_count(list) == 0 && argc != 0) 1526fa9e4066Sahrens return (1); 1527fa9e4066Sahrens 1528fa9e4066Sahrens if (pool_list_count(list) == 0 && interval == 0) { 1529fa9e4066Sahrens (void) fprintf(stderr, gettext("no pools available\n")); 1530fa9e4066Sahrens return (1); 1531fa9e4066Sahrens } 1532fa9e4066Sahrens 1533fa9e4066Sahrens /* 1534fa9e4066Sahrens * Enter the main iostat loop. 1535fa9e4066Sahrens */ 1536fa9e4066Sahrens cb.cb_list = list; 1537fa9e4066Sahrens cb.cb_verbose = verbose; 1538fa9e4066Sahrens cb.cb_iteration = 0; 1539fa9e4066Sahrens cb.cb_namewidth = 0; 1540fa9e4066Sahrens 1541fa9e4066Sahrens for (;;) { 1542fa9e4066Sahrens pool_list_update(list); 1543fa9e4066Sahrens 1544fa9e4066Sahrens if ((npools = pool_list_count(list)) == 0) 1545fa9e4066Sahrens break; 1546fa9e4066Sahrens 1547088e9d47Seschrock /* 1548088e9d47Seschrock * Refresh all statistics. This is done as an explicit step 1549088e9d47Seschrock * before calculating the maximum name width, so that any 1550088e9d47Seschrock * configuration changes are properly accounted for. 1551088e9d47Seschrock */ 1552088e9d47Seschrock (void) pool_list_iter(list, FALSE, refresh_iostat, &cb); 1553088e9d47Seschrock 1554fa9e4066Sahrens /* 1555fa9e4066Sahrens * Iterate over all pools to determine the maximum width 1556fa9e4066Sahrens * for the pool / device name column across all pools. 1557fa9e4066Sahrens */ 1558fa9e4066Sahrens cb.cb_namewidth = 0; 1559fa9e4066Sahrens (void) pool_list_iter(list, FALSE, get_namewidth, &cb); 1560fa9e4066Sahrens 1561fa9e4066Sahrens /* 1562fa9e4066Sahrens * If it's the first time, or verbose mode, print the header. 1563fa9e4066Sahrens */ 1564fa9e4066Sahrens if (++cb.cb_iteration == 1 || verbose) 1565fa9e4066Sahrens print_iostat_header(&cb); 1566fa9e4066Sahrens 1567fa9e4066Sahrens (void) pool_list_iter(list, FALSE, print_iostat, &cb); 1568fa9e4066Sahrens 1569fa9e4066Sahrens /* 1570fa9e4066Sahrens * If there's more than one pool, and we're not in verbose mode 1571fa9e4066Sahrens * (which prints a separator for us), then print a separator. 1572fa9e4066Sahrens */ 1573fa9e4066Sahrens if (npools > 1 && !verbose) 1574fa9e4066Sahrens print_iostat_separator(&cb); 1575fa9e4066Sahrens 1576fa9e4066Sahrens if (verbose) 1577fa9e4066Sahrens (void) printf("\n"); 1578fa9e4066Sahrens 1579fa9e4066Sahrens if (interval == 0) 1580fa9e4066Sahrens break; 1581fa9e4066Sahrens 1582fa9e4066Sahrens if (count != 0 && --count == 0) 1583fa9e4066Sahrens break; 1584fa9e4066Sahrens 1585fa9e4066Sahrens (void) sleep(interval); 1586fa9e4066Sahrens } 1587fa9e4066Sahrens 1588fa9e4066Sahrens pool_list_free(list); 1589fa9e4066Sahrens 1590fa9e4066Sahrens return (ret); 1591fa9e4066Sahrens } 1592fa9e4066Sahrens 1593fa9e4066Sahrens typedef struct list_cbdata { 1594fa9e4066Sahrens int cb_scripted; 1595fa9e4066Sahrens int cb_first; 1596fa9e4066Sahrens int cb_fields[MAX_FIELDS]; 1597fa9e4066Sahrens int cb_fieldcount; 1598fa9e4066Sahrens } list_cbdata_t; 1599fa9e4066Sahrens 1600fa9e4066Sahrens /* 1601fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 1602fa9e4066Sahrens */ 1603fa9e4066Sahrens void 1604fa9e4066Sahrens print_header(int *fields, size_t count) 1605fa9e4066Sahrens { 1606fa9e4066Sahrens int i; 1607fa9e4066Sahrens column_def_t *col; 1608fa9e4066Sahrens const char *fmt; 1609fa9e4066Sahrens 1610fa9e4066Sahrens for (i = 0; i < count; i++) { 1611fa9e4066Sahrens col = &column_table[fields[i]]; 1612fa9e4066Sahrens if (i != 0) 1613fa9e4066Sahrens (void) printf(" "); 1614fa9e4066Sahrens if (col->cd_justify == left_justify) 1615fa9e4066Sahrens fmt = "%-*s"; 1616fa9e4066Sahrens else 1617fa9e4066Sahrens fmt = "%*s"; 1618fa9e4066Sahrens 1619fa9e4066Sahrens (void) printf(fmt, i == count - 1 ? strlen(col->cd_title) : 1620fa9e4066Sahrens col->cd_width, col->cd_title); 1621fa9e4066Sahrens } 1622fa9e4066Sahrens 1623fa9e4066Sahrens (void) printf("\n"); 1624fa9e4066Sahrens } 1625fa9e4066Sahrens 1626fa9e4066Sahrens int 1627fa9e4066Sahrens list_callback(zpool_handle_t *zhp, void *data) 1628fa9e4066Sahrens { 1629fa9e4066Sahrens list_cbdata_t *cbp = data; 1630fa9e4066Sahrens nvlist_t *config; 1631fa9e4066Sahrens int i; 1632fa9e4066Sahrens char buf[ZPOOL_MAXNAMELEN]; 1633fa9e4066Sahrens uint64_t total; 1634fa9e4066Sahrens uint64_t used; 1635fa9e4066Sahrens const char *fmt; 1636fa9e4066Sahrens column_def_t *col; 1637fa9e4066Sahrens 1638fa9e4066Sahrens if (cbp->cb_first) { 1639fa9e4066Sahrens if (!cbp->cb_scripted) 1640fa9e4066Sahrens print_header(cbp->cb_fields, cbp->cb_fieldcount); 1641fa9e4066Sahrens cbp->cb_first = FALSE; 1642fa9e4066Sahrens } 1643fa9e4066Sahrens 1644fa9e4066Sahrens if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 1645fa9e4066Sahrens config = NULL; 1646fa9e4066Sahrens } else { 1647088e9d47Seschrock config = zpool_get_config(zhp, NULL); 1648fa9e4066Sahrens total = zpool_get_space_total(zhp); 1649fa9e4066Sahrens used = zpool_get_space_used(zhp); 1650fa9e4066Sahrens } 1651fa9e4066Sahrens 1652fa9e4066Sahrens for (i = 0; i < cbp->cb_fieldcount; i++) { 1653fa9e4066Sahrens if (i != 0) { 1654fa9e4066Sahrens if (cbp->cb_scripted) 1655fa9e4066Sahrens (void) printf("\t"); 1656fa9e4066Sahrens else 1657fa9e4066Sahrens (void) printf(" "); 1658fa9e4066Sahrens } 1659fa9e4066Sahrens 1660fa9e4066Sahrens col = &column_table[cbp->cb_fields[i]]; 1661fa9e4066Sahrens 1662fa9e4066Sahrens switch (cbp->cb_fields[i]) { 1663fa9e4066Sahrens case ZPOOL_FIELD_NAME: 1664fa9e4066Sahrens (void) strlcpy(buf, zpool_get_name(zhp), sizeof (buf)); 1665fa9e4066Sahrens break; 1666fa9e4066Sahrens 1667fa9e4066Sahrens case ZPOOL_FIELD_SIZE: 1668fa9e4066Sahrens if (config == NULL) 1669fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1670fa9e4066Sahrens else 1671fa9e4066Sahrens zfs_nicenum(total, buf, sizeof (buf)); 1672fa9e4066Sahrens break; 1673fa9e4066Sahrens 1674fa9e4066Sahrens case ZPOOL_FIELD_USED: 1675fa9e4066Sahrens if (config == NULL) 1676fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1677fa9e4066Sahrens else 1678fa9e4066Sahrens zfs_nicenum(used, buf, sizeof (buf)); 1679fa9e4066Sahrens break; 1680fa9e4066Sahrens 1681fa9e4066Sahrens case ZPOOL_FIELD_AVAILABLE: 1682fa9e4066Sahrens if (config == NULL) 1683fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1684fa9e4066Sahrens else 1685fa9e4066Sahrens zfs_nicenum(total - used, buf, sizeof (buf)); 1686fa9e4066Sahrens break; 1687fa9e4066Sahrens 1688fa9e4066Sahrens case ZPOOL_FIELD_CAPACITY: 1689fa9e4066Sahrens if (config == NULL) { 1690fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1691fa9e4066Sahrens } else { 1692fa9e4066Sahrens uint64_t capacity = (total == 0 ? 0 : 1693fa9e4066Sahrens (used * 100 / total)); 1694fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%llu%%", 1695fa9e4066Sahrens capacity); 1696fa9e4066Sahrens } 1697fa9e4066Sahrens break; 1698fa9e4066Sahrens 1699fa9e4066Sahrens case ZPOOL_FIELD_HEALTH: 1700fa9e4066Sahrens if (config == NULL) { 1701fa9e4066Sahrens (void) strlcpy(buf, "FAULTED", sizeof (buf)); 1702fa9e4066Sahrens } else { 1703fa9e4066Sahrens nvlist_t *nvroot; 1704fa9e4066Sahrens vdev_stat_t *vs; 1705fa9e4066Sahrens uint_t vsc; 1706fa9e4066Sahrens 1707fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, 1708fa9e4066Sahrens ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0); 1709fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, 1710fa9e4066Sahrens ZPOOL_CONFIG_STATS, (uint64_t **)&vs, 1711fa9e4066Sahrens &vsc) == 0); 1712ea8dc4b6Seschrock (void) strlcpy(buf, state_to_name(vs), 1713fa9e4066Sahrens sizeof (buf)); 1714fa9e4066Sahrens } 1715fa9e4066Sahrens break; 1716fa9e4066Sahrens 1717fa9e4066Sahrens case ZPOOL_FIELD_ROOT: 1718fa9e4066Sahrens if (config == NULL) 1719fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1720fa9e4066Sahrens else if (zpool_get_root(zhp, buf, sizeof (buf)) != 0) 1721fa9e4066Sahrens (void) strlcpy(buf, "-", sizeof (buf)); 1722fa9e4066Sahrens break; 1723fa9e4066Sahrens } 1724fa9e4066Sahrens 1725fa9e4066Sahrens if (cbp->cb_scripted) 1726fa9e4066Sahrens (void) printf("%s", buf); 1727fa9e4066Sahrens else { 1728fa9e4066Sahrens if (col->cd_justify == left_justify) 1729fa9e4066Sahrens fmt = "%-*s"; 1730fa9e4066Sahrens else 1731fa9e4066Sahrens fmt = "%*s"; 1732fa9e4066Sahrens 1733fa9e4066Sahrens (void) printf(fmt, i == cbp->cb_fieldcount - 1 ? 1734fa9e4066Sahrens strlen(buf) : col->cd_width, buf); 1735fa9e4066Sahrens } 1736fa9e4066Sahrens } 1737fa9e4066Sahrens 1738fa9e4066Sahrens (void) printf("\n"); 1739fa9e4066Sahrens 1740fa9e4066Sahrens return (0); 1741fa9e4066Sahrens } 1742fa9e4066Sahrens 1743fa9e4066Sahrens /* 1744fa9e4066Sahrens * zpool list [-H] [-o field[,field]*] [pool] ... 1745fa9e4066Sahrens * 1746fa9e4066Sahrens * -H Scripted mode. Don't display headers, and separate fields by 1747fa9e4066Sahrens * a single tab. 1748fa9e4066Sahrens * -o List of fields to display. Defaults to all fields, or 1749fa9e4066Sahrens * "name,size,used,available,capacity,health,root" 1750fa9e4066Sahrens * 1751fa9e4066Sahrens * List all pools in the system, whether or not they're healthy. Output space 1752fa9e4066Sahrens * statistics for each one, as well as health status summary. 1753fa9e4066Sahrens */ 1754fa9e4066Sahrens int 1755fa9e4066Sahrens zpool_do_list(int argc, char **argv) 1756fa9e4066Sahrens { 1757fa9e4066Sahrens int c; 1758fa9e4066Sahrens int ret; 1759fa9e4066Sahrens list_cbdata_t cb = { 0 }; 1760fa9e4066Sahrens static char default_fields[] = 1761fa9e4066Sahrens "name,size,used,available,capacity,health,root"; 1762fa9e4066Sahrens char *fields = default_fields; 1763fa9e4066Sahrens char *value; 1764fa9e4066Sahrens 1765fa9e4066Sahrens /* check options */ 1766fa9e4066Sahrens while ((c = getopt(argc, argv, ":Ho:")) != -1) { 1767fa9e4066Sahrens switch (c) { 1768fa9e4066Sahrens case 'H': 1769fa9e4066Sahrens cb.cb_scripted = TRUE; 1770fa9e4066Sahrens break; 1771fa9e4066Sahrens case 'o': 1772fa9e4066Sahrens fields = optarg; 1773fa9e4066Sahrens break; 1774fa9e4066Sahrens case ':': 1775fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1776fa9e4066Sahrens "'%c' option\n"), optopt); 1777fa9e4066Sahrens usage(FALSE); 1778fa9e4066Sahrens break; 1779fa9e4066Sahrens case '?': 1780fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1781fa9e4066Sahrens optopt); 1782fa9e4066Sahrens usage(FALSE); 1783fa9e4066Sahrens } 1784fa9e4066Sahrens } 1785fa9e4066Sahrens 1786fa9e4066Sahrens argc -= optind; 1787fa9e4066Sahrens argv += optind; 1788fa9e4066Sahrens 1789fa9e4066Sahrens while (*fields != '\0') { 1790fa9e4066Sahrens if (cb.cb_fieldcount == MAX_FIELDS) { 1791fa9e4066Sahrens (void) fprintf(stderr, gettext("too many " 1792fa9e4066Sahrens "properties given to -o option\n")); 1793fa9e4066Sahrens usage(FALSE); 1794fa9e4066Sahrens } 1795fa9e4066Sahrens 1796fa9e4066Sahrens if ((cb.cb_fields[cb.cb_fieldcount] = getsubopt(&fields, 1797fa9e4066Sahrens column_subopts, &value)) == -1) { 1798fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid property " 1799fa9e4066Sahrens "'%s'\n"), value); 1800fa9e4066Sahrens usage(FALSE); 1801fa9e4066Sahrens } 1802fa9e4066Sahrens 1803fa9e4066Sahrens cb.cb_fieldcount++; 1804fa9e4066Sahrens } 1805fa9e4066Sahrens 1806fa9e4066Sahrens 1807fa9e4066Sahrens cb.cb_first = TRUE; 1808fa9e4066Sahrens 1809fa9e4066Sahrens ret = for_each_pool(argc, argv, TRUE, list_callback, &cb); 1810fa9e4066Sahrens 1811fa9e4066Sahrens if (argc == 0 && cb.cb_first) { 1812fa9e4066Sahrens (void) printf(gettext("no pools available\n")); 1813fa9e4066Sahrens return (0); 1814fa9e4066Sahrens } 1815fa9e4066Sahrens 1816fa9e4066Sahrens return (ret); 1817fa9e4066Sahrens } 1818fa9e4066Sahrens 1819fa9e4066Sahrens static nvlist_t * 1820fa9e4066Sahrens zpool_get_vdev_by_name(nvlist_t *nv, char *name) 1821fa9e4066Sahrens { 1822fa9e4066Sahrens nvlist_t **child; 1823fa9e4066Sahrens uint_t c, children; 1824fa9e4066Sahrens nvlist_t *match; 1825fa9e4066Sahrens char *path; 1826fa9e4066Sahrens 1827fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1828fa9e4066Sahrens &child, &children) != 0) { 1829fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1830fa9e4066Sahrens if (strncmp(name, "/dev/dsk/", 9) == 0) 1831fa9e4066Sahrens name += 9; 1832fa9e4066Sahrens if (strncmp(path, "/dev/dsk/", 9) == 0) 1833fa9e4066Sahrens path += 9; 1834fa9e4066Sahrens if (strcmp(name, path) == 0) 1835fa9e4066Sahrens return (nv); 1836fa9e4066Sahrens return (NULL); 1837fa9e4066Sahrens } 1838fa9e4066Sahrens 1839fa9e4066Sahrens for (c = 0; c < children; c++) 1840fa9e4066Sahrens if ((match = zpool_get_vdev_by_name(child[c], name)) != NULL) 1841fa9e4066Sahrens return (match); 1842fa9e4066Sahrens 1843fa9e4066Sahrens return (NULL); 1844fa9e4066Sahrens } 1845fa9e4066Sahrens 1846fa9e4066Sahrens static int 1847fa9e4066Sahrens zpool_do_attach_or_replace(int argc, char **argv, int replacing) 1848fa9e4066Sahrens { 1849fa9e4066Sahrens int force = FALSE; 1850fa9e4066Sahrens int c; 1851fa9e4066Sahrens nvlist_t *nvroot; 1852fa9e4066Sahrens char *poolname, *old_disk, *new_disk; 1853fa9e4066Sahrens zpool_handle_t *zhp; 1854fa9e4066Sahrens nvlist_t *config; 1855fa9e4066Sahrens 1856fa9e4066Sahrens /* check options */ 1857fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 1858fa9e4066Sahrens switch (c) { 1859fa9e4066Sahrens case 'f': 1860fa9e4066Sahrens force = TRUE; 1861fa9e4066Sahrens break; 1862fa9e4066Sahrens case '?': 1863fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1864fa9e4066Sahrens optopt); 1865fa9e4066Sahrens usage(FALSE); 1866fa9e4066Sahrens } 1867fa9e4066Sahrens } 1868fa9e4066Sahrens 1869fa9e4066Sahrens argc -= optind; 1870fa9e4066Sahrens argv += optind; 1871fa9e4066Sahrens 1872fa9e4066Sahrens /* get pool name and check number of arguments */ 1873fa9e4066Sahrens if (argc < 1) { 1874fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 1875fa9e4066Sahrens usage(FALSE); 1876fa9e4066Sahrens } 1877fa9e4066Sahrens 1878fa9e4066Sahrens poolname = argv[0]; 1879fa9e4066Sahrens 1880fa9e4066Sahrens if (argc < 2) { 1881fa9e4066Sahrens (void) fprintf(stderr, 1882fa9e4066Sahrens gettext("missing <device> specification\n")); 1883fa9e4066Sahrens usage(FALSE); 1884fa9e4066Sahrens } 1885fa9e4066Sahrens 1886fa9e4066Sahrens old_disk = argv[1]; 1887fa9e4066Sahrens 1888fa9e4066Sahrens if (argc < 3) { 1889fa9e4066Sahrens if (!replacing) { 1890fa9e4066Sahrens (void) fprintf(stderr, 1891fa9e4066Sahrens gettext("missing <new_device> specification\n")); 1892fa9e4066Sahrens usage(FALSE); 1893fa9e4066Sahrens } 1894fa9e4066Sahrens new_disk = old_disk; 1895fa9e4066Sahrens argc -= 1; 1896fa9e4066Sahrens argv += 1; 1897fa9e4066Sahrens } else { 1898fa9e4066Sahrens new_disk = argv[2]; 1899fa9e4066Sahrens argc -= 2; 1900fa9e4066Sahrens argv += 2; 1901fa9e4066Sahrens } 1902fa9e4066Sahrens 1903fa9e4066Sahrens if (argc > 1) { 1904fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 1905fa9e4066Sahrens usage(FALSE); 1906fa9e4066Sahrens } 1907fa9e4066Sahrens 1908fa9e4066Sahrens if ((zhp = zpool_open(poolname)) == NULL) 1909fa9e4066Sahrens return (1); 1910fa9e4066Sahrens 1911088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 1912fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 1913fa9e4066Sahrens poolname); 1914fa9e4066Sahrens zpool_close(zhp); 1915fa9e4066Sahrens return (1); 1916fa9e4066Sahrens } 1917fa9e4066Sahrens 1918fa9e4066Sahrens nvroot = make_root_vdev(config, force, B_FALSE, argc, argv); 1919fa9e4066Sahrens if (nvroot == NULL) { 1920fa9e4066Sahrens zpool_close(zhp); 1921fa9e4066Sahrens return (1); 1922fa9e4066Sahrens } 1923fa9e4066Sahrens 1924fa9e4066Sahrens return (zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing)); 1925fa9e4066Sahrens } 1926fa9e4066Sahrens 1927fa9e4066Sahrens /* 1928fa9e4066Sahrens * zpool replace [-f] <pool> <device> <new_device> 1929fa9e4066Sahrens * 1930fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 1931fa9e4066Sahrens * 1932fa9e4066Sahrens * Replace <device> with <new_device>. 1933fa9e4066Sahrens */ 1934fa9e4066Sahrens /* ARGSUSED */ 1935fa9e4066Sahrens int 1936fa9e4066Sahrens zpool_do_replace(int argc, char **argv) 1937fa9e4066Sahrens { 1938fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_TRUE)); 1939fa9e4066Sahrens } 1940fa9e4066Sahrens 1941fa9e4066Sahrens /* 1942fa9e4066Sahrens * zpool attach [-f] <pool> <device> <new_device> 1943fa9e4066Sahrens * 1944fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 1945fa9e4066Sahrens * 1946fa9e4066Sahrens * Attach <new_device> to the mirror containing <device>. If <device> is not 1947fa9e4066Sahrens * part of a mirror, then <device> will be transformed into a mirror of 1948fa9e4066Sahrens * <device> and <new_device>. In either case, <new_device> will begin life 1949fa9e4066Sahrens * with a DTL of [0, now], and will immediately begin to resilver itself. 1950fa9e4066Sahrens */ 1951fa9e4066Sahrens int 1952fa9e4066Sahrens zpool_do_attach(int argc, char **argv) 1953fa9e4066Sahrens { 1954fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_FALSE)); 1955fa9e4066Sahrens } 1956fa9e4066Sahrens 1957fa9e4066Sahrens /* 1958fa9e4066Sahrens * zpool detach [-f] <pool> <device> 1959fa9e4066Sahrens * 1960fa9e4066Sahrens * -f Force detach of <device>, even if DTLs argue against it 1961fa9e4066Sahrens * (not supported yet) 1962fa9e4066Sahrens * 1963fa9e4066Sahrens * Detach a device from a mirror. The operation will be refused if <device> 1964fa9e4066Sahrens * is the last device in the mirror, or if the DTLs indicate that this device 1965fa9e4066Sahrens * has the only valid copy of some data. 1966fa9e4066Sahrens */ 1967fa9e4066Sahrens /* ARGSUSED */ 1968fa9e4066Sahrens int 1969fa9e4066Sahrens zpool_do_detach(int argc, char **argv) 1970fa9e4066Sahrens { 1971fa9e4066Sahrens int c; 1972fa9e4066Sahrens char *poolname, *path; 1973fa9e4066Sahrens zpool_handle_t *zhp; 1974fa9e4066Sahrens 1975fa9e4066Sahrens /* check options */ 1976fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 1977fa9e4066Sahrens switch (c) { 1978fa9e4066Sahrens case 'f': 1979fa9e4066Sahrens case '?': 1980fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1981fa9e4066Sahrens optopt); 1982fa9e4066Sahrens usage(FALSE); 1983fa9e4066Sahrens } 1984fa9e4066Sahrens } 1985fa9e4066Sahrens 1986fa9e4066Sahrens argc -= optind; 1987fa9e4066Sahrens argv += optind; 1988fa9e4066Sahrens 1989fa9e4066Sahrens /* get pool name and check number of arguments */ 1990fa9e4066Sahrens if (argc < 1) { 1991fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 1992fa9e4066Sahrens usage(FALSE); 1993fa9e4066Sahrens } 1994fa9e4066Sahrens 1995fa9e4066Sahrens if (argc < 2) { 1996fa9e4066Sahrens (void) fprintf(stderr, 1997fa9e4066Sahrens gettext("missing <device> specification\n")); 1998fa9e4066Sahrens usage(FALSE); 1999fa9e4066Sahrens } 2000fa9e4066Sahrens 2001fa9e4066Sahrens poolname = argv[0]; 2002fa9e4066Sahrens path = argv[1]; 2003fa9e4066Sahrens 2004fa9e4066Sahrens if ((zhp = zpool_open(poolname)) == NULL) 2005fa9e4066Sahrens return (1); 2006fa9e4066Sahrens 2007fa9e4066Sahrens return (zpool_vdev_detach(zhp, path)); 2008fa9e4066Sahrens } 2009fa9e4066Sahrens 2010fa9e4066Sahrens /* 2011441d80aaSlling * zpool online <pool> <device> ... 2012fa9e4066Sahrens */ 2013fa9e4066Sahrens /* ARGSUSED */ 2014fa9e4066Sahrens int 2015fa9e4066Sahrens zpool_do_online(int argc, char **argv) 2016fa9e4066Sahrens { 2017fa9e4066Sahrens int c, i; 2018fa9e4066Sahrens char *poolname; 2019fa9e4066Sahrens zpool_handle_t *zhp; 2020fa9e4066Sahrens int ret = 0; 2021fa9e4066Sahrens 2022fa9e4066Sahrens /* check options */ 2023fa9e4066Sahrens while ((c = getopt(argc, argv, "t")) != -1) { 2024fa9e4066Sahrens switch (c) { 2025fa9e4066Sahrens case 't': 2026fa9e4066Sahrens case '?': 2027fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2028fa9e4066Sahrens optopt); 2029fa9e4066Sahrens usage(FALSE); 2030fa9e4066Sahrens } 2031fa9e4066Sahrens } 2032fa9e4066Sahrens 2033fa9e4066Sahrens argc -= optind; 2034fa9e4066Sahrens argv += optind; 2035fa9e4066Sahrens 2036fa9e4066Sahrens /* get pool name and check number of arguments */ 2037fa9e4066Sahrens if (argc < 1) { 2038fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 2039fa9e4066Sahrens usage(FALSE); 2040fa9e4066Sahrens } 2041fa9e4066Sahrens if (argc < 2) { 2042fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 2043fa9e4066Sahrens usage(FALSE); 2044fa9e4066Sahrens } 2045fa9e4066Sahrens 2046fa9e4066Sahrens poolname = argv[0]; 2047fa9e4066Sahrens 2048fa9e4066Sahrens if ((zhp = zpool_open(poolname)) == NULL) 2049fa9e4066Sahrens return (1); 2050fa9e4066Sahrens 2051fa9e4066Sahrens for (i = 1; i < argc; i++) 2052fa9e4066Sahrens if (zpool_vdev_online(zhp, argv[i]) == 0) 2053fa9e4066Sahrens (void) printf(gettext("Bringing device %s online\n"), 2054fa9e4066Sahrens argv[i]); 2055fa9e4066Sahrens else 2056fa9e4066Sahrens ret = 1; 2057fa9e4066Sahrens 2058fa9e4066Sahrens return (ret); 2059fa9e4066Sahrens } 2060fa9e4066Sahrens 2061fa9e4066Sahrens /* 2062441d80aaSlling * zpool offline [-ft] <pool> <device> ... 2063fa9e4066Sahrens * 2064fa9e4066Sahrens * -f Force the device into the offline state, even if doing 2065fa9e4066Sahrens * so would appear to compromise pool availability. 2066fa9e4066Sahrens * (not supported yet) 2067fa9e4066Sahrens * 2068fa9e4066Sahrens * -t Only take the device off-line temporarily. The offline 2069fa9e4066Sahrens * state will not be persistent across reboots. 2070fa9e4066Sahrens */ 2071fa9e4066Sahrens /* ARGSUSED */ 2072fa9e4066Sahrens int 2073fa9e4066Sahrens zpool_do_offline(int argc, char **argv) 2074fa9e4066Sahrens { 2075fa9e4066Sahrens int c, i; 2076fa9e4066Sahrens char *poolname; 2077fa9e4066Sahrens zpool_handle_t *zhp; 2078441d80aaSlling int ret = 0, istmp = FALSE; 2079fa9e4066Sahrens 2080fa9e4066Sahrens /* check options */ 2081fa9e4066Sahrens while ((c = getopt(argc, argv, "ft")) != -1) { 2082fa9e4066Sahrens switch (c) { 2083fa9e4066Sahrens case 't': 2084441d80aaSlling istmp = TRUE; 2085441d80aaSlling break; 2086441d80aaSlling case 'f': 2087fa9e4066Sahrens case '?': 2088fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2089fa9e4066Sahrens optopt); 2090fa9e4066Sahrens usage(FALSE); 2091fa9e4066Sahrens } 2092fa9e4066Sahrens } 2093fa9e4066Sahrens 2094fa9e4066Sahrens argc -= optind; 2095fa9e4066Sahrens argv += optind; 2096fa9e4066Sahrens 2097fa9e4066Sahrens /* get pool name and check number of arguments */ 2098fa9e4066Sahrens if (argc < 1) { 2099fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 2100fa9e4066Sahrens usage(FALSE); 2101fa9e4066Sahrens } 2102fa9e4066Sahrens if (argc < 2) { 2103fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 2104fa9e4066Sahrens usage(FALSE); 2105fa9e4066Sahrens } 2106fa9e4066Sahrens 2107fa9e4066Sahrens poolname = argv[0]; 2108fa9e4066Sahrens 2109fa9e4066Sahrens if ((zhp = zpool_open(poolname)) == NULL) 2110fa9e4066Sahrens return (1); 2111fa9e4066Sahrens 2112fa9e4066Sahrens for (i = 1; i < argc; i++) 2113441d80aaSlling if (zpool_vdev_offline(zhp, argv[i], istmp) == 0) 2114fa9e4066Sahrens (void) printf(gettext("Bringing device %s offline\n"), 2115fa9e4066Sahrens argv[i]); 2116fa9e4066Sahrens else 2117fa9e4066Sahrens ret = 1; 2118fa9e4066Sahrens 2119fa9e4066Sahrens return (ret); 2120fa9e4066Sahrens } 2121fa9e4066Sahrens 2122ea8dc4b6Seschrock /* 2123ea8dc4b6Seschrock * zpool clear <pool> [device] 2124ea8dc4b6Seschrock * 2125ea8dc4b6Seschrock * Clear all errors associated with a pool or a particular device. 2126ea8dc4b6Seschrock */ 2127ea8dc4b6Seschrock int 2128ea8dc4b6Seschrock zpool_do_clear(int argc, char **argv) 2129ea8dc4b6Seschrock { 2130ea8dc4b6Seschrock int ret = 0; 2131ea8dc4b6Seschrock zpool_handle_t *zhp; 2132ea8dc4b6Seschrock char *pool, *device; 2133ea8dc4b6Seschrock 2134ea8dc4b6Seschrock if (argc < 2) { 2135ea8dc4b6Seschrock (void) fprintf(stderr, gettext("missing pool name\n")); 2136ea8dc4b6Seschrock usage(FALSE); 2137ea8dc4b6Seschrock } 2138ea8dc4b6Seschrock 2139ea8dc4b6Seschrock if (argc > 3) { 2140ea8dc4b6Seschrock (void) fprintf(stderr, gettext("too many arguments\n")); 2141ea8dc4b6Seschrock usage(FALSE); 2142ea8dc4b6Seschrock } 2143ea8dc4b6Seschrock 2144ea8dc4b6Seschrock pool = argv[1]; 2145ea8dc4b6Seschrock device = argc == 3 ? argv[2] : NULL; 2146ea8dc4b6Seschrock 2147ea8dc4b6Seschrock if ((zhp = zpool_open(pool)) == NULL) 2148ea8dc4b6Seschrock return (1); 2149ea8dc4b6Seschrock 2150ea8dc4b6Seschrock if (zpool_clear(zhp, device) != 0) 2151ea8dc4b6Seschrock ret = 1; 2152ea8dc4b6Seschrock 2153ea8dc4b6Seschrock zpool_close(zhp); 2154ea8dc4b6Seschrock 2155ea8dc4b6Seschrock return (ret); 2156ea8dc4b6Seschrock } 2157ea8dc4b6Seschrock 2158fa9e4066Sahrens typedef struct scrub_cbdata { 2159fa9e4066Sahrens int cb_type; 2160fa9e4066Sahrens } scrub_cbdata_t; 2161fa9e4066Sahrens 2162fa9e4066Sahrens int 2163fa9e4066Sahrens scrub_callback(zpool_handle_t *zhp, void *data) 2164fa9e4066Sahrens { 2165fa9e4066Sahrens scrub_cbdata_t *cb = data; 2166fa9e4066Sahrens 2167ea8dc4b6Seschrock /* 2168ea8dc4b6Seschrock * Ignore faulted pools. 2169ea8dc4b6Seschrock */ 2170ea8dc4b6Seschrock if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 2171ea8dc4b6Seschrock (void) fprintf(stderr, gettext("cannot scrub '%s': pool is " 2172ea8dc4b6Seschrock "currently unavailable\n"), zpool_get_name(zhp)); 2173ea8dc4b6Seschrock return (1); 2174ea8dc4b6Seschrock } 2175ea8dc4b6Seschrock 2176fa9e4066Sahrens return (zpool_scrub(zhp, cb->cb_type) != 0); 2177fa9e4066Sahrens } 2178fa9e4066Sahrens 2179fa9e4066Sahrens /* 2180fa9e4066Sahrens * zpool scrub [-s] <pool> ... 2181fa9e4066Sahrens * 2182fa9e4066Sahrens * -s Stop. Stops any in-progress scrub. 2183fa9e4066Sahrens */ 2184fa9e4066Sahrens int 2185fa9e4066Sahrens zpool_do_scrub(int argc, char **argv) 2186fa9e4066Sahrens { 2187fa9e4066Sahrens int c; 2188fa9e4066Sahrens scrub_cbdata_t cb; 2189fa9e4066Sahrens 2190fa9e4066Sahrens cb.cb_type = POOL_SCRUB_EVERYTHING; 2191fa9e4066Sahrens 2192fa9e4066Sahrens /* check options */ 2193fa9e4066Sahrens while ((c = getopt(argc, argv, "s")) != -1) { 2194fa9e4066Sahrens switch (c) { 2195fa9e4066Sahrens case 's': 2196fa9e4066Sahrens cb.cb_type = POOL_SCRUB_NONE; 2197fa9e4066Sahrens break; 2198fa9e4066Sahrens case '?': 2199fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2200fa9e4066Sahrens optopt); 2201fa9e4066Sahrens usage(FALSE); 2202fa9e4066Sahrens } 2203fa9e4066Sahrens } 2204fa9e4066Sahrens 2205fa9e4066Sahrens argc -= optind; 2206fa9e4066Sahrens argv += optind; 2207fa9e4066Sahrens 2208fa9e4066Sahrens if (argc < 1) { 2209fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 2210fa9e4066Sahrens usage(FALSE); 2211fa9e4066Sahrens } 2212fa9e4066Sahrens 2213fa9e4066Sahrens return (for_each_pool(argc, argv, TRUE, scrub_callback, &cb)); 2214fa9e4066Sahrens } 2215fa9e4066Sahrens 2216fa9e4066Sahrens typedef struct status_cbdata { 2217fa9e4066Sahrens int cb_verbose; 2218fa9e4066Sahrens int cb_explain; 2219fa9e4066Sahrens int cb_count; 2220fa9e4066Sahrens int cb_first; 2221fa9e4066Sahrens } status_cbdata_t; 2222fa9e4066Sahrens 2223fa9e4066Sahrens /* 2224fa9e4066Sahrens * Print out detailed scrub status. 2225fa9e4066Sahrens */ 2226fa9e4066Sahrens void 2227fa9e4066Sahrens print_scrub_status(nvlist_t *nvroot) 2228fa9e4066Sahrens { 2229fa9e4066Sahrens vdev_stat_t *vs; 2230fa9e4066Sahrens uint_t vsc; 2231fa9e4066Sahrens time_t start, end, now; 2232fa9e4066Sahrens double fraction_done; 2233fa9e4066Sahrens uint64_t examined, total, minutes_left; 2234fa9e4066Sahrens char *scrub_type; 2235fa9e4066Sahrens 2236fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 2237fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 2238fa9e4066Sahrens 2239fa9e4066Sahrens /* 2240fa9e4066Sahrens * If there's never been a scrub, there's not much to say. 2241fa9e4066Sahrens */ 2242fa9e4066Sahrens if (vs->vs_scrub_end == 0 && vs->vs_scrub_type == POOL_SCRUB_NONE) { 2243fa9e4066Sahrens (void) printf(gettext("none requested\n")); 2244fa9e4066Sahrens return; 2245fa9e4066Sahrens } 2246fa9e4066Sahrens 2247fa9e4066Sahrens scrub_type = (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ? 2248fa9e4066Sahrens "resilver" : "scrub"; 2249fa9e4066Sahrens 2250fa9e4066Sahrens start = vs->vs_scrub_start; 2251fa9e4066Sahrens end = vs->vs_scrub_end; 2252fa9e4066Sahrens now = time(NULL); 2253fa9e4066Sahrens examined = vs->vs_scrub_examined; 2254fa9e4066Sahrens total = vs->vs_alloc; 2255fa9e4066Sahrens 2256fa9e4066Sahrens if (end != 0) { 2257fa9e4066Sahrens (void) printf(gettext("%s %s with %llu errors on %s"), 2258fa9e4066Sahrens scrub_type, vs->vs_scrub_complete ? "completed" : "stopped", 2259fa9e4066Sahrens (u_longlong_t)vs->vs_scrub_errors, ctime(&end)); 2260fa9e4066Sahrens return; 2261fa9e4066Sahrens } 2262fa9e4066Sahrens 2263fa9e4066Sahrens if (examined == 0) 2264fa9e4066Sahrens examined = 1; 2265fa9e4066Sahrens if (examined > total) 2266fa9e4066Sahrens total = examined; 2267fa9e4066Sahrens 2268fa9e4066Sahrens fraction_done = (double)examined / total; 2269fa9e4066Sahrens minutes_left = (uint64_t)((now - start) * 2270fa9e4066Sahrens (1 - fraction_done) / fraction_done / 60); 2271fa9e4066Sahrens 2272fa9e4066Sahrens (void) printf(gettext("%s in progress, %.2f%% done, %lluh%um to go\n"), 2273fa9e4066Sahrens scrub_type, 100 * fraction_done, 2274fa9e4066Sahrens (u_longlong_t)(minutes_left / 60), (uint_t)(minutes_left % 60)); 2275fa9e4066Sahrens } 2276fa9e4066Sahrens 2277fa9e4066Sahrens /* 2278fa9e4066Sahrens * Print out configuration state as requested by status_callback. 2279fa9e4066Sahrens */ 2280fa9e4066Sahrens void 2281c67d9675Seschrock print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 2282c67d9675Seschrock int namewidth, int depth) 2283fa9e4066Sahrens { 2284fa9e4066Sahrens nvlist_t **child; 2285fa9e4066Sahrens uint_t c, children; 2286fa9e4066Sahrens vdev_stat_t *vs; 2287ea8dc4b6Seschrock char rbuf[6], wbuf[6], cbuf[6], repaired[7]; 2288afefbcddSeschrock char *vname; 2289ea8dc4b6Seschrock uint64_t notpresent; 2290fa9e4066Sahrens 2291fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS, 2292fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 2293fa9e4066Sahrens 2294fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2295fa9e4066Sahrens &child, &children) != 0) 2296fa9e4066Sahrens children = 0; 2297fa9e4066Sahrens 2298fa9e4066Sahrens (void) printf("\t%*s%-*s %-8s", depth, "", namewidth - depth, 2299ea8dc4b6Seschrock name, state_to_name(vs)); 2300fa9e4066Sahrens 2301fa9e4066Sahrens zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf)); 2302fa9e4066Sahrens zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf)); 2303fa9e4066Sahrens zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf)); 2304fa9e4066Sahrens (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf); 2305fa9e4066Sahrens 2306ea8dc4b6Seschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 2307ea8dc4b6Seschrock ¬present) == 0) { 2308ea8dc4b6Seschrock char *path; 2309ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 23100917b783Seschrock (void) printf(" was %s", path); 2311ea8dc4b6Seschrock } else if (vs->vs_aux != 0) { 2312fa9e4066Sahrens (void) printf(" "); 2313fa9e4066Sahrens 2314fa9e4066Sahrens switch (vs->vs_aux) { 2315fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 2316fa9e4066Sahrens (void) printf(gettext("cannot open")); 2317fa9e4066Sahrens break; 2318fa9e4066Sahrens 2319fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 2320fa9e4066Sahrens (void) printf(gettext("missing device")); 2321fa9e4066Sahrens break; 2322fa9e4066Sahrens 2323fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 2324fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 2325fa9e4066Sahrens break; 2326fa9e4066Sahrens 2327fa9e4066Sahrens default: 2328fa9e4066Sahrens (void) printf(gettext("corrupted data")); 2329fa9e4066Sahrens break; 2330fa9e4066Sahrens } 2331fa9e4066Sahrens } else if (vs->vs_scrub_repaired != 0 && children == 0) { 2332fa9e4066Sahrens /* 2333fa9e4066Sahrens * Report bytes resilvered/repaired on leaf devices. 2334fa9e4066Sahrens */ 2335fa9e4066Sahrens zfs_nicenum(vs->vs_scrub_repaired, repaired, sizeof (repaired)); 2336fa9e4066Sahrens (void) printf(gettext(" %s %s"), repaired, 2337fa9e4066Sahrens (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ? 2338fa9e4066Sahrens "resilvered" : "repaired"); 2339fa9e4066Sahrens } 2340fa9e4066Sahrens 2341fa9e4066Sahrens (void) printf("\n"); 2342fa9e4066Sahrens 2343afefbcddSeschrock for (c = 0; c < children; c++) { 2344c67d9675Seschrock vname = zpool_vdev_name(zhp, child[c]); 2345c67d9675Seschrock print_status_config(zhp, vname, child[c], 2346fa9e4066Sahrens namewidth, depth + 2); 2347afefbcddSeschrock free(vname); 2348afefbcddSeschrock } 2349fa9e4066Sahrens } 2350fa9e4066Sahrens 2351ea8dc4b6Seschrock static void 2352ea8dc4b6Seschrock print_error_log(zpool_handle_t *zhp) 2353ea8dc4b6Seschrock { 2354ea8dc4b6Seschrock nvlist_t **log; 2355ea8dc4b6Seschrock size_t nelem; 2356ea8dc4b6Seschrock size_t maxdsname = sizeof ("DATASET") - 1; 2357ea8dc4b6Seschrock size_t maxobjname = sizeof ("OBJECT") - 1; 2358ea8dc4b6Seschrock int i; 2359ea8dc4b6Seschrock nvlist_t *nv; 2360ea8dc4b6Seschrock size_t len; 2361ea8dc4b6Seschrock char *dsname, *objname, *range; 2362ea8dc4b6Seschrock 2363ea8dc4b6Seschrock if (zpool_get_errlog(zhp, &log, &nelem) != 0) { 2364ea8dc4b6Seschrock (void) printf("errors: List of errors unavailable " 2365ea8dc4b6Seschrock "(insufficient privileges)\n"); 2366ea8dc4b6Seschrock return; 2367ea8dc4b6Seschrock } 2368ea8dc4b6Seschrock 2369ea8dc4b6Seschrock for (i = 0; i < nelem; i++) { 2370ea8dc4b6Seschrock nv = log[i]; 2371ea8dc4b6Seschrock 2372ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_DATASET, 2373ea8dc4b6Seschrock &dsname) == 0); 2374ea8dc4b6Seschrock len = strlen(dsname); 2375ea8dc4b6Seschrock if (len > maxdsname) 2376ea8dc4b6Seschrock maxdsname = len; 2377ea8dc4b6Seschrock 2378ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_OBJECT, 2379ea8dc4b6Seschrock &objname) == 0); 2380ea8dc4b6Seschrock len = strlen(objname); 2381ea8dc4b6Seschrock if (len > maxobjname) 2382ea8dc4b6Seschrock maxobjname = len; 2383ea8dc4b6Seschrock } 2384ea8dc4b6Seschrock 2385ea8dc4b6Seschrock (void) printf("errors: The following persistent errors have been " 2386ea8dc4b6Seschrock "detected:\n\n"); 2387ea8dc4b6Seschrock (void) printf("%8s %-*s %-*s %s\n", "", maxdsname, "DATASET", 2388ea8dc4b6Seschrock maxobjname, "OBJECT", "RANGE"); 2389ea8dc4b6Seschrock 2390ea8dc4b6Seschrock for (i = 0; i < nelem; i++) { 2391ea8dc4b6Seschrock nv = log[i]; 2392ea8dc4b6Seschrock 2393ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_DATASET, 2394ea8dc4b6Seschrock &dsname) == 0); 2395ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_OBJECT, 2396ea8dc4b6Seschrock &objname) == 0); 2397ea8dc4b6Seschrock verify(nvlist_lookup_string(nv, ZPOOL_ERR_RANGE, 2398ea8dc4b6Seschrock &range) == 0); 2399ea8dc4b6Seschrock 2400ea8dc4b6Seschrock (void) printf("%8s %-*s %-*s %s\n", "", maxdsname, 2401ea8dc4b6Seschrock dsname, maxobjname, objname, range); 2402ea8dc4b6Seschrock } 2403ea8dc4b6Seschrock } 2404ea8dc4b6Seschrock 2405fa9e4066Sahrens /* 2406fa9e4066Sahrens * Display a summary of pool status. Displays a summary such as: 2407fa9e4066Sahrens * 2408fa9e4066Sahrens * pool: tank 2409fa9e4066Sahrens * status: DEGRADED 2410fa9e4066Sahrens * reason: One or more devices ... 2411fa9e4066Sahrens * see: http://www.sun.com/msg/ZFS-xxxx-01 2412fa9e4066Sahrens * config: 2413fa9e4066Sahrens * mirror DEGRADED 2414fa9e4066Sahrens * c1t0d0 OK 2415ea8dc4b6Seschrock * c2t0d0 UNAVAIL 2416fa9e4066Sahrens * 2417fa9e4066Sahrens * When given the '-v' option, we print out the complete config. If the '-e' 2418fa9e4066Sahrens * option is specified, then we print out error rate information as well. 2419fa9e4066Sahrens */ 2420fa9e4066Sahrens int 2421fa9e4066Sahrens status_callback(zpool_handle_t *zhp, void *data) 2422fa9e4066Sahrens { 2423fa9e4066Sahrens status_cbdata_t *cbp = data; 2424fa9e4066Sahrens nvlist_t *config, *nvroot; 2425fa9e4066Sahrens char *msgid; 2426fa9e4066Sahrens int reason; 2427fa9e4066Sahrens char *health; 2428fa9e4066Sahrens 2429088e9d47Seschrock config = zpool_get_config(zhp, NULL); 2430fa9e4066Sahrens reason = zpool_get_status(zhp, &msgid); 2431fa9e4066Sahrens 2432fa9e4066Sahrens cbp->cb_count++; 2433fa9e4066Sahrens 2434fa9e4066Sahrens /* 2435fa9e4066Sahrens * If we were given 'zpool status -x', only report those pools with 2436fa9e4066Sahrens * problems. 2437fa9e4066Sahrens */ 2438fa9e4066Sahrens if (reason == ZPOOL_STATUS_OK && cbp->cb_explain) 2439fa9e4066Sahrens return (0); 2440fa9e4066Sahrens 2441fa9e4066Sahrens if (cbp->cb_first) 2442fa9e4066Sahrens cbp->cb_first = FALSE; 2443fa9e4066Sahrens else 2444fa9e4066Sahrens (void) printf("\n"); 2445fa9e4066Sahrens 2446fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_HEALTH, 2447fa9e4066Sahrens &health) == 0); 2448fa9e4066Sahrens 2449fa9e4066Sahrens (void) printf(gettext(" pool: %s\n"), zpool_get_name(zhp)); 2450fa9e4066Sahrens (void) printf(gettext(" state: %s\n"), health); 2451fa9e4066Sahrens 2452fa9e4066Sahrens switch (reason) { 2453fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 2454fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2455fa9e4066Sahrens "be opened. Sufficient replicas exist for\n\tthe pool to " 2456fa9e4066Sahrens "continue functioning in a degraded state.\n")); 2457fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 2458fa9e4066Sahrens "online it using 'zpool online'.\n")); 2459fa9e4066Sahrens break; 2460fa9e4066Sahrens 2461fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 2462fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2463fa9e4066Sahrens "be opened. There are insufficient\n\treplicas for the " 2464fa9e4066Sahrens "pool to continue functioning.\n")); 2465fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 2466fa9e4066Sahrens "online it using 'zpool online'.\n")); 2467fa9e4066Sahrens break; 2468fa9e4066Sahrens 2469fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 2470fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2471fa9e4066Sahrens "be used because the label is missing or\n\tinvalid. " 2472fa9e4066Sahrens "Sufficient replicas exist for the pool to continue\n\t" 2473fa9e4066Sahrens "functioning in a degraded state.\n")); 2474fa9e4066Sahrens (void) printf(gettext("action: Replace the device using " 2475fa9e4066Sahrens "'zpool replace'.\n")); 2476fa9e4066Sahrens break; 2477fa9e4066Sahrens 2478fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 2479fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 2480fa9e4066Sahrens "be used because the the label is missing \n\tor invalid. " 2481fa9e4066Sahrens "There are insufficient replicas for the pool to " 2482fa9e4066Sahrens "continue\n\tfunctioning.\n")); 2483fa9e4066Sahrens (void) printf(gettext("action: Destroy and re-create the pool " 2484fa9e4066Sahrens "from a backup source.\n")); 2485fa9e4066Sahrens break; 2486fa9e4066Sahrens 2487fa9e4066Sahrens case ZPOOL_STATUS_FAILING_DEV: 2488fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 2489fa9e4066Sahrens "experienced an unrecoverable error. An\n\tattempt was " 2490fa9e4066Sahrens "made to correct the error. Applications are " 2491fa9e4066Sahrens "unaffected.\n")); 2492fa9e4066Sahrens (void) printf(gettext("action: Determine if the device needs " 2493fa9e4066Sahrens "to be replaced, and clear the errors\n\tusing " 2494ea8dc4b6Seschrock "'zpool clear' or replace the device with 'zpool " 2495fa9e4066Sahrens "replace'.\n")); 2496fa9e4066Sahrens break; 2497fa9e4066Sahrens 2498fa9e4066Sahrens case ZPOOL_STATUS_OFFLINE_DEV: 2499fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 2500fa9e4066Sahrens "been taken offline by the adminstrator.\n\tSufficient " 2501fa9e4066Sahrens "replicas exist for the pool to continue functioning in " 2502fa9e4066Sahrens "a\n\tdegraded state.\n")); 2503fa9e4066Sahrens (void) printf(gettext("action: Online the device using " 2504fa9e4066Sahrens "'zpool online' or replace the device with\n\t'zpool " 2505fa9e4066Sahrens "replace'.\n")); 2506fa9e4066Sahrens break; 2507fa9e4066Sahrens 2508fa9e4066Sahrens case ZPOOL_STATUS_RESILVERING: 2509fa9e4066Sahrens (void) printf(gettext("status: One or more devices is " 2510fa9e4066Sahrens "currently being resilvered. The pool will\n\tcontinue " 2511fa9e4066Sahrens "to function, possibly in a degraded state.\n")); 2512fa9e4066Sahrens (void) printf(gettext("action: Wait for the resilver to " 2513fa9e4066Sahrens "complete.\n")); 2514fa9e4066Sahrens break; 2515fa9e4066Sahrens 2516ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_DATA: 2517ea8dc4b6Seschrock (void) printf(gettext("status: One or more devices has " 2518ea8dc4b6Seschrock "experienced an error resulting in data\n\tcorruption. " 2519ea8dc4b6Seschrock "Applications may be affected.\n")); 2520ea8dc4b6Seschrock (void) printf(gettext("action: Restore the file in question " 2521ea8dc4b6Seschrock "if possible. Otherwise restore the\n\tentire pool from " 2522ea8dc4b6Seschrock "backup.\n")); 2523ea8dc4b6Seschrock break; 2524ea8dc4b6Seschrock 2525ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 2526ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is corrupted " 2527ea8dc4b6Seschrock "and the pool cannot be opened.\n")); 2528ea8dc4b6Seschrock (void) printf(gettext("action: Destroy and re-create the pool " 2529ea8dc4b6Seschrock "from a backup source.\n")); 2530ea8dc4b6Seschrock break; 2531ea8dc4b6Seschrock 2532fa9e4066Sahrens default: 2533fa9e4066Sahrens /* 2534fa9e4066Sahrens * The remaining errors can't actually be generated, yet. 2535fa9e4066Sahrens */ 2536fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 2537fa9e4066Sahrens } 2538fa9e4066Sahrens 2539fa9e4066Sahrens if (msgid != NULL) 2540fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 2541fa9e4066Sahrens msgid); 2542fa9e4066Sahrens 2543fa9e4066Sahrens if (config != NULL) { 2544fa9e4066Sahrens int namewidth; 2545ea8dc4b6Seschrock uint64_t nerr; 2546ea8dc4b6Seschrock size_t realerr; 2547fa9e4066Sahrens 2548fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2549fa9e4066Sahrens &nvroot) == 0); 2550fa9e4066Sahrens 2551fa9e4066Sahrens (void) printf(gettext(" scrub: ")); 2552fa9e4066Sahrens print_scrub_status(nvroot); 2553fa9e4066Sahrens 2554c67d9675Seschrock namewidth = max_width(zhp, nvroot, 0, 0); 2555fa9e4066Sahrens if (namewidth < 10) 2556fa9e4066Sahrens namewidth = 10; 2557fa9e4066Sahrens 2558fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 2559fa9e4066Sahrens (void) printf(gettext("\t%-*s %-8s %5s %5s %5s\n"), namewidth, 2560fa9e4066Sahrens "NAME", "STATE", "READ", "WRITE", "CKSUM"); 2561c67d9675Seschrock print_status_config(zhp, zpool_get_name(zhp), nvroot, 2562c67d9675Seschrock namewidth, 0); 2563ea8dc4b6Seschrock 2564ea8dc4b6Seschrock if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT, 2565ea8dc4b6Seschrock &nerr) == 0) { 2566ea8dc4b6Seschrock /* 2567ea8dc4b6Seschrock * If the approximate error count is small, get a 2568ea8dc4b6Seschrock * precise count by fetching the entire log and 2569ea8dc4b6Seschrock * uniquifying the results. 2570ea8dc4b6Seschrock */ 2571ea8dc4b6Seschrock if (nerr < 100 && !cbp->cb_verbose && 2572ea8dc4b6Seschrock zpool_get_errlog(zhp, NULL, &realerr) == 0) 2573ea8dc4b6Seschrock nerr = realerr; 2574ea8dc4b6Seschrock 2575ea8dc4b6Seschrock (void) printf("\n"); 2576ea8dc4b6Seschrock if (nerr == 0) 2577ea8dc4b6Seschrock (void) printf(gettext("errors: No known data " 2578ea8dc4b6Seschrock "errors\n")); 2579ea8dc4b6Seschrock else if (!cbp->cb_verbose) 2580ea8dc4b6Seschrock (void) printf(gettext("errors: %d data errors, " 2581ea8dc4b6Seschrock "use '-v' for a list\n"), nerr); 2582ea8dc4b6Seschrock else 2583ea8dc4b6Seschrock print_error_log(zhp); 2584ea8dc4b6Seschrock } 2585fa9e4066Sahrens } else { 2586fa9e4066Sahrens (void) printf(gettext("config: The configuration cannot be " 2587fa9e4066Sahrens "determined.\n")); 2588fa9e4066Sahrens } 2589fa9e4066Sahrens 2590fa9e4066Sahrens return (0); 2591fa9e4066Sahrens } 2592fa9e4066Sahrens 2593fa9e4066Sahrens /* 2594fa9e4066Sahrens * zpool status [-vx] [pool] ... 2595fa9e4066Sahrens * 2596fa9e4066Sahrens * -v Display complete error logs 2597fa9e4066Sahrens * -x Display only pools with potential problems 2598fa9e4066Sahrens * 2599fa9e4066Sahrens * Describes the health status of all pools or some subset. 2600fa9e4066Sahrens */ 2601fa9e4066Sahrens int 2602fa9e4066Sahrens zpool_do_status(int argc, char **argv) 2603fa9e4066Sahrens { 2604fa9e4066Sahrens int c; 2605fa9e4066Sahrens int ret; 2606fa9e4066Sahrens status_cbdata_t cb = { 0 }; 2607fa9e4066Sahrens 2608fa9e4066Sahrens /* check options */ 2609fa9e4066Sahrens while ((c = getopt(argc, argv, "vx")) != -1) { 2610fa9e4066Sahrens switch (c) { 2611fa9e4066Sahrens case 'v': 2612fa9e4066Sahrens cb.cb_verbose = TRUE; 2613fa9e4066Sahrens break; 2614fa9e4066Sahrens case 'x': 2615fa9e4066Sahrens cb.cb_explain = TRUE; 2616fa9e4066Sahrens break; 2617fa9e4066Sahrens case '?': 2618fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2619fa9e4066Sahrens optopt); 2620fa9e4066Sahrens usage(FALSE); 2621fa9e4066Sahrens } 2622fa9e4066Sahrens } 2623fa9e4066Sahrens 2624fa9e4066Sahrens argc -= optind; 2625fa9e4066Sahrens argv += optind; 2626fa9e4066Sahrens 2627fa9e4066Sahrens cb.cb_first = TRUE; 2628fa9e4066Sahrens 2629fa9e4066Sahrens ret = for_each_pool(argc, argv, TRUE, status_callback, &cb); 2630fa9e4066Sahrens 2631fa9e4066Sahrens if (argc == 0 && cb.cb_count == 0) 2632fa9e4066Sahrens (void) printf(gettext("no pools available\n")); 2633fa9e4066Sahrens else if (cb.cb_explain && cb.cb_first) { 2634fa9e4066Sahrens if (argc == 0) { 2635fa9e4066Sahrens (void) printf(gettext("all pools are healthy\n")); 2636fa9e4066Sahrens } else { 2637fa9e4066Sahrens int i; 2638fa9e4066Sahrens for (i = 0; i < argc; i++) 2639fa9e4066Sahrens (void) printf(gettext("pool '%s' is healthy\n"), 2640fa9e4066Sahrens argv[i]); 2641fa9e4066Sahrens } 2642fa9e4066Sahrens } 2643fa9e4066Sahrens 2644fa9e4066Sahrens return (ret); 2645fa9e4066Sahrens } 2646fa9e4066Sahrens 2647fa9e4066Sahrens int 2648fa9e4066Sahrens main(int argc, char **argv) 2649fa9e4066Sahrens { 2650fa9e4066Sahrens int ret; 2651fa9e4066Sahrens int i; 2652fa9e4066Sahrens char *cmdname; 2653fa9e4066Sahrens 2654fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 2655fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 2656fa9e4066Sahrens 2657fa9e4066Sahrens opterr = 0; 2658fa9e4066Sahrens 2659fa9e4066Sahrens /* 2660fa9e4066Sahrens * Make sure the user has specified some command. 2661fa9e4066Sahrens */ 2662fa9e4066Sahrens if (argc < 2) { 2663fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 2664fa9e4066Sahrens usage(FALSE); 2665fa9e4066Sahrens } 2666fa9e4066Sahrens 2667fa9e4066Sahrens cmdname = argv[1]; 2668fa9e4066Sahrens 2669fa9e4066Sahrens /* 2670fa9e4066Sahrens * Special case '-?' 2671fa9e4066Sahrens */ 2672fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 2673fa9e4066Sahrens usage(TRUE); 2674fa9e4066Sahrens 2675fa9e4066Sahrens /* 2676fa9e4066Sahrens * Run the appropriate command. 2677fa9e4066Sahrens */ 2678fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 2679fa9e4066Sahrens if (command_table[i].name == NULL) 2680fa9e4066Sahrens continue; 2681fa9e4066Sahrens 2682fa9e4066Sahrens if (strcmp(cmdname, command_table[i].name) == 0) { 2683fa9e4066Sahrens current_command = &command_table[i]; 2684fa9e4066Sahrens ret = command_table[i].func(argc - 1, argv + 1); 2685fa9e4066Sahrens break; 2686fa9e4066Sahrens } 2687fa9e4066Sahrens } 2688fa9e4066Sahrens 2689fa9e4066Sahrens /* 2690fa9e4066Sahrens * 'freeze' is a vile debugging abomination, so we treat it as such. 2691fa9e4066Sahrens */ 2692fa9e4066Sahrens if (strcmp(cmdname, "freeze") == 0 && argc == 3) { 2693ea8dc4b6Seschrock char buf[16384]; 2694ea8dc4b6Seschrock int fd = open(ZFS_DEV, O_RDWR); 2695fa9e4066Sahrens (void) strcpy((void *)buf, argv[2]); 2696fa9e4066Sahrens return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf)); 2697fa9e4066Sahrens } 2698fa9e4066Sahrens 2699fa9e4066Sahrens if (i == NCOMMAND) { 2700fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 2701fa9e4066Sahrens "command '%s'\n"), cmdname); 2702fa9e4066Sahrens usage(FALSE); 2703fa9e4066Sahrens } 2704fa9e4066Sahrens 2705fa9e4066Sahrens /* 2706fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 2707fa9e4066Sahrens * for the purposes of running ::findleaks. 2708fa9e4066Sahrens */ 2709fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 2710fa9e4066Sahrens (void) printf("dumping core by request\n"); 2711fa9e4066Sahrens abort(); 2712fa9e4066Sahrens } 2713fa9e4066Sahrens 2714fa9e4066Sahrens return (ret); 2715fa9e4066Sahrens } 2716