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