1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5441d80aaSlling * Common Development and Distribution License (the "License"). 6441d80aaSlling * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 2199653d4eSeschrock 22fa9e4066Sahrens /* 23*1195e687SMark J Musante * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24fa9e4066Sahrens * Use is subject to license terms. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens #include <assert.h> 28fa9e4066Sahrens #include <ctype.h> 29fa9e4066Sahrens #include <dirent.h> 30fa9e4066Sahrens #include <errno.h> 31fa9e4066Sahrens #include <fcntl.h> 32fa9e4066Sahrens #include <libgen.h> 33fa9e4066Sahrens #include <libintl.h> 34fa9e4066Sahrens #include <libuutil.h> 35fa9e4066Sahrens #include <locale.h> 36fa9e4066Sahrens #include <stdio.h> 37fa9e4066Sahrens #include <stdlib.h> 38fa9e4066Sahrens #include <string.h> 39fa9e4066Sahrens #include <strings.h> 40fa9e4066Sahrens #include <unistd.h> 41fa9e4066Sahrens #include <priv.h> 42ecd6cf80Smarks #include <pwd.h> 43ecd6cf80Smarks #include <zone.h> 44b1b8ab34Slling #include <sys/fs/zfs.h> 45fa9e4066Sahrens 46fa9e4066Sahrens #include <sys/stat.h> 47fa9e4066Sahrens 48fa9e4066Sahrens #include <libzfs.h> 49fa9e4066Sahrens 50fa9e4066Sahrens #include "zpool_util.h" 51b7b97454Sperrin #include "zfs_comutil.h" 52fa9e4066Sahrens 5326fd7700SKrishnendu Sadhukhan - Sun Microsystems #include "statcommon.h" 5426fd7700SKrishnendu Sadhukhan - Sun Microsystems 55fa9e4066Sahrens static int zpool_do_create(int, char **); 56fa9e4066Sahrens static int zpool_do_destroy(int, char **); 57fa9e4066Sahrens 58fa9e4066Sahrens static int zpool_do_add(int, char **); 5999653d4eSeschrock static int zpool_do_remove(int, char **); 60fa9e4066Sahrens 61fa9e4066Sahrens static int zpool_do_list(int, char **); 62fa9e4066Sahrens static int zpool_do_iostat(int, char **); 63fa9e4066Sahrens static int zpool_do_status(int, char **); 64fa9e4066Sahrens 65fa9e4066Sahrens static int zpool_do_online(int, char **); 66fa9e4066Sahrens static int zpool_do_offline(int, char **); 67ea8dc4b6Seschrock static int zpool_do_clear(int, char **); 68fa9e4066Sahrens 69fa9e4066Sahrens static int zpool_do_attach(int, char **); 70fa9e4066Sahrens static int zpool_do_detach(int, char **); 71fa9e4066Sahrens static int zpool_do_replace(int, char **); 72*1195e687SMark J Musante static int zpool_do_split(int, char **); 73fa9e4066Sahrens 74fa9e4066Sahrens static int zpool_do_scrub(int, char **); 75fa9e4066Sahrens 76fa9e4066Sahrens static int zpool_do_import(int, char **); 77fa9e4066Sahrens static int zpool_do_export(int, char **); 78fa9e4066Sahrens 79eaca9bbdSeschrock static int zpool_do_upgrade(int, char **); 80eaca9bbdSeschrock 8106eeb2adSek static int zpool_do_history(int, char **); 8206eeb2adSek 83b1b8ab34Slling static int zpool_do_get(int, char **); 84b1b8ab34Slling static int zpool_do_set(int, char **); 85b1b8ab34Slling 86fa9e4066Sahrens /* 87fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 88fa9e4066Sahrens * debugging facilities. 89fa9e4066Sahrens */ 9029ab75c9Srm 9129ab75c9Srm #ifdef DEBUG 92fa9e4066Sahrens const char * 9399653d4eSeschrock _umem_debug_init(void) 94fa9e4066Sahrens { 95fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 96fa9e4066Sahrens } 97fa9e4066Sahrens 98fa9e4066Sahrens const char * 99fa9e4066Sahrens _umem_logging_init(void) 100fa9e4066Sahrens { 101fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 102fa9e4066Sahrens } 10329ab75c9Srm #endif 104fa9e4066Sahrens 10565cd9f28Seschrock typedef enum { 10665cd9f28Seschrock HELP_ADD, 10765cd9f28Seschrock HELP_ATTACH, 108ea8dc4b6Seschrock HELP_CLEAR, 10965cd9f28Seschrock HELP_CREATE, 11065cd9f28Seschrock HELP_DESTROY, 11165cd9f28Seschrock HELP_DETACH, 11265cd9f28Seschrock HELP_EXPORT, 11306eeb2adSek HELP_HISTORY, 11465cd9f28Seschrock HELP_IMPORT, 11565cd9f28Seschrock HELP_IOSTAT, 11665cd9f28Seschrock HELP_LIST, 11765cd9f28Seschrock HELP_OFFLINE, 11865cd9f28Seschrock HELP_ONLINE, 11965cd9f28Seschrock HELP_REPLACE, 12099653d4eSeschrock HELP_REMOVE, 12165cd9f28Seschrock HELP_SCRUB, 122eaca9bbdSeschrock HELP_STATUS, 123b1b8ab34Slling HELP_UPGRADE, 124b1b8ab34Slling HELP_GET, 125*1195e687SMark J Musante HELP_SET, 126*1195e687SMark J Musante HELP_SPLIT 12765cd9f28Seschrock } zpool_help_t; 12865cd9f28Seschrock 12965cd9f28Seschrock 130fa9e4066Sahrens typedef struct zpool_command { 131fa9e4066Sahrens const char *name; 132fa9e4066Sahrens int (*func)(int, char **); 13365cd9f28Seschrock zpool_help_t usage; 134fa9e4066Sahrens } zpool_command_t; 135fa9e4066Sahrens 136fa9e4066Sahrens /* 137fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and 138ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have 139ea8dc4b6Seschrock * to have a function to return the usage message based on a command index. 14065cd9f28Seschrock * 14165cd9f28Seschrock * These commands are organized according to how they are displayed in the usage 14265cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in 14365cd9f28Seschrock * the generic usage message. 144fa9e4066Sahrens */ 145fa9e4066Sahrens static zpool_command_t command_table[] = { 14665cd9f28Seschrock { "create", zpool_do_create, HELP_CREATE }, 14765cd9f28Seschrock { "destroy", zpool_do_destroy, HELP_DESTROY }, 148fa9e4066Sahrens { NULL }, 14965cd9f28Seschrock { "add", zpool_do_add, HELP_ADD }, 15099653d4eSeschrock { "remove", zpool_do_remove, HELP_REMOVE }, 151fa9e4066Sahrens { NULL }, 15265cd9f28Seschrock { "list", zpool_do_list, HELP_LIST }, 15365cd9f28Seschrock { "iostat", zpool_do_iostat, HELP_IOSTAT }, 15465cd9f28Seschrock { "status", zpool_do_status, HELP_STATUS }, 155fa9e4066Sahrens { NULL }, 15665cd9f28Seschrock { "online", zpool_do_online, HELP_ONLINE }, 15765cd9f28Seschrock { "offline", zpool_do_offline, HELP_OFFLINE }, 158ea8dc4b6Seschrock { "clear", zpool_do_clear, HELP_CLEAR }, 159fa9e4066Sahrens { NULL }, 16065cd9f28Seschrock { "attach", zpool_do_attach, HELP_ATTACH }, 16165cd9f28Seschrock { "detach", zpool_do_detach, HELP_DETACH }, 16265cd9f28Seschrock { "replace", zpool_do_replace, HELP_REPLACE }, 163*1195e687SMark J Musante { "split", zpool_do_split, HELP_SPLIT }, 164fa9e4066Sahrens { NULL }, 16565cd9f28Seschrock { "scrub", zpool_do_scrub, HELP_SCRUB }, 166fa9e4066Sahrens { NULL }, 16765cd9f28Seschrock { "import", zpool_do_import, HELP_IMPORT }, 16865cd9f28Seschrock { "export", zpool_do_export, HELP_EXPORT }, 16906eeb2adSek { "upgrade", zpool_do_upgrade, HELP_UPGRADE }, 17006eeb2adSek { NULL }, 171b1b8ab34Slling { "history", zpool_do_history, HELP_HISTORY }, 172b1b8ab34Slling { "get", zpool_do_get, HELP_GET }, 173b1b8ab34Slling { "set", zpool_do_set, HELP_SET }, 174fa9e4066Sahrens }; 175fa9e4066Sahrens 176fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0])) 177fa9e4066Sahrens 178fa9e4066Sahrens zpool_command_t *current_command; 1792a6b87f0Sek static char history_str[HIS_MAX_RECORD_LEN]; 180fa9e4066Sahrens 18126fd7700SKrishnendu Sadhukhan - Sun Microsystems static uint_t timestamp_fmt = NODATE; 18226fd7700SKrishnendu Sadhukhan - Sun Microsystems 18365cd9f28Seschrock static const char * 18465cd9f28Seschrock get_usage(zpool_help_t idx) { 18565cd9f28Seschrock switch (idx) { 18665cd9f28Seschrock case HELP_ADD: 18765cd9f28Seschrock return (gettext("\tadd [-fn] <pool> <vdev> ...\n")); 18865cd9f28Seschrock case HELP_ATTACH: 18965cd9f28Seschrock return (gettext("\tattach [-f] <pool> <device> " 190e45ce728Sahrens "<new-device>\n")); 191ea8dc4b6Seschrock case HELP_CLEAR: 192468c413aSTim Haley return (gettext("\tclear [-nF] <pool> [device]\n")); 19365cd9f28Seschrock case HELP_CREATE: 194990b4856Slling return (gettext("\tcreate [-fn] [-o property=value] ... \n" 1950a48a24eStimh "\t [-O file-system-property=value] ... \n" 196990b4856Slling "\t [-m mountpoint] [-R root] <pool> <vdev> ...\n")); 19765cd9f28Seschrock case HELP_DESTROY: 19865cd9f28Seschrock return (gettext("\tdestroy [-f] <pool>\n")); 19965cd9f28Seschrock case HELP_DETACH: 20065cd9f28Seschrock return (gettext("\tdetach <pool> <device>\n")); 20165cd9f28Seschrock case HELP_EXPORT: 20265cd9f28Seschrock return (gettext("\texport [-f] <pool> ...\n")); 20306eeb2adSek case HELP_HISTORY: 204ecd6cf80Smarks return (gettext("\thistory [-il] [<pool>] ...\n")); 20565cd9f28Seschrock case HELP_IMPORT: 2064c58d714Sdarrenm return (gettext("\timport [-d dir] [-D]\n" 207468c413aSTim Haley "\timport [-d dir | -c cachefile] [-n] -F <pool | id>\n" 2082f8aaab3Seschrock "\timport [-o mntopts] [-o property=value] ... \n" 2092f8aaab3Seschrock "\t [-d dir | -c cachefile] [-D] [-f] [-R root] -a\n" 2102f8aaab3Seschrock "\timport [-o mntopts] [-o property=value] ... \n" 2112f8aaab3Seschrock "\t [-d dir | -c cachefile] [-D] [-f] [-R root] " 2122f8aaab3Seschrock "<pool | id> [newpool]\n")); 21365cd9f28Seschrock case HELP_IOSTAT: 21426fd7700SKrishnendu Sadhukhan - Sun Microsystems return (gettext("\tiostat [-v] [-T d|u] [pool] ... [interval " 21565cd9f28Seschrock "[count]]\n")); 21665cd9f28Seschrock case HELP_LIST: 217990b4856Slling return (gettext("\tlist [-H] [-o property[,...]] " 218990b4856Slling "[pool] ...\n")); 21965cd9f28Seschrock case HELP_OFFLINE: 220441d80aaSlling return (gettext("\toffline [-t] <pool> <device> ...\n")); 22165cd9f28Seschrock case HELP_ONLINE: 222441d80aaSlling return (gettext("\tonline <pool> <device> ...\n")); 22365cd9f28Seschrock case HELP_REPLACE: 22465cd9f28Seschrock return (gettext("\treplace [-f] <pool> <device> " 225e45ce728Sahrens "[new-device]\n")); 22699653d4eSeschrock case HELP_REMOVE: 227fa94a07fSbrendan return (gettext("\tremove <pool> <device> ...\n")); 22865cd9f28Seschrock case HELP_SCRUB: 22965cd9f28Seschrock return (gettext("\tscrub [-s] <pool> ...\n")); 23065cd9f28Seschrock case HELP_STATUS: 23165cd9f28Seschrock return (gettext("\tstatus [-vx] [pool] ...\n")); 232eaca9bbdSeschrock case HELP_UPGRADE: 233eaca9bbdSeschrock return (gettext("\tupgrade\n" 234eaca9bbdSeschrock "\tupgrade -v\n" 235990b4856Slling "\tupgrade [-V version] <-a | pool ...>\n")); 236b1b8ab34Slling case HELP_GET: 237e45ce728Sahrens return (gettext("\tget <\"all\" | property[,...]> " 238b1b8ab34Slling "<pool> ...\n")); 239b1b8ab34Slling case HELP_SET: 240b1b8ab34Slling return (gettext("\tset <property=value> <pool> \n")); 241*1195e687SMark J Musante case HELP_SPLIT: 242*1195e687SMark J Musante return (gettext("\tsplit [-n] [-R altroot] [-o mntopts]\n" 243*1195e687SMark J Musante "\t [-o property=value] <pool> <newpool> " 244*1195e687SMark J Musante "[<device> ...]\n")); 24565cd9f28Seschrock } 24665cd9f28Seschrock 24765cd9f28Seschrock abort(); 24865cd9f28Seschrock /* NOTREACHED */ 24965cd9f28Seschrock } 25065cd9f28Seschrock 251fa9e4066Sahrens 252b1b8ab34Slling /* 253b1b8ab34Slling * Callback routine that will print out a pool property value. 254b1b8ab34Slling */ 255990b4856Slling static int 256990b4856Slling print_prop_cb(int prop, void *cb) 257b1b8ab34Slling { 258b1b8ab34Slling FILE *fp = cb; 259b1b8ab34Slling 260b24ab676SJeff Bonwick (void) fprintf(fp, "\t%-15s ", zpool_prop_to_name(prop)); 261b1b8ab34Slling 262990b4856Slling if (zpool_prop_readonly(prop)) 263990b4856Slling (void) fprintf(fp, " NO "); 264990b4856Slling else 265b24ab676SJeff Bonwick (void) fprintf(fp, " YES "); 266990b4856Slling 267b1b8ab34Slling if (zpool_prop_values(prop) == NULL) 268b1b8ab34Slling (void) fprintf(fp, "-\n"); 269b1b8ab34Slling else 270b1b8ab34Slling (void) fprintf(fp, "%s\n", zpool_prop_values(prop)); 271b1b8ab34Slling 272990b4856Slling return (ZPROP_CONT); 273b1b8ab34Slling } 274b1b8ab34Slling 275fa9e4066Sahrens /* 276fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 277fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 278fa9e4066Sahrens * a complete usage message. 279fa9e4066Sahrens */ 280fa9e4066Sahrens void 28199653d4eSeschrock usage(boolean_t requested) 282fa9e4066Sahrens { 283fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 284fa9e4066Sahrens 285fa9e4066Sahrens if (current_command == NULL) { 286fa9e4066Sahrens int i; 287fa9e4066Sahrens 288fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zpool command args ...\n")); 289fa9e4066Sahrens (void) fprintf(fp, 290fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 291fa9e4066Sahrens 292fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 293fa9e4066Sahrens if (command_table[i].name == NULL) 294fa9e4066Sahrens (void) fprintf(fp, "\n"); 295fa9e4066Sahrens else 296fa9e4066Sahrens (void) fprintf(fp, "%s", 29765cd9f28Seschrock get_usage(command_table[i].usage)); 298fa9e4066Sahrens } 299fa9e4066Sahrens } else { 300fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 30165cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 302fa9e4066Sahrens } 303fa9e4066Sahrens 304b1b8ab34Slling if (current_command != NULL && 305b1b8ab34Slling ((strcmp(current_command->name, "set") == 0) || 306990b4856Slling (strcmp(current_command->name, "get") == 0) || 307990b4856Slling (strcmp(current_command->name, "list") == 0))) { 308b1b8ab34Slling 309b1b8ab34Slling (void) fprintf(fp, 310b1b8ab34Slling gettext("\nthe following properties are supported:\n")); 311b1b8ab34Slling 312b24ab676SJeff Bonwick (void) fprintf(fp, "\n\t%-15s %s %s\n\n", 313990b4856Slling "PROPERTY", "EDIT", "VALUES"); 314b1b8ab34Slling 315b1b8ab34Slling /* Iterate over all properties */ 316990b4856Slling (void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE, 317990b4856Slling ZFS_TYPE_POOL); 318b1b8ab34Slling } 319b1b8ab34Slling 320e9dbad6fSeschrock /* 321e9dbad6fSeschrock * See comments at end of main(). 322e9dbad6fSeschrock */ 323e9dbad6fSeschrock if (getenv("ZFS_ABORT") != NULL) { 324e9dbad6fSeschrock (void) printf("dumping core by request\n"); 325e9dbad6fSeschrock abort(); 326e9dbad6fSeschrock } 327e9dbad6fSeschrock 328fa9e4066Sahrens exit(requested ? 0 : 2); 329fa9e4066Sahrens } 330fa9e4066Sahrens 331fa9e4066Sahrens void 3328654d025Sperrin print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent, 3338654d025Sperrin boolean_t print_logs) 334fa9e4066Sahrens { 335fa9e4066Sahrens nvlist_t **child; 336fa9e4066Sahrens uint_t c, children; 337afefbcddSeschrock char *vname; 338fa9e4066Sahrens 339fa9e4066Sahrens if (name != NULL) 340fa9e4066Sahrens (void) printf("\t%*s%s\n", indent, "", name); 341fa9e4066Sahrens 342fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 343fa9e4066Sahrens &child, &children) != 0) 344fa9e4066Sahrens return; 345fa9e4066Sahrens 346afefbcddSeschrock for (c = 0; c < children; c++) { 3478654d025Sperrin uint64_t is_log = B_FALSE; 3488654d025Sperrin 3498654d025Sperrin (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 3508654d025Sperrin &is_log); 3518654d025Sperrin if ((is_log && !print_logs) || (!is_log && print_logs)) 3528654d025Sperrin continue; 3538654d025Sperrin 35488ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE); 3558654d025Sperrin print_vdev_tree(zhp, vname, child[c], indent + 2, 3568654d025Sperrin B_FALSE); 357afefbcddSeschrock free(vname); 358afefbcddSeschrock } 359fa9e4066Sahrens } 360fa9e4066Sahrens 361990b4856Slling /* 362990b4856Slling * Add a property pair (name, string-value) into a property nvlist. 363990b4856Slling */ 364990b4856Slling static int 3650a48a24eStimh add_prop_list(const char *propname, char *propval, nvlist_t **props, 3660a48a24eStimh boolean_t poolprop) 367990b4856Slling { 3680a48a24eStimh zpool_prop_t prop = ZPROP_INVAL; 3690a48a24eStimh zfs_prop_t fprop; 370990b4856Slling nvlist_t *proplist; 3710a48a24eStimh const char *normnm; 3720a48a24eStimh char *strval; 373990b4856Slling 374990b4856Slling if (*props == NULL && 375990b4856Slling nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) { 376990b4856Slling (void) fprintf(stderr, 377990b4856Slling gettext("internal error: out of memory\n")); 378990b4856Slling return (1); 379990b4856Slling } 380990b4856Slling 381990b4856Slling proplist = *props; 382990b4856Slling 3830a48a24eStimh if (poolprop) { 3840a48a24eStimh if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL) { 3850a48a24eStimh (void) fprintf(stderr, gettext("property '%s' is " 3860a48a24eStimh "not a valid pool property\n"), propname); 3870a48a24eStimh return (2); 3880a48a24eStimh } 3890a48a24eStimh normnm = zpool_prop_to_name(prop); 3900a48a24eStimh } else { 39114843421SMatthew Ahrens if ((fprop = zfs_name_to_prop(propname)) != ZPROP_INVAL) { 39214843421SMatthew Ahrens normnm = zfs_prop_to_name(fprop); 39314843421SMatthew Ahrens } else { 39414843421SMatthew Ahrens normnm = propname; 3950a48a24eStimh } 396990b4856Slling } 397990b4856Slling 3980a48a24eStimh if (nvlist_lookup_string(proplist, normnm, &strval) == 0 && 3990a48a24eStimh prop != ZPOOL_PROP_CACHEFILE) { 400990b4856Slling (void) fprintf(stderr, gettext("property '%s' " 401990b4856Slling "specified multiple times\n"), propname); 402990b4856Slling return (2); 403990b4856Slling } 404990b4856Slling 4050a48a24eStimh if (nvlist_add_string(proplist, normnm, propval) != 0) { 406990b4856Slling (void) fprintf(stderr, gettext("internal " 407990b4856Slling "error: out of memory\n")); 408990b4856Slling return (1); 409990b4856Slling } 410990b4856Slling 411990b4856Slling return (0); 412990b4856Slling } 413990b4856Slling 414fa9e4066Sahrens /* 415fa9e4066Sahrens * zpool add [-fn] <pool> <vdev> ... 416fa9e4066Sahrens * 417fa9e4066Sahrens * -f Force addition of devices, even if they appear in use 418fa9e4066Sahrens * -n Do not add the devices, but display the resulting layout if 419fa9e4066Sahrens * they were to be added. 420fa9e4066Sahrens * 421fa9e4066Sahrens * Adds the given vdevs to 'pool'. As with create, the bulk of this work is 422fa9e4066Sahrens * handled by get_vdev_spec(), which constructs the nvlist needed to pass to 423fa9e4066Sahrens * libzfs. 424fa9e4066Sahrens */ 425fa9e4066Sahrens int 426fa9e4066Sahrens zpool_do_add(int argc, char **argv) 427fa9e4066Sahrens { 42899653d4eSeschrock boolean_t force = B_FALSE; 42999653d4eSeschrock boolean_t dryrun = B_FALSE; 430fa9e4066Sahrens int c; 431fa9e4066Sahrens nvlist_t *nvroot; 432fa9e4066Sahrens char *poolname; 433fa9e4066Sahrens int ret; 434fa9e4066Sahrens zpool_handle_t *zhp; 435fa9e4066Sahrens nvlist_t *config; 436fa9e4066Sahrens 437fa9e4066Sahrens /* check options */ 438fa9e4066Sahrens while ((c = getopt(argc, argv, "fn")) != -1) { 439fa9e4066Sahrens switch (c) { 440fa9e4066Sahrens case 'f': 44199653d4eSeschrock force = B_TRUE; 442fa9e4066Sahrens break; 443fa9e4066Sahrens case 'n': 44499653d4eSeschrock dryrun = B_TRUE; 445fa9e4066Sahrens break; 446fa9e4066Sahrens case '?': 447fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 448fa9e4066Sahrens optopt); 44999653d4eSeschrock usage(B_FALSE); 450fa9e4066Sahrens } 451fa9e4066Sahrens } 452fa9e4066Sahrens 453fa9e4066Sahrens argc -= optind; 454fa9e4066Sahrens argv += optind; 455fa9e4066Sahrens 456fa9e4066Sahrens /* get pool name and check number of arguments */ 457fa9e4066Sahrens if (argc < 1) { 458fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 45999653d4eSeschrock usage(B_FALSE); 460fa9e4066Sahrens } 461fa9e4066Sahrens if (argc < 2) { 462fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 46399653d4eSeschrock usage(B_FALSE); 464fa9e4066Sahrens } 465fa9e4066Sahrens 466fa9e4066Sahrens poolname = argv[0]; 467fa9e4066Sahrens 468fa9e4066Sahrens argc--; 469fa9e4066Sahrens argv++; 470fa9e4066Sahrens 47199653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 472fa9e4066Sahrens return (1); 473fa9e4066Sahrens 474088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 475fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 476fa9e4066Sahrens poolname); 477fa9e4066Sahrens zpool_close(zhp); 478fa9e4066Sahrens return (1); 479fa9e4066Sahrens } 480fa9e4066Sahrens 481fa9e4066Sahrens /* pass off to get_vdev_spec for processing */ 482705040edSEric Taylor nvroot = make_root_vdev(zhp, force, !force, B_FALSE, dryrun, 483705040edSEric Taylor argc, argv); 484fa9e4066Sahrens if (nvroot == NULL) { 485fa9e4066Sahrens zpool_close(zhp); 486fa9e4066Sahrens return (1); 487fa9e4066Sahrens } 488fa9e4066Sahrens 489fa9e4066Sahrens if (dryrun) { 490fa9e4066Sahrens nvlist_t *poolnvroot; 491fa9e4066Sahrens 492fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 493fa9e4066Sahrens &poolnvroot) == 0); 494fa9e4066Sahrens 495fa9e4066Sahrens (void) printf(gettext("would update '%s' to the following " 496fa9e4066Sahrens "configuration:\n"), zpool_get_name(zhp)); 497fa9e4066Sahrens 4988654d025Sperrin /* print original main pool and new tree */ 4998654d025Sperrin print_vdev_tree(zhp, poolname, poolnvroot, 0, B_FALSE); 5008654d025Sperrin print_vdev_tree(zhp, NULL, nvroot, 0, B_FALSE); 5018654d025Sperrin 5028654d025Sperrin /* Do the same for the logs */ 5038654d025Sperrin if (num_logs(poolnvroot) > 0) { 5048654d025Sperrin print_vdev_tree(zhp, "logs", poolnvroot, 0, B_TRUE); 5058654d025Sperrin print_vdev_tree(zhp, NULL, nvroot, 0, B_TRUE); 5068654d025Sperrin } else if (num_logs(nvroot) > 0) { 5078654d025Sperrin print_vdev_tree(zhp, "logs", nvroot, 0, B_TRUE); 5088654d025Sperrin } 509fa9e4066Sahrens 510fa9e4066Sahrens ret = 0; 511fa9e4066Sahrens } else { 512fa9e4066Sahrens ret = (zpool_add(zhp, nvroot) != 0); 513fa9e4066Sahrens } 514fa9e4066Sahrens 51599653d4eSeschrock nvlist_free(nvroot); 51699653d4eSeschrock zpool_close(zhp); 51799653d4eSeschrock 51899653d4eSeschrock return (ret); 51999653d4eSeschrock } 52099653d4eSeschrock 52199653d4eSeschrock /* 522fa94a07fSbrendan * zpool remove <pool> <vdev> ... 52399653d4eSeschrock * 52499653d4eSeschrock * Removes the given vdev from the pool. Currently, this only supports removing 525fa94a07fSbrendan * spares and cache devices from the pool. Eventually, we'll want to support 526fa94a07fSbrendan * removing leaf vdevs (as an alias for 'detach') as well as toplevel vdevs. 52799653d4eSeschrock */ 52899653d4eSeschrock int 52999653d4eSeschrock zpool_do_remove(int argc, char **argv) 53099653d4eSeschrock { 53199653d4eSeschrock char *poolname; 532fa94a07fSbrendan int i, ret = 0; 53399653d4eSeschrock zpool_handle_t *zhp; 53499653d4eSeschrock 53599653d4eSeschrock argc--; 53699653d4eSeschrock argv++; 53799653d4eSeschrock 53899653d4eSeschrock /* get pool name and check number of arguments */ 53999653d4eSeschrock if (argc < 1) { 54099653d4eSeschrock (void) fprintf(stderr, gettext("missing pool name argument\n")); 54199653d4eSeschrock usage(B_FALSE); 54299653d4eSeschrock } 54399653d4eSeschrock if (argc < 2) { 54499653d4eSeschrock (void) fprintf(stderr, gettext("missing device\n")); 54599653d4eSeschrock usage(B_FALSE); 54699653d4eSeschrock } 54799653d4eSeschrock 54899653d4eSeschrock poolname = argv[0]; 54999653d4eSeschrock 55099653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 55199653d4eSeschrock return (1); 55299653d4eSeschrock 553fa94a07fSbrendan for (i = 1; i < argc; i++) { 554fa94a07fSbrendan if (zpool_vdev_remove(zhp, argv[i]) != 0) 555fa94a07fSbrendan ret = 1; 556fa94a07fSbrendan } 55799653d4eSeschrock 558fa9e4066Sahrens return (ret); 559fa9e4066Sahrens } 560fa9e4066Sahrens 561fa9e4066Sahrens /* 5620a48a24eStimh * zpool create [-fn] [-o property=value] ... 5630a48a24eStimh * [-O file-system-property=value] ... 5640a48a24eStimh * [-R root] [-m mountpoint] <pool> <dev> ... 565fa9e4066Sahrens * 566fa9e4066Sahrens * -f Force creation, even if devices appear in use 567fa9e4066Sahrens * -n Do not create the pool, but display the resulting layout if it 568fa9e4066Sahrens * were to be created. 569fa9e4066Sahrens * -R Create a pool under an alternate root 570fa9e4066Sahrens * -m Set default mountpoint for the root dataset. By default it's 571fa9e4066Sahrens * '/<pool>' 572990b4856Slling * -o Set property=value. 5730a48a24eStimh * -O Set fsproperty=value in the pool's root file system 574fa9e4066Sahrens * 575b1b8ab34Slling * Creates the named pool according to the given vdev specification. The 576fa9e4066Sahrens * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once 577fa9e4066Sahrens * we get the nvlist back from get_vdev_spec(), we either print out the contents 578fa9e4066Sahrens * (if '-n' was specified), or pass it to libzfs to do the creation. 579fa9e4066Sahrens */ 580fa9e4066Sahrens int 581fa9e4066Sahrens zpool_do_create(int argc, char **argv) 582fa9e4066Sahrens { 58399653d4eSeschrock boolean_t force = B_FALSE; 58499653d4eSeschrock boolean_t dryrun = B_FALSE; 585fa9e4066Sahrens int c; 586990b4856Slling nvlist_t *nvroot = NULL; 587fa9e4066Sahrens char *poolname; 588990b4856Slling int ret = 1; 589fa9e4066Sahrens char *altroot = NULL; 590fa9e4066Sahrens char *mountpoint = NULL; 5910a48a24eStimh nvlist_t *fsprops = NULL; 592990b4856Slling nvlist_t *props = NULL; 5932f8aaab3Seschrock char *propval; 594fa9e4066Sahrens 595fa9e4066Sahrens /* check options */ 5960a48a24eStimh while ((c = getopt(argc, argv, ":fnR:m:o:O:")) != -1) { 597fa9e4066Sahrens switch (c) { 598fa9e4066Sahrens case 'f': 59999653d4eSeschrock force = B_TRUE; 600fa9e4066Sahrens break; 601fa9e4066Sahrens case 'n': 60299653d4eSeschrock dryrun = B_TRUE; 603fa9e4066Sahrens break; 604fa9e4066Sahrens case 'R': 605fa9e4066Sahrens altroot = optarg; 606990b4856Slling if (add_prop_list(zpool_prop_to_name( 6070a48a24eStimh ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 608990b4856Slling goto errout; 6092f8aaab3Seschrock if (nvlist_lookup_string(props, 6102f8aaab3Seschrock zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 6112f8aaab3Seschrock &propval) == 0) 6122f8aaab3Seschrock break; 613990b4856Slling if (add_prop_list(zpool_prop_to_name( 6140a48a24eStimh ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE)) 615990b4856Slling goto errout; 616fa9e4066Sahrens break; 617fa9e4066Sahrens case 'm': 618fa9e4066Sahrens mountpoint = optarg; 619fa9e4066Sahrens break; 620990b4856Slling case 'o': 621990b4856Slling if ((propval = strchr(optarg, '=')) == NULL) { 622990b4856Slling (void) fprintf(stderr, gettext("missing " 623990b4856Slling "'=' for -o option\n")); 624990b4856Slling goto errout; 625990b4856Slling } 626990b4856Slling *propval = '\0'; 627990b4856Slling propval++; 628990b4856Slling 6290a48a24eStimh if (add_prop_list(optarg, propval, &props, B_TRUE)) 6300a48a24eStimh goto errout; 6310a48a24eStimh break; 6320a48a24eStimh case 'O': 6330a48a24eStimh if ((propval = strchr(optarg, '=')) == NULL) { 6340a48a24eStimh (void) fprintf(stderr, gettext("missing " 6350a48a24eStimh "'=' for -O option\n")); 6360a48a24eStimh goto errout; 6370a48a24eStimh } 6380a48a24eStimh *propval = '\0'; 6390a48a24eStimh propval++; 6400a48a24eStimh 6410a48a24eStimh if (add_prop_list(optarg, propval, &fsprops, B_FALSE)) 642990b4856Slling goto errout; 643990b4856Slling break; 644fa9e4066Sahrens case ':': 645fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 646fa9e4066Sahrens "'%c' option\n"), optopt); 647990b4856Slling goto badusage; 648fa9e4066Sahrens case '?': 649fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 650fa9e4066Sahrens optopt); 651990b4856Slling goto badusage; 652fa9e4066Sahrens } 653fa9e4066Sahrens } 654fa9e4066Sahrens 655fa9e4066Sahrens argc -= optind; 656fa9e4066Sahrens argv += optind; 657fa9e4066Sahrens 658fa9e4066Sahrens /* get pool name and check number of arguments */ 659fa9e4066Sahrens if (argc < 1) { 660fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 661990b4856Slling goto badusage; 662fa9e4066Sahrens } 663fa9e4066Sahrens if (argc < 2) { 664fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 665990b4856Slling goto badusage; 666fa9e4066Sahrens } 667fa9e4066Sahrens 668fa9e4066Sahrens poolname = argv[0]; 669fa9e4066Sahrens 670fa9e4066Sahrens /* 671fa9e4066Sahrens * As a special case, check for use of '/' in the name, and direct the 672fa9e4066Sahrens * user to use 'zfs create' instead. 673fa9e4066Sahrens */ 674fa9e4066Sahrens if (strchr(poolname, '/') != NULL) { 675fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot create '%s': invalid " 676fa9e4066Sahrens "character '/' in pool name\n"), poolname); 677fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs create' to " 678fa9e4066Sahrens "create a dataset\n")); 679990b4856Slling goto errout; 680fa9e4066Sahrens } 681fa9e4066Sahrens 682fa9e4066Sahrens /* pass off to get_vdev_spec for bulk processing */ 683705040edSEric Taylor nvroot = make_root_vdev(NULL, force, !force, B_FALSE, dryrun, 684705040edSEric Taylor argc - 1, argv + 1); 685fa9e4066Sahrens if (nvroot == NULL) 6860a48a24eStimh goto errout; 687fa9e4066Sahrens 68899653d4eSeschrock /* make_root_vdev() allows 0 toplevel children if there are spares */ 689b7b97454Sperrin if (!zfs_allocatable_devs(nvroot)) { 69099653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev " 69199653d4eSeschrock "specification: at least one toplevel vdev must be " 69299653d4eSeschrock "specified\n")); 693990b4856Slling goto errout; 69499653d4eSeschrock } 69599653d4eSeschrock 69699653d4eSeschrock 697fa9e4066Sahrens if (altroot != NULL && altroot[0] != '/') { 698fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid alternate root '%s': " 699e9dbad6fSeschrock "must be an absolute path\n"), altroot); 700990b4856Slling goto errout; 701fa9e4066Sahrens } 702fa9e4066Sahrens 703fa9e4066Sahrens /* 704fa9e4066Sahrens * Check the validity of the mountpoint and direct the user to use the 705fa9e4066Sahrens * '-m' mountpoint option if it looks like its in use. 706fa9e4066Sahrens */ 707fa9e4066Sahrens if (mountpoint == NULL || 708fa9e4066Sahrens (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 && 709fa9e4066Sahrens strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) { 710fa9e4066Sahrens char buf[MAXPATHLEN]; 71111022c7cStimh DIR *dirp; 712fa9e4066Sahrens 713fa9e4066Sahrens if (mountpoint && mountpoint[0] != '/') { 714fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid mountpoint " 715fa9e4066Sahrens "'%s': must be an absolute path, 'legacy', or " 716fa9e4066Sahrens "'none'\n"), mountpoint); 717990b4856Slling goto errout; 718fa9e4066Sahrens } 719fa9e4066Sahrens 720fa9e4066Sahrens if (mountpoint == NULL) { 721fa9e4066Sahrens if (altroot != NULL) 722fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s/%s", 723fa9e4066Sahrens altroot, poolname); 724fa9e4066Sahrens else 725fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "/%s", 726fa9e4066Sahrens poolname); 727fa9e4066Sahrens } else { 728fa9e4066Sahrens if (altroot != NULL) 729fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s%s", 730fa9e4066Sahrens altroot, mountpoint); 731fa9e4066Sahrens else 732fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s", 733fa9e4066Sahrens mountpoint); 734fa9e4066Sahrens } 735fa9e4066Sahrens 73611022c7cStimh if ((dirp = opendir(buf)) == NULL && errno != ENOENT) { 73711022c7cStimh (void) fprintf(stderr, gettext("mountpoint '%s' : " 73811022c7cStimh "%s\n"), buf, strerror(errno)); 739fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-m' " 740fa9e4066Sahrens "option to provide a different default\n")); 741990b4856Slling goto errout; 74211022c7cStimh } else if (dirp) { 74311022c7cStimh int count = 0; 74411022c7cStimh 74511022c7cStimh while (count < 3 && readdir(dirp) != NULL) 74611022c7cStimh count++; 74711022c7cStimh (void) closedir(dirp); 74811022c7cStimh 74911022c7cStimh if (count > 2) { 75011022c7cStimh (void) fprintf(stderr, gettext("mountpoint " 75111022c7cStimh "'%s' exists and is not empty\n"), buf); 75211022c7cStimh (void) fprintf(stderr, gettext("use '-m' " 75311022c7cStimh "option to provide a " 75411022c7cStimh "different default\n")); 75511022c7cStimh goto errout; 75611022c7cStimh } 757fa9e4066Sahrens } 758fa9e4066Sahrens } 759fa9e4066Sahrens 760fa9e4066Sahrens if (dryrun) { 761fa9e4066Sahrens /* 762fa9e4066Sahrens * For a dry run invocation, print out a basic message and run 763fa9e4066Sahrens * through all the vdevs in the list and print out in an 764fa9e4066Sahrens * appropriate hierarchy. 765fa9e4066Sahrens */ 766fa9e4066Sahrens (void) printf(gettext("would create '%s' with the " 767fa9e4066Sahrens "following layout:\n\n"), poolname); 768fa9e4066Sahrens 7698654d025Sperrin print_vdev_tree(NULL, poolname, nvroot, 0, B_FALSE); 7708654d025Sperrin if (num_logs(nvroot) > 0) 7718654d025Sperrin print_vdev_tree(NULL, "logs", nvroot, 0, B_TRUE); 772fa9e4066Sahrens 773fa9e4066Sahrens ret = 0; 774fa9e4066Sahrens } else { 775fa9e4066Sahrens /* 776fa9e4066Sahrens * Hand off to libzfs. 777fa9e4066Sahrens */ 7780a48a24eStimh if (zpool_create(g_zfs, poolname, 7790a48a24eStimh nvroot, props, fsprops) == 0) { 78099653d4eSeschrock zfs_handle_t *pool = zfs_open(g_zfs, poolname, 781fa9e4066Sahrens ZFS_TYPE_FILESYSTEM); 782fa9e4066Sahrens if (pool != NULL) { 783fa9e4066Sahrens if (mountpoint != NULL) 784fa9e4066Sahrens verify(zfs_prop_set(pool, 785e9dbad6fSeschrock zfs_prop_to_name( 786e9dbad6fSeschrock ZFS_PROP_MOUNTPOINT), 787fa9e4066Sahrens mountpoint) == 0); 788fa9e4066Sahrens if (zfs_mount(pool, NULL, 0) == 0) 789da6c28aaSamw ret = zfs_shareall(pool); 790fa9e4066Sahrens zfs_close(pool); 791fa9e4066Sahrens } 79299653d4eSeschrock } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) { 79399653d4eSeschrock (void) fprintf(stderr, gettext("pool name may have " 79499653d4eSeschrock "been omitted\n")); 795fa9e4066Sahrens } 796fa9e4066Sahrens } 797fa9e4066Sahrens 798990b4856Slling errout: 7992f8aaab3Seschrock nvlist_free(nvroot); 8000a48a24eStimh nvlist_free(fsprops); 8012f8aaab3Seschrock nvlist_free(props); 802fa9e4066Sahrens return (ret); 803990b4856Slling badusage: 8040a48a24eStimh nvlist_free(fsprops); 805990b4856Slling nvlist_free(props); 806990b4856Slling usage(B_FALSE); 807990b4856Slling return (2); 808fa9e4066Sahrens } 809fa9e4066Sahrens 810fa9e4066Sahrens /* 811fa9e4066Sahrens * zpool destroy <pool> 812fa9e4066Sahrens * 813fa9e4066Sahrens * -f Forcefully unmount any datasets 814fa9e4066Sahrens * 815fa9e4066Sahrens * Destroy the given pool. Automatically unmounts any datasets in the pool. 816fa9e4066Sahrens */ 817fa9e4066Sahrens int 818fa9e4066Sahrens zpool_do_destroy(int argc, char **argv) 819fa9e4066Sahrens { 82099653d4eSeschrock boolean_t force = B_FALSE; 821fa9e4066Sahrens int c; 822fa9e4066Sahrens char *pool; 823fa9e4066Sahrens zpool_handle_t *zhp; 824fa9e4066Sahrens int ret; 825fa9e4066Sahrens 826fa9e4066Sahrens /* check options */ 827fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 828fa9e4066Sahrens switch (c) { 829fa9e4066Sahrens case 'f': 83099653d4eSeschrock force = B_TRUE; 831fa9e4066Sahrens break; 832fa9e4066Sahrens case '?': 833fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 834fa9e4066Sahrens optopt); 83599653d4eSeschrock usage(B_FALSE); 836fa9e4066Sahrens } 837fa9e4066Sahrens } 838fa9e4066Sahrens 839fa9e4066Sahrens argc -= optind; 840fa9e4066Sahrens argv += optind; 841fa9e4066Sahrens 842fa9e4066Sahrens /* check arguments */ 843fa9e4066Sahrens if (argc < 1) { 844fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 84599653d4eSeschrock usage(B_FALSE); 846fa9e4066Sahrens } 847fa9e4066Sahrens if (argc > 1) { 848fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 84999653d4eSeschrock usage(B_FALSE); 850fa9e4066Sahrens } 851fa9e4066Sahrens 852fa9e4066Sahrens pool = argv[0]; 853fa9e4066Sahrens 85499653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 855fa9e4066Sahrens /* 856fa9e4066Sahrens * As a special case, check for use of '/' in the name, and 857fa9e4066Sahrens * direct the user to use 'zfs destroy' instead. 858fa9e4066Sahrens */ 859fa9e4066Sahrens if (strchr(pool, '/') != NULL) 860fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy' to " 861fa9e4066Sahrens "destroy a dataset\n")); 862fa9e4066Sahrens return (1); 863fa9e4066Sahrens } 864fa9e4066Sahrens 865f3861e1aSahl if (zpool_disable_datasets(zhp, force) != 0) { 866fa9e4066Sahrens (void) fprintf(stderr, gettext("could not destroy '%s': " 867fa9e4066Sahrens "could not unmount datasets\n"), zpool_get_name(zhp)); 868fa9e4066Sahrens return (1); 869fa9e4066Sahrens } 870fa9e4066Sahrens 871fa9e4066Sahrens ret = (zpool_destroy(zhp) != 0); 872fa9e4066Sahrens 873fa9e4066Sahrens zpool_close(zhp); 874fa9e4066Sahrens 875fa9e4066Sahrens return (ret); 876fa9e4066Sahrens } 877fa9e4066Sahrens 878fa9e4066Sahrens /* 879fa9e4066Sahrens * zpool export [-f] <pool> ... 880fa9e4066Sahrens * 881fa9e4066Sahrens * -f Forcefully unmount datasets 882fa9e4066Sahrens * 883b1b8ab34Slling * Export the given pools. By default, the command will attempt to cleanly 884fa9e4066Sahrens * unmount any active datasets within the pool. If the '-f' flag is specified, 885fa9e4066Sahrens * then the datasets will be forcefully unmounted. 886fa9e4066Sahrens */ 887fa9e4066Sahrens int 888fa9e4066Sahrens zpool_do_export(int argc, char **argv) 889fa9e4066Sahrens { 89099653d4eSeschrock boolean_t force = B_FALSE; 891394ab0cbSGeorge Wilson boolean_t hardforce = B_FALSE; 892fa9e4066Sahrens int c; 893fa9e4066Sahrens zpool_handle_t *zhp; 894fa9e4066Sahrens int ret; 895fa9e4066Sahrens int i; 896fa9e4066Sahrens 897fa9e4066Sahrens /* check options */ 898394ab0cbSGeorge Wilson while ((c = getopt(argc, argv, "fF")) != -1) { 899fa9e4066Sahrens switch (c) { 900fa9e4066Sahrens case 'f': 90199653d4eSeschrock force = B_TRUE; 902fa9e4066Sahrens break; 903394ab0cbSGeorge Wilson case 'F': 904394ab0cbSGeorge Wilson hardforce = B_TRUE; 905394ab0cbSGeorge Wilson break; 906fa9e4066Sahrens case '?': 907fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 908fa9e4066Sahrens optopt); 90999653d4eSeschrock usage(B_FALSE); 910fa9e4066Sahrens } 911fa9e4066Sahrens } 912fa9e4066Sahrens 913fa9e4066Sahrens argc -= optind; 914fa9e4066Sahrens argv += optind; 915fa9e4066Sahrens 916fa9e4066Sahrens /* check arguments */ 917fa9e4066Sahrens if (argc < 1) { 918fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 91999653d4eSeschrock usage(B_FALSE); 920fa9e4066Sahrens } 921fa9e4066Sahrens 922fa9e4066Sahrens ret = 0; 923fa9e4066Sahrens for (i = 0; i < argc; i++) { 92499653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, argv[i])) == NULL) { 925fa9e4066Sahrens ret = 1; 926fa9e4066Sahrens continue; 927fa9e4066Sahrens } 928fa9e4066Sahrens 929f3861e1aSahl if (zpool_disable_datasets(zhp, force) != 0) { 930fa9e4066Sahrens ret = 1; 931fa9e4066Sahrens zpool_close(zhp); 932fa9e4066Sahrens continue; 933fa9e4066Sahrens } 934fa9e4066Sahrens 935394ab0cbSGeorge Wilson if (hardforce) { 936394ab0cbSGeorge Wilson if (zpool_export_force(zhp) != 0) 937394ab0cbSGeorge Wilson ret = 1; 938394ab0cbSGeorge Wilson } else if (zpool_export(zhp, force) != 0) { 939fa9e4066Sahrens ret = 1; 940394ab0cbSGeorge Wilson } 941fa9e4066Sahrens 942fa9e4066Sahrens zpool_close(zhp); 943fa9e4066Sahrens } 944fa9e4066Sahrens 945fa9e4066Sahrens return (ret); 946fa9e4066Sahrens } 947fa9e4066Sahrens 948fa9e4066Sahrens /* 949fa9e4066Sahrens * Given a vdev configuration, determine the maximum width needed for the device 950fa9e4066Sahrens * name column. 951fa9e4066Sahrens */ 952fa9e4066Sahrens static int 953c67d9675Seschrock max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max) 954fa9e4066Sahrens { 95588ecc943SGeorge Wilson char *name = zpool_vdev_name(g_zfs, zhp, nv, B_TRUE); 956fa9e4066Sahrens nvlist_t **child; 957fa9e4066Sahrens uint_t c, children; 958fa9e4066Sahrens int ret; 959fa9e4066Sahrens 960fa9e4066Sahrens if (strlen(name) + depth > max) 961fa9e4066Sahrens max = strlen(name) + depth; 962fa9e4066Sahrens 963afefbcddSeschrock free(name); 964afefbcddSeschrock 96599653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 96699653d4eSeschrock &child, &children) == 0) { 96799653d4eSeschrock for (c = 0; c < children; c++) 96899653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 96999653d4eSeschrock max)) > max) 97099653d4eSeschrock max = ret; 97199653d4eSeschrock } 97299653d4eSeschrock 973fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 974fa94a07fSbrendan &child, &children) == 0) { 975fa94a07fSbrendan for (c = 0; c < children; c++) 976fa94a07fSbrendan if ((ret = max_width(zhp, child[c], depth + 2, 977fa94a07fSbrendan max)) > max) 978fa94a07fSbrendan max = ret; 979fa94a07fSbrendan } 980fa94a07fSbrendan 981fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 98299653d4eSeschrock &child, &children) == 0) { 98399653d4eSeschrock for (c = 0; c < children; c++) 98499653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 98599653d4eSeschrock max)) > max) 98699653d4eSeschrock max = ret; 98799653d4eSeschrock } 988fa9e4066Sahrens 989fa9e4066Sahrens 990fa9e4066Sahrens return (max); 991fa9e4066Sahrens } 992fa9e4066Sahrens 993e6ca193dSGeorge Wilson typedef struct spare_cbdata { 994e6ca193dSGeorge Wilson uint64_t cb_guid; 995e6ca193dSGeorge Wilson zpool_handle_t *cb_zhp; 996e6ca193dSGeorge Wilson } spare_cbdata_t; 997e6ca193dSGeorge Wilson 998e6ca193dSGeorge Wilson static boolean_t 999e6ca193dSGeorge Wilson find_vdev(nvlist_t *nv, uint64_t search) 1000e6ca193dSGeorge Wilson { 1001e6ca193dSGeorge Wilson uint64_t guid; 1002e6ca193dSGeorge Wilson nvlist_t **child; 1003e6ca193dSGeorge Wilson uint_t c, children; 1004e6ca193dSGeorge Wilson 1005e6ca193dSGeorge Wilson if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 && 1006e6ca193dSGeorge Wilson search == guid) 1007e6ca193dSGeorge Wilson return (B_TRUE); 1008e6ca193dSGeorge Wilson 1009e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1010e6ca193dSGeorge Wilson &child, &children) == 0) { 1011e6ca193dSGeorge Wilson for (c = 0; c < children; c++) 1012e6ca193dSGeorge Wilson if (find_vdev(child[c], search)) 1013e6ca193dSGeorge Wilson return (B_TRUE); 1014e6ca193dSGeorge Wilson } 1015e6ca193dSGeorge Wilson 1016e6ca193dSGeorge Wilson return (B_FALSE); 1017e6ca193dSGeorge Wilson } 1018e6ca193dSGeorge Wilson 1019e6ca193dSGeorge Wilson static int 1020e6ca193dSGeorge Wilson find_spare(zpool_handle_t *zhp, void *data) 1021e6ca193dSGeorge Wilson { 1022e6ca193dSGeorge Wilson spare_cbdata_t *cbp = data; 1023e6ca193dSGeorge Wilson nvlist_t *config, *nvroot; 1024e6ca193dSGeorge Wilson 1025e6ca193dSGeorge Wilson config = zpool_get_config(zhp, NULL); 1026e6ca193dSGeorge Wilson verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1027e6ca193dSGeorge Wilson &nvroot) == 0); 1028e6ca193dSGeorge Wilson 1029e6ca193dSGeorge Wilson if (find_vdev(nvroot, cbp->cb_guid)) { 1030e6ca193dSGeorge Wilson cbp->cb_zhp = zhp; 1031e6ca193dSGeorge Wilson return (1); 1032e6ca193dSGeorge Wilson } 1033e6ca193dSGeorge Wilson 1034e6ca193dSGeorge Wilson zpool_close(zhp); 1035e6ca193dSGeorge Wilson return (0); 1036e6ca193dSGeorge Wilson } 1037e6ca193dSGeorge Wilson 1038e6ca193dSGeorge Wilson /* 1039e6ca193dSGeorge Wilson * Print out configuration state as requested by status_callback. 1040e6ca193dSGeorge Wilson */ 1041e6ca193dSGeorge Wilson void 1042e6ca193dSGeorge Wilson print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 1043e6ca193dSGeorge Wilson int namewidth, int depth, boolean_t isspare) 1044e6ca193dSGeorge Wilson { 1045e6ca193dSGeorge Wilson nvlist_t **child; 1046e6ca193dSGeorge Wilson uint_t c, children; 1047e6ca193dSGeorge Wilson vdev_stat_t *vs; 1048e6ca193dSGeorge Wilson char rbuf[6], wbuf[6], cbuf[6], repaired[7]; 1049e6ca193dSGeorge Wilson char *vname; 1050e6ca193dSGeorge Wilson uint64_t notpresent; 1051e6ca193dSGeorge Wilson spare_cbdata_t cb; 1052e6ca193dSGeorge Wilson char *state; 1053e6ca193dSGeorge Wilson 1054e6ca193dSGeorge Wilson verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS, 1055e6ca193dSGeorge Wilson (uint64_t **)&vs, &c) == 0); 1056e6ca193dSGeorge Wilson 1057e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1058e6ca193dSGeorge Wilson &child, &children) != 0) 1059e6ca193dSGeorge Wilson children = 0; 1060e6ca193dSGeorge Wilson 1061e6ca193dSGeorge Wilson state = zpool_state_to_name(vs->vs_state, vs->vs_aux); 1062e6ca193dSGeorge Wilson if (isspare) { 1063e6ca193dSGeorge Wilson /* 1064e6ca193dSGeorge Wilson * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for 1065e6ca193dSGeorge Wilson * online drives. 1066e6ca193dSGeorge Wilson */ 1067e6ca193dSGeorge Wilson if (vs->vs_aux == VDEV_AUX_SPARED) 1068e6ca193dSGeorge Wilson state = "INUSE"; 1069e6ca193dSGeorge Wilson else if (vs->vs_state == VDEV_STATE_HEALTHY) 1070e6ca193dSGeorge Wilson state = "AVAIL"; 1071e6ca193dSGeorge Wilson } 1072e6ca193dSGeorge Wilson 1073e6ca193dSGeorge Wilson (void) printf("\t%*s%-*s %-8s", depth, "", namewidth - depth, 1074e6ca193dSGeorge Wilson name, state); 1075e6ca193dSGeorge Wilson 1076e6ca193dSGeorge Wilson if (!isspare) { 1077e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf)); 1078e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf)); 1079e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf)); 1080e6ca193dSGeorge Wilson (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf); 1081e6ca193dSGeorge Wilson } 1082e6ca193dSGeorge Wilson 1083e6ca193dSGeorge Wilson if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1084e6ca193dSGeorge Wilson ¬present) == 0) { 1085e6ca193dSGeorge Wilson char *path; 1086e6ca193dSGeorge Wilson verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1087e6ca193dSGeorge Wilson (void) printf(" was %s", path); 1088e6ca193dSGeorge Wilson } else if (vs->vs_aux != 0) { 1089e6ca193dSGeorge Wilson (void) printf(" "); 1090e6ca193dSGeorge Wilson 1091e6ca193dSGeorge Wilson switch (vs->vs_aux) { 1092e6ca193dSGeorge Wilson case VDEV_AUX_OPEN_FAILED: 1093e6ca193dSGeorge Wilson (void) printf(gettext("cannot open")); 1094e6ca193dSGeorge Wilson break; 1095e6ca193dSGeorge Wilson 1096e6ca193dSGeorge Wilson case VDEV_AUX_BAD_GUID_SUM: 1097e6ca193dSGeorge Wilson (void) printf(gettext("missing device")); 1098e6ca193dSGeorge Wilson break; 1099e6ca193dSGeorge Wilson 1100e6ca193dSGeorge Wilson case VDEV_AUX_NO_REPLICAS: 1101e6ca193dSGeorge Wilson (void) printf(gettext("insufficient replicas")); 1102e6ca193dSGeorge Wilson break; 1103e6ca193dSGeorge Wilson 1104e6ca193dSGeorge Wilson case VDEV_AUX_VERSION_NEWER: 1105e6ca193dSGeorge Wilson (void) printf(gettext("newer version")); 1106e6ca193dSGeorge Wilson break; 1107e6ca193dSGeorge Wilson 1108e6ca193dSGeorge Wilson case VDEV_AUX_SPARED: 1109e6ca193dSGeorge Wilson verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, 1110e6ca193dSGeorge Wilson &cb.cb_guid) == 0); 1111e6ca193dSGeorge Wilson if (zpool_iter(g_zfs, find_spare, &cb) == 1) { 1112e6ca193dSGeorge Wilson if (strcmp(zpool_get_name(cb.cb_zhp), 1113e6ca193dSGeorge Wilson zpool_get_name(zhp)) == 0) 1114e6ca193dSGeorge Wilson (void) printf(gettext("currently in " 1115e6ca193dSGeorge Wilson "use")); 1116e6ca193dSGeorge Wilson else 1117e6ca193dSGeorge Wilson (void) printf(gettext("in use by " 1118e6ca193dSGeorge Wilson "pool '%s'"), 1119e6ca193dSGeorge Wilson zpool_get_name(cb.cb_zhp)); 1120e6ca193dSGeorge Wilson zpool_close(cb.cb_zhp); 1121e6ca193dSGeorge Wilson } else { 1122e6ca193dSGeorge Wilson (void) printf(gettext("currently in use")); 1123e6ca193dSGeorge Wilson } 1124e6ca193dSGeorge Wilson break; 1125e6ca193dSGeorge Wilson 1126e6ca193dSGeorge Wilson case VDEV_AUX_ERR_EXCEEDED: 1127e6ca193dSGeorge Wilson (void) printf(gettext("too many errors")); 1128e6ca193dSGeorge Wilson break; 1129e6ca193dSGeorge Wilson 1130e6ca193dSGeorge Wilson case VDEV_AUX_IO_FAILURE: 1131e6ca193dSGeorge Wilson (void) printf(gettext("experienced I/O failures")); 1132e6ca193dSGeorge Wilson break; 1133e6ca193dSGeorge Wilson 1134e6ca193dSGeorge Wilson case VDEV_AUX_BAD_LOG: 1135e6ca193dSGeorge Wilson (void) printf(gettext("bad intent log")); 1136e6ca193dSGeorge Wilson break; 1137e6ca193dSGeorge Wilson 1138069f55e2SEric Schrock case VDEV_AUX_EXTERNAL: 1139069f55e2SEric Schrock (void) printf(gettext("external device fault")); 1140069f55e2SEric Schrock break; 1141069f55e2SEric Schrock 1142*1195e687SMark J Musante case VDEV_AUX_SPLIT_POOL: 1143*1195e687SMark J Musante (void) printf(gettext("split into new pool")); 1144*1195e687SMark J Musante break; 1145*1195e687SMark J Musante 1146e6ca193dSGeorge Wilson default: 1147e6ca193dSGeorge Wilson (void) printf(gettext("corrupted data")); 1148e6ca193dSGeorge Wilson break; 1149e6ca193dSGeorge Wilson } 1150e6ca193dSGeorge Wilson } else if (vs->vs_scrub_repaired != 0 && children == 0) { 1151e6ca193dSGeorge Wilson /* 1152e6ca193dSGeorge Wilson * Report bytes resilvered/repaired on leaf devices. 1153e6ca193dSGeorge Wilson */ 1154e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_scrub_repaired, repaired, sizeof (repaired)); 1155e6ca193dSGeorge Wilson (void) printf(gettext(" %s %s"), repaired, 1156e6ca193dSGeorge Wilson (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ? 1157e6ca193dSGeorge Wilson "resilvered" : "repaired"); 1158e6ca193dSGeorge Wilson } 1159e6ca193dSGeorge Wilson 1160e6ca193dSGeorge Wilson (void) printf("\n"); 1161e6ca193dSGeorge Wilson 1162e6ca193dSGeorge Wilson for (c = 0; c < children; c++) { 116388ecc943SGeorge Wilson uint64_t islog = B_FALSE, ishole = B_FALSE; 1164e6ca193dSGeorge Wilson 116588ecc943SGeorge Wilson /* Don't print logs or holes here */ 1166e6ca193dSGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 116788ecc943SGeorge Wilson &islog); 116888ecc943SGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 116988ecc943SGeorge Wilson &ishole); 117088ecc943SGeorge Wilson if (islog || ishole) 1171e6ca193dSGeorge Wilson continue; 117288ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE); 1173e6ca193dSGeorge Wilson print_status_config(zhp, vname, child[c], 1174e6ca193dSGeorge Wilson namewidth, depth + 2, isspare); 1175e6ca193dSGeorge Wilson free(vname); 1176e6ca193dSGeorge Wilson } 1177e6ca193dSGeorge Wilson } 1178e6ca193dSGeorge Wilson 1179fa9e4066Sahrens 1180fa9e4066Sahrens /* 1181fa9e4066Sahrens * Print the configuration of an exported pool. Iterate over all vdevs in the 1182fa9e4066Sahrens * pool, printing out the name and status for each one. 1183fa9e4066Sahrens */ 1184fa9e4066Sahrens void 1185e6ca193dSGeorge Wilson print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth) 1186fa9e4066Sahrens { 1187fa9e4066Sahrens nvlist_t **child; 1188fa9e4066Sahrens uint_t c, children; 1189fa9e4066Sahrens vdev_stat_t *vs; 1190afefbcddSeschrock char *type, *vname; 1191fa9e4066Sahrens 1192fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 119388ecc943SGeorge Wilson if (strcmp(type, VDEV_TYPE_MISSING) == 0 || 119488ecc943SGeorge Wilson strcmp(type, VDEV_TYPE_HOLE) == 0) 1195fa9e4066Sahrens return; 1196fa9e4066Sahrens 1197fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS, 1198fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 1199fa9e4066Sahrens 1200fa9e4066Sahrens (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name); 1201990b4856Slling (void) printf(" %s", zpool_state_to_name(vs->vs_state, vs->vs_aux)); 1202fa9e4066Sahrens 1203fa9e4066Sahrens if (vs->vs_aux != 0) { 12043d7072f8Seschrock (void) printf(" "); 1205fa9e4066Sahrens 1206fa9e4066Sahrens switch (vs->vs_aux) { 1207fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 1208fa9e4066Sahrens (void) printf(gettext("cannot open")); 1209fa9e4066Sahrens break; 1210fa9e4066Sahrens 1211fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 1212fa9e4066Sahrens (void) printf(gettext("missing device")); 1213fa9e4066Sahrens break; 1214fa9e4066Sahrens 1215fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 1216fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 1217fa9e4066Sahrens break; 1218fa9e4066Sahrens 1219eaca9bbdSeschrock case VDEV_AUX_VERSION_NEWER: 1220eaca9bbdSeschrock (void) printf(gettext("newer version")); 1221eaca9bbdSeschrock break; 1222eaca9bbdSeschrock 12233d7072f8Seschrock case VDEV_AUX_ERR_EXCEEDED: 12243d7072f8Seschrock (void) printf(gettext("too many errors")); 12253d7072f8Seschrock break; 12263d7072f8Seschrock 1227fa9e4066Sahrens default: 1228fa9e4066Sahrens (void) printf(gettext("corrupted data")); 1229fa9e4066Sahrens break; 1230fa9e4066Sahrens } 1231fa9e4066Sahrens } 1232fa9e4066Sahrens (void) printf("\n"); 1233fa9e4066Sahrens 1234fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1235fa9e4066Sahrens &child, &children) != 0) 1236fa9e4066Sahrens return; 1237fa9e4066Sahrens 1238afefbcddSeschrock for (c = 0; c < children; c++) { 12398654d025Sperrin uint64_t is_log = B_FALSE; 12408654d025Sperrin 12418654d025Sperrin (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 12428654d025Sperrin &is_log); 1243e6ca193dSGeorge Wilson if (is_log) 12448654d025Sperrin continue; 12458654d025Sperrin 124688ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_TRUE); 1247e6ca193dSGeorge Wilson print_import_config(vname, child[c], namewidth, depth + 2); 1248afefbcddSeschrock free(vname); 1249afefbcddSeschrock } 125099653d4eSeschrock 1251fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 1252fa94a07fSbrendan &child, &children) == 0) { 1253fa94a07fSbrendan (void) printf(gettext("\tcache\n")); 1254fa94a07fSbrendan for (c = 0; c < children; c++) { 125588ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE); 1256fa94a07fSbrendan (void) printf("\t %s\n", vname); 1257fa94a07fSbrendan free(vname); 1258fa94a07fSbrendan } 1259fa94a07fSbrendan } 126099653d4eSeschrock 1261fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 1262fa94a07fSbrendan &child, &children) == 0) { 1263fa94a07fSbrendan (void) printf(gettext("\tspares\n")); 1264fa94a07fSbrendan for (c = 0; c < children; c++) { 126588ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE); 1266fa94a07fSbrendan (void) printf("\t %s\n", vname); 1267fa94a07fSbrendan free(vname); 1268fa94a07fSbrendan } 126999653d4eSeschrock } 1270fa9e4066Sahrens } 1271fa9e4066Sahrens 1272e6ca193dSGeorge Wilson /* 1273e6ca193dSGeorge Wilson * Print log vdevs. 1274e6ca193dSGeorge Wilson * Logs are recorded as top level vdevs in the main pool child array 1275e6ca193dSGeorge Wilson * but with "is_log" set to 1. We use either print_status_config() or 1276e6ca193dSGeorge Wilson * print_import_config() to print the top level logs then any log 1277e6ca193dSGeorge Wilson * children (eg mirrored slogs) are printed recursively - which 1278e6ca193dSGeorge Wilson * works because only the top level vdev is marked "is_log" 1279e6ca193dSGeorge Wilson */ 1280e6ca193dSGeorge Wilson static void 1281e6ca193dSGeorge Wilson print_logs(zpool_handle_t *zhp, nvlist_t *nv, int namewidth, boolean_t verbose) 1282e6ca193dSGeorge Wilson { 1283e6ca193dSGeorge Wilson uint_t c, children; 1284e6ca193dSGeorge Wilson nvlist_t **child; 1285e6ca193dSGeorge Wilson 1286e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child, 1287e6ca193dSGeorge Wilson &children) != 0) 1288e6ca193dSGeorge Wilson return; 1289e6ca193dSGeorge Wilson 1290e6ca193dSGeorge Wilson (void) printf(gettext("\tlogs\n")); 1291e6ca193dSGeorge Wilson 1292e6ca193dSGeorge Wilson for (c = 0; c < children; c++) { 1293e6ca193dSGeorge Wilson uint64_t is_log = B_FALSE; 1294e6ca193dSGeorge Wilson char *name; 1295e6ca193dSGeorge Wilson 1296e6ca193dSGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 1297e6ca193dSGeorge Wilson &is_log); 1298e6ca193dSGeorge Wilson if (!is_log) 1299e6ca193dSGeorge Wilson continue; 130088ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE); 1301e6ca193dSGeorge Wilson if (verbose) 1302e6ca193dSGeorge Wilson print_status_config(zhp, name, child[c], namewidth, 1303e6ca193dSGeorge Wilson 2, B_FALSE); 1304e6ca193dSGeorge Wilson else 1305e6ca193dSGeorge Wilson print_import_config(name, child[c], namewidth, 2); 1306e6ca193dSGeorge Wilson free(name); 1307e6ca193dSGeorge Wilson } 1308e6ca193dSGeorge Wilson } 1309468c413aSTim Haley 1310fa9e4066Sahrens /* 1311fa9e4066Sahrens * Display the status for the given pool. 1312fa9e4066Sahrens */ 1313fa9e4066Sahrens static void 1314fa9e4066Sahrens show_import(nvlist_t *config) 1315fa9e4066Sahrens { 1316fa9e4066Sahrens uint64_t pool_state; 1317fa9e4066Sahrens vdev_stat_t *vs; 1318fa9e4066Sahrens char *name; 1319fa9e4066Sahrens uint64_t guid; 1320fa9e4066Sahrens char *msgid; 1321fa9e4066Sahrens nvlist_t *nvroot; 1322fa9e4066Sahrens int reason; 132346657f8dSmmusante const char *health; 1324fa9e4066Sahrens uint_t vsc; 1325fa9e4066Sahrens int namewidth; 1326fa9e4066Sahrens 1327fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1328fa9e4066Sahrens &name) == 0); 1329fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 1330fa9e4066Sahrens &guid) == 0); 1331fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 1332fa9e4066Sahrens &pool_state) == 0); 1333fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1334fa9e4066Sahrens &nvroot) == 0); 1335fa9e4066Sahrens 1336fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 1337fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 1338990b4856Slling health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 1339fa9e4066Sahrens 1340fa9e4066Sahrens reason = zpool_import_status(config, &msgid); 1341fa9e4066Sahrens 134246657f8dSmmusante (void) printf(gettext(" pool: %s\n"), name); 134346657f8dSmmusante (void) printf(gettext(" id: %llu\n"), (u_longlong_t)guid); 134446657f8dSmmusante (void) printf(gettext(" state: %s"), health); 13454c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 1346b1b8ab34Slling (void) printf(gettext(" (DESTROYED)")); 13474c58d714Sdarrenm (void) printf("\n"); 1348fa9e4066Sahrens 1349fa9e4066Sahrens switch (reason) { 1350fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 1351fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 1352fa9e4066Sahrens case ZPOOL_STATUS_BAD_GUID_SUM: 1353fa9e4066Sahrens (void) printf(gettext("status: One or more devices are missing " 1354fa9e4066Sahrens "from the system.\n")); 1355fa9e4066Sahrens break; 1356fa9e4066Sahrens 1357fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 1358fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 1359fa9e4066Sahrens (void) printf(gettext("status: One or more devices contains " 1360fa9e4066Sahrens "corrupted data.\n")); 1361fa9e4066Sahrens break; 1362fa9e4066Sahrens 1363fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_DATA: 1364fa9e4066Sahrens (void) printf(gettext("status: The pool data is corrupted.\n")); 1365fa9e4066Sahrens break; 1366fa9e4066Sahrens 1367441d80aaSlling case ZPOOL_STATUS_OFFLINE_DEV: 1368441d80aaSlling (void) printf(gettext("status: One or more devices " 1369441d80aaSlling "are offlined.\n")); 1370441d80aaSlling break; 1371441d80aaSlling 1372ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 1373ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is " 1374ea8dc4b6Seschrock "corrupted.\n")); 1375ea8dc4b6Seschrock break; 1376ea8dc4b6Seschrock 1377eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 1378eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 1379eaca9bbdSeschrock "older on-disk version.\n")); 1380eaca9bbdSeschrock break; 1381eaca9bbdSeschrock 1382eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 1383eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 1384eaca9bbdSeschrock "incompatible version.\n")); 1385eaca9bbdSeschrock break; 1386b87f3af3Sperrin 138795173954Sek case ZPOOL_STATUS_HOSTID_MISMATCH: 138895173954Sek (void) printf(gettext("status: The pool was last accessed by " 138995173954Sek "another system.\n")); 139095173954Sek break; 1391b87f3af3Sperrin 13923d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_R: 13933d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_NR: 13943d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 13953d7072f8Seschrock "faulted.\n")); 13963d7072f8Seschrock break; 13973d7072f8Seschrock 1398b87f3af3Sperrin case ZPOOL_STATUS_BAD_LOG: 1399b87f3af3Sperrin (void) printf(gettext("status: An intent log record cannot be " 1400b87f3af3Sperrin "read.\n")); 1401b87f3af3Sperrin break; 1402b87f3af3Sperrin 1403fa9e4066Sahrens default: 1404fa9e4066Sahrens /* 1405fa9e4066Sahrens * No other status can be seen when importing pools. 1406fa9e4066Sahrens */ 1407fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 1408fa9e4066Sahrens } 1409fa9e4066Sahrens 1410fa9e4066Sahrens /* 1411fa9e4066Sahrens * Print out an action according to the overall state of the pool. 1412fa9e4066Sahrens */ 141346657f8dSmmusante if (vs->vs_state == VDEV_STATE_HEALTHY) { 1414eaca9bbdSeschrock if (reason == ZPOOL_STATUS_VERSION_OLDER) 1415eaca9bbdSeschrock (void) printf(gettext("action: The pool can be " 1416eaca9bbdSeschrock "imported using its name or numeric identifier, " 1417eaca9bbdSeschrock "though\n\tsome features will not be available " 1418eaca9bbdSeschrock "without an explicit 'zpool upgrade'.\n")); 141995173954Sek else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) 142095173954Sek (void) printf(gettext("action: The pool can be " 142195173954Sek "imported using its name or numeric " 142295173954Sek "identifier and\n\tthe '-f' flag.\n")); 1423fa9e4066Sahrens else 1424eaca9bbdSeschrock (void) printf(gettext("action: The pool can be " 1425eaca9bbdSeschrock "imported using its name or numeric " 1426eaca9bbdSeschrock "identifier.\n")); 142746657f8dSmmusante } else if (vs->vs_state == VDEV_STATE_DEGRADED) { 1428fa9e4066Sahrens (void) printf(gettext("action: The pool can be imported " 1429fa9e4066Sahrens "despite missing or damaged devices. The\n\tfault " 1430eaca9bbdSeschrock "tolerance of the pool may be compromised if imported.\n")); 1431fa9e4066Sahrens } else { 1432eaca9bbdSeschrock switch (reason) { 1433eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 1434eaca9bbdSeschrock (void) printf(gettext("action: The pool cannot be " 1435eaca9bbdSeschrock "imported. Access the pool on a system running " 1436eaca9bbdSeschrock "newer\n\tsoftware, or recreate the pool from " 1437eaca9bbdSeschrock "backup.\n")); 1438eaca9bbdSeschrock break; 1439eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_R: 1440eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_NR: 1441eaca9bbdSeschrock case ZPOOL_STATUS_BAD_GUID_SUM: 1442fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 1443fa9e4066Sahrens "imported. Attach the missing\n\tdevices and try " 1444fa9e4066Sahrens "again.\n")); 1445eaca9bbdSeschrock break; 1446eaca9bbdSeschrock default: 1447fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 1448fa9e4066Sahrens "imported due to damaged devices or data.\n")); 1449eaca9bbdSeschrock } 1450eaca9bbdSeschrock } 1451eaca9bbdSeschrock 145246657f8dSmmusante /* 145346657f8dSmmusante * If the state is "closed" or "can't open", and the aux state 145446657f8dSmmusante * is "corrupt data": 145546657f8dSmmusante */ 145646657f8dSmmusante if (((vs->vs_state == VDEV_STATE_CLOSED) || 145746657f8dSmmusante (vs->vs_state == VDEV_STATE_CANT_OPEN)) && 145846657f8dSmmusante (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) { 1459eaca9bbdSeschrock if (pool_state == POOL_STATE_DESTROYED) 1460eaca9bbdSeschrock (void) printf(gettext("\tThe pool was destroyed, " 1461eaca9bbdSeschrock "but can be imported using the '-Df' flags.\n")); 1462eaca9bbdSeschrock else if (pool_state != POOL_STATE_EXPORTED) 1463eaca9bbdSeschrock (void) printf(gettext("\tThe pool may be active on " 146418ce54dfSek "another system, but can be imported using\n\t" 1465eaca9bbdSeschrock "the '-f' flag.\n")); 1466fa9e4066Sahrens } 1467fa9e4066Sahrens 1468fa9e4066Sahrens if (msgid != NULL) 1469fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 1470fa9e4066Sahrens msgid); 1471fa9e4066Sahrens 1472fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 1473fa9e4066Sahrens 1474c67d9675Seschrock namewidth = max_width(NULL, nvroot, 0, 0); 1475fa9e4066Sahrens if (namewidth < 10) 1476fa9e4066Sahrens namewidth = 10; 14778654d025Sperrin 1478e6ca193dSGeorge Wilson print_import_config(name, nvroot, namewidth, 0); 1479e6ca193dSGeorge Wilson if (num_logs(nvroot) > 0) 1480e6ca193dSGeorge Wilson print_logs(NULL, nvroot, namewidth, B_FALSE); 1481fa9e4066Sahrens 1482fa9e4066Sahrens if (reason == ZPOOL_STATUS_BAD_GUID_SUM) { 148346657f8dSmmusante (void) printf(gettext("\n\tAdditional devices are known to " 1484fa9e4066Sahrens "be part of this pool, though their\n\texact " 148546657f8dSmmusante "configuration cannot be determined.\n")); 1486fa9e4066Sahrens } 1487fa9e4066Sahrens } 1488fa9e4066Sahrens 1489fa9e4066Sahrens /* 1490fa9e4066Sahrens * Perform the import for the given configuration. This passes the heavy 1491990b4856Slling * lifting off to zpool_import_props(), and then mounts the datasets contained 1492990b4856Slling * within the pool. 1493fa9e4066Sahrens */ 1494fa9e4066Sahrens static int 1495fa9e4066Sahrens do_import(nvlist_t *config, const char *newname, const char *mntopts, 14964f0f5e5bSVictor Latushkin int force, nvlist_t *props, boolean_t do_verbatim) 1497fa9e4066Sahrens { 1498fa9e4066Sahrens zpool_handle_t *zhp; 1499fa9e4066Sahrens char *name; 1500fa9e4066Sahrens uint64_t state; 1501eaca9bbdSeschrock uint64_t version; 1502fa9e4066Sahrens 1503fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1504fa9e4066Sahrens &name) == 0); 1505fa9e4066Sahrens 1506fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1507fa9e4066Sahrens ZPOOL_CONFIG_POOL_STATE, &state) == 0); 1508eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, 1509eaca9bbdSeschrock ZPOOL_CONFIG_VERSION, &version) == 0); 1510e7437265Sahrens if (version > SPA_VERSION) { 1511eaca9bbdSeschrock (void) fprintf(stderr, gettext("cannot import '%s': pool " 1512eaca9bbdSeschrock "is formatted using a newer ZFS version\n"), name); 1513eaca9bbdSeschrock return (1); 1514eaca9bbdSeschrock } else if (state != POOL_STATE_EXPORTED && !force) { 151595173954Sek uint64_t hostid; 151695173954Sek 151795173954Sek if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, 151895173954Sek &hostid) == 0) { 151995173954Sek if ((unsigned long)hostid != gethostid()) { 152095173954Sek char *hostname; 152195173954Sek uint64_t timestamp; 152295173954Sek time_t t; 152395173954Sek 152495173954Sek verify(nvlist_lookup_string(config, 152595173954Sek ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); 152695173954Sek verify(nvlist_lookup_uint64(config, 152795173954Sek ZPOOL_CONFIG_TIMESTAMP, ×tamp) == 0); 152895173954Sek t = timestamp; 152995173954Sek (void) fprintf(stderr, gettext("cannot import " 153095173954Sek "'%s': pool may be in use from other " 153195173954Sek "system, it was last accessed by %s " 153295173954Sek "(hostid: 0x%lx) on %s"), name, hostname, 153395173954Sek (unsigned long)hostid, 153495173954Sek asctime(localtime(&t))); 153595173954Sek (void) fprintf(stderr, gettext("use '-f' to " 153695173954Sek "import anyway\n")); 153795173954Sek return (1); 153895173954Sek } 153995173954Sek } else { 154095173954Sek (void) fprintf(stderr, gettext("cannot import '%s': " 154195173954Sek "pool may be in use from other system\n"), name); 154295173954Sek (void) fprintf(stderr, gettext("use '-f' to import " 154395173954Sek "anyway\n")); 154495173954Sek return (1); 154595173954Sek } 1546fa9e4066Sahrens } 1547fa9e4066Sahrens 15484f0f5e5bSVictor Latushkin if (zpool_import_props(g_zfs, config, newname, props, do_verbatim) != 0) 1549fa9e4066Sahrens return (1); 1550fa9e4066Sahrens 1551fa9e4066Sahrens if (newname != NULL) 1552fa9e4066Sahrens name = (char *)newname; 1553fa9e4066Sahrens 15544f0f5e5bSVictor Latushkin if ((zhp = zpool_open_canfail(g_zfs, name)) == NULL) 15554f0f5e5bSVictor Latushkin return (1); 1556fa9e4066Sahrens 1557379c004dSEric Schrock if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 1558379c004dSEric Schrock zpool_enable_datasets(zhp, mntopts, 0) != 0) { 1559fa9e4066Sahrens zpool_close(zhp); 1560fa9e4066Sahrens return (1); 1561fa9e4066Sahrens } 1562fa9e4066Sahrens 1563fa9e4066Sahrens zpool_close(zhp); 1564468c413aSTim Haley return (0); 1565fa9e4066Sahrens } 1566fa9e4066Sahrens 1567fa9e4066Sahrens /* 15684c58d714Sdarrenm * zpool import [-d dir] [-D] 15692f8aaab3Seschrock * import [-o mntopts] [-o prop=value] ... [-R root] [-D] 15702f8aaab3Seschrock * [-d dir | -c cachefile] [-f] -a 15712f8aaab3Seschrock * import [-o mntopts] [-o prop=value] ... [-R root] [-D] 1572468c413aSTim Haley * [-d dir | -c cachefile] [-f] [-n] [-F] <pool | id> [newpool] 15732f8aaab3Seschrock * 15742f8aaab3Seschrock * -c Read pool information from a cachefile instead of searching 15752f8aaab3Seschrock * devices. 1576fa9e4066Sahrens * 1577fa9e4066Sahrens * -d Scan in a specific directory, other than /dev/dsk. More than 1578fa9e4066Sahrens * one directory can be specified using multiple '-d' options. 1579fa9e4066Sahrens * 15804c58d714Sdarrenm * -D Scan for previously destroyed pools or import all or only 15814c58d714Sdarrenm * specified destroyed pools. 15824c58d714Sdarrenm * 1583fa9e4066Sahrens * -R Temporarily import the pool, with all mountpoints relative to 1584fa9e4066Sahrens * the given root. The pool will remain exported when the machine 1585fa9e4066Sahrens * is rebooted. 1586fa9e4066Sahrens * 1587468c413aSTim Haley * -V Import even in the presence of faulted vdevs. This is an 1588c5904d13Seschrock * intentionally undocumented option for testing purposes, and 1589c5904d13Seschrock * treats the pool configuration as complete, leaving any bad 15904f0f5e5bSVictor Latushkin * vdevs in the FAULTED state. In other words, it does verbatim 15914f0f5e5bSVictor Latushkin * import. 1592c5904d13Seschrock * 1593468c413aSTim Haley * -f Force import, even if it appears that the pool is active. 1594468c413aSTim Haley * 1595468c413aSTim Haley * -F Attempt rewind if necessary. 1596468c413aSTim Haley * 1597468c413aSTim Haley * -n See if rewind would work, but don't actually rewind. 1598468c413aSTim Haley * 1599fa9e4066Sahrens * -a Import all pools found. 1600fa9e4066Sahrens * 1601990b4856Slling * -o Set property=value and/or temporary mount options (without '='). 1602ecd6cf80Smarks * 1603fa9e4066Sahrens * The import command scans for pools to import, and import pools based on pool 1604fa9e4066Sahrens * name and GUID. The pool can also be renamed as part of the import process. 1605fa9e4066Sahrens */ 1606fa9e4066Sahrens int 1607fa9e4066Sahrens zpool_do_import(int argc, char **argv) 1608fa9e4066Sahrens { 1609fa9e4066Sahrens char **searchdirs = NULL; 1610fa9e4066Sahrens int nsearch = 0; 1611fa9e4066Sahrens int c; 1612fa9e4066Sahrens int err; 16132f8aaab3Seschrock nvlist_t *pools = NULL; 161499653d4eSeschrock boolean_t do_all = B_FALSE; 161599653d4eSeschrock boolean_t do_destroyed = B_FALSE; 1616fa9e4066Sahrens char *mntopts = NULL; 161799653d4eSeschrock boolean_t do_force = B_FALSE; 1618fa9e4066Sahrens nvpair_t *elem; 1619fa9e4066Sahrens nvlist_t *config; 162024e697d4Sck uint64_t searchguid = 0; 162124e697d4Sck char *searchname = NULL; 1622990b4856Slling char *propval; 1623fa9e4066Sahrens nvlist_t *found_config; 1624468c413aSTim Haley nvlist_t *policy = NULL; 1625ecd6cf80Smarks nvlist_t *props = NULL; 162699653d4eSeschrock boolean_t first; 16274f0f5e5bSVictor Latushkin boolean_t do_verbatim = B_FALSE; 1628468c413aSTim Haley uint32_t rewind_policy = ZPOOL_NO_REWIND; 1629468c413aSTim Haley boolean_t dryrun = B_FALSE; 1630468c413aSTim Haley boolean_t do_rewind = B_FALSE; 1631468c413aSTim Haley boolean_t xtreme_rewind = B_FALSE; 16324c58d714Sdarrenm uint64_t pool_state; 16332f8aaab3Seschrock char *cachefile = NULL; 1634fa9e4066Sahrens 1635fa9e4066Sahrens /* check options */ 1636*1195e687SMark J Musante while ((c = getopt(argc, argv, ":aCc:d:DEfFno:rR:VX")) != -1) { 1637fa9e4066Sahrens switch (c) { 1638fa9e4066Sahrens case 'a': 163999653d4eSeschrock do_all = B_TRUE; 1640fa9e4066Sahrens break; 16412f8aaab3Seschrock case 'c': 16422f8aaab3Seschrock cachefile = optarg; 16432f8aaab3Seschrock break; 1644fa9e4066Sahrens case 'd': 1645fa9e4066Sahrens if (searchdirs == NULL) { 1646fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1647fa9e4066Sahrens } else { 1648fa9e4066Sahrens char **tmp = safe_malloc((nsearch + 1) * 1649fa9e4066Sahrens sizeof (char *)); 1650fa9e4066Sahrens bcopy(searchdirs, tmp, nsearch * 1651fa9e4066Sahrens sizeof (char *)); 1652fa9e4066Sahrens free(searchdirs); 1653fa9e4066Sahrens searchdirs = tmp; 1654fa9e4066Sahrens } 1655fa9e4066Sahrens searchdirs[nsearch++] = optarg; 1656fa9e4066Sahrens break; 16574c58d714Sdarrenm case 'D': 165899653d4eSeschrock do_destroyed = B_TRUE; 16594c58d714Sdarrenm break; 1660fa9e4066Sahrens case 'f': 166199653d4eSeschrock do_force = B_TRUE; 1662fa9e4066Sahrens break; 1663c5904d13Seschrock case 'F': 1664468c413aSTim Haley do_rewind = B_TRUE; 1665468c413aSTim Haley break; 1666468c413aSTim Haley case 'n': 1667468c413aSTim Haley dryrun = B_TRUE; 1668c5904d13Seschrock break; 1669fa9e4066Sahrens case 'o': 1670990b4856Slling if ((propval = strchr(optarg, '=')) != NULL) { 1671990b4856Slling *propval = '\0'; 1672990b4856Slling propval++; 16730a48a24eStimh if (add_prop_list(optarg, propval, 16740a48a24eStimh &props, B_TRUE)) 1675990b4856Slling goto error; 1676990b4856Slling } else { 1677990b4856Slling mntopts = optarg; 1678990b4856Slling } 1679fa9e4066Sahrens break; 1680fa9e4066Sahrens case 'R': 1681990b4856Slling if (add_prop_list(zpool_prop_to_name( 16820a48a24eStimh ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 1683990b4856Slling goto error; 16842f8aaab3Seschrock if (nvlist_lookup_string(props, 16852f8aaab3Seschrock zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 16862f8aaab3Seschrock &propval) == 0) 16872f8aaab3Seschrock break; 1688990b4856Slling if (add_prop_list(zpool_prop_to_name( 16890a48a24eStimh ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE)) 1690990b4856Slling goto error; 1691fa9e4066Sahrens break; 1692468c413aSTim Haley case 'V': 1693468c413aSTim Haley do_verbatim = B_TRUE; 1694468c413aSTim Haley break; 1695468c413aSTim Haley case 'X': 1696468c413aSTim Haley xtreme_rewind = B_TRUE; 1697468c413aSTim Haley break; 1698fa9e4066Sahrens case ':': 1699fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1700fa9e4066Sahrens "'%c' option\n"), optopt); 170199653d4eSeschrock usage(B_FALSE); 1702fa9e4066Sahrens break; 1703fa9e4066Sahrens case '?': 1704fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1705fa9e4066Sahrens optopt); 170699653d4eSeschrock usage(B_FALSE); 1707fa9e4066Sahrens } 1708fa9e4066Sahrens } 1709fa9e4066Sahrens 1710fa9e4066Sahrens argc -= optind; 1711fa9e4066Sahrens argv += optind; 1712fa9e4066Sahrens 17132f8aaab3Seschrock if (cachefile && nsearch != 0) { 17142f8aaab3Seschrock (void) fprintf(stderr, gettext("-c is incompatible with -d\n")); 17152f8aaab3Seschrock usage(B_FALSE); 17162f8aaab3Seschrock } 17172f8aaab3Seschrock 1718468c413aSTim Haley if ((dryrun || xtreme_rewind) && !do_rewind) { 1719468c413aSTim Haley (void) fprintf(stderr, 1720468c413aSTim Haley gettext("-n or -X only meaningful with -F\n")); 1721468c413aSTim Haley usage(B_FALSE); 1722468c413aSTim Haley } 1723468c413aSTim Haley if (dryrun) 1724468c413aSTim Haley rewind_policy = ZPOOL_TRY_REWIND; 1725468c413aSTim Haley else if (do_rewind) 1726468c413aSTim Haley rewind_policy = ZPOOL_DO_REWIND; 1727468c413aSTim Haley if (xtreme_rewind) 1728468c413aSTim Haley rewind_policy |= ZPOOL_EXTREME_REWIND; 1729468c413aSTim Haley 1730468c413aSTim Haley /* In the future, we can capture further policy and include it here */ 1731468c413aSTim Haley if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 1732468c413aSTim Haley nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) 1733468c413aSTim Haley goto error; 1734468c413aSTim Haley 1735fa9e4066Sahrens if (searchdirs == NULL) { 1736fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1737fa9e4066Sahrens searchdirs[0] = "/dev/dsk"; 1738fa9e4066Sahrens nsearch = 1; 1739fa9e4066Sahrens } 1740fa9e4066Sahrens 1741fa9e4066Sahrens /* check argument count */ 1742fa9e4066Sahrens if (do_all) { 1743fa9e4066Sahrens if (argc != 0) { 1744fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 174599653d4eSeschrock usage(B_FALSE); 1746fa9e4066Sahrens } 1747fa9e4066Sahrens } else { 1748fa9e4066Sahrens if (argc > 2) { 1749fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 175099653d4eSeschrock usage(B_FALSE); 1751fa9e4066Sahrens } 1752fa9e4066Sahrens 1753fa9e4066Sahrens /* 1754fa9e4066Sahrens * Check for the SYS_CONFIG privilege. We do this explicitly 1755fa9e4066Sahrens * here because otherwise any attempt to discover pools will 1756fa9e4066Sahrens * silently fail. 1757fa9e4066Sahrens */ 1758fa9e4066Sahrens if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) { 1759fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1760fa9e4066Sahrens "discover pools: permission denied\n")); 176199653d4eSeschrock free(searchdirs); 1762468c413aSTim Haley nvlist_free(policy); 1763fa9e4066Sahrens return (1); 1764fa9e4066Sahrens } 1765fa9e4066Sahrens } 1766fa9e4066Sahrens 1767fa9e4066Sahrens /* 1768fa9e4066Sahrens * Depending on the arguments given, we do one of the following: 1769fa9e4066Sahrens * 1770fa9e4066Sahrens * <none> Iterate through all pools and display information about 1771fa9e4066Sahrens * each one. 1772fa9e4066Sahrens * 1773fa9e4066Sahrens * -a Iterate through all pools and try to import each one. 1774fa9e4066Sahrens * 1775fa9e4066Sahrens * <id> Find the pool that corresponds to the given GUID/pool 1776fa9e4066Sahrens * name and import that one. 17774c58d714Sdarrenm * 17784c58d714Sdarrenm * -D Above options applies only to destroyed pools. 1779fa9e4066Sahrens */ 1780fa9e4066Sahrens if (argc != 0) { 1781fa9e4066Sahrens char *endptr; 1782fa9e4066Sahrens 1783fa9e4066Sahrens errno = 0; 1784fa9e4066Sahrens searchguid = strtoull(argv[0], &endptr, 10); 1785fa9e4066Sahrens if (errno != 0 || *endptr != '\0') 1786fa9e4066Sahrens searchname = argv[0]; 1787fa9e4066Sahrens found_config = NULL; 1788fa9e4066Sahrens } 1789fa9e4066Sahrens 179024e697d4Sck if (cachefile) { 1791e829d913Sck pools = zpool_find_import_cached(g_zfs, cachefile, searchname, 1792e829d913Sck searchguid); 179324e697d4Sck } else if (searchname != NULL) { 179424e697d4Sck pools = zpool_find_import_byname(g_zfs, nsearch, searchdirs, 179524e697d4Sck searchname); 179624e697d4Sck } else { 179724e697d4Sck /* 179824e697d4Sck * It's OK to search by guid even if searchguid is 0. 179924e697d4Sck */ 180024e697d4Sck pools = zpool_find_import_byguid(g_zfs, nsearch, searchdirs, 180124e697d4Sck searchguid); 180224e697d4Sck } 180324e697d4Sck 180424e697d4Sck if (pools == NULL) { 180524e697d4Sck if (argc != 0) { 180624e697d4Sck (void) fprintf(stderr, gettext("cannot import '%s': " 180724e697d4Sck "no such pool available\n"), argv[0]); 180824e697d4Sck } 180924e697d4Sck free(searchdirs); 1810468c413aSTim Haley nvlist_free(policy); 181124e697d4Sck return (1); 181224e697d4Sck } 181324e697d4Sck 181424e697d4Sck /* 181524e697d4Sck * At this point we have a list of import candidate configs. Even if 181624e697d4Sck * we were searching by pool name or guid, we still need to 181724e697d4Sck * post-process the list to deal with pool state and possible 181824e697d4Sck * duplicate names. 181924e697d4Sck */ 1820fa9e4066Sahrens err = 0; 1821fa9e4066Sahrens elem = NULL; 182299653d4eSeschrock first = B_TRUE; 1823fa9e4066Sahrens while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { 1824fa9e4066Sahrens 1825fa9e4066Sahrens verify(nvpair_value_nvlist(elem, &config) == 0); 1826fa9e4066Sahrens 18274c58d714Sdarrenm verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 18284c58d714Sdarrenm &pool_state) == 0); 18294c58d714Sdarrenm if (!do_destroyed && pool_state == POOL_STATE_DESTROYED) 18304c58d714Sdarrenm continue; 18314c58d714Sdarrenm if (do_destroyed && pool_state != POOL_STATE_DESTROYED) 18324c58d714Sdarrenm continue; 18334c58d714Sdarrenm 1834468c413aSTim Haley verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY, 1835468c413aSTim Haley policy) == 0); 1836468c413aSTim Haley 1837fa9e4066Sahrens if (argc == 0) { 1838fa9e4066Sahrens if (first) 183999653d4eSeschrock first = B_FALSE; 18403bb79becSeschrock else if (!do_all) 1841fa9e4066Sahrens (void) printf("\n"); 1842fa9e4066Sahrens 1843468c413aSTim Haley if (do_all) { 1844fa9e4066Sahrens err |= do_import(config, NULL, mntopts, 18454f0f5e5bSVictor Latushkin do_force, props, do_verbatim); 1846468c413aSTim Haley } else { 1847fa9e4066Sahrens show_import(config); 1848468c413aSTim Haley } 1849fa9e4066Sahrens } else if (searchname != NULL) { 1850fa9e4066Sahrens char *name; 1851fa9e4066Sahrens 1852fa9e4066Sahrens /* 1853fa9e4066Sahrens * We are searching for a pool based on name. 1854fa9e4066Sahrens */ 1855fa9e4066Sahrens verify(nvlist_lookup_string(config, 1856fa9e4066Sahrens ZPOOL_CONFIG_POOL_NAME, &name) == 0); 1857fa9e4066Sahrens 1858fa9e4066Sahrens if (strcmp(name, searchname) == 0) { 1859fa9e4066Sahrens if (found_config != NULL) { 1860fa9e4066Sahrens (void) fprintf(stderr, gettext( 1861fa9e4066Sahrens "cannot import '%s': more than " 1862fa9e4066Sahrens "one matching pool\n"), searchname); 1863fa9e4066Sahrens (void) fprintf(stderr, gettext( 1864fa9e4066Sahrens "import by numeric ID instead\n")); 186599653d4eSeschrock err = B_TRUE; 1866fa9e4066Sahrens } 1867fa9e4066Sahrens found_config = config; 1868fa9e4066Sahrens } 1869fa9e4066Sahrens } else { 1870fa9e4066Sahrens uint64_t guid; 1871fa9e4066Sahrens 1872fa9e4066Sahrens /* 1873fa9e4066Sahrens * Search for a pool by guid. 1874fa9e4066Sahrens */ 1875fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1876fa9e4066Sahrens ZPOOL_CONFIG_POOL_GUID, &guid) == 0); 1877fa9e4066Sahrens 1878fa9e4066Sahrens if (guid == searchguid) 1879fa9e4066Sahrens found_config = config; 1880fa9e4066Sahrens } 1881fa9e4066Sahrens } 1882fa9e4066Sahrens 1883fa9e4066Sahrens /* 1884fa9e4066Sahrens * If we were searching for a specific pool, verify that we found a 1885fa9e4066Sahrens * pool, and then do the import. 1886fa9e4066Sahrens */ 1887fa9e4066Sahrens if (argc != 0 && err == 0) { 1888fa9e4066Sahrens if (found_config == NULL) { 1889fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': " 1890fa9e4066Sahrens "no such pool available\n"), argv[0]); 189199653d4eSeschrock err = B_TRUE; 1892fa9e4066Sahrens } else { 1893fa9e4066Sahrens err |= do_import(found_config, argc == 1 ? NULL : 18944f0f5e5bSVictor Latushkin argv[1], mntopts, do_force, props, do_verbatim); 1895fa9e4066Sahrens } 1896fa9e4066Sahrens } 1897fa9e4066Sahrens 1898fa9e4066Sahrens /* 1899fa9e4066Sahrens * If we were just looking for pools, report an error if none were 1900fa9e4066Sahrens * found. 1901fa9e4066Sahrens */ 1902fa9e4066Sahrens if (argc == 0 && first) 1903fa9e4066Sahrens (void) fprintf(stderr, 1904fa9e4066Sahrens gettext("no pools available to import\n")); 1905fa9e4066Sahrens 1906ecd6cf80Smarks error: 19072f8aaab3Seschrock nvlist_free(props); 1908fa9e4066Sahrens nvlist_free(pools); 1909468c413aSTim Haley nvlist_free(policy); 191099653d4eSeschrock free(searchdirs); 1911fa9e4066Sahrens 1912fa9e4066Sahrens return (err ? 1 : 0); 1913fa9e4066Sahrens } 1914fa9e4066Sahrens 1915fa9e4066Sahrens typedef struct iostat_cbdata { 1916fa9e4066Sahrens zpool_list_t *cb_list; 1917fa9e4066Sahrens int cb_verbose; 1918fa9e4066Sahrens int cb_iteration; 1919fa9e4066Sahrens int cb_namewidth; 1920fa9e4066Sahrens } iostat_cbdata_t; 1921fa9e4066Sahrens 1922fa9e4066Sahrens static void 1923fa9e4066Sahrens print_iostat_separator(iostat_cbdata_t *cb) 1924fa9e4066Sahrens { 1925fa9e4066Sahrens int i = 0; 1926fa9e4066Sahrens 1927fa9e4066Sahrens for (i = 0; i < cb->cb_namewidth; i++) 1928fa9e4066Sahrens (void) printf("-"); 1929fa9e4066Sahrens (void) printf(" ----- ----- ----- ----- ----- -----\n"); 1930fa9e4066Sahrens } 1931fa9e4066Sahrens 1932fa9e4066Sahrens static void 1933fa9e4066Sahrens print_iostat_header(iostat_cbdata_t *cb) 1934fa9e4066Sahrens { 1935fa9e4066Sahrens (void) printf("%*s capacity operations bandwidth\n", 1936fa9e4066Sahrens cb->cb_namewidth, ""); 1937485bbbf5SGeorge Wilson (void) printf("%-*s alloc free read write read write\n", 1938fa9e4066Sahrens cb->cb_namewidth, "pool"); 1939fa9e4066Sahrens print_iostat_separator(cb); 1940fa9e4066Sahrens } 1941fa9e4066Sahrens 1942fa9e4066Sahrens /* 1943fa9e4066Sahrens * Display a single statistic. 1944fa9e4066Sahrens */ 1945990b4856Slling static void 1946fa9e4066Sahrens print_one_stat(uint64_t value) 1947fa9e4066Sahrens { 1948fa9e4066Sahrens char buf[64]; 1949fa9e4066Sahrens 1950fa9e4066Sahrens zfs_nicenum(value, buf, sizeof (buf)); 1951fa9e4066Sahrens (void) printf(" %5s", buf); 1952fa9e4066Sahrens } 1953fa9e4066Sahrens 1954fa9e4066Sahrens /* 1955fa9e4066Sahrens * Print out all the statistics for the given vdev. This can either be the 1956fa9e4066Sahrens * toplevel configuration, or called recursively. If 'name' is NULL, then this 1957fa9e4066Sahrens * is a verbose output, and we don't want to display the toplevel pool stats. 1958fa9e4066Sahrens */ 1959fa9e4066Sahrens void 1960c67d9675Seschrock print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, 1961c67d9675Seschrock nvlist_t *newnv, iostat_cbdata_t *cb, int depth) 1962fa9e4066Sahrens { 1963fa9e4066Sahrens nvlist_t **oldchild, **newchild; 1964fa9e4066Sahrens uint_t c, children; 1965fa9e4066Sahrens vdev_stat_t *oldvs, *newvs; 1966fa9e4066Sahrens vdev_stat_t zerovs = { 0 }; 1967fa9e4066Sahrens uint64_t tdelta; 1968fa9e4066Sahrens double scale; 1969afefbcddSeschrock char *vname; 1970fa9e4066Sahrens 1971fa9e4066Sahrens if (oldnv != NULL) { 1972fa9e4066Sahrens verify(nvlist_lookup_uint64_array(oldnv, ZPOOL_CONFIG_STATS, 1973fa9e4066Sahrens (uint64_t **)&oldvs, &c) == 0); 1974fa9e4066Sahrens } else { 1975fa9e4066Sahrens oldvs = &zerovs; 1976fa9e4066Sahrens } 1977fa9e4066Sahrens 1978fa9e4066Sahrens verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_STATS, 1979fa9e4066Sahrens (uint64_t **)&newvs, &c) == 0); 1980fa9e4066Sahrens 1981fa9e4066Sahrens if (strlen(name) + depth > cb->cb_namewidth) 1982fa9e4066Sahrens (void) printf("%*s%s", depth, "", name); 1983fa9e4066Sahrens else 1984fa9e4066Sahrens (void) printf("%*s%s%*s", depth, "", name, 1985fa9e4066Sahrens (int)(cb->cb_namewidth - strlen(name) - depth), ""); 1986fa9e4066Sahrens 1987fa9e4066Sahrens tdelta = newvs->vs_timestamp - oldvs->vs_timestamp; 1988fa9e4066Sahrens 1989fa9e4066Sahrens if (tdelta == 0) 1990fa9e4066Sahrens scale = 1.0; 1991fa9e4066Sahrens else 1992fa9e4066Sahrens scale = (double)NANOSEC / tdelta; 1993fa9e4066Sahrens 1994fa9e4066Sahrens /* only toplevel vdevs have capacity stats */ 1995fa9e4066Sahrens if (newvs->vs_space == 0) { 1996fa9e4066Sahrens (void) printf(" - -"); 1997fa9e4066Sahrens } else { 1998fa9e4066Sahrens print_one_stat(newvs->vs_alloc); 1999fa9e4066Sahrens print_one_stat(newvs->vs_space - newvs->vs_alloc); 2000fa9e4066Sahrens } 2001fa9e4066Sahrens 2002fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] - 2003fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_READ]))); 2004fa9e4066Sahrens 2005fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] - 2006fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_WRITE]))); 2007fa9e4066Sahrens 2008fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] - 2009fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_READ]))); 2010fa9e4066Sahrens 2011fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] - 2012fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_WRITE]))); 2013fa9e4066Sahrens 2014fa9e4066Sahrens (void) printf("\n"); 2015fa9e4066Sahrens 2016fa9e4066Sahrens if (!cb->cb_verbose) 2017fa9e4066Sahrens return; 2018fa9e4066Sahrens 2019fa9e4066Sahrens if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN, 2020fa9e4066Sahrens &newchild, &children) != 0) 2021fa9e4066Sahrens return; 2022fa9e4066Sahrens 2023fa9e4066Sahrens if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN, 2024fa9e4066Sahrens &oldchild, &c) != 0) 2025fa9e4066Sahrens return; 2026fa9e4066Sahrens 2027afefbcddSeschrock for (c = 0; c < children; c++) { 202888ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, newchild[c], B_FALSE); 2029c67d9675Seschrock print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 2030afefbcddSeschrock newchild[c], cb, depth + 2); 2031afefbcddSeschrock free(vname); 2032afefbcddSeschrock } 2033fa94a07fSbrendan 2034fa94a07fSbrendan /* 2035fa94a07fSbrendan * Include level 2 ARC devices in iostat output 2036fa94a07fSbrendan */ 2037fa94a07fSbrendan if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE, 2038fa94a07fSbrendan &newchild, &children) != 0) 2039fa94a07fSbrendan return; 2040fa94a07fSbrendan 2041fa94a07fSbrendan if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE, 2042fa94a07fSbrendan &oldchild, &c) != 0) 2043fa94a07fSbrendan return; 2044fa94a07fSbrendan 2045fa94a07fSbrendan if (children > 0) { 2046fa94a07fSbrendan (void) printf("%-*s - - - - - " 2047fa94a07fSbrendan "-\n", cb->cb_namewidth, "cache"); 2048fa94a07fSbrendan for (c = 0; c < children; c++) { 204988ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 205088ecc943SGeorge Wilson B_FALSE); 2051fa94a07fSbrendan print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 2052fa94a07fSbrendan newchild[c], cb, depth + 2); 2053fa94a07fSbrendan free(vname); 2054fa94a07fSbrendan } 2055fa94a07fSbrendan } 2056fa9e4066Sahrens } 2057fa9e4066Sahrens 2058088e9d47Seschrock static int 2059088e9d47Seschrock refresh_iostat(zpool_handle_t *zhp, void *data) 2060088e9d47Seschrock { 2061088e9d47Seschrock iostat_cbdata_t *cb = data; 206294de1d4cSeschrock boolean_t missing; 2063088e9d47Seschrock 2064088e9d47Seschrock /* 2065088e9d47Seschrock * If the pool has disappeared, remove it from the list and continue. 2066088e9d47Seschrock */ 206794de1d4cSeschrock if (zpool_refresh_stats(zhp, &missing) != 0) 206894de1d4cSeschrock return (-1); 206994de1d4cSeschrock 207094de1d4cSeschrock if (missing) 2071088e9d47Seschrock pool_list_remove(cb->cb_list, zhp); 2072088e9d47Seschrock 2073088e9d47Seschrock return (0); 2074088e9d47Seschrock } 2075088e9d47Seschrock 2076fa9e4066Sahrens /* 2077fa9e4066Sahrens * Callback to print out the iostats for the given pool. 2078fa9e4066Sahrens */ 2079fa9e4066Sahrens int 2080fa9e4066Sahrens print_iostat(zpool_handle_t *zhp, void *data) 2081fa9e4066Sahrens { 2082fa9e4066Sahrens iostat_cbdata_t *cb = data; 2083fa9e4066Sahrens nvlist_t *oldconfig, *newconfig; 2084fa9e4066Sahrens nvlist_t *oldnvroot, *newnvroot; 2085fa9e4066Sahrens 2086088e9d47Seschrock newconfig = zpool_get_config(zhp, &oldconfig); 2087fa9e4066Sahrens 2088088e9d47Seschrock if (cb->cb_iteration == 1) 2089fa9e4066Sahrens oldconfig = NULL; 2090fa9e4066Sahrens 2091fa9e4066Sahrens verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE, 2092fa9e4066Sahrens &newnvroot) == 0); 2093fa9e4066Sahrens 2094088e9d47Seschrock if (oldconfig == NULL) 2095fa9e4066Sahrens oldnvroot = NULL; 2096088e9d47Seschrock else 2097088e9d47Seschrock verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE, 2098088e9d47Seschrock &oldnvroot) == 0); 2099fa9e4066Sahrens 2100fa9e4066Sahrens /* 2101fa9e4066Sahrens * Print out the statistics for the pool. 2102fa9e4066Sahrens */ 2103c67d9675Seschrock print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0); 2104fa9e4066Sahrens 2105fa9e4066Sahrens if (cb->cb_verbose) 2106fa9e4066Sahrens print_iostat_separator(cb); 2107fa9e4066Sahrens 2108fa9e4066Sahrens return (0); 2109fa9e4066Sahrens } 2110fa9e4066Sahrens 2111fa9e4066Sahrens int 2112fa9e4066Sahrens get_namewidth(zpool_handle_t *zhp, void *data) 2113fa9e4066Sahrens { 2114fa9e4066Sahrens iostat_cbdata_t *cb = data; 2115fa9e4066Sahrens nvlist_t *config, *nvroot; 2116fa9e4066Sahrens 2117088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) != NULL) { 2118fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2119fa9e4066Sahrens &nvroot) == 0); 2120fa9e4066Sahrens if (!cb->cb_verbose) 2121fa9e4066Sahrens cb->cb_namewidth = strlen(zpool_get_name(zhp)); 2122fa9e4066Sahrens else 2123c67d9675Seschrock cb->cb_namewidth = max_width(zhp, nvroot, 0, 0); 2124fa9e4066Sahrens } 2125fa9e4066Sahrens 2126fa9e4066Sahrens /* 2127fa9e4066Sahrens * The width must fall into the range [10,38]. The upper limit is the 2128fa9e4066Sahrens * maximum we can have and still fit in 80 columns. 2129fa9e4066Sahrens */ 2130fa9e4066Sahrens if (cb->cb_namewidth < 10) 2131fa9e4066Sahrens cb->cb_namewidth = 10; 2132fa9e4066Sahrens if (cb->cb_namewidth > 38) 2133fa9e4066Sahrens cb->cb_namewidth = 38; 2134fa9e4066Sahrens 2135fa9e4066Sahrens return (0); 2136fa9e4066Sahrens } 2137fa9e4066Sahrens 2138fa9e4066Sahrens /* 213926fd7700SKrishnendu Sadhukhan - Sun Microsystems * zpool iostat [-T d|u] [-v] [pool] ... [interval [count]] 2140fa9e4066Sahrens * 214126fd7700SKrishnendu Sadhukhan - Sun Microsystems * -T Display a timestamp in date(1) or Unix format 2142fa9e4066Sahrens * -v Display statistics for individual vdevs 2143fa9e4066Sahrens * 2144fa9e4066Sahrens * This command can be tricky because we want to be able to deal with pool 2145fa9e4066Sahrens * creation/destruction as well as vdev configuration changes. The bulk of this 2146fa9e4066Sahrens * processing is handled by the pool_list_* routines in zpool_iter.c. We rely 2147fa9e4066Sahrens * on pool_list_update() to detect the addition of new pools. Configuration 2148fa9e4066Sahrens * changes are all handled within libzfs. 2149fa9e4066Sahrens */ 2150fa9e4066Sahrens int 2151fa9e4066Sahrens zpool_do_iostat(int argc, char **argv) 2152fa9e4066Sahrens { 2153fa9e4066Sahrens int c; 2154fa9e4066Sahrens int ret; 2155fa9e4066Sahrens int npools; 2156fa9e4066Sahrens unsigned long interval = 0, count = 0; 2157fa9e4066Sahrens zpool_list_t *list; 215899653d4eSeschrock boolean_t verbose = B_FALSE; 2159fa9e4066Sahrens iostat_cbdata_t cb; 2160fa9e4066Sahrens 2161fa9e4066Sahrens /* check options */ 216226fd7700SKrishnendu Sadhukhan - Sun Microsystems while ((c = getopt(argc, argv, "T:v")) != -1) { 2163fa9e4066Sahrens switch (c) { 216426fd7700SKrishnendu Sadhukhan - Sun Microsystems case 'T': 216526fd7700SKrishnendu Sadhukhan - Sun Microsystems if (optarg) { 216626fd7700SKrishnendu Sadhukhan - Sun Microsystems if (*optarg == 'u') 216726fd7700SKrishnendu Sadhukhan - Sun Microsystems timestamp_fmt = UDATE; 216826fd7700SKrishnendu Sadhukhan - Sun Microsystems else if (*optarg == 'd') 216926fd7700SKrishnendu Sadhukhan - Sun Microsystems timestamp_fmt = DDATE; 217026fd7700SKrishnendu Sadhukhan - Sun Microsystems else 217126fd7700SKrishnendu Sadhukhan - Sun Microsystems usage(B_FALSE); 217226fd7700SKrishnendu Sadhukhan - Sun Microsystems } else { 217326fd7700SKrishnendu Sadhukhan - Sun Microsystems usage(B_FALSE); 217426fd7700SKrishnendu Sadhukhan - Sun Microsystems } 217526fd7700SKrishnendu Sadhukhan - Sun Microsystems break; 2176fa9e4066Sahrens case 'v': 217799653d4eSeschrock verbose = B_TRUE; 2178fa9e4066Sahrens break; 2179fa9e4066Sahrens case '?': 2180fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2181fa9e4066Sahrens optopt); 218299653d4eSeschrock usage(B_FALSE); 2183fa9e4066Sahrens } 2184fa9e4066Sahrens } 2185fa9e4066Sahrens 2186fa9e4066Sahrens argc -= optind; 2187fa9e4066Sahrens argv += optind; 2188fa9e4066Sahrens 2189fa9e4066Sahrens /* 2190fa9e4066Sahrens * Determine if the last argument is an integer or a pool name 2191fa9e4066Sahrens */ 2192fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 2193fa9e4066Sahrens char *end; 2194fa9e4066Sahrens 2195fa9e4066Sahrens errno = 0; 2196fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 2197fa9e4066Sahrens 2198fa9e4066Sahrens if (*end == '\0' && errno == 0) { 2199fa9e4066Sahrens if (interval == 0) { 2200fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 2201fa9e4066Sahrens "cannot be zero\n")); 220299653d4eSeschrock usage(B_FALSE); 2203fa9e4066Sahrens } 2204fa9e4066Sahrens 2205fa9e4066Sahrens /* 2206fa9e4066Sahrens * Ignore the last parameter 2207fa9e4066Sahrens */ 2208fa9e4066Sahrens argc--; 2209fa9e4066Sahrens } else { 2210fa9e4066Sahrens /* 2211fa9e4066Sahrens * If this is not a valid number, just plow on. The 2212fa9e4066Sahrens * user will get a more informative error message later 2213fa9e4066Sahrens * on. 2214fa9e4066Sahrens */ 2215fa9e4066Sahrens interval = 0; 2216fa9e4066Sahrens } 2217fa9e4066Sahrens } 2218fa9e4066Sahrens 2219fa9e4066Sahrens /* 2220fa9e4066Sahrens * If the last argument is also an integer, then we have both a count 2221fa9e4066Sahrens * and an integer. 2222fa9e4066Sahrens */ 2223fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 2224fa9e4066Sahrens char *end; 2225fa9e4066Sahrens 2226fa9e4066Sahrens errno = 0; 2227fa9e4066Sahrens count = interval; 2228fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 2229fa9e4066Sahrens 2230fa9e4066Sahrens if (*end == '\0' && errno == 0) { 2231fa9e4066Sahrens if (interval == 0) { 2232fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 2233fa9e4066Sahrens "cannot be zero\n")); 223499653d4eSeschrock usage(B_FALSE); 2235fa9e4066Sahrens } 2236fa9e4066Sahrens 2237fa9e4066Sahrens /* 2238fa9e4066Sahrens * Ignore the last parameter 2239fa9e4066Sahrens */ 2240fa9e4066Sahrens argc--; 2241fa9e4066Sahrens } else { 2242fa9e4066Sahrens interval = 0; 2243fa9e4066Sahrens } 2244fa9e4066Sahrens } 2245fa9e4066Sahrens 2246fa9e4066Sahrens /* 2247fa9e4066Sahrens * Construct the list of all interesting pools. 2248fa9e4066Sahrens */ 2249fa9e4066Sahrens ret = 0; 2250b1b8ab34Slling if ((list = pool_list_get(argc, argv, NULL, &ret)) == NULL) 2251fa9e4066Sahrens return (1); 2252fa9e4066Sahrens 225399653d4eSeschrock if (pool_list_count(list) == 0 && argc != 0) { 225499653d4eSeschrock pool_list_free(list); 2255fa9e4066Sahrens return (1); 225699653d4eSeschrock } 2257fa9e4066Sahrens 2258fa9e4066Sahrens if (pool_list_count(list) == 0 && interval == 0) { 225999653d4eSeschrock pool_list_free(list); 2260fa9e4066Sahrens (void) fprintf(stderr, gettext("no pools available\n")); 2261fa9e4066Sahrens return (1); 2262fa9e4066Sahrens } 2263fa9e4066Sahrens 2264fa9e4066Sahrens /* 2265fa9e4066Sahrens * Enter the main iostat loop. 2266fa9e4066Sahrens */ 2267fa9e4066Sahrens cb.cb_list = list; 2268fa9e4066Sahrens cb.cb_verbose = verbose; 2269fa9e4066Sahrens cb.cb_iteration = 0; 2270fa9e4066Sahrens cb.cb_namewidth = 0; 2271fa9e4066Sahrens 2272fa9e4066Sahrens for (;;) { 2273fa9e4066Sahrens pool_list_update(list); 2274fa9e4066Sahrens 2275fa9e4066Sahrens if ((npools = pool_list_count(list)) == 0) 2276fa9e4066Sahrens break; 2277fa9e4066Sahrens 2278088e9d47Seschrock /* 2279088e9d47Seschrock * Refresh all statistics. This is done as an explicit step 2280088e9d47Seschrock * before calculating the maximum name width, so that any 2281088e9d47Seschrock * configuration changes are properly accounted for. 2282088e9d47Seschrock */ 228399653d4eSeschrock (void) pool_list_iter(list, B_FALSE, refresh_iostat, &cb); 2284088e9d47Seschrock 2285fa9e4066Sahrens /* 2286fa9e4066Sahrens * Iterate over all pools to determine the maximum width 2287fa9e4066Sahrens * for the pool / device name column across all pools. 2288fa9e4066Sahrens */ 2289fa9e4066Sahrens cb.cb_namewidth = 0; 229099653d4eSeschrock (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb); 2291fa9e4066Sahrens 229226fd7700SKrishnendu Sadhukhan - Sun Microsystems if (timestamp_fmt != NODATE) 229326fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt); 229426fd7700SKrishnendu Sadhukhan - Sun Microsystems 2295fa9e4066Sahrens /* 2296fa9e4066Sahrens * If it's the first time, or verbose mode, print the header. 2297fa9e4066Sahrens */ 2298fa9e4066Sahrens if (++cb.cb_iteration == 1 || verbose) 2299fa9e4066Sahrens print_iostat_header(&cb); 2300fa9e4066Sahrens 230199653d4eSeschrock (void) pool_list_iter(list, B_FALSE, print_iostat, &cb); 2302fa9e4066Sahrens 2303fa9e4066Sahrens /* 2304fa9e4066Sahrens * If there's more than one pool, and we're not in verbose mode 2305fa9e4066Sahrens * (which prints a separator for us), then print a separator. 2306fa9e4066Sahrens */ 2307fa9e4066Sahrens if (npools > 1 && !verbose) 2308fa9e4066Sahrens print_iostat_separator(&cb); 2309fa9e4066Sahrens 2310fa9e4066Sahrens if (verbose) 2311fa9e4066Sahrens (void) printf("\n"); 2312fa9e4066Sahrens 231339c23413Seschrock /* 231439c23413Seschrock * Flush the output so that redirection to a file isn't buffered 231539c23413Seschrock * indefinitely. 231639c23413Seschrock */ 231739c23413Seschrock (void) fflush(stdout); 231839c23413Seschrock 2319fa9e4066Sahrens if (interval == 0) 2320fa9e4066Sahrens break; 2321fa9e4066Sahrens 2322fa9e4066Sahrens if (count != 0 && --count == 0) 2323fa9e4066Sahrens break; 2324fa9e4066Sahrens 2325fa9e4066Sahrens (void) sleep(interval); 2326fa9e4066Sahrens } 2327fa9e4066Sahrens 2328fa9e4066Sahrens pool_list_free(list); 2329fa9e4066Sahrens 2330fa9e4066Sahrens return (ret); 2331fa9e4066Sahrens } 2332fa9e4066Sahrens 2333fa9e4066Sahrens typedef struct list_cbdata { 233499653d4eSeschrock boolean_t cb_scripted; 233599653d4eSeschrock boolean_t cb_first; 2336990b4856Slling zprop_list_t *cb_proplist; 2337fa9e4066Sahrens } list_cbdata_t; 2338fa9e4066Sahrens 2339fa9e4066Sahrens /* 2340fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 2341fa9e4066Sahrens */ 2342990b4856Slling static void 2343990b4856Slling print_header(zprop_list_t *pl) 2344fa9e4066Sahrens { 2345990b4856Slling const char *header; 2346990b4856Slling boolean_t first = B_TRUE; 2347990b4856Slling boolean_t right_justify; 2348990b4856Slling 2349990b4856Slling for (; pl != NULL; pl = pl->pl_next) { 2350990b4856Slling if (pl->pl_prop == ZPROP_INVAL) 2351990b4856Slling continue; 2352fa9e4066Sahrens 2353990b4856Slling if (!first) 2354fa9e4066Sahrens (void) printf(" "); 2355fa9e4066Sahrens else 2356990b4856Slling first = B_FALSE; 2357990b4856Slling 2358990b4856Slling header = zpool_prop_column_name(pl->pl_prop); 2359990b4856Slling right_justify = zpool_prop_align_right(pl->pl_prop); 2360fa9e4066Sahrens 2361990b4856Slling if (pl->pl_next == NULL && !right_justify) 2362990b4856Slling (void) printf("%s", header); 2363990b4856Slling else if (right_justify) 2364990b4856Slling (void) printf("%*s", pl->pl_width, header); 2365990b4856Slling else 2366990b4856Slling (void) printf("%-*s", pl->pl_width, header); 2367fa9e4066Sahrens } 2368fa9e4066Sahrens 2369fa9e4066Sahrens (void) printf("\n"); 2370fa9e4066Sahrens } 2371fa9e4066Sahrens 2372990b4856Slling /* 2373990b4856Slling * Given a pool and a list of properties, print out all the properties according 2374990b4856Slling * to the described layout. 2375990b4856Slling */ 2376990b4856Slling static void 2377990b4856Slling print_pool(zpool_handle_t *zhp, zprop_list_t *pl, int scripted) 2378fa9e4066Sahrens { 2379990b4856Slling boolean_t first = B_TRUE; 2380990b4856Slling char property[ZPOOL_MAXPROPLEN]; 2381990b4856Slling char *propstr; 2382990b4856Slling boolean_t right_justify; 2383990b4856Slling int width; 2384990b4856Slling 2385990b4856Slling for (; pl != NULL; pl = pl->pl_next) { 2386990b4856Slling if (!first) { 2387990b4856Slling if (scripted) 2388fa9e4066Sahrens (void) printf("\t"); 2389fa9e4066Sahrens else 2390fa9e4066Sahrens (void) printf(" "); 2391990b4856Slling } else { 2392990b4856Slling first = B_FALSE; 2393fa9e4066Sahrens } 2394fa9e4066Sahrens 2395990b4856Slling right_justify = B_FALSE; 2396990b4856Slling if (pl->pl_prop != ZPROP_INVAL) { 2397990b4856Slling if (zpool_get_prop(zhp, pl->pl_prop, property, 2398990b4856Slling sizeof (property), NULL) != 0) 2399990b4856Slling propstr = "-"; 2400fa9e4066Sahrens else 2401990b4856Slling propstr = property; 2402fa9e4066Sahrens 2403990b4856Slling right_justify = zpool_prop_align_right(pl->pl_prop); 2404990b4856Slling } else { 2405990b4856Slling propstr = "-"; 2406990b4856Slling } 2407fa9e4066Sahrens 2408990b4856Slling width = pl->pl_width; 2409fa9e4066Sahrens 2410990b4856Slling /* 2411990b4856Slling * If this is being called in scripted mode, or if this is the 2412990b4856Slling * last column and it is left-justified, don't include a width 2413990b4856Slling * format specifier. 2414990b4856Slling */ 2415990b4856Slling if (scripted || (pl->pl_next == NULL && !right_justify)) 2416990b4856Slling (void) printf("%s", propstr); 2417990b4856Slling else if (right_justify) 2418990b4856Slling (void) printf("%*s", width, propstr); 2419990b4856Slling else 2420990b4856Slling (void) printf("%-*s", width, propstr); 2421990b4856Slling } 2422fa9e4066Sahrens 2423990b4856Slling (void) printf("\n"); 2424990b4856Slling } 2425fa9e4066Sahrens 2426990b4856Slling /* 2427990b4856Slling * Generic callback function to list a pool. 2428990b4856Slling */ 2429990b4856Slling int 2430990b4856Slling list_callback(zpool_handle_t *zhp, void *data) 2431990b4856Slling { 2432990b4856Slling list_cbdata_t *cbp = data; 2433fa9e4066Sahrens 2434990b4856Slling if (cbp->cb_first) { 2435990b4856Slling if (!cbp->cb_scripted) 2436990b4856Slling print_header(cbp->cb_proplist); 2437990b4856Slling cbp->cb_first = B_FALSE; 2438fa9e4066Sahrens } 2439fa9e4066Sahrens 2440990b4856Slling print_pool(zhp, cbp->cb_proplist, cbp->cb_scripted); 2441fa9e4066Sahrens 2442fa9e4066Sahrens return (0); 2443fa9e4066Sahrens } 2444fa9e4066Sahrens 2445fa9e4066Sahrens /* 2446990b4856Slling * zpool list [-H] [-o prop[,prop]*] [pool] ... 2447fa9e4066Sahrens * 2448990b4856Slling * -H Scripted mode. Don't display headers, and separate properties 2449990b4856Slling * by a single tab. 2450990b4856Slling * -o List of properties to display. Defaults to 2451485bbbf5SGeorge Wilson * "name,size,allocated,free,capacity,health,altroot" 2452fa9e4066Sahrens * 2453fa9e4066Sahrens * List all pools in the system, whether or not they're healthy. Output space 2454fa9e4066Sahrens * statistics for each one, as well as health status summary. 2455fa9e4066Sahrens */ 2456fa9e4066Sahrens int 2457fa9e4066Sahrens zpool_do_list(int argc, char **argv) 2458fa9e4066Sahrens { 2459fa9e4066Sahrens int c; 2460fa9e4066Sahrens int ret; 2461fa9e4066Sahrens list_cbdata_t cb = { 0 }; 2462990b4856Slling static char default_props[] = 2463485bbbf5SGeorge Wilson "name,size,allocated,free,capacity,dedupratio,health,altroot"; 2464990b4856Slling char *props = default_props; 2465fa9e4066Sahrens 2466fa9e4066Sahrens /* check options */ 2467fa9e4066Sahrens while ((c = getopt(argc, argv, ":Ho:")) != -1) { 2468fa9e4066Sahrens switch (c) { 2469fa9e4066Sahrens case 'H': 247099653d4eSeschrock cb.cb_scripted = B_TRUE; 2471fa9e4066Sahrens break; 2472fa9e4066Sahrens case 'o': 2473990b4856Slling props = optarg; 2474fa9e4066Sahrens break; 2475fa9e4066Sahrens case ':': 2476fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2477fa9e4066Sahrens "'%c' option\n"), optopt); 247899653d4eSeschrock usage(B_FALSE); 2479fa9e4066Sahrens break; 2480fa9e4066Sahrens case '?': 2481fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2482fa9e4066Sahrens optopt); 248399653d4eSeschrock usage(B_FALSE); 2484fa9e4066Sahrens } 2485fa9e4066Sahrens } 2486fa9e4066Sahrens 2487fa9e4066Sahrens argc -= optind; 2488fa9e4066Sahrens argv += optind; 2489fa9e4066Sahrens 2490990b4856Slling if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0) 2491990b4856Slling usage(B_FALSE); 2492fa9e4066Sahrens 249399653d4eSeschrock cb.cb_first = B_TRUE; 2494fa9e4066Sahrens 2495990b4856Slling ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist, 2496990b4856Slling list_callback, &cb); 2497990b4856Slling 2498990b4856Slling zprop_free_list(cb.cb_proplist); 2499fa9e4066Sahrens 2500fce7d82bSmmusante if (argc == 0 && cb.cb_first && !cb.cb_scripted) { 2501fa9e4066Sahrens (void) printf(gettext("no pools available\n")); 2502fa9e4066Sahrens return (0); 2503fa9e4066Sahrens } 2504fa9e4066Sahrens 2505fa9e4066Sahrens return (ret); 2506fa9e4066Sahrens } 2507fa9e4066Sahrens 2508fa9e4066Sahrens static nvlist_t * 2509fa9e4066Sahrens zpool_get_vdev_by_name(nvlist_t *nv, char *name) 2510fa9e4066Sahrens { 2511fa9e4066Sahrens nvlist_t **child; 2512fa9e4066Sahrens uint_t c, children; 2513fa9e4066Sahrens nvlist_t *match; 2514fa9e4066Sahrens char *path; 2515fa9e4066Sahrens 2516fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2517fa9e4066Sahrens &child, &children) != 0) { 2518fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 2519fa9e4066Sahrens if (strncmp(name, "/dev/dsk/", 9) == 0) 2520fa9e4066Sahrens name += 9; 2521fa9e4066Sahrens if (strncmp(path, "/dev/dsk/", 9) == 0) 2522fa9e4066Sahrens path += 9; 2523fa9e4066Sahrens if (strcmp(name, path) == 0) 2524fa9e4066Sahrens return (nv); 2525fa9e4066Sahrens return (NULL); 2526fa9e4066Sahrens } 2527fa9e4066Sahrens 2528fa9e4066Sahrens for (c = 0; c < children; c++) 2529fa9e4066Sahrens if ((match = zpool_get_vdev_by_name(child[c], name)) != NULL) 2530fa9e4066Sahrens return (match); 2531fa9e4066Sahrens 2532fa9e4066Sahrens return (NULL); 2533fa9e4066Sahrens } 2534fa9e4066Sahrens 2535fa9e4066Sahrens static int 2536fa9e4066Sahrens zpool_do_attach_or_replace(int argc, char **argv, int replacing) 2537fa9e4066Sahrens { 253899653d4eSeschrock boolean_t force = B_FALSE; 2539fa9e4066Sahrens int c; 2540fa9e4066Sahrens nvlist_t *nvroot; 2541fa9e4066Sahrens char *poolname, *old_disk, *new_disk; 2542fa9e4066Sahrens zpool_handle_t *zhp; 254399653d4eSeschrock int ret; 2544fa9e4066Sahrens 2545fa9e4066Sahrens /* check options */ 2546fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2547fa9e4066Sahrens switch (c) { 2548fa9e4066Sahrens case 'f': 254999653d4eSeschrock force = B_TRUE; 2550fa9e4066Sahrens break; 2551fa9e4066Sahrens case '?': 2552fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2553fa9e4066Sahrens optopt); 255499653d4eSeschrock usage(B_FALSE); 2555fa9e4066Sahrens } 2556fa9e4066Sahrens } 2557fa9e4066Sahrens 2558fa9e4066Sahrens argc -= optind; 2559fa9e4066Sahrens argv += optind; 2560fa9e4066Sahrens 2561fa9e4066Sahrens /* get pool name and check number of arguments */ 2562fa9e4066Sahrens if (argc < 1) { 2563fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 256499653d4eSeschrock usage(B_FALSE); 2565fa9e4066Sahrens } 2566fa9e4066Sahrens 2567fa9e4066Sahrens poolname = argv[0]; 2568fa9e4066Sahrens 2569fa9e4066Sahrens if (argc < 2) { 2570fa9e4066Sahrens (void) fprintf(stderr, 2571fa9e4066Sahrens gettext("missing <device> specification\n")); 257299653d4eSeschrock usage(B_FALSE); 2573fa9e4066Sahrens } 2574fa9e4066Sahrens 2575fa9e4066Sahrens old_disk = argv[1]; 2576fa9e4066Sahrens 2577fa9e4066Sahrens if (argc < 3) { 2578fa9e4066Sahrens if (!replacing) { 2579fa9e4066Sahrens (void) fprintf(stderr, 2580fa9e4066Sahrens gettext("missing <new_device> specification\n")); 258199653d4eSeschrock usage(B_FALSE); 2582fa9e4066Sahrens } 2583fa9e4066Sahrens new_disk = old_disk; 2584fa9e4066Sahrens argc -= 1; 2585fa9e4066Sahrens argv += 1; 2586fa9e4066Sahrens } else { 2587fa9e4066Sahrens new_disk = argv[2]; 2588fa9e4066Sahrens argc -= 2; 2589fa9e4066Sahrens argv += 2; 2590fa9e4066Sahrens } 2591fa9e4066Sahrens 2592fa9e4066Sahrens if (argc > 1) { 2593fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 259499653d4eSeschrock usage(B_FALSE); 2595fa9e4066Sahrens } 2596fa9e4066Sahrens 259799653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2598fa9e4066Sahrens return (1); 2599fa9e4066Sahrens 26008488aeb5Staylor if (zpool_get_config(zhp, NULL) == NULL) { 2601fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 2602fa9e4066Sahrens poolname); 2603fa9e4066Sahrens zpool_close(zhp); 2604fa9e4066Sahrens return (1); 2605fa9e4066Sahrens } 2606fa9e4066Sahrens 2607705040edSEric Taylor nvroot = make_root_vdev(zhp, force, B_FALSE, replacing, B_FALSE, 2608705040edSEric Taylor argc, argv); 2609fa9e4066Sahrens if (nvroot == NULL) { 2610fa9e4066Sahrens zpool_close(zhp); 2611fa9e4066Sahrens return (1); 2612fa9e4066Sahrens } 2613fa9e4066Sahrens 261499653d4eSeschrock ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing); 261599653d4eSeschrock 261699653d4eSeschrock nvlist_free(nvroot); 261799653d4eSeschrock zpool_close(zhp); 261899653d4eSeschrock 261999653d4eSeschrock return (ret); 2620fa9e4066Sahrens } 2621fa9e4066Sahrens 2622fa9e4066Sahrens /* 2623fa9e4066Sahrens * zpool replace [-f] <pool> <device> <new_device> 2624fa9e4066Sahrens * 2625fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 2626fa9e4066Sahrens * 2627fa9e4066Sahrens * Replace <device> with <new_device>. 2628fa9e4066Sahrens */ 2629fa9e4066Sahrens /* ARGSUSED */ 2630fa9e4066Sahrens int 2631fa9e4066Sahrens zpool_do_replace(int argc, char **argv) 2632fa9e4066Sahrens { 2633fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_TRUE)); 2634fa9e4066Sahrens } 2635fa9e4066Sahrens 2636fa9e4066Sahrens /* 2637fa9e4066Sahrens * zpool attach [-f] <pool> <device> <new_device> 2638fa9e4066Sahrens * 2639fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 2640fa9e4066Sahrens * 2641fa9e4066Sahrens * Attach <new_device> to the mirror containing <device>. If <device> is not 2642fa9e4066Sahrens * part of a mirror, then <device> will be transformed into a mirror of 2643fa9e4066Sahrens * <device> and <new_device>. In either case, <new_device> will begin life 2644fa9e4066Sahrens * with a DTL of [0, now], and will immediately begin to resilver itself. 2645fa9e4066Sahrens */ 2646fa9e4066Sahrens int 2647fa9e4066Sahrens zpool_do_attach(int argc, char **argv) 2648fa9e4066Sahrens { 2649fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_FALSE)); 2650fa9e4066Sahrens } 2651fa9e4066Sahrens 2652fa9e4066Sahrens /* 2653fa9e4066Sahrens * zpool detach [-f] <pool> <device> 2654fa9e4066Sahrens * 2655fa9e4066Sahrens * -f Force detach of <device>, even if DTLs argue against it 2656fa9e4066Sahrens * (not supported yet) 2657fa9e4066Sahrens * 2658fa9e4066Sahrens * Detach a device from a mirror. The operation will be refused if <device> 2659fa9e4066Sahrens * is the last device in the mirror, or if the DTLs indicate that this device 2660fa9e4066Sahrens * has the only valid copy of some data. 2661fa9e4066Sahrens */ 2662fa9e4066Sahrens /* ARGSUSED */ 2663fa9e4066Sahrens int 2664fa9e4066Sahrens zpool_do_detach(int argc, char **argv) 2665fa9e4066Sahrens { 2666fa9e4066Sahrens int c; 2667fa9e4066Sahrens char *poolname, *path; 2668fa9e4066Sahrens zpool_handle_t *zhp; 266999653d4eSeschrock int ret; 2670fa9e4066Sahrens 2671fa9e4066Sahrens /* check options */ 2672fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2673fa9e4066Sahrens switch (c) { 2674fa9e4066Sahrens case 'f': 2675fa9e4066Sahrens case '?': 2676fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2677fa9e4066Sahrens optopt); 267899653d4eSeschrock usage(B_FALSE); 2679fa9e4066Sahrens } 2680fa9e4066Sahrens } 2681fa9e4066Sahrens 2682fa9e4066Sahrens argc -= optind; 2683fa9e4066Sahrens argv += optind; 2684fa9e4066Sahrens 2685fa9e4066Sahrens /* get pool name and check number of arguments */ 2686fa9e4066Sahrens if (argc < 1) { 2687fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 268899653d4eSeschrock usage(B_FALSE); 2689fa9e4066Sahrens } 2690fa9e4066Sahrens 2691fa9e4066Sahrens if (argc < 2) { 2692fa9e4066Sahrens (void) fprintf(stderr, 2693fa9e4066Sahrens gettext("missing <device> specification\n")); 269499653d4eSeschrock usage(B_FALSE); 2695fa9e4066Sahrens } 2696fa9e4066Sahrens 2697fa9e4066Sahrens poolname = argv[0]; 2698fa9e4066Sahrens path = argv[1]; 2699fa9e4066Sahrens 270099653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2701fa9e4066Sahrens return (1); 2702fa9e4066Sahrens 270399653d4eSeschrock ret = zpool_vdev_detach(zhp, path); 270499653d4eSeschrock 270599653d4eSeschrock zpool_close(zhp); 270699653d4eSeschrock 270799653d4eSeschrock return (ret); 2708fa9e4066Sahrens } 2709fa9e4066Sahrens 2710*1195e687SMark J Musante /* 2711*1195e687SMark J Musante * zpool split [-n] [-o prop=val] ... 2712*1195e687SMark J Musante * [-o mntopt] ... 2713*1195e687SMark J Musante * [-R altroot] <pool> <newpool> [<device> ...] 2714*1195e687SMark J Musante * 2715*1195e687SMark J Musante * -n Do not split the pool, but display the resulting layout if 2716*1195e687SMark J Musante * it were to be split. 2717*1195e687SMark J Musante * -o Set property=value, or set mount options. 2718*1195e687SMark J Musante * -R Mount the split-off pool under an alternate root. 2719*1195e687SMark J Musante * 2720*1195e687SMark J Musante * Splits the named pool and gives it the new pool name. Devices to be split 2721*1195e687SMark J Musante * off may be listed, provided that no more than one device is specified 2722*1195e687SMark J Musante * per top-level vdev mirror. The newly split pool is left in an exported 2723*1195e687SMark J Musante * state unless -R is specified. 2724*1195e687SMark J Musante * 2725*1195e687SMark J Musante * Restrictions: the top-level of the pool pool must only be made up of 2726*1195e687SMark J Musante * mirrors; all devices in the pool must be healthy; no device may be 2727*1195e687SMark J Musante * undergoing a resilvering operation. 2728*1195e687SMark J Musante */ 2729*1195e687SMark J Musante int 2730*1195e687SMark J Musante zpool_do_split(int argc, char **argv) 2731*1195e687SMark J Musante { 2732*1195e687SMark J Musante char *srcpool, *newpool, *propval; 2733*1195e687SMark J Musante char *mntopts = NULL; 2734*1195e687SMark J Musante splitflags_t flags; 2735*1195e687SMark J Musante int c, ret = 0; 2736*1195e687SMark J Musante zpool_handle_t *zhp; 2737*1195e687SMark J Musante nvlist_t *config, *props = NULL; 2738*1195e687SMark J Musante 2739*1195e687SMark J Musante flags.dryrun = B_FALSE; 2740*1195e687SMark J Musante flags.import = B_FALSE; 2741*1195e687SMark J Musante 2742*1195e687SMark J Musante /* check options */ 2743*1195e687SMark J Musante while ((c = getopt(argc, argv, ":R:no:")) != -1) { 2744*1195e687SMark J Musante switch (c) { 2745*1195e687SMark J Musante case 'R': 2746*1195e687SMark J Musante flags.import = B_TRUE; 2747*1195e687SMark J Musante if (add_prop_list( 2748*1195e687SMark J Musante zpool_prop_to_name(ZPOOL_PROP_ALTROOT), optarg, 2749*1195e687SMark J Musante &props, B_TRUE) != 0) { 2750*1195e687SMark J Musante if (props) 2751*1195e687SMark J Musante nvlist_free(props); 2752*1195e687SMark J Musante usage(B_FALSE); 2753*1195e687SMark J Musante } 2754*1195e687SMark J Musante break; 2755*1195e687SMark J Musante case 'n': 2756*1195e687SMark J Musante flags.dryrun = B_TRUE; 2757*1195e687SMark J Musante break; 2758*1195e687SMark J Musante case 'o': 2759*1195e687SMark J Musante if ((propval = strchr(optarg, '=')) != NULL) { 2760*1195e687SMark J Musante *propval = '\0'; 2761*1195e687SMark J Musante propval++; 2762*1195e687SMark J Musante if (add_prop_list(optarg, propval, 2763*1195e687SMark J Musante &props, B_TRUE) != 0) { 2764*1195e687SMark J Musante if (props) 2765*1195e687SMark J Musante nvlist_free(props); 2766*1195e687SMark J Musante usage(B_FALSE); 2767*1195e687SMark J Musante } 2768*1195e687SMark J Musante } else { 2769*1195e687SMark J Musante mntopts = optarg; 2770*1195e687SMark J Musante } 2771*1195e687SMark J Musante break; 2772*1195e687SMark J Musante case ':': 2773*1195e687SMark J Musante (void) fprintf(stderr, gettext("missing argument for " 2774*1195e687SMark J Musante "'%c' option\n"), optopt); 2775*1195e687SMark J Musante usage(B_FALSE); 2776*1195e687SMark J Musante break; 2777*1195e687SMark J Musante case '?': 2778*1195e687SMark J Musante (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2779*1195e687SMark J Musante optopt); 2780*1195e687SMark J Musante usage(B_FALSE); 2781*1195e687SMark J Musante break; 2782*1195e687SMark J Musante } 2783*1195e687SMark J Musante } 2784*1195e687SMark J Musante 2785*1195e687SMark J Musante if (!flags.import && mntopts != NULL) { 2786*1195e687SMark J Musante (void) fprintf(stderr, gettext("setting mntopts is only " 2787*1195e687SMark J Musante "valid when importing the pool\n")); 2788*1195e687SMark J Musante usage(B_FALSE); 2789*1195e687SMark J Musante } 2790*1195e687SMark J Musante 2791*1195e687SMark J Musante argc -= optind; 2792*1195e687SMark J Musante argv += optind; 2793*1195e687SMark J Musante 2794*1195e687SMark J Musante if (argc < 1) { 2795*1195e687SMark J Musante (void) fprintf(stderr, gettext("Missing pool name\n")); 2796*1195e687SMark J Musante usage(B_FALSE); 2797*1195e687SMark J Musante } 2798*1195e687SMark J Musante if (argc < 2) { 2799*1195e687SMark J Musante (void) fprintf(stderr, gettext("Missing new pool name\n")); 2800*1195e687SMark J Musante usage(B_FALSE); 2801*1195e687SMark J Musante } 2802*1195e687SMark J Musante 2803*1195e687SMark J Musante srcpool = argv[0]; 2804*1195e687SMark J Musante newpool = argv[1]; 2805*1195e687SMark J Musante 2806*1195e687SMark J Musante argc -= 2; 2807*1195e687SMark J Musante argv += 2; 2808*1195e687SMark J Musante 2809*1195e687SMark J Musante if ((zhp = zpool_open(g_zfs, srcpool)) == NULL) 2810*1195e687SMark J Musante return (1); 2811*1195e687SMark J Musante 2812*1195e687SMark J Musante config = split_mirror_vdev(zhp, newpool, props, flags, argc, argv); 2813*1195e687SMark J Musante if (config == NULL) { 2814*1195e687SMark J Musante ret = 1; 2815*1195e687SMark J Musante } else { 2816*1195e687SMark J Musante if (flags.dryrun) { 2817*1195e687SMark J Musante (void) printf(gettext("would create '%s' with the " 2818*1195e687SMark J Musante "following layout:\n\n"), newpool); 2819*1195e687SMark J Musante print_vdev_tree(NULL, newpool, config, 0, B_FALSE); 2820*1195e687SMark J Musante } 2821*1195e687SMark J Musante nvlist_free(config); 2822*1195e687SMark J Musante } 2823*1195e687SMark J Musante 2824*1195e687SMark J Musante zpool_close(zhp); 2825*1195e687SMark J Musante 2826*1195e687SMark J Musante if (ret != 0 || flags.dryrun || !flags.import) 2827*1195e687SMark J Musante return (ret); 2828*1195e687SMark J Musante 2829*1195e687SMark J Musante /* 2830*1195e687SMark J Musante * The split was successful. Now we need to open the new 2831*1195e687SMark J Musante * pool and import it. 2832*1195e687SMark J Musante */ 2833*1195e687SMark J Musante if ((zhp = zpool_open_canfail(g_zfs, newpool)) == NULL) 2834*1195e687SMark J Musante return (1); 2835*1195e687SMark J Musante if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 2836*1195e687SMark J Musante zpool_enable_datasets(zhp, mntopts, 0) != 0) { 2837*1195e687SMark J Musante ret = 1; 2838*1195e687SMark J Musante (void) fprintf(stderr, gettext("Split was succssful, but " 2839*1195e687SMark J Musante "the datasets could not all be mounted\n")); 2840*1195e687SMark J Musante (void) fprintf(stderr, gettext("Try doing '%s' with a " 2841*1195e687SMark J Musante "different altroot\n"), "zpool import"); 2842*1195e687SMark J Musante } 2843*1195e687SMark J Musante zpool_close(zhp); 2844*1195e687SMark J Musante 2845*1195e687SMark J Musante return (ret); 2846*1195e687SMark J Musante } 2847*1195e687SMark J Musante 2848*1195e687SMark J Musante 2849*1195e687SMark J Musante 2850fa9e4066Sahrens /* 2851441d80aaSlling * zpool online <pool> <device> ... 2852fa9e4066Sahrens */ 2853fa9e4066Sahrens int 2854fa9e4066Sahrens zpool_do_online(int argc, char **argv) 2855fa9e4066Sahrens { 2856fa9e4066Sahrens int c, i; 2857fa9e4066Sahrens char *poolname; 2858fa9e4066Sahrens zpool_handle_t *zhp; 2859fa9e4066Sahrens int ret = 0; 28603d7072f8Seschrock vdev_state_t newstate; 2861573ca77eSGeorge Wilson int flags = 0; 2862fa9e4066Sahrens 2863fa9e4066Sahrens /* check options */ 2864573ca77eSGeorge Wilson while ((c = getopt(argc, argv, "et")) != -1) { 2865fa9e4066Sahrens switch (c) { 2866573ca77eSGeorge Wilson case 'e': 2867573ca77eSGeorge Wilson flags |= ZFS_ONLINE_EXPAND; 2868573ca77eSGeorge Wilson break; 2869fa9e4066Sahrens case 't': 2870fa9e4066Sahrens case '?': 2871fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2872fa9e4066Sahrens optopt); 287399653d4eSeschrock usage(B_FALSE); 2874fa9e4066Sahrens } 2875fa9e4066Sahrens } 2876fa9e4066Sahrens 2877fa9e4066Sahrens argc -= optind; 2878fa9e4066Sahrens argv += optind; 2879fa9e4066Sahrens 2880fa9e4066Sahrens /* get pool name and check number of arguments */ 2881fa9e4066Sahrens if (argc < 1) { 2882fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 288399653d4eSeschrock usage(B_FALSE); 2884fa9e4066Sahrens } 2885fa9e4066Sahrens if (argc < 2) { 2886fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 288799653d4eSeschrock usage(B_FALSE); 2888fa9e4066Sahrens } 2889fa9e4066Sahrens 2890fa9e4066Sahrens poolname = argv[0]; 2891fa9e4066Sahrens 289299653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2893fa9e4066Sahrens return (1); 2894fa9e4066Sahrens 28953d7072f8Seschrock for (i = 1; i < argc; i++) { 2896573ca77eSGeorge Wilson if (zpool_vdev_online(zhp, argv[i], flags, &newstate) == 0) { 28973d7072f8Seschrock if (newstate != VDEV_STATE_HEALTHY) { 28983d7072f8Seschrock (void) printf(gettext("warning: device '%s' " 28993d7072f8Seschrock "onlined, but remains in faulted state\n"), 29003d7072f8Seschrock argv[i]); 29013d7072f8Seschrock if (newstate == VDEV_STATE_FAULTED) 29023d7072f8Seschrock (void) printf(gettext("use 'zpool " 29033d7072f8Seschrock "clear' to restore a faulted " 29043d7072f8Seschrock "device\n")); 29053d7072f8Seschrock else 29063d7072f8Seschrock (void) printf(gettext("use 'zpool " 29073d7072f8Seschrock "replace' to replace devices " 29083d7072f8Seschrock "that are no longer present\n")); 29093d7072f8Seschrock } 29103d7072f8Seschrock } else { 2911fa9e4066Sahrens ret = 1; 29123d7072f8Seschrock } 29133d7072f8Seschrock } 2914fa9e4066Sahrens 291599653d4eSeschrock zpool_close(zhp); 291699653d4eSeschrock 2917fa9e4066Sahrens return (ret); 2918fa9e4066Sahrens } 2919fa9e4066Sahrens 2920fa9e4066Sahrens /* 2921441d80aaSlling * zpool offline [-ft] <pool> <device> ... 2922fa9e4066Sahrens * 2923fa9e4066Sahrens * -f Force the device into the offline state, even if doing 2924fa9e4066Sahrens * so would appear to compromise pool availability. 2925fa9e4066Sahrens * (not supported yet) 2926fa9e4066Sahrens * 2927fa9e4066Sahrens * -t Only take the device off-line temporarily. The offline 2928fa9e4066Sahrens * state will not be persistent across reboots. 2929fa9e4066Sahrens */ 2930fa9e4066Sahrens /* ARGSUSED */ 2931fa9e4066Sahrens int 2932fa9e4066Sahrens zpool_do_offline(int argc, char **argv) 2933fa9e4066Sahrens { 2934fa9e4066Sahrens int c, i; 2935fa9e4066Sahrens char *poolname; 2936fa9e4066Sahrens zpool_handle_t *zhp; 293799653d4eSeschrock int ret = 0; 293899653d4eSeschrock boolean_t istmp = B_FALSE; 2939fa9e4066Sahrens 2940fa9e4066Sahrens /* check options */ 2941fa9e4066Sahrens while ((c = getopt(argc, argv, "ft")) != -1) { 2942fa9e4066Sahrens switch (c) { 2943fa9e4066Sahrens case 't': 294499653d4eSeschrock istmp = B_TRUE; 2945441d80aaSlling break; 2946441d80aaSlling case 'f': 2947fa9e4066Sahrens case '?': 2948fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2949fa9e4066Sahrens optopt); 295099653d4eSeschrock usage(B_FALSE); 2951fa9e4066Sahrens } 2952fa9e4066Sahrens } 2953fa9e4066Sahrens 2954fa9e4066Sahrens argc -= optind; 2955fa9e4066Sahrens argv += optind; 2956fa9e4066Sahrens 2957fa9e4066Sahrens /* get pool name and check number of arguments */ 2958fa9e4066Sahrens if (argc < 1) { 2959fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 296099653d4eSeschrock usage(B_FALSE); 2961fa9e4066Sahrens } 2962fa9e4066Sahrens if (argc < 2) { 2963fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 296499653d4eSeschrock usage(B_FALSE); 2965fa9e4066Sahrens } 2966fa9e4066Sahrens 2967fa9e4066Sahrens poolname = argv[0]; 2968fa9e4066Sahrens 296999653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2970fa9e4066Sahrens return (1); 2971fa9e4066Sahrens 29723d7072f8Seschrock for (i = 1; i < argc; i++) { 29733d7072f8Seschrock if (zpool_vdev_offline(zhp, argv[i], istmp) != 0) 2974fa9e4066Sahrens ret = 1; 29753d7072f8Seschrock } 2976fa9e4066Sahrens 297799653d4eSeschrock zpool_close(zhp); 297899653d4eSeschrock 2979fa9e4066Sahrens return (ret); 2980fa9e4066Sahrens } 2981fa9e4066Sahrens 2982ea8dc4b6Seschrock /* 2983ea8dc4b6Seschrock * zpool clear <pool> [device] 2984ea8dc4b6Seschrock * 2985ea8dc4b6Seschrock * Clear all errors associated with a pool or a particular device. 2986ea8dc4b6Seschrock */ 2987ea8dc4b6Seschrock int 2988ea8dc4b6Seschrock zpool_do_clear(int argc, char **argv) 2989ea8dc4b6Seschrock { 2990468c413aSTim Haley int c; 2991ea8dc4b6Seschrock int ret = 0; 2992468c413aSTim Haley boolean_t dryrun = B_FALSE; 2993468c413aSTim Haley boolean_t do_rewind = B_FALSE; 2994468c413aSTim Haley boolean_t xtreme_rewind = B_FALSE; 2995468c413aSTim Haley uint32_t rewind_policy = ZPOOL_NO_REWIND; 2996468c413aSTim Haley nvlist_t *policy = NULL; 2997ea8dc4b6Seschrock zpool_handle_t *zhp; 2998ea8dc4b6Seschrock char *pool, *device; 2999ea8dc4b6Seschrock 3000468c413aSTim Haley /* check options */ 3001468c413aSTim Haley while ((c = getopt(argc, argv, "FnX")) != -1) { 3002468c413aSTim Haley switch (c) { 3003468c413aSTim Haley case 'F': 3004468c413aSTim Haley do_rewind = B_TRUE; 3005468c413aSTim Haley break; 3006468c413aSTim Haley case 'n': 3007468c413aSTim Haley dryrun = B_TRUE; 3008468c413aSTim Haley break; 3009468c413aSTim Haley case 'X': 3010468c413aSTim Haley xtreme_rewind = B_TRUE; 3011468c413aSTim Haley break; 3012468c413aSTim Haley case '?': 3013468c413aSTim Haley (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3014468c413aSTim Haley optopt); 3015468c413aSTim Haley usage(B_FALSE); 3016468c413aSTim Haley } 3017468c413aSTim Haley } 3018468c413aSTim Haley 3019468c413aSTim Haley argc -= optind; 3020468c413aSTim Haley argv += optind; 3021468c413aSTim Haley 3022468c413aSTim Haley if (argc < 1) { 3023ea8dc4b6Seschrock (void) fprintf(stderr, gettext("missing pool name\n")); 302499653d4eSeschrock usage(B_FALSE); 3025ea8dc4b6Seschrock } 3026ea8dc4b6Seschrock 3027468c413aSTim Haley if (argc > 2) { 3028ea8dc4b6Seschrock (void) fprintf(stderr, gettext("too many arguments\n")); 302999653d4eSeschrock usage(B_FALSE); 3030ea8dc4b6Seschrock } 3031ea8dc4b6Seschrock 3032468c413aSTim Haley if ((dryrun || xtreme_rewind) && !do_rewind) { 3033468c413aSTim Haley (void) fprintf(stderr, 3034468c413aSTim Haley gettext("-n or -X only meaningful with -F\n")); 3035468c413aSTim Haley usage(B_FALSE); 3036468c413aSTim Haley } 3037468c413aSTim Haley if (dryrun) 3038468c413aSTim Haley rewind_policy = ZPOOL_TRY_REWIND; 3039468c413aSTim Haley else if (do_rewind) 3040468c413aSTim Haley rewind_policy = ZPOOL_DO_REWIND; 3041468c413aSTim Haley if (xtreme_rewind) 3042468c413aSTim Haley rewind_policy |= ZPOOL_EXTREME_REWIND; 3043468c413aSTim Haley 3044468c413aSTim Haley /* In future, further rewind policy choices can be passed along here */ 3045468c413aSTim Haley if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 3046468c413aSTim Haley nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) 3047468c413aSTim Haley return (1); 3048468c413aSTim Haley 3049468c413aSTim Haley pool = argv[0]; 3050468c413aSTim Haley device = argc == 2 ? argv[1] : NULL; 3051ea8dc4b6Seschrock 3052468c413aSTim Haley if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 3053468c413aSTim Haley nvlist_free(policy); 3054ea8dc4b6Seschrock return (1); 3055468c413aSTim Haley } 3056ea8dc4b6Seschrock 3057468c413aSTim Haley if (zpool_clear(zhp, device, policy) != 0) 3058ea8dc4b6Seschrock ret = 1; 3059ea8dc4b6Seschrock 3060ea8dc4b6Seschrock zpool_close(zhp); 3061ea8dc4b6Seschrock 3062468c413aSTim Haley nvlist_free(policy); 3063468c413aSTim Haley 3064ea8dc4b6Seschrock return (ret); 3065ea8dc4b6Seschrock } 3066ea8dc4b6Seschrock 3067fa9e4066Sahrens typedef struct scrub_cbdata { 3068fa9e4066Sahrens int cb_type; 306906eeb2adSek int cb_argc; 307006eeb2adSek char **cb_argv; 3071fa9e4066Sahrens } scrub_cbdata_t; 3072fa9e4066Sahrens 3073fa9e4066Sahrens int 3074fa9e4066Sahrens scrub_callback(zpool_handle_t *zhp, void *data) 3075fa9e4066Sahrens { 3076fa9e4066Sahrens scrub_cbdata_t *cb = data; 307706eeb2adSek int err; 3078fa9e4066Sahrens 3079ea8dc4b6Seschrock /* 3080ea8dc4b6Seschrock * Ignore faulted pools. 3081ea8dc4b6Seschrock */ 3082ea8dc4b6Seschrock if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 3083ea8dc4b6Seschrock (void) fprintf(stderr, gettext("cannot scrub '%s': pool is " 3084ea8dc4b6Seschrock "currently unavailable\n"), zpool_get_name(zhp)); 3085ea8dc4b6Seschrock return (1); 3086ea8dc4b6Seschrock } 3087ea8dc4b6Seschrock 308806eeb2adSek err = zpool_scrub(zhp, cb->cb_type); 308906eeb2adSek 309006eeb2adSek return (err != 0); 3091fa9e4066Sahrens } 3092fa9e4066Sahrens 3093fa9e4066Sahrens /* 3094fa9e4066Sahrens * zpool scrub [-s] <pool> ... 3095fa9e4066Sahrens * 3096fa9e4066Sahrens * -s Stop. Stops any in-progress scrub. 3097fa9e4066Sahrens */ 3098fa9e4066Sahrens int 3099fa9e4066Sahrens zpool_do_scrub(int argc, char **argv) 3100fa9e4066Sahrens { 3101fa9e4066Sahrens int c; 3102fa9e4066Sahrens scrub_cbdata_t cb; 3103fa9e4066Sahrens 3104fa9e4066Sahrens cb.cb_type = POOL_SCRUB_EVERYTHING; 3105fa9e4066Sahrens 3106fa9e4066Sahrens /* check options */ 3107fa9e4066Sahrens while ((c = getopt(argc, argv, "s")) != -1) { 3108fa9e4066Sahrens switch (c) { 3109fa9e4066Sahrens case 's': 3110fa9e4066Sahrens cb.cb_type = POOL_SCRUB_NONE; 3111fa9e4066Sahrens break; 3112fa9e4066Sahrens case '?': 3113fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3114fa9e4066Sahrens optopt); 311599653d4eSeschrock usage(B_FALSE); 3116fa9e4066Sahrens } 3117fa9e4066Sahrens } 3118fa9e4066Sahrens 311906eeb2adSek cb.cb_argc = argc; 312006eeb2adSek cb.cb_argv = argv; 3121fa9e4066Sahrens argc -= optind; 3122fa9e4066Sahrens argv += optind; 3123fa9e4066Sahrens 3124fa9e4066Sahrens if (argc < 1) { 3125fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 312699653d4eSeschrock usage(B_FALSE); 3127fa9e4066Sahrens } 3128fa9e4066Sahrens 3129b1b8ab34Slling return (for_each_pool(argc, argv, B_TRUE, NULL, scrub_callback, &cb)); 3130fa9e4066Sahrens } 3131fa9e4066Sahrens 3132fa9e4066Sahrens typedef struct status_cbdata { 313399653d4eSeschrock int cb_count; 3134e9dbad6fSeschrock boolean_t cb_allpools; 313599653d4eSeschrock boolean_t cb_verbose; 313699653d4eSeschrock boolean_t cb_explain; 313799653d4eSeschrock boolean_t cb_first; 31389eb19f4dSGeorge Wilson boolean_t cb_dedup_stats; 3139fa9e4066Sahrens } status_cbdata_t; 3140fa9e4066Sahrens 3141fa9e4066Sahrens /* 3142fa9e4066Sahrens * Print out detailed scrub status. 3143fa9e4066Sahrens */ 3144fa9e4066Sahrens void 3145fa9e4066Sahrens print_scrub_status(nvlist_t *nvroot) 3146fa9e4066Sahrens { 3147fa9e4066Sahrens vdev_stat_t *vs; 3148fa9e4066Sahrens uint_t vsc; 3149fa9e4066Sahrens time_t start, end, now; 3150fa9e4066Sahrens double fraction_done; 315118ce54dfSek uint64_t examined, total, minutes_left, minutes_taken; 3152fa9e4066Sahrens char *scrub_type; 3153fa9e4066Sahrens 3154fa9e4066Sahrens verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 3155fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 3156fa9e4066Sahrens 3157fa9e4066Sahrens /* 3158fa9e4066Sahrens * If there's never been a scrub, there's not much to say. 3159fa9e4066Sahrens */ 3160fa9e4066Sahrens if (vs->vs_scrub_end == 0 && vs->vs_scrub_type == POOL_SCRUB_NONE) { 3161fa9e4066Sahrens (void) printf(gettext("none requested\n")); 3162fa9e4066Sahrens return; 3163fa9e4066Sahrens } 3164fa9e4066Sahrens 3165fa9e4066Sahrens scrub_type = (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ? 3166fa9e4066Sahrens "resilver" : "scrub"; 3167fa9e4066Sahrens 3168fa9e4066Sahrens start = vs->vs_scrub_start; 3169fa9e4066Sahrens end = vs->vs_scrub_end; 3170fa9e4066Sahrens now = time(NULL); 3171fa9e4066Sahrens examined = vs->vs_scrub_examined; 3172fa9e4066Sahrens total = vs->vs_alloc; 3173fa9e4066Sahrens 3174fa9e4066Sahrens if (end != 0) { 317518ce54dfSek minutes_taken = (uint64_t)((end - start) / 60); 317618ce54dfSek 317718ce54dfSek (void) printf(gettext("%s %s after %lluh%um with %llu errors " 317818ce54dfSek "on %s"), 3179fa9e4066Sahrens scrub_type, vs->vs_scrub_complete ? "completed" : "stopped", 318018ce54dfSek (u_longlong_t)(minutes_taken / 60), 318118ce54dfSek (uint_t)(minutes_taken % 60), 3182fa9e4066Sahrens (u_longlong_t)vs->vs_scrub_errors, ctime(&end)); 3183fa9e4066Sahrens return; 3184fa9e4066Sahrens } 3185fa9e4066Sahrens 3186fa9e4066Sahrens if (examined == 0) 3187fa9e4066Sahrens examined = 1; 3188fa9e4066Sahrens if (examined > total) 3189fa9e4066Sahrens total = examined; 3190fa9e4066Sahrens 3191fa9e4066Sahrens fraction_done = (double)examined / total; 3192fa9e4066Sahrens minutes_left = (uint64_t)((now - start) * 3193fa9e4066Sahrens (1 - fraction_done) / fraction_done / 60); 319418ce54dfSek minutes_taken = (uint64_t)((now - start) / 60); 3195fa9e4066Sahrens 319618ce54dfSek (void) printf(gettext("%s in progress for %lluh%um, %.2f%% done, " 319718ce54dfSek "%lluh%um to go\n"), 319818ce54dfSek scrub_type, (u_longlong_t)(minutes_taken / 60), 319918ce54dfSek (uint_t)(minutes_taken % 60), 100 * fraction_done, 3200fa9e4066Sahrens (u_longlong_t)(minutes_left / 60), (uint_t)(minutes_left % 60)); 3201fa9e4066Sahrens } 3202fa9e4066Sahrens 3203ea8dc4b6Seschrock static void 3204ea8dc4b6Seschrock print_error_log(zpool_handle_t *zhp) 3205ea8dc4b6Seschrock { 320675519f38Sek nvlist_t *nverrlist = NULL; 320755434c77Sek nvpair_t *elem; 320855434c77Sek char *pathname; 320955434c77Sek size_t len = MAXPATHLEN * 2; 3210ea8dc4b6Seschrock 321155434c77Sek if (zpool_get_errlog(zhp, &nverrlist) != 0) { 3212ea8dc4b6Seschrock (void) printf("errors: List of errors unavailable " 3213ea8dc4b6Seschrock "(insufficient privileges)\n"); 3214ea8dc4b6Seschrock return; 3215ea8dc4b6Seschrock } 3216ea8dc4b6Seschrock 321755434c77Sek (void) printf("errors: Permanent errors have been " 321855434c77Sek "detected in the following files:\n\n"); 3219ea8dc4b6Seschrock 322055434c77Sek pathname = safe_malloc(len); 322155434c77Sek elem = NULL; 322255434c77Sek while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) { 322355434c77Sek nvlist_t *nv; 322455434c77Sek uint64_t dsobj, obj; 322555434c77Sek 322655434c77Sek verify(nvpair_value_nvlist(elem, &nv) == 0); 322755434c77Sek verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET, 322855434c77Sek &dsobj) == 0); 322955434c77Sek verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT, 323055434c77Sek &obj) == 0); 323155434c77Sek zpool_obj_to_path(zhp, dsobj, obj, pathname, len); 323255434c77Sek (void) printf("%7s %s\n", "", pathname); 323355434c77Sek } 323455434c77Sek free(pathname); 323555434c77Sek nvlist_free(nverrlist); 3236ea8dc4b6Seschrock } 3237ea8dc4b6Seschrock 323899653d4eSeschrock static void 323999653d4eSeschrock print_spares(zpool_handle_t *zhp, nvlist_t **spares, uint_t nspares, 324099653d4eSeschrock int namewidth) 324199653d4eSeschrock { 324299653d4eSeschrock uint_t i; 324399653d4eSeschrock char *name; 324499653d4eSeschrock 324599653d4eSeschrock if (nspares == 0) 324699653d4eSeschrock return; 324799653d4eSeschrock 324899653d4eSeschrock (void) printf(gettext("\tspares\n")); 324999653d4eSeschrock 325099653d4eSeschrock for (i = 0; i < nspares; i++) { 325188ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, spares[i], B_FALSE); 325299653d4eSeschrock print_status_config(zhp, name, spares[i], 3253aa8cf21aSNeil Perrin namewidth, 2, B_TRUE); 325499653d4eSeschrock free(name); 325599653d4eSeschrock } 325699653d4eSeschrock } 325799653d4eSeschrock 3258fa94a07fSbrendan static void 3259fa94a07fSbrendan print_l2cache(zpool_handle_t *zhp, nvlist_t **l2cache, uint_t nl2cache, 3260fa94a07fSbrendan int namewidth) 3261fa94a07fSbrendan { 3262fa94a07fSbrendan uint_t i; 3263fa94a07fSbrendan char *name; 3264fa94a07fSbrendan 3265fa94a07fSbrendan if (nl2cache == 0) 3266fa94a07fSbrendan return; 3267fa94a07fSbrendan 3268fa94a07fSbrendan (void) printf(gettext("\tcache\n")); 3269fa94a07fSbrendan 3270fa94a07fSbrendan for (i = 0; i < nl2cache; i++) { 327188ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, l2cache[i], B_FALSE); 3272fa94a07fSbrendan print_status_config(zhp, name, l2cache[i], 3273aa8cf21aSNeil Perrin namewidth, 2, B_FALSE); 3274aa8cf21aSNeil Perrin free(name); 3275aa8cf21aSNeil Perrin } 3276aa8cf21aSNeil Perrin } 3277aa8cf21aSNeil Perrin 32789eb19f4dSGeorge Wilson static void 32799eb19f4dSGeorge Wilson print_dedup_stats(nvlist_t *config) 32809eb19f4dSGeorge Wilson { 32819eb19f4dSGeorge Wilson ddt_histogram_t *ddh; 32829eb19f4dSGeorge Wilson ddt_stat_t *dds; 32839eb19f4dSGeorge Wilson ddt_object_t *ddo; 32849eb19f4dSGeorge Wilson uint_t c; 32859eb19f4dSGeorge Wilson 32869eb19f4dSGeorge Wilson /* 32879eb19f4dSGeorge Wilson * If the pool was faulted then we may not have been able to 32889eb19f4dSGeorge Wilson * obtain the config. Otherwise, if have anything in the dedup 32899eb19f4dSGeorge Wilson * table continue processing the stats. 32909eb19f4dSGeorge Wilson */ 32919eb19f4dSGeorge Wilson if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_OBJ_STATS, 32929eb19f4dSGeorge Wilson (uint64_t **)&ddo, &c) != 0 || ddo->ddo_count == 0) 32939eb19f4dSGeorge Wilson return; 32949eb19f4dSGeorge Wilson 32959eb19f4dSGeorge Wilson (void) printf("\n"); 32969eb19f4dSGeorge Wilson (void) printf("DDT entries %llu, size %llu on disk, %llu in core\n", 32979eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_count, 32989eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_dspace, 32999eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_mspace); 33009eb19f4dSGeorge Wilson 33019eb19f4dSGeorge Wilson verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS, 33029eb19f4dSGeorge Wilson (uint64_t **)&dds, &c) == 0); 33039eb19f4dSGeorge Wilson verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_HISTOGRAM, 33049eb19f4dSGeorge Wilson (uint64_t **)&ddh, &c) == 0); 33059eb19f4dSGeorge Wilson zpool_dump_ddt(dds, ddh); 33069eb19f4dSGeorge Wilson } 33079eb19f4dSGeorge Wilson 3308fa9e4066Sahrens /* 3309fa9e4066Sahrens * Display a summary of pool status. Displays a summary such as: 3310fa9e4066Sahrens * 3311fa9e4066Sahrens * pool: tank 3312fa9e4066Sahrens * status: DEGRADED 3313fa9e4066Sahrens * reason: One or more devices ... 3314fa9e4066Sahrens * see: http://www.sun.com/msg/ZFS-xxxx-01 3315fa9e4066Sahrens * config: 3316fa9e4066Sahrens * mirror DEGRADED 3317fa9e4066Sahrens * c1t0d0 OK 3318ea8dc4b6Seschrock * c2t0d0 UNAVAIL 3319fa9e4066Sahrens * 3320fa9e4066Sahrens * When given the '-v' option, we print out the complete config. If the '-e' 3321fa9e4066Sahrens * option is specified, then we print out error rate information as well. 3322fa9e4066Sahrens */ 3323fa9e4066Sahrens int 3324fa9e4066Sahrens status_callback(zpool_handle_t *zhp, void *data) 3325fa9e4066Sahrens { 3326fa9e4066Sahrens status_cbdata_t *cbp = data; 3327fa9e4066Sahrens nvlist_t *config, *nvroot; 3328fa9e4066Sahrens char *msgid; 3329fa9e4066Sahrens int reason; 333046657f8dSmmusante const char *health; 333146657f8dSmmusante uint_t c; 333246657f8dSmmusante vdev_stat_t *vs; 3333fa9e4066Sahrens 3334088e9d47Seschrock config = zpool_get_config(zhp, NULL); 3335fa9e4066Sahrens reason = zpool_get_status(zhp, &msgid); 3336fa9e4066Sahrens 3337fa9e4066Sahrens cbp->cb_count++; 3338fa9e4066Sahrens 3339fa9e4066Sahrens /* 3340fa9e4066Sahrens * If we were given 'zpool status -x', only report those pools with 3341fa9e4066Sahrens * problems. 3342fa9e4066Sahrens */ 3343e9dbad6fSeschrock if (reason == ZPOOL_STATUS_OK && cbp->cb_explain) { 3344e9dbad6fSeschrock if (!cbp->cb_allpools) { 3345e9dbad6fSeschrock (void) printf(gettext("pool '%s' is healthy\n"), 3346e9dbad6fSeschrock zpool_get_name(zhp)); 3347e9dbad6fSeschrock if (cbp->cb_first) 3348e9dbad6fSeschrock cbp->cb_first = B_FALSE; 3349e9dbad6fSeschrock } 3350fa9e4066Sahrens return (0); 3351e9dbad6fSeschrock } 3352fa9e4066Sahrens 3353fa9e4066Sahrens if (cbp->cb_first) 335499653d4eSeschrock cbp->cb_first = B_FALSE; 3355fa9e4066Sahrens else 3356fa9e4066Sahrens (void) printf("\n"); 3357fa9e4066Sahrens 335846657f8dSmmusante verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 335946657f8dSmmusante &nvroot) == 0); 336046657f8dSmmusante verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS, 336146657f8dSmmusante (uint64_t **)&vs, &c) == 0); 3362990b4856Slling health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 3363fa9e4066Sahrens 3364fa9e4066Sahrens (void) printf(gettext(" pool: %s\n"), zpool_get_name(zhp)); 3365fa9e4066Sahrens (void) printf(gettext(" state: %s\n"), health); 3366fa9e4066Sahrens 3367fa9e4066Sahrens switch (reason) { 3368fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 3369fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3370fa9e4066Sahrens "be opened. Sufficient replicas exist for\n\tthe pool to " 3371fa9e4066Sahrens "continue functioning in a degraded state.\n")); 3372fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 3373fa9e4066Sahrens "online it using 'zpool online'.\n")); 3374fa9e4066Sahrens break; 3375fa9e4066Sahrens 3376fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 3377fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3378fa9e4066Sahrens "be opened. There are insufficient\n\treplicas for the " 3379fa9e4066Sahrens "pool to continue functioning.\n")); 3380fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 3381fa9e4066Sahrens "online it using 'zpool online'.\n")); 3382fa9e4066Sahrens break; 3383fa9e4066Sahrens 3384fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 3385fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3386fa9e4066Sahrens "be used because the label is missing or\n\tinvalid. " 3387fa9e4066Sahrens "Sufficient replicas exist for the pool to continue\n\t" 3388fa9e4066Sahrens "functioning in a degraded state.\n")); 3389fa9e4066Sahrens (void) printf(gettext("action: Replace the device using " 3390fa9e4066Sahrens "'zpool replace'.\n")); 3391fa9e4066Sahrens break; 3392fa9e4066Sahrens 3393fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 3394fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3395b1b8ab34Slling "be used because the label is missing \n\tor invalid. " 3396fa9e4066Sahrens "There are insufficient replicas for the pool to " 3397fa9e4066Sahrens "continue\n\tfunctioning.\n")); 3398468c413aSTim Haley zpool_explain_recover(zpool_get_handle(zhp), 3399468c413aSTim Haley zpool_get_name(zhp), reason, config); 3400fa9e4066Sahrens break; 3401fa9e4066Sahrens 3402fa9e4066Sahrens case ZPOOL_STATUS_FAILING_DEV: 3403fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 3404fa9e4066Sahrens "experienced an unrecoverable error. An\n\tattempt was " 3405fa9e4066Sahrens "made to correct the error. Applications are " 3406fa9e4066Sahrens "unaffected.\n")); 3407fa9e4066Sahrens (void) printf(gettext("action: Determine if the device needs " 3408fa9e4066Sahrens "to be replaced, and clear the errors\n\tusing " 3409ea8dc4b6Seschrock "'zpool clear' or replace the device with 'zpool " 3410fa9e4066Sahrens "replace'.\n")); 3411fa9e4066Sahrens break; 3412fa9e4066Sahrens 3413fa9e4066Sahrens case ZPOOL_STATUS_OFFLINE_DEV: 3414fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 3415d7d4af51Smmusante "been taken offline by the administrator.\n\tSufficient " 3416fa9e4066Sahrens "replicas exist for the pool to continue functioning in " 3417fa9e4066Sahrens "a\n\tdegraded state.\n")); 3418fa9e4066Sahrens (void) printf(gettext("action: Online the device using " 3419fa9e4066Sahrens "'zpool online' or replace the device with\n\t'zpool " 3420fa9e4066Sahrens "replace'.\n")); 3421fa9e4066Sahrens break; 3422fa9e4066Sahrens 3423c25309d4SGeorge Wilson case ZPOOL_STATUS_REMOVED_DEV: 3424c25309d4SGeorge Wilson (void) printf(gettext("status: One or more devices has " 3425c25309d4SGeorge Wilson "been removed by the administrator.\n\tSufficient " 3426c25309d4SGeorge Wilson "replicas exist for the pool to continue functioning in " 3427c25309d4SGeorge Wilson "a\n\tdegraded state.\n")); 3428c25309d4SGeorge Wilson (void) printf(gettext("action: Online the device using " 3429c25309d4SGeorge Wilson "'zpool online' or replace the device with\n\t'zpool " 3430c25309d4SGeorge Wilson "replace'.\n")); 3431c25309d4SGeorge Wilson break; 3432c25309d4SGeorge Wilson 3433c25309d4SGeorge Wilson 3434fa9e4066Sahrens case ZPOOL_STATUS_RESILVERING: 3435fa9e4066Sahrens (void) printf(gettext("status: One or more devices is " 3436fa9e4066Sahrens "currently being resilvered. The pool will\n\tcontinue " 3437fa9e4066Sahrens "to function, possibly in a degraded state.\n")); 3438fa9e4066Sahrens (void) printf(gettext("action: Wait for the resilver to " 3439fa9e4066Sahrens "complete.\n")); 3440fa9e4066Sahrens break; 3441fa9e4066Sahrens 3442ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_DATA: 3443ea8dc4b6Seschrock (void) printf(gettext("status: One or more devices has " 3444ea8dc4b6Seschrock "experienced an error resulting in data\n\tcorruption. " 3445ea8dc4b6Seschrock "Applications may be affected.\n")); 3446ea8dc4b6Seschrock (void) printf(gettext("action: Restore the file in question " 3447ea8dc4b6Seschrock "if possible. Otherwise restore the\n\tentire pool from " 3448ea8dc4b6Seschrock "backup.\n")); 3449ea8dc4b6Seschrock break; 3450ea8dc4b6Seschrock 3451ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 3452ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is corrupted " 3453ea8dc4b6Seschrock "and the pool cannot be opened.\n")); 3454468c413aSTim Haley zpool_explain_recover(zpool_get_handle(zhp), 3455468c413aSTim Haley zpool_get_name(zhp), reason, config); 3456ea8dc4b6Seschrock break; 3457ea8dc4b6Seschrock 3458eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 3459eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 3460eaca9bbdSeschrock "older on-disk format. The pool can\n\tstill be used, but " 3461eaca9bbdSeschrock "some features are unavailable.\n")); 3462eaca9bbdSeschrock (void) printf(gettext("action: Upgrade the pool using 'zpool " 3463eaca9bbdSeschrock "upgrade'. Once this is done, the\n\tpool will no longer " 3464eaca9bbdSeschrock "be accessible on older software versions.\n")); 3465eaca9bbdSeschrock break; 3466eaca9bbdSeschrock 3467eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 3468eaca9bbdSeschrock (void) printf(gettext("status: The pool has been upgraded to a " 3469eaca9bbdSeschrock "newer, incompatible on-disk version.\n\tThe pool cannot " 3470eaca9bbdSeschrock "be accessed on this system.\n")); 3471eaca9bbdSeschrock (void) printf(gettext("action: Access the pool from a system " 3472eaca9bbdSeschrock "running more recent software, or\n\trestore the pool from " 3473eaca9bbdSeschrock "backup.\n")); 3474eaca9bbdSeschrock break; 3475eaca9bbdSeschrock 34763d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_R: 34773d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 34783d7072f8Seschrock "faulted in response to persistent errors.\n\tSufficient " 34793d7072f8Seschrock "replicas exist for the pool to continue functioning " 34803d7072f8Seschrock "in a\n\tdegraded state.\n")); 34813d7072f8Seschrock (void) printf(gettext("action: Replace the faulted device, " 34823d7072f8Seschrock "or use 'zpool clear' to mark the device\n\trepaired.\n")); 34833d7072f8Seschrock break; 34843d7072f8Seschrock 34853d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_NR: 34863d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 34873d7072f8Seschrock "faulted in response to persistent errors. There are " 34883d7072f8Seschrock "insufficient replicas for the pool to\n\tcontinue " 34893d7072f8Seschrock "functioning.\n")); 34903d7072f8Seschrock (void) printf(gettext("action: Destroy and re-create the pool " 34913d7072f8Seschrock "from a backup source. Manually marking the device\n" 34923d7072f8Seschrock "\trepaired using 'zpool clear' may allow some data " 34933d7072f8Seschrock "to be recovered.\n")); 34943d7072f8Seschrock break; 34953d7072f8Seschrock 349632b87932Sek case ZPOOL_STATUS_IO_FAILURE_WAIT: 349732b87932Sek case ZPOOL_STATUS_IO_FAILURE_CONTINUE: 349832b87932Sek (void) printf(gettext("status: One or more devices are " 34998a79c1b5Sek "faulted in response to IO failures.\n")); 350032b87932Sek (void) printf(gettext("action: Make sure the affected devices " 350132b87932Sek "are connected, then run 'zpool clear'.\n")); 350232b87932Sek break; 350332b87932Sek 3504b87f3af3Sperrin case ZPOOL_STATUS_BAD_LOG: 3505b87f3af3Sperrin (void) printf(gettext("status: An intent log record " 3506b87f3af3Sperrin "could not be read.\n" 3507b87f3af3Sperrin "\tWaiting for adminstrator intervention to fix the " 3508b87f3af3Sperrin "faulted pool.\n")); 3509b87f3af3Sperrin (void) printf(gettext("action: Either restore the affected " 3510b87f3af3Sperrin "device(s) and run 'zpool online',\n" 3511b87f3af3Sperrin "\tor ignore the intent log records by running " 3512b87f3af3Sperrin "'zpool clear'.\n")); 3513b87f3af3Sperrin break; 3514b87f3af3Sperrin 3515fa9e4066Sahrens default: 3516fa9e4066Sahrens /* 3517fa9e4066Sahrens * The remaining errors can't actually be generated, yet. 3518fa9e4066Sahrens */ 3519fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 3520fa9e4066Sahrens } 3521fa9e4066Sahrens 3522fa9e4066Sahrens if (msgid != NULL) 3523fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 3524fa9e4066Sahrens msgid); 3525fa9e4066Sahrens 3526fa9e4066Sahrens if (config != NULL) { 3527fa9e4066Sahrens int namewidth; 3528ea8dc4b6Seschrock uint64_t nerr; 3529fa94a07fSbrendan nvlist_t **spares, **l2cache; 3530fa94a07fSbrendan uint_t nspares, nl2cache; 3531fa9e4066Sahrens 3532fa9e4066Sahrens 3533fa9e4066Sahrens (void) printf(gettext(" scrub: ")); 3534fa9e4066Sahrens print_scrub_status(nvroot); 3535fa9e4066Sahrens 3536c67d9675Seschrock namewidth = max_width(zhp, nvroot, 0, 0); 3537fa9e4066Sahrens if (namewidth < 10) 3538fa9e4066Sahrens namewidth = 10; 3539fa9e4066Sahrens 3540fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 3541fa9e4066Sahrens (void) printf(gettext("\t%-*s %-8s %5s %5s %5s\n"), namewidth, 3542fa9e4066Sahrens "NAME", "STATE", "READ", "WRITE", "CKSUM"); 3543c67d9675Seschrock print_status_config(zhp, zpool_get_name(zhp), nvroot, 3544aa8cf21aSNeil Perrin namewidth, 0, B_FALSE); 354599653d4eSeschrock 35464dea40f0SNeil Perrin if (num_logs(nvroot) > 0) 3547e6ca193dSGeorge Wilson print_logs(zhp, nvroot, namewidth, B_TRUE); 3548fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 3549fa94a07fSbrendan &l2cache, &nl2cache) == 0) 3550fa94a07fSbrendan print_l2cache(zhp, l2cache, nl2cache, namewidth); 3551fa94a07fSbrendan 355299653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 355399653d4eSeschrock &spares, &nspares) == 0) 355499653d4eSeschrock print_spares(zhp, spares, nspares, namewidth); 3555ea8dc4b6Seschrock 3556ea8dc4b6Seschrock if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT, 3557ea8dc4b6Seschrock &nerr) == 0) { 355855434c77Sek nvlist_t *nverrlist = NULL; 355955434c77Sek 3560ea8dc4b6Seschrock /* 3561ea8dc4b6Seschrock * If the approximate error count is small, get a 3562ea8dc4b6Seschrock * precise count by fetching the entire log and 3563ea8dc4b6Seschrock * uniquifying the results. 3564ea8dc4b6Seschrock */ 356575519f38Sek if (nerr > 0 && nerr < 100 && !cbp->cb_verbose && 356655434c77Sek zpool_get_errlog(zhp, &nverrlist) == 0) { 356755434c77Sek nvpair_t *elem; 356855434c77Sek 356955434c77Sek elem = NULL; 357055434c77Sek nerr = 0; 357155434c77Sek while ((elem = nvlist_next_nvpair(nverrlist, 357255434c77Sek elem)) != NULL) { 357355434c77Sek nerr++; 357455434c77Sek } 357555434c77Sek } 357655434c77Sek nvlist_free(nverrlist); 3577ea8dc4b6Seschrock 3578ea8dc4b6Seschrock (void) printf("\n"); 357999653d4eSeschrock 3580ea8dc4b6Seschrock if (nerr == 0) 3581ea8dc4b6Seschrock (void) printf(gettext("errors: No known data " 3582ea8dc4b6Seschrock "errors\n")); 3583ea8dc4b6Seschrock else if (!cbp->cb_verbose) 3584e9dbad6fSeschrock (void) printf(gettext("errors: %llu data " 35855ad82045Snd "errors, use '-v' for a list\n"), 35865ad82045Snd (u_longlong_t)nerr); 3587ea8dc4b6Seschrock else 3588ea8dc4b6Seschrock print_error_log(zhp); 3589ea8dc4b6Seschrock } 35909eb19f4dSGeorge Wilson 35919eb19f4dSGeorge Wilson if (cbp->cb_dedup_stats) 35929eb19f4dSGeorge Wilson print_dedup_stats(config); 3593fa9e4066Sahrens } else { 3594fa9e4066Sahrens (void) printf(gettext("config: The configuration cannot be " 3595fa9e4066Sahrens "determined.\n")); 3596fa9e4066Sahrens } 3597fa9e4066Sahrens 3598fa9e4066Sahrens return (0); 3599fa9e4066Sahrens } 3600fa9e4066Sahrens 3601fa9e4066Sahrens /* 3602fa9e4066Sahrens * zpool status [-vx] [pool] ... 3603fa9e4066Sahrens * 3604fa9e4066Sahrens * -v Display complete error logs 3605fa9e4066Sahrens * -x Display only pools with potential problems 36069eb19f4dSGeorge Wilson * -D Display dedup status (undocumented) 3607fa9e4066Sahrens * 3608fa9e4066Sahrens * Describes the health status of all pools or some subset. 3609fa9e4066Sahrens */ 3610fa9e4066Sahrens int 3611fa9e4066Sahrens zpool_do_status(int argc, char **argv) 3612fa9e4066Sahrens { 3613fa9e4066Sahrens int c; 3614fa9e4066Sahrens int ret; 3615fa9e4066Sahrens status_cbdata_t cb = { 0 }; 3616fa9e4066Sahrens 3617fa9e4066Sahrens /* check options */ 36189eb19f4dSGeorge Wilson while ((c = getopt(argc, argv, "vxD")) != -1) { 3619fa9e4066Sahrens switch (c) { 3620fa9e4066Sahrens case 'v': 362199653d4eSeschrock cb.cb_verbose = B_TRUE; 3622fa9e4066Sahrens break; 3623fa9e4066Sahrens case 'x': 362499653d4eSeschrock cb.cb_explain = B_TRUE; 3625fa9e4066Sahrens break; 36269eb19f4dSGeorge Wilson case 'D': 36279eb19f4dSGeorge Wilson cb.cb_dedup_stats = B_TRUE; 36289eb19f4dSGeorge Wilson break; 3629fa9e4066Sahrens case '?': 3630fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3631fa9e4066Sahrens optopt); 363299653d4eSeschrock usage(B_FALSE); 3633fa9e4066Sahrens } 3634fa9e4066Sahrens } 3635fa9e4066Sahrens 3636fa9e4066Sahrens argc -= optind; 3637fa9e4066Sahrens argv += optind; 3638fa9e4066Sahrens 363999653d4eSeschrock cb.cb_first = B_TRUE; 3640fa9e4066Sahrens 3641e9dbad6fSeschrock if (argc == 0) 3642e9dbad6fSeschrock cb.cb_allpools = B_TRUE; 3643e9dbad6fSeschrock 3644b1b8ab34Slling ret = for_each_pool(argc, argv, B_TRUE, NULL, status_callback, &cb); 3645fa9e4066Sahrens 3646fa9e4066Sahrens if (argc == 0 && cb.cb_count == 0) 3647fa9e4066Sahrens (void) printf(gettext("no pools available\n")); 3648e9dbad6fSeschrock else if (cb.cb_explain && cb.cb_first && cb.cb_allpools) 3649e9dbad6fSeschrock (void) printf(gettext("all pools are healthy\n")); 3650fa9e4066Sahrens 3651fa9e4066Sahrens return (ret); 3652fa9e4066Sahrens } 3653fa9e4066Sahrens 3654eaca9bbdSeschrock typedef struct upgrade_cbdata { 3655eaca9bbdSeschrock int cb_all; 3656eaca9bbdSeschrock int cb_first; 3657eaca9bbdSeschrock int cb_newer; 365806eeb2adSek int cb_argc; 3659990b4856Slling uint64_t cb_version; 366006eeb2adSek char **cb_argv; 3661eaca9bbdSeschrock } upgrade_cbdata_t; 3662eaca9bbdSeschrock 3663eaca9bbdSeschrock static int 3664eaca9bbdSeschrock upgrade_cb(zpool_handle_t *zhp, void *arg) 3665eaca9bbdSeschrock { 3666eaca9bbdSeschrock upgrade_cbdata_t *cbp = arg; 3667eaca9bbdSeschrock nvlist_t *config; 3668eaca9bbdSeschrock uint64_t version; 3669eaca9bbdSeschrock int ret = 0; 3670eaca9bbdSeschrock 3671eaca9bbdSeschrock config = zpool_get_config(zhp, NULL); 3672eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 3673eaca9bbdSeschrock &version) == 0); 3674eaca9bbdSeschrock 3675e7437265Sahrens if (!cbp->cb_newer && version < SPA_VERSION) { 3676eaca9bbdSeschrock if (!cbp->cb_all) { 3677eaca9bbdSeschrock if (cbp->cb_first) { 3678eaca9bbdSeschrock (void) printf(gettext("The following pools are " 3679eaca9bbdSeschrock "out of date, and can be upgraded. After " 3680eaca9bbdSeschrock "being\nupgraded, these pools will no " 3681eaca9bbdSeschrock "longer be accessible by older software " 3682eaca9bbdSeschrock "versions.\n\n")); 3683eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 3684eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 368599653d4eSeschrock cbp->cb_first = B_FALSE; 3686eaca9bbdSeschrock } 3687eaca9bbdSeschrock 36885ad82045Snd (void) printf("%2llu %s\n", (u_longlong_t)version, 3689eaca9bbdSeschrock zpool_get_name(zhp)); 3690eaca9bbdSeschrock } else { 369199653d4eSeschrock cbp->cb_first = B_FALSE; 3692990b4856Slling ret = zpool_upgrade(zhp, cbp->cb_version); 369306eeb2adSek if (!ret) { 3694eaca9bbdSeschrock (void) printf(gettext("Successfully upgraded " 3695990b4856Slling "'%s'\n\n"), zpool_get_name(zhp)); 369606eeb2adSek } 3697eaca9bbdSeschrock } 3698e7437265Sahrens } else if (cbp->cb_newer && version > SPA_VERSION) { 3699eaca9bbdSeschrock assert(!cbp->cb_all); 3700eaca9bbdSeschrock 3701eaca9bbdSeschrock if (cbp->cb_first) { 3702eaca9bbdSeschrock (void) printf(gettext("The following pools are " 3703eaca9bbdSeschrock "formatted using a newer software version and\n" 3704eaca9bbdSeschrock "cannot be accessed on the current system.\n\n")); 3705eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 3706eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 370799653d4eSeschrock cbp->cb_first = B_FALSE; 3708eaca9bbdSeschrock } 3709eaca9bbdSeschrock 37105ad82045Snd (void) printf("%2llu %s\n", (u_longlong_t)version, 3711eaca9bbdSeschrock zpool_get_name(zhp)); 3712eaca9bbdSeschrock } 3713eaca9bbdSeschrock 3714eaca9bbdSeschrock zpool_close(zhp); 3715eaca9bbdSeschrock return (ret); 3716eaca9bbdSeschrock } 3717eaca9bbdSeschrock 3718eaca9bbdSeschrock /* ARGSUSED */ 3719eaca9bbdSeschrock static int 372006eeb2adSek upgrade_one(zpool_handle_t *zhp, void *data) 3721eaca9bbdSeschrock { 3722990b4856Slling upgrade_cbdata_t *cbp = data; 3723990b4856Slling uint64_t cur_version; 3724eaca9bbdSeschrock int ret; 3725eaca9bbdSeschrock 37268654d025Sperrin if (strcmp("log", zpool_get_name(zhp)) == 0) { 37278654d025Sperrin (void) printf(gettext("'log' is now a reserved word\n" 37288654d025Sperrin "Pool 'log' must be renamed using export and import" 37298654d025Sperrin " to upgrade.\n")); 37308654d025Sperrin return (1); 37318654d025Sperrin } 3732990b4856Slling 3733990b4856Slling cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 3734e6c728e1Sbrendan if (cur_version > cbp->cb_version) { 3735eaca9bbdSeschrock (void) printf(gettext("Pool '%s' is already formatted " 3736e6c728e1Sbrendan "using more current version '%llu'.\n"), 3737e6c728e1Sbrendan zpool_get_name(zhp), cur_version); 3738e6c728e1Sbrendan return (0); 3739e6c728e1Sbrendan } 3740e6c728e1Sbrendan if (cur_version == cbp->cb_version) { 3741e6c728e1Sbrendan (void) printf(gettext("Pool '%s' is already formatted " 3742e6c728e1Sbrendan "using the current version.\n"), zpool_get_name(zhp)); 3743eaca9bbdSeschrock return (0); 3744eaca9bbdSeschrock } 3745eaca9bbdSeschrock 3746990b4856Slling ret = zpool_upgrade(zhp, cbp->cb_version); 374706eeb2adSek 374806eeb2adSek if (!ret) { 374944cd46caSbillm (void) printf(gettext("Successfully upgraded '%s' " 3750990b4856Slling "from version %llu to version %llu\n\n"), 3751990b4856Slling zpool_get_name(zhp), (u_longlong_t)cur_version, 3752990b4856Slling (u_longlong_t)cbp->cb_version); 375306eeb2adSek } 3754eaca9bbdSeschrock 3755eaca9bbdSeschrock return (ret != 0); 3756eaca9bbdSeschrock } 3757eaca9bbdSeschrock 3758eaca9bbdSeschrock /* 3759eaca9bbdSeschrock * zpool upgrade 3760eaca9bbdSeschrock * zpool upgrade -v 3761990b4856Slling * zpool upgrade [-V version] <-a | pool ...> 3762eaca9bbdSeschrock * 3763eaca9bbdSeschrock * With no arguments, display downrev'd ZFS pool available for upgrade. 3764eaca9bbdSeschrock * Individual pools can be upgraded by specifying the pool, and '-a' will 3765eaca9bbdSeschrock * upgrade all pools. 3766eaca9bbdSeschrock */ 3767eaca9bbdSeschrock int 3768eaca9bbdSeschrock zpool_do_upgrade(int argc, char **argv) 3769eaca9bbdSeschrock { 3770eaca9bbdSeschrock int c; 3771eaca9bbdSeschrock upgrade_cbdata_t cb = { 0 }; 3772eaca9bbdSeschrock int ret = 0; 3773eaca9bbdSeschrock boolean_t showversions = B_FALSE; 3774990b4856Slling char *end; 3775990b4856Slling 3776eaca9bbdSeschrock 3777eaca9bbdSeschrock /* check options */ 3778478ed9adSEric Taylor while ((c = getopt(argc, argv, ":avV:")) != -1) { 3779eaca9bbdSeschrock switch (c) { 3780eaca9bbdSeschrock case 'a': 378199653d4eSeschrock cb.cb_all = B_TRUE; 3782eaca9bbdSeschrock break; 3783eaca9bbdSeschrock case 'v': 3784eaca9bbdSeschrock showversions = B_TRUE; 3785eaca9bbdSeschrock break; 3786990b4856Slling case 'V': 3787990b4856Slling cb.cb_version = strtoll(optarg, &end, 10); 3788351420b3Slling if (*end != '\0' || cb.cb_version > SPA_VERSION || 3789351420b3Slling cb.cb_version < SPA_VERSION_1) { 3790990b4856Slling (void) fprintf(stderr, 3791990b4856Slling gettext("invalid version '%s'\n"), optarg); 3792990b4856Slling usage(B_FALSE); 3793990b4856Slling } 3794990b4856Slling break; 3795478ed9adSEric Taylor case ':': 3796478ed9adSEric Taylor (void) fprintf(stderr, gettext("missing argument for " 3797478ed9adSEric Taylor "'%c' option\n"), optopt); 3798478ed9adSEric Taylor usage(B_FALSE); 3799478ed9adSEric Taylor break; 3800eaca9bbdSeschrock case '?': 3801eaca9bbdSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3802eaca9bbdSeschrock optopt); 380399653d4eSeschrock usage(B_FALSE); 3804eaca9bbdSeschrock } 3805eaca9bbdSeschrock } 3806eaca9bbdSeschrock 380706eeb2adSek cb.cb_argc = argc; 380806eeb2adSek cb.cb_argv = argv; 3809eaca9bbdSeschrock argc -= optind; 3810eaca9bbdSeschrock argv += optind; 3811eaca9bbdSeschrock 3812351420b3Slling if (cb.cb_version == 0) { 3813351420b3Slling cb.cb_version = SPA_VERSION; 3814351420b3Slling } else if (!cb.cb_all && argc == 0) { 3815351420b3Slling (void) fprintf(stderr, gettext("-V option is " 3816351420b3Slling "incompatible with other arguments\n")); 3817351420b3Slling usage(B_FALSE); 3818351420b3Slling } 3819351420b3Slling 3820eaca9bbdSeschrock if (showversions) { 3821eaca9bbdSeschrock if (cb.cb_all || argc != 0) { 3822eaca9bbdSeschrock (void) fprintf(stderr, gettext("-v option is " 3823eaca9bbdSeschrock "incompatible with other arguments\n")); 382499653d4eSeschrock usage(B_FALSE); 3825eaca9bbdSeschrock } 3826eaca9bbdSeschrock } else if (cb.cb_all) { 3827eaca9bbdSeschrock if (argc != 0) { 3828351420b3Slling (void) fprintf(stderr, gettext("-a option should not " 3829351420b3Slling "be used along with a pool name\n")); 383099653d4eSeschrock usage(B_FALSE); 3831eaca9bbdSeschrock } 3832eaca9bbdSeschrock } 3833eaca9bbdSeschrock 3834e7437265Sahrens (void) printf(gettext("This system is currently running " 3835e7437265Sahrens "ZFS pool version %llu.\n\n"), SPA_VERSION); 383699653d4eSeschrock cb.cb_first = B_TRUE; 3837eaca9bbdSeschrock if (showversions) { 3838eaca9bbdSeschrock (void) printf(gettext("The following versions are " 3839d7d4af51Smmusante "supported:\n\n")); 3840eaca9bbdSeschrock (void) printf(gettext("VER DESCRIPTION\n")); 3841eaca9bbdSeschrock (void) printf("--- -----------------------------------------" 3842eaca9bbdSeschrock "---------------\n"); 384399653d4eSeschrock (void) printf(gettext(" 1 Initial ZFS version\n")); 384444cd46caSbillm (void) printf(gettext(" 2 Ditto blocks " 384544cd46caSbillm "(replicated metadata)\n")); 384699653d4eSeschrock (void) printf(gettext(" 3 Hot spares and double parity " 384799653d4eSeschrock "RAID-Z\n")); 3848d7306b64Sek (void) printf(gettext(" 4 zpool history\n")); 3849c9431fa1Sahl (void) printf(gettext(" 5 Compression using the gzip " 3850c9431fa1Sahl "algorithm\n")); 3851990b4856Slling (void) printf(gettext(" 6 bootfs pool property\n")); 38528654d025Sperrin (void) printf(gettext(" 7 Separate intent log devices\n")); 3853ecd6cf80Smarks (void) printf(gettext(" 8 Delegated administration\n")); 38548eed72d4Sck (void) printf(gettext(" 9 refquota and refreservation " 3855a9799022Sck "properties\n")); 3856fa94a07fSbrendan (void) printf(gettext(" 10 Cache devices\n")); 3857088f3894Sahrens (void) printf(gettext(" 11 Improved scrub performance\n")); 3858bb0ade09Sahrens (void) printf(gettext(" 12 Snapshot properties\n")); 385974e7dc98SMatthew Ahrens (void) printf(gettext(" 13 snapused property\n")); 386014843421SMatthew Ahrens (void) printf(gettext(" 14 passthrough-x aclinherit\n")); 386114843421SMatthew Ahrens (void) printf(gettext(" 15 user/group space accounting\n")); 3862478ed9adSEric Taylor (void) printf(gettext(" 16 stmf property support\n")); 38637aeab329SAdam Leventhal (void) printf(gettext(" 17 Triple-parity RAID-Z\n")); 3864b24ab676SJeff Bonwick (void) printf(gettext(" 18 Snapshot user holds\n")); 386588ecc943SGeorge Wilson (void) printf(gettext(" 19 Log device removal\n")); 3866b24ab676SJeff Bonwick (void) printf(gettext(" 20 Compression using zle " 3867b24ab676SJeff Bonwick "(zero-length encoding)\n")); 3868b24ab676SJeff Bonwick (void) printf(gettext(" 21 Deduplication\n")); 386992241e0bSTom Erickson (void) printf(gettext(" 22 Received properties\n")); 3870b24ab676SJeff Bonwick (void) printf(gettext("\nFor more information on a particular " 3871eaca9bbdSeschrock "version, including supported releases, see:\n\n")); 3872eaca9bbdSeschrock (void) printf("http://www.opensolaris.org/os/community/zfs/" 3873eaca9bbdSeschrock "version/N\n\n"); 3874eaca9bbdSeschrock (void) printf(gettext("Where 'N' is the version number.\n")); 3875eaca9bbdSeschrock } else if (argc == 0) { 3876eaca9bbdSeschrock int notfound; 3877eaca9bbdSeschrock 387899653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 3879eaca9bbdSeschrock notfound = cb.cb_first; 3880eaca9bbdSeschrock 3881eaca9bbdSeschrock if (!cb.cb_all && ret == 0) { 3882eaca9bbdSeschrock if (!cb.cb_first) 3883eaca9bbdSeschrock (void) printf("\n"); 3884eaca9bbdSeschrock cb.cb_first = B_TRUE; 3885eaca9bbdSeschrock cb.cb_newer = B_TRUE; 388699653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 3887eaca9bbdSeschrock if (!cb.cb_first) { 3888eaca9bbdSeschrock notfound = B_FALSE; 3889eaca9bbdSeschrock (void) printf("\n"); 3890eaca9bbdSeschrock } 3891eaca9bbdSeschrock } 3892eaca9bbdSeschrock 3893eaca9bbdSeschrock if (ret == 0) { 3894eaca9bbdSeschrock if (notfound) 3895eaca9bbdSeschrock (void) printf(gettext("All pools are formatted " 3896eaca9bbdSeschrock "using this version.\n")); 3897eaca9bbdSeschrock else if (!cb.cb_all) 3898eaca9bbdSeschrock (void) printf(gettext("Use 'zpool upgrade -v' " 3899eaca9bbdSeschrock "for a list of available versions and " 3900eaca9bbdSeschrock "their associated\nfeatures.\n")); 3901eaca9bbdSeschrock } 3902eaca9bbdSeschrock } else { 3903b1b8ab34Slling ret = for_each_pool(argc, argv, B_FALSE, NULL, 3904b1b8ab34Slling upgrade_one, &cb); 390506eeb2adSek } 390606eeb2adSek 390706eeb2adSek return (ret); 390806eeb2adSek } 390906eeb2adSek 3910ecd6cf80Smarks typedef struct hist_cbdata { 3911ecd6cf80Smarks boolean_t first; 3912ecd6cf80Smarks int longfmt; 3913ecd6cf80Smarks int internal; 3914ecd6cf80Smarks } hist_cbdata_t; 3915ecd6cf80Smarks 391606eeb2adSek /* 391706eeb2adSek * Print out the command history for a specific pool. 391806eeb2adSek */ 391906eeb2adSek static int 392006eeb2adSek get_history_one(zpool_handle_t *zhp, void *data) 392106eeb2adSek { 392206eeb2adSek nvlist_t *nvhis; 392306eeb2adSek nvlist_t **records; 392406eeb2adSek uint_t numrecords; 392506eeb2adSek char *cmdstr; 3926ecd6cf80Smarks char *pathstr; 392706eeb2adSek uint64_t dst_time; 392806eeb2adSek time_t tsec; 392906eeb2adSek struct tm t; 393006eeb2adSek char tbuf[30]; 393106eeb2adSek int ret, i; 3932ecd6cf80Smarks uint64_t who; 3933ecd6cf80Smarks struct passwd *pwd; 3934ecd6cf80Smarks char *hostname; 3935ecd6cf80Smarks char *zonename; 3936ecd6cf80Smarks char internalstr[MAXPATHLEN]; 3937ecd6cf80Smarks hist_cbdata_t *cb = (hist_cbdata_t *)data; 3938ecd6cf80Smarks uint64_t txg; 3939ecd6cf80Smarks uint64_t ievent; 394006eeb2adSek 3941ecd6cf80Smarks cb->first = B_FALSE; 394206eeb2adSek 394306eeb2adSek (void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp)); 394406eeb2adSek 394506eeb2adSek if ((ret = zpool_get_history(zhp, &nvhis)) != 0) 394606eeb2adSek return (ret); 394706eeb2adSek 394806eeb2adSek verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD, 394906eeb2adSek &records, &numrecords) == 0); 395006eeb2adSek for (i = 0; i < numrecords; i++) { 395106eeb2adSek if (nvlist_lookup_uint64(records[i], ZPOOL_HIST_TIME, 3952ecd6cf80Smarks &dst_time) != 0) 3953ecd6cf80Smarks continue; 3954ecd6cf80Smarks 3955ecd6cf80Smarks /* is it an internal event or a standard event? */ 3956ecd6cf80Smarks if (nvlist_lookup_string(records[i], ZPOOL_HIST_CMD, 3957ecd6cf80Smarks &cmdstr) != 0) { 3958ecd6cf80Smarks if (cb->internal == 0) 3959ecd6cf80Smarks continue; 3960ecd6cf80Smarks 3961ecd6cf80Smarks if (nvlist_lookup_uint64(records[i], 3962ecd6cf80Smarks ZPOOL_HIST_INT_EVENT, &ievent) != 0) 3963ecd6cf80Smarks continue; 3964ecd6cf80Smarks verify(nvlist_lookup_uint64(records[i], 3965ecd6cf80Smarks ZPOOL_HIST_TXG, &txg) == 0); 3966ecd6cf80Smarks verify(nvlist_lookup_string(records[i], 3967ecd6cf80Smarks ZPOOL_HIST_INT_STR, &pathstr) == 0); 3968088f3894Sahrens if (ievent >= LOG_END) 3969ecd6cf80Smarks continue; 3970ecd6cf80Smarks (void) snprintf(internalstr, 3971ecd6cf80Smarks sizeof (internalstr), 3972ecd6cf80Smarks "[internal %s txg:%lld] %s", 3973ecd6cf80Smarks hist_event_table[ievent], txg, 3974ecd6cf80Smarks pathstr); 3975ecd6cf80Smarks cmdstr = internalstr; 397606eeb2adSek } 3977ecd6cf80Smarks tsec = dst_time; 3978ecd6cf80Smarks (void) localtime_r(&tsec, &t); 3979ecd6cf80Smarks (void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t); 3980ecd6cf80Smarks (void) printf("%s %s", tbuf, cmdstr); 3981ecd6cf80Smarks 3982ecd6cf80Smarks if (!cb->longfmt) { 3983ecd6cf80Smarks (void) printf("\n"); 3984ecd6cf80Smarks continue; 3985ecd6cf80Smarks } 3986ecd6cf80Smarks (void) printf(" ["); 3987ecd6cf80Smarks if (nvlist_lookup_uint64(records[i], 3988ecd6cf80Smarks ZPOOL_HIST_WHO, &who) == 0) { 3989ecd6cf80Smarks pwd = getpwuid((uid_t)who); 3990ecd6cf80Smarks if (pwd) 3991ecd6cf80Smarks (void) printf("user %s on", 3992ecd6cf80Smarks pwd->pw_name); 3993ecd6cf80Smarks else 3994ecd6cf80Smarks (void) printf("user %d on", 3995ecd6cf80Smarks (int)who); 3996ecd6cf80Smarks } else { 3997ecd6cf80Smarks (void) printf(gettext("no info]\n")); 3998ecd6cf80Smarks continue; 3999ecd6cf80Smarks } 4000ecd6cf80Smarks if (nvlist_lookup_string(records[i], 4001ecd6cf80Smarks ZPOOL_HIST_HOST, &hostname) == 0) { 4002ecd6cf80Smarks (void) printf(" %s", hostname); 4003ecd6cf80Smarks } 4004ecd6cf80Smarks if (nvlist_lookup_string(records[i], 4005ecd6cf80Smarks ZPOOL_HIST_ZONE, &zonename) == 0) { 4006ecd6cf80Smarks (void) printf(":%s", zonename); 4007ecd6cf80Smarks } 4008ecd6cf80Smarks 4009ecd6cf80Smarks (void) printf("]"); 4010ecd6cf80Smarks (void) printf("\n"); 401106eeb2adSek } 401206eeb2adSek (void) printf("\n"); 401306eeb2adSek nvlist_free(nvhis); 401406eeb2adSek 401506eeb2adSek return (ret); 401606eeb2adSek } 401706eeb2adSek 401806eeb2adSek /* 401906eeb2adSek * zpool history <pool> 402006eeb2adSek * 402106eeb2adSek * Displays the history of commands that modified pools. 402206eeb2adSek */ 4023ecd6cf80Smarks 4024ecd6cf80Smarks 402506eeb2adSek int 402606eeb2adSek zpool_do_history(int argc, char **argv) 402706eeb2adSek { 4028ecd6cf80Smarks hist_cbdata_t cbdata = { 0 }; 402906eeb2adSek int ret; 4030ecd6cf80Smarks int c; 403106eeb2adSek 4032ecd6cf80Smarks cbdata.first = B_TRUE; 4033ecd6cf80Smarks /* check options */ 4034ecd6cf80Smarks while ((c = getopt(argc, argv, "li")) != -1) { 4035ecd6cf80Smarks switch (c) { 4036ecd6cf80Smarks case 'l': 4037ecd6cf80Smarks cbdata.longfmt = 1; 4038ecd6cf80Smarks break; 4039ecd6cf80Smarks case 'i': 4040ecd6cf80Smarks cbdata.internal = 1; 4041ecd6cf80Smarks break; 4042ecd6cf80Smarks case '?': 4043ecd6cf80Smarks (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4044ecd6cf80Smarks optopt); 4045ecd6cf80Smarks usage(B_FALSE); 4046ecd6cf80Smarks } 4047ecd6cf80Smarks } 404806eeb2adSek argc -= optind; 404906eeb2adSek argv += optind; 405006eeb2adSek 4051b1b8ab34Slling ret = for_each_pool(argc, argv, B_FALSE, NULL, get_history_one, 4052ecd6cf80Smarks &cbdata); 405306eeb2adSek 4054ecd6cf80Smarks if (argc == 0 && cbdata.first == B_TRUE) { 405506eeb2adSek (void) printf(gettext("no pools available\n")); 405606eeb2adSek return (0); 4057eaca9bbdSeschrock } 4058eaca9bbdSeschrock 4059eaca9bbdSeschrock return (ret); 4060eaca9bbdSeschrock } 4061eaca9bbdSeschrock 4062b1b8ab34Slling static int 4063b1b8ab34Slling get_callback(zpool_handle_t *zhp, void *data) 4064b1b8ab34Slling { 4065990b4856Slling zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 4066b1b8ab34Slling char value[MAXNAMELEN]; 4067990b4856Slling zprop_source_t srctype; 4068990b4856Slling zprop_list_t *pl; 4069b1b8ab34Slling 4070b1b8ab34Slling for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) { 4071b1b8ab34Slling 4072b1b8ab34Slling /* 4073990b4856Slling * Skip the special fake placeholder. This will also skip 4074990b4856Slling * over the name property when 'all' is specified. 4075b1b8ab34Slling */ 4076990b4856Slling if (pl->pl_prop == ZPOOL_PROP_NAME && 4077b1b8ab34Slling pl == cbp->cb_proplist) 4078b1b8ab34Slling continue; 4079b1b8ab34Slling 4080b1b8ab34Slling if (zpool_get_prop(zhp, pl->pl_prop, 4081b1b8ab34Slling value, sizeof (value), &srctype) != 0) 4082b1b8ab34Slling continue; 4083b1b8ab34Slling 4084990b4856Slling zprop_print_one_property(zpool_get_name(zhp), cbp, 408592241e0bSTom Erickson zpool_prop_to_name(pl->pl_prop), value, srctype, NULL, 408692241e0bSTom Erickson NULL); 4087b1b8ab34Slling } 4088b1b8ab34Slling return (0); 4089b1b8ab34Slling } 4090b1b8ab34Slling 4091b1b8ab34Slling int 4092b1b8ab34Slling zpool_do_get(int argc, char **argv) 4093b1b8ab34Slling { 4094990b4856Slling zprop_get_cbdata_t cb = { 0 }; 4095990b4856Slling zprop_list_t fake_name = { 0 }; 4096b1b8ab34Slling int ret; 4097b1b8ab34Slling 4098b1b8ab34Slling if (argc < 3) 4099b1b8ab34Slling usage(B_FALSE); 4100b1b8ab34Slling 4101b1b8ab34Slling cb.cb_first = B_TRUE; 4102990b4856Slling cb.cb_sources = ZPROP_SRC_ALL; 4103b1b8ab34Slling cb.cb_columns[0] = GET_COL_NAME; 4104b1b8ab34Slling cb.cb_columns[1] = GET_COL_PROPERTY; 4105b1b8ab34Slling cb.cb_columns[2] = GET_COL_VALUE; 4106b1b8ab34Slling cb.cb_columns[3] = GET_COL_SOURCE; 4107990b4856Slling cb.cb_type = ZFS_TYPE_POOL; 4108b1b8ab34Slling 4109990b4856Slling if (zprop_get_list(g_zfs, argv[1], &cb.cb_proplist, 4110990b4856Slling ZFS_TYPE_POOL) != 0) 4111b1b8ab34Slling usage(B_FALSE); 4112b1b8ab34Slling 4113b1b8ab34Slling if (cb.cb_proplist != NULL) { 4114990b4856Slling fake_name.pl_prop = ZPOOL_PROP_NAME; 4115b1b8ab34Slling fake_name.pl_width = strlen(gettext("NAME")); 4116b1b8ab34Slling fake_name.pl_next = cb.cb_proplist; 4117b1b8ab34Slling cb.cb_proplist = &fake_name; 4118b1b8ab34Slling } 4119b1b8ab34Slling 4120b1b8ab34Slling ret = for_each_pool(argc - 2, argv + 2, B_TRUE, &cb.cb_proplist, 4121b1b8ab34Slling get_callback, &cb); 4122b1b8ab34Slling 4123b1b8ab34Slling if (cb.cb_proplist == &fake_name) 4124990b4856Slling zprop_free_list(fake_name.pl_next); 4125b1b8ab34Slling else 4126990b4856Slling zprop_free_list(cb.cb_proplist); 4127b1b8ab34Slling 4128b1b8ab34Slling return (ret); 4129b1b8ab34Slling } 4130b1b8ab34Slling 4131b1b8ab34Slling typedef struct set_cbdata { 4132b1b8ab34Slling char *cb_propname; 4133b1b8ab34Slling char *cb_value; 4134b1b8ab34Slling boolean_t cb_any_successful; 4135b1b8ab34Slling } set_cbdata_t; 4136b1b8ab34Slling 4137b1b8ab34Slling int 4138b1b8ab34Slling set_callback(zpool_handle_t *zhp, void *data) 4139b1b8ab34Slling { 4140b1b8ab34Slling int error; 4141b1b8ab34Slling set_cbdata_t *cb = (set_cbdata_t *)data; 4142b1b8ab34Slling 4143b1b8ab34Slling error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value); 4144b1b8ab34Slling 4145b1b8ab34Slling if (!error) 4146b1b8ab34Slling cb->cb_any_successful = B_TRUE; 4147b1b8ab34Slling 4148b1b8ab34Slling return (error); 4149b1b8ab34Slling } 4150b1b8ab34Slling 4151b1b8ab34Slling int 4152b1b8ab34Slling zpool_do_set(int argc, char **argv) 4153b1b8ab34Slling { 4154b1b8ab34Slling set_cbdata_t cb = { 0 }; 4155b1b8ab34Slling int error; 4156b1b8ab34Slling 4157b1b8ab34Slling if (argc > 1 && argv[1][0] == '-') { 4158b1b8ab34Slling (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4159b1b8ab34Slling argv[1][1]); 4160b1b8ab34Slling usage(B_FALSE); 4161b1b8ab34Slling } 4162b1b8ab34Slling 4163b1b8ab34Slling if (argc < 2) { 4164b1b8ab34Slling (void) fprintf(stderr, gettext("missing property=value " 4165b1b8ab34Slling "argument\n")); 4166b1b8ab34Slling usage(B_FALSE); 4167b1b8ab34Slling } 4168b1b8ab34Slling 4169b1b8ab34Slling if (argc < 3) { 4170b1b8ab34Slling (void) fprintf(stderr, gettext("missing pool name\n")); 4171b1b8ab34Slling usage(B_FALSE); 4172b1b8ab34Slling } 4173b1b8ab34Slling 4174b1b8ab34Slling if (argc > 3) { 4175b1b8ab34Slling (void) fprintf(stderr, gettext("too many pool names\n")); 4176b1b8ab34Slling usage(B_FALSE); 4177b1b8ab34Slling } 4178b1b8ab34Slling 4179b1b8ab34Slling cb.cb_propname = argv[1]; 4180b1b8ab34Slling cb.cb_value = strchr(cb.cb_propname, '='); 4181b1b8ab34Slling if (cb.cb_value == NULL) { 4182b1b8ab34Slling (void) fprintf(stderr, gettext("missing value in " 4183b1b8ab34Slling "property=value argument\n")); 4184b1b8ab34Slling usage(B_FALSE); 4185b1b8ab34Slling } 4186b1b8ab34Slling 4187b1b8ab34Slling *(cb.cb_value) = '\0'; 4188b1b8ab34Slling cb.cb_value++; 4189b1b8ab34Slling 4190b1b8ab34Slling error = for_each_pool(argc - 2, argv + 2, B_TRUE, NULL, 4191b1b8ab34Slling set_callback, &cb); 4192b1b8ab34Slling 4193b1b8ab34Slling return (error); 4194b1b8ab34Slling } 4195b1b8ab34Slling 4196b1b8ab34Slling static int 4197b1b8ab34Slling find_command_idx(char *command, int *idx) 4198b1b8ab34Slling { 4199b1b8ab34Slling int i; 4200b1b8ab34Slling 4201b1b8ab34Slling for (i = 0; i < NCOMMAND; i++) { 4202b1b8ab34Slling if (command_table[i].name == NULL) 4203b1b8ab34Slling continue; 4204b1b8ab34Slling 4205b1b8ab34Slling if (strcmp(command, command_table[i].name) == 0) { 4206b1b8ab34Slling *idx = i; 4207b1b8ab34Slling return (0); 4208b1b8ab34Slling } 4209b1b8ab34Slling } 4210b1b8ab34Slling return (1); 4211b1b8ab34Slling } 4212b1b8ab34Slling 4213fa9e4066Sahrens int 4214fa9e4066Sahrens main(int argc, char **argv) 4215fa9e4066Sahrens { 4216fa9e4066Sahrens int ret; 4217fa9e4066Sahrens int i; 4218fa9e4066Sahrens char *cmdname; 4219fa9e4066Sahrens 4220fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 4221fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 4222fa9e4066Sahrens 422399653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 422499653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to " 4225203a47d8Snd "initialize ZFS library\n")); 422699653d4eSeschrock return (1); 422799653d4eSeschrock } 422899653d4eSeschrock 422999653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE); 423099653d4eSeschrock 4231fa9e4066Sahrens opterr = 0; 4232fa9e4066Sahrens 4233fa9e4066Sahrens /* 4234fa9e4066Sahrens * Make sure the user has specified some command. 4235fa9e4066Sahrens */ 4236fa9e4066Sahrens if (argc < 2) { 4237fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 423899653d4eSeschrock usage(B_FALSE); 4239fa9e4066Sahrens } 4240fa9e4066Sahrens 4241fa9e4066Sahrens cmdname = argv[1]; 4242fa9e4066Sahrens 4243fa9e4066Sahrens /* 4244fa9e4066Sahrens * Special case '-?' 4245fa9e4066Sahrens */ 4246fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 424799653d4eSeschrock usage(B_TRUE); 4248fa9e4066Sahrens 42492a6b87f0Sek zpool_set_history_str("zpool", argc, argv, history_str); 42502a6b87f0Sek verify(zpool_stage_history(g_zfs, history_str) == 0); 42512a6b87f0Sek 4252fa9e4066Sahrens /* 4253fa9e4066Sahrens * Run the appropriate command. 4254fa9e4066Sahrens */ 4255b1b8ab34Slling if (find_command_idx(cmdname, &i) == 0) { 4256b1b8ab34Slling current_command = &command_table[i]; 4257b1b8ab34Slling ret = command_table[i].func(argc - 1, argv + 1); 425891ebeef5Sahrens } else if (strchr(cmdname, '=')) { 425991ebeef5Sahrens verify(find_command_idx("set", &i) == 0); 426091ebeef5Sahrens current_command = &command_table[i]; 426191ebeef5Sahrens ret = command_table[i].func(argc, argv); 426291ebeef5Sahrens } else if (strcmp(cmdname, "freeze") == 0 && argc == 3) { 426391ebeef5Sahrens /* 426491ebeef5Sahrens * 'freeze' is a vile debugging abomination, so we treat 426591ebeef5Sahrens * it as such. 426691ebeef5Sahrens */ 4267ea8dc4b6Seschrock char buf[16384]; 4268ea8dc4b6Seschrock int fd = open(ZFS_DEV, O_RDWR); 4269fa9e4066Sahrens (void) strcpy((void *)buf, argv[2]); 4270fa9e4066Sahrens return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf)); 427191ebeef5Sahrens } else { 4272fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 4273fa9e4066Sahrens "command '%s'\n"), cmdname); 427499653d4eSeschrock usage(B_FALSE); 4275fa9e4066Sahrens } 4276fa9e4066Sahrens 427799653d4eSeschrock libzfs_fini(g_zfs); 427899653d4eSeschrock 4279fa9e4066Sahrens /* 4280fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 4281fa9e4066Sahrens * for the purposes of running ::findleaks. 4282fa9e4066Sahrens */ 4283fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 4284fa9e4066Sahrens (void) printf("dumping core by request\n"); 4285fa9e4066Sahrens abort(); 4286fa9e4066Sahrens } 4287fa9e4066Sahrens 4288fa9e4066Sahrens return (ret); 4289fa9e4066Sahrens } 4290