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