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 /* 233f9d6ad7SLin Ling * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24ce72e614SYuri Pankov * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 254263d13fSGeorge Wilson * Copyright (c) 2012 by Delphix. All rights reserved. 26e1d5e507SFrederik Wessels * Copyright (c) 2012 by Frederik Wessels. All rights reserved. 27fa9e4066Sahrens */ 28fa9e4066Sahrens 29fa9e4066Sahrens #include <assert.h> 30fa9e4066Sahrens #include <ctype.h> 31fa9e4066Sahrens #include <dirent.h> 32fa9e4066Sahrens #include <errno.h> 33fa9e4066Sahrens #include <fcntl.h> 34fa9e4066Sahrens #include <libgen.h> 35fa9e4066Sahrens #include <libintl.h> 36fa9e4066Sahrens #include <libuutil.h> 37fa9e4066Sahrens #include <locale.h> 38fa9e4066Sahrens #include <stdio.h> 39fa9e4066Sahrens #include <stdlib.h> 40fa9e4066Sahrens #include <string.h> 41fa9e4066Sahrens #include <strings.h> 42fa9e4066Sahrens #include <unistd.h> 43fa9e4066Sahrens #include <priv.h> 44ecd6cf80Smarks #include <pwd.h> 45ecd6cf80Smarks #include <zone.h> 464263d13fSGeorge Wilson #include <zfs_prop.h> 47b1b8ab34Slling #include <sys/fs/zfs.h> 48fa9e4066Sahrens #include <sys/stat.h> 49fa9e4066Sahrens 50fa9e4066Sahrens #include <libzfs.h> 51fa9e4066Sahrens 52fa9e4066Sahrens #include "zpool_util.h" 53b7b97454Sperrin #include "zfs_comutil.h" 54ad135b5dSChristopher Siden #include "zfeature_common.h" 55fa9e4066Sahrens 5626fd7700SKrishnendu Sadhukhan - Sun Microsystems #include "statcommon.h" 5726fd7700SKrishnendu Sadhukhan - Sun Microsystems 58fa9e4066Sahrens static int zpool_do_create(int, char **); 59fa9e4066Sahrens static int zpool_do_destroy(int, char **); 60fa9e4066Sahrens 61fa9e4066Sahrens static int zpool_do_add(int, char **); 6299653d4eSeschrock static int zpool_do_remove(int, char **); 63fa9e4066Sahrens 64fa9e4066Sahrens static int zpool_do_list(int, char **); 65fa9e4066Sahrens static int zpool_do_iostat(int, char **); 66fa9e4066Sahrens static int zpool_do_status(int, char **); 67fa9e4066Sahrens 68fa9e4066Sahrens static int zpool_do_online(int, char **); 69fa9e4066Sahrens static int zpool_do_offline(int, char **); 70ea8dc4b6Seschrock static int zpool_do_clear(int, char **); 714263d13fSGeorge Wilson static int zpool_do_reopen(int, char **); 72fa9e4066Sahrens 73e9103aaeSGarrett D'Amore static int zpool_do_reguid(int, char **); 74e9103aaeSGarrett D'Amore 75fa9e4066Sahrens static int zpool_do_attach(int, char **); 76fa9e4066Sahrens static int zpool_do_detach(int, char **); 77fa9e4066Sahrens static int zpool_do_replace(int, char **); 781195e687SMark J Musante static int zpool_do_split(int, char **); 79fa9e4066Sahrens 80fa9e4066Sahrens static int zpool_do_scrub(int, char **); 81fa9e4066Sahrens 82fa9e4066Sahrens static int zpool_do_import(int, char **); 83fa9e4066Sahrens static int zpool_do_export(int, char **); 84fa9e4066Sahrens 85eaca9bbdSeschrock static int zpool_do_upgrade(int, char **); 86eaca9bbdSeschrock 8706eeb2adSek static int zpool_do_history(int, char **); 8806eeb2adSek 89b1b8ab34Slling static int zpool_do_get(int, char **); 90b1b8ab34Slling static int zpool_do_set(int, char **); 91b1b8ab34Slling 92fa9e4066Sahrens /* 93fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 94fa9e4066Sahrens * debugging facilities. 95fa9e4066Sahrens */ 9629ab75c9Srm 9729ab75c9Srm #ifdef DEBUG 98fa9e4066Sahrens const char * 9999653d4eSeschrock _umem_debug_init(void) 100fa9e4066Sahrens { 101fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 102fa9e4066Sahrens } 103fa9e4066Sahrens 104fa9e4066Sahrens const char * 105fa9e4066Sahrens _umem_logging_init(void) 106fa9e4066Sahrens { 107fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 108fa9e4066Sahrens } 10929ab75c9Srm #endif 110fa9e4066Sahrens 11165cd9f28Seschrock typedef enum { 11265cd9f28Seschrock HELP_ADD, 11365cd9f28Seschrock HELP_ATTACH, 114ea8dc4b6Seschrock HELP_CLEAR, 11565cd9f28Seschrock HELP_CREATE, 11665cd9f28Seschrock HELP_DESTROY, 11765cd9f28Seschrock HELP_DETACH, 11865cd9f28Seschrock HELP_EXPORT, 11906eeb2adSek HELP_HISTORY, 12065cd9f28Seschrock HELP_IMPORT, 12165cd9f28Seschrock HELP_IOSTAT, 12265cd9f28Seschrock HELP_LIST, 12365cd9f28Seschrock HELP_OFFLINE, 12465cd9f28Seschrock HELP_ONLINE, 12565cd9f28Seschrock HELP_REPLACE, 12699653d4eSeschrock HELP_REMOVE, 12765cd9f28Seschrock HELP_SCRUB, 128eaca9bbdSeschrock HELP_STATUS, 129b1b8ab34Slling HELP_UPGRADE, 130b1b8ab34Slling HELP_GET, 1311195e687SMark J Musante HELP_SET, 132e9103aaeSGarrett D'Amore HELP_SPLIT, 1334263d13fSGeorge Wilson HELP_REGUID, 1344263d13fSGeorge Wilson HELP_REOPEN 13565cd9f28Seschrock } zpool_help_t; 13665cd9f28Seschrock 13765cd9f28Seschrock 138fa9e4066Sahrens typedef struct zpool_command { 139fa9e4066Sahrens const char *name; 140fa9e4066Sahrens int (*func)(int, char **); 14165cd9f28Seschrock zpool_help_t usage; 142fa9e4066Sahrens } zpool_command_t; 143fa9e4066Sahrens 144fa9e4066Sahrens /* 145fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and 146ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have 147ea8dc4b6Seschrock * to have a function to return the usage message based on a command index. 14865cd9f28Seschrock * 14965cd9f28Seschrock * These commands are organized according to how they are displayed in the usage 15065cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in 15165cd9f28Seschrock * the generic usage message. 152fa9e4066Sahrens */ 153fa9e4066Sahrens static zpool_command_t command_table[] = { 15465cd9f28Seschrock { "create", zpool_do_create, HELP_CREATE }, 15565cd9f28Seschrock { "destroy", zpool_do_destroy, HELP_DESTROY }, 156fa9e4066Sahrens { NULL }, 15765cd9f28Seschrock { "add", zpool_do_add, HELP_ADD }, 15899653d4eSeschrock { "remove", zpool_do_remove, HELP_REMOVE }, 159fa9e4066Sahrens { NULL }, 16065cd9f28Seschrock { "list", zpool_do_list, HELP_LIST }, 16165cd9f28Seschrock { "iostat", zpool_do_iostat, HELP_IOSTAT }, 16265cd9f28Seschrock { "status", zpool_do_status, HELP_STATUS }, 163fa9e4066Sahrens { NULL }, 16465cd9f28Seschrock { "online", zpool_do_online, HELP_ONLINE }, 16565cd9f28Seschrock { "offline", zpool_do_offline, HELP_OFFLINE }, 166ea8dc4b6Seschrock { "clear", zpool_do_clear, HELP_CLEAR }, 1674263d13fSGeorge Wilson { "reopen", zpool_do_reopen, HELP_REOPEN }, 168fa9e4066Sahrens { NULL }, 16965cd9f28Seschrock { "attach", zpool_do_attach, HELP_ATTACH }, 17065cd9f28Seschrock { "detach", zpool_do_detach, HELP_DETACH }, 17165cd9f28Seschrock { "replace", zpool_do_replace, HELP_REPLACE }, 1721195e687SMark J Musante { "split", zpool_do_split, HELP_SPLIT }, 173fa9e4066Sahrens { NULL }, 17465cd9f28Seschrock { "scrub", zpool_do_scrub, HELP_SCRUB }, 175fa9e4066Sahrens { NULL }, 17665cd9f28Seschrock { "import", zpool_do_import, HELP_IMPORT }, 17765cd9f28Seschrock { "export", zpool_do_export, HELP_EXPORT }, 17806eeb2adSek { "upgrade", zpool_do_upgrade, HELP_UPGRADE }, 179e9103aaeSGarrett D'Amore { "reguid", zpool_do_reguid, HELP_REGUID }, 18006eeb2adSek { NULL }, 181b1b8ab34Slling { "history", zpool_do_history, HELP_HISTORY }, 182b1b8ab34Slling { "get", zpool_do_get, HELP_GET }, 183b1b8ab34Slling { "set", zpool_do_set, HELP_SET }, 184fa9e4066Sahrens }; 185fa9e4066Sahrens 186fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0])) 187fa9e4066Sahrens 1884445fffbSMatthew Ahrens static zpool_command_t *current_command; 1892a6b87f0Sek static char history_str[HIS_MAX_RECORD_LEN]; 1904445fffbSMatthew Ahrens static boolean_t log_history = B_TRUE; 19126fd7700SKrishnendu Sadhukhan - Sun Microsystems static uint_t timestamp_fmt = NODATE; 19226fd7700SKrishnendu Sadhukhan - Sun Microsystems 19365cd9f28Seschrock static const char * 19465cd9f28Seschrock get_usage(zpool_help_t idx) { 19565cd9f28Seschrock switch (idx) { 19665cd9f28Seschrock case HELP_ADD: 19765cd9f28Seschrock return (gettext("\tadd [-fn] <pool> <vdev> ...\n")); 19865cd9f28Seschrock case HELP_ATTACH: 19965cd9f28Seschrock return (gettext("\tattach [-f] <pool> <device> " 200e45ce728Sahrens "<new-device>\n")); 201ea8dc4b6Seschrock case HELP_CLEAR: 202468c413aSTim Haley return (gettext("\tclear [-nF] <pool> [device]\n")); 20365cd9f28Seschrock case HELP_CREATE: 204ad135b5dSChristopher Siden return (gettext("\tcreate [-fnd] [-o property=value] ... \n" 2050a48a24eStimh "\t [-O file-system-property=value] ... \n" 206990b4856Slling "\t [-m mountpoint] [-R root] <pool> <vdev> ...\n")); 20765cd9f28Seschrock case HELP_DESTROY: 20865cd9f28Seschrock return (gettext("\tdestroy [-f] <pool>\n")); 20965cd9f28Seschrock case HELP_DETACH: 21065cd9f28Seschrock return (gettext("\tdetach <pool> <device>\n")); 21165cd9f28Seschrock case HELP_EXPORT: 21265cd9f28Seschrock return (gettext("\texport [-f] <pool> ...\n")); 21306eeb2adSek case HELP_HISTORY: 214ecd6cf80Smarks return (gettext("\thistory [-il] [<pool>] ...\n")); 21565cd9f28Seschrock case HELP_IMPORT: 2164c58d714Sdarrenm return (gettext("\timport [-d dir] [-D]\n" 217f9af39baSGeorge Wilson "\timport [-d dir | -c cachefile] [-F [-n]] <pool | id>\n" 2182f8aaab3Seschrock "\timport [-o mntopts] [-o property=value] ... \n" 219f9af39baSGeorge Wilson "\t [-d dir | -c cachefile] [-D] [-f] [-m] [-N] " 220f9af39baSGeorge Wilson "[-R root] [-F [-n]] -a\n" 2212f8aaab3Seschrock "\timport [-o mntopts] [-o property=value] ... \n" 222f9af39baSGeorge Wilson "\t [-d dir | -c cachefile] [-D] [-f] [-m] [-N] " 223f9af39baSGeorge Wilson "[-R root] [-F [-n]]\n" 224f9af39baSGeorge Wilson "\t <pool | id> [newpool]\n")); 22565cd9f28Seschrock case HELP_IOSTAT: 22626fd7700SKrishnendu Sadhukhan - Sun Microsystems return (gettext("\tiostat [-v] [-T d|u] [pool] ... [interval " 22765cd9f28Seschrock "[count]]\n")); 22865cd9f28Seschrock case HELP_LIST: 229990b4856Slling return (gettext("\tlist [-H] [-o property[,...]] " 2303f9d6ad7SLin Ling "[-T d|u] [pool] ... [interval [count]]\n")); 23165cd9f28Seschrock case HELP_OFFLINE: 232441d80aaSlling return (gettext("\toffline [-t] <pool> <device> ...\n")); 23365cd9f28Seschrock case HELP_ONLINE: 234441d80aaSlling return (gettext("\tonline <pool> <device> ...\n")); 23565cd9f28Seschrock case HELP_REPLACE: 23665cd9f28Seschrock return (gettext("\treplace [-f] <pool> <device> " 237e45ce728Sahrens "[new-device]\n")); 23899653d4eSeschrock case HELP_REMOVE: 239fa94a07fSbrendan return (gettext("\tremove <pool> <device> ...\n")); 2404263d13fSGeorge Wilson case HELP_REOPEN: 2414263d13fSGeorge Wilson return (""); /* Undocumented command */ 24265cd9f28Seschrock case HELP_SCRUB: 24365cd9f28Seschrock return (gettext("\tscrub [-s] <pool> ...\n")); 24465cd9f28Seschrock case HELP_STATUS: 2453f9d6ad7SLin Ling return (gettext("\tstatus [-vx] [-T d|u] [pool] ... [interval " 2463f9d6ad7SLin Ling "[count]]\n")); 247eaca9bbdSeschrock case HELP_UPGRADE: 248eaca9bbdSeschrock return (gettext("\tupgrade\n" 249eaca9bbdSeschrock "\tupgrade -v\n" 250990b4856Slling "\tupgrade [-V version] <-a | pool ...>\n")); 251b1b8ab34Slling case HELP_GET: 252e45ce728Sahrens return (gettext("\tget <\"all\" | property[,...]> " 253b1b8ab34Slling "<pool> ...\n")); 254b1b8ab34Slling case HELP_SET: 255b1b8ab34Slling return (gettext("\tset <property=value> <pool> \n")); 2561195e687SMark J Musante case HELP_SPLIT: 2571195e687SMark J Musante return (gettext("\tsplit [-n] [-R altroot] [-o mntopts]\n" 2581195e687SMark J Musante "\t [-o property=value] <pool> <newpool> " 2591195e687SMark J Musante "[<device> ...]\n")); 260e9103aaeSGarrett D'Amore case HELP_REGUID: 261e9103aaeSGarrett D'Amore return (gettext("\treguid <pool>\n")); 26265cd9f28Seschrock } 26365cd9f28Seschrock 26465cd9f28Seschrock abort(); 26565cd9f28Seschrock /* NOTREACHED */ 26665cd9f28Seschrock } 26765cd9f28Seschrock 268fa9e4066Sahrens 269b1b8ab34Slling /* 270b1b8ab34Slling * Callback routine that will print out a pool property value. 271b1b8ab34Slling */ 272990b4856Slling static int 273990b4856Slling print_prop_cb(int prop, void *cb) 274b1b8ab34Slling { 275b1b8ab34Slling FILE *fp = cb; 276b1b8ab34Slling 277b24ab676SJeff Bonwick (void) fprintf(fp, "\t%-15s ", zpool_prop_to_name(prop)); 278b1b8ab34Slling 279990b4856Slling if (zpool_prop_readonly(prop)) 280990b4856Slling (void) fprintf(fp, " NO "); 281990b4856Slling else 282b24ab676SJeff Bonwick (void) fprintf(fp, " YES "); 283990b4856Slling 284b1b8ab34Slling if (zpool_prop_values(prop) == NULL) 285b1b8ab34Slling (void) fprintf(fp, "-\n"); 286b1b8ab34Slling else 287b1b8ab34Slling (void) fprintf(fp, "%s\n", zpool_prop_values(prop)); 288b1b8ab34Slling 289990b4856Slling return (ZPROP_CONT); 290b1b8ab34Slling } 291b1b8ab34Slling 292fa9e4066Sahrens /* 293fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 294fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 295fa9e4066Sahrens * a complete usage message. 296fa9e4066Sahrens */ 297fa9e4066Sahrens void 29899653d4eSeschrock usage(boolean_t requested) 299fa9e4066Sahrens { 300fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 301fa9e4066Sahrens 302fa9e4066Sahrens if (current_command == NULL) { 303fa9e4066Sahrens int i; 304fa9e4066Sahrens 305fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zpool command args ...\n")); 306fa9e4066Sahrens (void) fprintf(fp, 307fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 308fa9e4066Sahrens 309fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 310fa9e4066Sahrens if (command_table[i].name == NULL) 311fa9e4066Sahrens (void) fprintf(fp, "\n"); 312fa9e4066Sahrens else 313fa9e4066Sahrens (void) fprintf(fp, "%s", 31465cd9f28Seschrock get_usage(command_table[i].usage)); 315fa9e4066Sahrens } 316fa9e4066Sahrens } else { 317fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 31865cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 319fa9e4066Sahrens } 320fa9e4066Sahrens 321b1b8ab34Slling if (current_command != NULL && 322b1b8ab34Slling ((strcmp(current_command->name, "set") == 0) || 323990b4856Slling (strcmp(current_command->name, "get") == 0) || 324990b4856Slling (strcmp(current_command->name, "list") == 0))) { 325b1b8ab34Slling 326b1b8ab34Slling (void) fprintf(fp, 327b1b8ab34Slling gettext("\nthe following properties are supported:\n")); 328b1b8ab34Slling 329b24ab676SJeff Bonwick (void) fprintf(fp, "\n\t%-15s %s %s\n\n", 330990b4856Slling "PROPERTY", "EDIT", "VALUES"); 331b1b8ab34Slling 332b1b8ab34Slling /* Iterate over all properties */ 333990b4856Slling (void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE, 334990b4856Slling ZFS_TYPE_POOL); 335ad135b5dSChristopher Siden 336ad135b5dSChristopher Siden (void) fprintf(fp, "\t%-15s ", "feature@..."); 337ad135b5dSChristopher Siden (void) fprintf(fp, "YES disabled | enabled | active\n"); 338ad135b5dSChristopher Siden 339ad135b5dSChristopher Siden (void) fprintf(fp, gettext("\nThe feature@ properties must be " 340ad135b5dSChristopher Siden "appended with a feature name.\nSee zpool-features(5).\n")); 341b1b8ab34Slling } 342b1b8ab34Slling 343e9dbad6fSeschrock /* 344e9dbad6fSeschrock * See comments at end of main(). 345e9dbad6fSeschrock */ 346e9dbad6fSeschrock if (getenv("ZFS_ABORT") != NULL) { 347e9dbad6fSeschrock (void) printf("dumping core by request\n"); 348e9dbad6fSeschrock abort(); 349e9dbad6fSeschrock } 350e9dbad6fSeschrock 351fa9e4066Sahrens exit(requested ? 0 : 2); 352fa9e4066Sahrens } 353fa9e4066Sahrens 354fa9e4066Sahrens void 3558654d025Sperrin print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent, 3568654d025Sperrin boolean_t print_logs) 357fa9e4066Sahrens { 358fa9e4066Sahrens nvlist_t **child; 359fa9e4066Sahrens uint_t c, children; 360afefbcddSeschrock char *vname; 361fa9e4066Sahrens 362fa9e4066Sahrens if (name != NULL) 363fa9e4066Sahrens (void) printf("\t%*s%s\n", indent, "", name); 364fa9e4066Sahrens 365fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 366fa9e4066Sahrens &child, &children) != 0) 367fa9e4066Sahrens return; 368fa9e4066Sahrens 369afefbcddSeschrock for (c = 0; c < children; c++) { 3708654d025Sperrin uint64_t is_log = B_FALSE; 3718654d025Sperrin 3728654d025Sperrin (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 3738654d025Sperrin &is_log); 3748654d025Sperrin if ((is_log && !print_logs) || (!is_log && print_logs)) 3758654d025Sperrin continue; 3768654d025Sperrin 37788ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE); 3788654d025Sperrin print_vdev_tree(zhp, vname, child[c], indent + 2, 3798654d025Sperrin B_FALSE); 380afefbcddSeschrock free(vname); 381afefbcddSeschrock } 382fa9e4066Sahrens } 383fa9e4066Sahrens 384*57221772SChristopher Siden static boolean_t 385*57221772SChristopher Siden prop_list_contains_feature(nvlist_t *proplist) 386*57221772SChristopher Siden { 387*57221772SChristopher Siden nvpair_t *nvp; 388*57221772SChristopher Siden for (nvp = nvlist_next_nvpair(proplist, NULL); NULL != nvp; 389*57221772SChristopher Siden nvp = nvlist_next_nvpair(proplist, nvp)) { 390*57221772SChristopher Siden if (zpool_prop_feature(nvpair_name(nvp))) 391*57221772SChristopher Siden return (B_TRUE); 392*57221772SChristopher Siden } 393*57221772SChristopher Siden return (B_FALSE); 394*57221772SChristopher Siden } 395*57221772SChristopher Siden 396990b4856Slling /* 397990b4856Slling * Add a property pair (name, string-value) into a property nvlist. 398990b4856Slling */ 399990b4856Slling static int 4000a48a24eStimh add_prop_list(const char *propname, char *propval, nvlist_t **props, 4010a48a24eStimh boolean_t poolprop) 402990b4856Slling { 4030a48a24eStimh zpool_prop_t prop = ZPROP_INVAL; 4040a48a24eStimh zfs_prop_t fprop; 405990b4856Slling nvlist_t *proplist; 4060a48a24eStimh const char *normnm; 4070a48a24eStimh char *strval; 408990b4856Slling 409990b4856Slling if (*props == NULL && 410990b4856Slling nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) { 411990b4856Slling (void) fprintf(stderr, 412990b4856Slling gettext("internal error: out of memory\n")); 413990b4856Slling return (1); 414990b4856Slling } 415990b4856Slling 416990b4856Slling proplist = *props; 417990b4856Slling 4180a48a24eStimh if (poolprop) { 419*57221772SChristopher Siden const char *vname = zpool_prop_to_name(ZPOOL_PROP_VERSION); 420*57221772SChristopher Siden 421ad135b5dSChristopher Siden if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL && 422ad135b5dSChristopher Siden !zpool_prop_feature(propname)) { 4230a48a24eStimh (void) fprintf(stderr, gettext("property '%s' is " 4240a48a24eStimh "not a valid pool property\n"), propname); 4250a48a24eStimh return (2); 4260a48a24eStimh } 427*57221772SChristopher Siden 428*57221772SChristopher Siden /* 429*57221772SChristopher Siden * feature@ properties and version should not be specified 430*57221772SChristopher Siden * at the same time. 431*57221772SChristopher Siden */ 432*57221772SChristopher Siden if ((prop == ZPROP_INVAL && zpool_prop_feature(propname) && 433*57221772SChristopher Siden nvlist_exists(proplist, vname)) || 434*57221772SChristopher Siden (prop == ZPOOL_PROP_VERSION && 435*57221772SChristopher Siden prop_list_contains_feature(proplist))) { 436*57221772SChristopher Siden (void) fprintf(stderr, gettext("'feature@' and " 437*57221772SChristopher Siden "'version' properties cannot be specified " 438*57221772SChristopher Siden "together\n")); 439*57221772SChristopher Siden return (2); 440*57221772SChristopher Siden } 441*57221772SChristopher Siden 442*57221772SChristopher Siden 443ad135b5dSChristopher Siden if (zpool_prop_feature(propname)) 444ad135b5dSChristopher Siden normnm = propname; 445ad135b5dSChristopher Siden else 446ad135b5dSChristopher Siden normnm = zpool_prop_to_name(prop); 4470a48a24eStimh } else { 44814843421SMatthew Ahrens if ((fprop = zfs_name_to_prop(propname)) != ZPROP_INVAL) { 44914843421SMatthew Ahrens normnm = zfs_prop_to_name(fprop); 45014843421SMatthew Ahrens } else { 45114843421SMatthew Ahrens normnm = propname; 4520a48a24eStimh } 453990b4856Slling } 454990b4856Slling 4550a48a24eStimh if (nvlist_lookup_string(proplist, normnm, &strval) == 0 && 4560a48a24eStimh prop != ZPOOL_PROP_CACHEFILE) { 457990b4856Slling (void) fprintf(stderr, gettext("property '%s' " 458990b4856Slling "specified multiple times\n"), propname); 459990b4856Slling return (2); 460990b4856Slling } 461990b4856Slling 4620a48a24eStimh if (nvlist_add_string(proplist, normnm, propval) != 0) { 463990b4856Slling (void) fprintf(stderr, gettext("internal " 464990b4856Slling "error: out of memory\n")); 465990b4856Slling return (1); 466990b4856Slling } 467990b4856Slling 468990b4856Slling return (0); 469990b4856Slling } 470990b4856Slling 471fa9e4066Sahrens /* 472fa9e4066Sahrens * zpool add [-fn] <pool> <vdev> ... 473fa9e4066Sahrens * 474fa9e4066Sahrens * -f Force addition of devices, even if they appear in use 475fa9e4066Sahrens * -n Do not add the devices, but display the resulting layout if 476fa9e4066Sahrens * they were to be added. 477fa9e4066Sahrens * 478fa9e4066Sahrens * Adds the given vdevs to 'pool'. As with create, the bulk of this work is 479fa9e4066Sahrens * handled by get_vdev_spec(), which constructs the nvlist needed to pass to 480fa9e4066Sahrens * libzfs. 481fa9e4066Sahrens */ 482fa9e4066Sahrens int 483fa9e4066Sahrens zpool_do_add(int argc, char **argv) 484fa9e4066Sahrens { 48599653d4eSeschrock boolean_t force = B_FALSE; 48699653d4eSeschrock boolean_t dryrun = B_FALSE; 487fa9e4066Sahrens int c; 488fa9e4066Sahrens nvlist_t *nvroot; 489fa9e4066Sahrens char *poolname; 490fa9e4066Sahrens int ret; 491fa9e4066Sahrens zpool_handle_t *zhp; 492fa9e4066Sahrens nvlist_t *config; 493fa9e4066Sahrens 494fa9e4066Sahrens /* check options */ 495fa9e4066Sahrens while ((c = getopt(argc, argv, "fn")) != -1) { 496fa9e4066Sahrens switch (c) { 497fa9e4066Sahrens case 'f': 49899653d4eSeschrock force = B_TRUE; 499fa9e4066Sahrens break; 500fa9e4066Sahrens case 'n': 50199653d4eSeschrock dryrun = B_TRUE; 502fa9e4066Sahrens break; 503fa9e4066Sahrens case '?': 504fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 505fa9e4066Sahrens optopt); 50699653d4eSeschrock usage(B_FALSE); 507fa9e4066Sahrens } 508fa9e4066Sahrens } 509fa9e4066Sahrens 510fa9e4066Sahrens argc -= optind; 511fa9e4066Sahrens argv += optind; 512fa9e4066Sahrens 513fa9e4066Sahrens /* get pool name and check number of arguments */ 514fa9e4066Sahrens if (argc < 1) { 515fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 51699653d4eSeschrock usage(B_FALSE); 517fa9e4066Sahrens } 518fa9e4066Sahrens if (argc < 2) { 519fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 52099653d4eSeschrock usage(B_FALSE); 521fa9e4066Sahrens } 522fa9e4066Sahrens 523fa9e4066Sahrens poolname = argv[0]; 524fa9e4066Sahrens 525fa9e4066Sahrens argc--; 526fa9e4066Sahrens argv++; 527fa9e4066Sahrens 52899653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 529fa9e4066Sahrens return (1); 530fa9e4066Sahrens 531088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 532fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 533fa9e4066Sahrens poolname); 534fa9e4066Sahrens zpool_close(zhp); 535fa9e4066Sahrens return (1); 536fa9e4066Sahrens } 537fa9e4066Sahrens 538fa9e4066Sahrens /* pass off to get_vdev_spec for processing */ 539705040edSEric Taylor nvroot = make_root_vdev(zhp, force, !force, B_FALSE, dryrun, 540705040edSEric Taylor argc, argv); 541fa9e4066Sahrens if (nvroot == NULL) { 542fa9e4066Sahrens zpool_close(zhp); 543fa9e4066Sahrens return (1); 544fa9e4066Sahrens } 545fa9e4066Sahrens 546fa9e4066Sahrens if (dryrun) { 547fa9e4066Sahrens nvlist_t *poolnvroot; 548fa9e4066Sahrens 549fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 550fa9e4066Sahrens &poolnvroot) == 0); 551fa9e4066Sahrens 552fa9e4066Sahrens (void) printf(gettext("would update '%s' to the following " 553fa9e4066Sahrens "configuration:\n"), zpool_get_name(zhp)); 554fa9e4066Sahrens 5558654d025Sperrin /* print original main pool and new tree */ 5568654d025Sperrin print_vdev_tree(zhp, poolname, poolnvroot, 0, B_FALSE); 5578654d025Sperrin print_vdev_tree(zhp, NULL, nvroot, 0, B_FALSE); 5588654d025Sperrin 5598654d025Sperrin /* Do the same for the logs */ 5608654d025Sperrin if (num_logs(poolnvroot) > 0) { 5618654d025Sperrin print_vdev_tree(zhp, "logs", poolnvroot, 0, B_TRUE); 5628654d025Sperrin print_vdev_tree(zhp, NULL, nvroot, 0, B_TRUE); 5638654d025Sperrin } else if (num_logs(nvroot) > 0) { 5648654d025Sperrin print_vdev_tree(zhp, "logs", nvroot, 0, B_TRUE); 5658654d025Sperrin } 566fa9e4066Sahrens 567fa9e4066Sahrens ret = 0; 568fa9e4066Sahrens } else { 569fa9e4066Sahrens ret = (zpool_add(zhp, nvroot) != 0); 570fa9e4066Sahrens } 571fa9e4066Sahrens 57299653d4eSeschrock nvlist_free(nvroot); 57399653d4eSeschrock zpool_close(zhp); 57499653d4eSeschrock 57599653d4eSeschrock return (ret); 57699653d4eSeschrock } 57799653d4eSeschrock 57899653d4eSeschrock /* 5793f9d6ad7SLin Ling * zpool remove <pool> <vdev> ... 58099653d4eSeschrock * 5813f9d6ad7SLin Ling * Removes the given vdev from the pool. Currently, this supports removing 5823f9d6ad7SLin Ling * spares, cache, and log devices from the pool. 58399653d4eSeschrock */ 58499653d4eSeschrock int 58599653d4eSeschrock zpool_do_remove(int argc, char **argv) 58699653d4eSeschrock { 58799653d4eSeschrock char *poolname; 588fa94a07fSbrendan int i, ret = 0; 58999653d4eSeschrock zpool_handle_t *zhp; 59099653d4eSeschrock 59199653d4eSeschrock argc--; 59299653d4eSeschrock argv++; 59399653d4eSeschrock 59499653d4eSeschrock /* get pool name and check number of arguments */ 59599653d4eSeschrock if (argc < 1) { 59699653d4eSeschrock (void) fprintf(stderr, gettext("missing pool name argument\n")); 59799653d4eSeschrock usage(B_FALSE); 59899653d4eSeschrock } 59999653d4eSeschrock if (argc < 2) { 60099653d4eSeschrock (void) fprintf(stderr, gettext("missing device\n")); 60199653d4eSeschrock usage(B_FALSE); 60299653d4eSeschrock } 60399653d4eSeschrock 60499653d4eSeschrock poolname = argv[0]; 60599653d4eSeschrock 60699653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 60799653d4eSeschrock return (1); 60899653d4eSeschrock 609fa94a07fSbrendan for (i = 1; i < argc; i++) { 610fa94a07fSbrendan if (zpool_vdev_remove(zhp, argv[i]) != 0) 611fa94a07fSbrendan ret = 1; 612fa94a07fSbrendan } 61399653d4eSeschrock 614fa9e4066Sahrens return (ret); 615fa9e4066Sahrens } 616fa9e4066Sahrens 617fa9e4066Sahrens /* 618ad135b5dSChristopher Siden * zpool create [-fnd] [-o property=value] ... 6190a48a24eStimh * [-O file-system-property=value] ... 6200a48a24eStimh * [-R root] [-m mountpoint] <pool> <dev> ... 621fa9e4066Sahrens * 622fa9e4066Sahrens * -f Force creation, even if devices appear in use 623fa9e4066Sahrens * -n Do not create the pool, but display the resulting layout if it 624fa9e4066Sahrens * were to be created. 625fa9e4066Sahrens * -R Create a pool under an alternate root 626fa9e4066Sahrens * -m Set default mountpoint for the root dataset. By default it's 627ad135b5dSChristopher Siden * '/<pool>' 628990b4856Slling * -o Set property=value. 629ad135b5dSChristopher Siden * -d Don't automatically enable all supported pool features 630ad135b5dSChristopher Siden * (individual features can be enabled with -o). 6310a48a24eStimh * -O Set fsproperty=value in the pool's root file system 632fa9e4066Sahrens * 633b1b8ab34Slling * Creates the named pool according to the given vdev specification. The 634fa9e4066Sahrens * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once 635fa9e4066Sahrens * we get the nvlist back from get_vdev_spec(), we either print out the contents 636fa9e4066Sahrens * (if '-n' was specified), or pass it to libzfs to do the creation. 637fa9e4066Sahrens */ 638fa9e4066Sahrens int 639fa9e4066Sahrens zpool_do_create(int argc, char **argv) 640fa9e4066Sahrens { 64199653d4eSeschrock boolean_t force = B_FALSE; 64299653d4eSeschrock boolean_t dryrun = B_FALSE; 643ad135b5dSChristopher Siden boolean_t enable_all_pool_feat = B_TRUE; 644fa9e4066Sahrens int c; 645990b4856Slling nvlist_t *nvroot = NULL; 646fa9e4066Sahrens char *poolname; 647990b4856Slling int ret = 1; 648fa9e4066Sahrens char *altroot = NULL; 649fa9e4066Sahrens char *mountpoint = NULL; 6500a48a24eStimh nvlist_t *fsprops = NULL; 651990b4856Slling nvlist_t *props = NULL; 6522f8aaab3Seschrock char *propval; 653fa9e4066Sahrens 654fa9e4066Sahrens /* check options */ 655ad135b5dSChristopher Siden while ((c = getopt(argc, argv, ":fndR:m:o:O:")) != -1) { 656fa9e4066Sahrens switch (c) { 657fa9e4066Sahrens case 'f': 65899653d4eSeschrock force = B_TRUE; 659fa9e4066Sahrens break; 660fa9e4066Sahrens case 'n': 66199653d4eSeschrock dryrun = B_TRUE; 662fa9e4066Sahrens break; 663ad135b5dSChristopher Siden case 'd': 664ad135b5dSChristopher Siden enable_all_pool_feat = B_FALSE; 665ad135b5dSChristopher Siden break; 666fa9e4066Sahrens case 'R': 667fa9e4066Sahrens altroot = optarg; 668990b4856Slling if (add_prop_list(zpool_prop_to_name( 6690a48a24eStimh ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 670990b4856Slling goto errout; 6712f8aaab3Seschrock if (nvlist_lookup_string(props, 6722f8aaab3Seschrock zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 6732f8aaab3Seschrock &propval) == 0) 6742f8aaab3Seschrock break; 675990b4856Slling if (add_prop_list(zpool_prop_to_name( 6760a48a24eStimh ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE)) 677990b4856Slling goto errout; 678fa9e4066Sahrens break; 679fa9e4066Sahrens case 'm': 680fa9e4066Sahrens mountpoint = optarg; 681fa9e4066Sahrens break; 682990b4856Slling case 'o': 683990b4856Slling if ((propval = strchr(optarg, '=')) == NULL) { 684990b4856Slling (void) fprintf(stderr, gettext("missing " 685990b4856Slling "'=' for -o option\n")); 686990b4856Slling goto errout; 687990b4856Slling } 688990b4856Slling *propval = '\0'; 689990b4856Slling propval++; 690990b4856Slling 6910a48a24eStimh if (add_prop_list(optarg, propval, &props, B_TRUE)) 6920a48a24eStimh goto errout; 693ad135b5dSChristopher Siden 694ad135b5dSChristopher Siden /* 695ad135b5dSChristopher Siden * If the user is creating a pool that doesn't support 696ad135b5dSChristopher Siden * feature flags, don't enable any features. 697ad135b5dSChristopher Siden */ 698ad135b5dSChristopher Siden if (zpool_name_to_prop(optarg) == ZPOOL_PROP_VERSION) { 699ad135b5dSChristopher Siden char *end; 700ad135b5dSChristopher Siden u_longlong_t ver; 701ad135b5dSChristopher Siden 702ad135b5dSChristopher Siden ver = strtoull(propval, &end, 10); 703ad135b5dSChristopher Siden if (*end == '\0' && 704ad135b5dSChristopher Siden ver < SPA_VERSION_FEATURES) { 705ad135b5dSChristopher Siden enable_all_pool_feat = B_FALSE; 706ad135b5dSChristopher Siden } 707ad135b5dSChristopher Siden } 7080a48a24eStimh break; 7090a48a24eStimh case 'O': 7100a48a24eStimh if ((propval = strchr(optarg, '=')) == NULL) { 7110a48a24eStimh (void) fprintf(stderr, gettext("missing " 7120a48a24eStimh "'=' for -O option\n")); 7130a48a24eStimh goto errout; 7140a48a24eStimh } 7150a48a24eStimh *propval = '\0'; 7160a48a24eStimh propval++; 7170a48a24eStimh 7180a48a24eStimh if (add_prop_list(optarg, propval, &fsprops, B_FALSE)) 719990b4856Slling goto errout; 720990b4856Slling break; 721fa9e4066Sahrens case ':': 722fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 723fa9e4066Sahrens "'%c' option\n"), optopt); 724990b4856Slling goto badusage; 725fa9e4066Sahrens case '?': 726fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 727fa9e4066Sahrens optopt); 728990b4856Slling goto badusage; 729fa9e4066Sahrens } 730fa9e4066Sahrens } 731fa9e4066Sahrens 732fa9e4066Sahrens argc -= optind; 733fa9e4066Sahrens argv += optind; 734fa9e4066Sahrens 735fa9e4066Sahrens /* get pool name and check number of arguments */ 736fa9e4066Sahrens if (argc < 1) { 737fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 738990b4856Slling goto badusage; 739fa9e4066Sahrens } 740fa9e4066Sahrens if (argc < 2) { 741fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 742990b4856Slling goto badusage; 743fa9e4066Sahrens } 744fa9e4066Sahrens 745fa9e4066Sahrens poolname = argv[0]; 746fa9e4066Sahrens 747fa9e4066Sahrens /* 748fa9e4066Sahrens * As a special case, check for use of '/' in the name, and direct the 749fa9e4066Sahrens * user to use 'zfs create' instead. 750fa9e4066Sahrens */ 751fa9e4066Sahrens if (strchr(poolname, '/') != NULL) { 752fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot create '%s': invalid " 753fa9e4066Sahrens "character '/' in pool name\n"), poolname); 754fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs create' to " 755fa9e4066Sahrens "create a dataset\n")); 756990b4856Slling goto errout; 757fa9e4066Sahrens } 758fa9e4066Sahrens 759fa9e4066Sahrens /* pass off to get_vdev_spec for bulk processing */ 760705040edSEric Taylor nvroot = make_root_vdev(NULL, force, !force, B_FALSE, dryrun, 761705040edSEric Taylor argc - 1, argv + 1); 762fa9e4066Sahrens if (nvroot == NULL) 7630a48a24eStimh goto errout; 764fa9e4066Sahrens 76599653d4eSeschrock /* make_root_vdev() allows 0 toplevel children if there are spares */ 766b7b97454Sperrin if (!zfs_allocatable_devs(nvroot)) { 76799653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev " 76899653d4eSeschrock "specification: at least one toplevel vdev must be " 76999653d4eSeschrock "specified\n")); 770990b4856Slling goto errout; 77199653d4eSeschrock } 77299653d4eSeschrock 773fa9e4066Sahrens if (altroot != NULL && altroot[0] != '/') { 774fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid alternate root '%s': " 775e9dbad6fSeschrock "must be an absolute path\n"), altroot); 776990b4856Slling goto errout; 777fa9e4066Sahrens } 778fa9e4066Sahrens 779fa9e4066Sahrens /* 780fa9e4066Sahrens * Check the validity of the mountpoint and direct the user to use the 781fa9e4066Sahrens * '-m' mountpoint option if it looks like its in use. 782fa9e4066Sahrens */ 783fa9e4066Sahrens if (mountpoint == NULL || 784fa9e4066Sahrens (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 && 785fa9e4066Sahrens strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) { 786fa9e4066Sahrens char buf[MAXPATHLEN]; 78711022c7cStimh DIR *dirp; 788fa9e4066Sahrens 789fa9e4066Sahrens if (mountpoint && mountpoint[0] != '/') { 790fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid mountpoint " 791fa9e4066Sahrens "'%s': must be an absolute path, 'legacy', or " 792fa9e4066Sahrens "'none'\n"), mountpoint); 793990b4856Slling goto errout; 794fa9e4066Sahrens } 795fa9e4066Sahrens 796fa9e4066Sahrens if (mountpoint == NULL) { 797fa9e4066Sahrens if (altroot != NULL) 798fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s/%s", 799fa9e4066Sahrens altroot, poolname); 800fa9e4066Sahrens else 801fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "/%s", 802fa9e4066Sahrens poolname); 803fa9e4066Sahrens } else { 804fa9e4066Sahrens if (altroot != NULL) 805fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s%s", 806fa9e4066Sahrens altroot, mountpoint); 807fa9e4066Sahrens else 808fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s", 809fa9e4066Sahrens mountpoint); 810fa9e4066Sahrens } 811fa9e4066Sahrens 81211022c7cStimh if ((dirp = opendir(buf)) == NULL && errno != ENOENT) { 81311022c7cStimh (void) fprintf(stderr, gettext("mountpoint '%s' : " 81411022c7cStimh "%s\n"), buf, strerror(errno)); 815fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-m' " 816fa9e4066Sahrens "option to provide a different default\n")); 817990b4856Slling goto errout; 81811022c7cStimh } else if (dirp) { 81911022c7cStimh int count = 0; 82011022c7cStimh 82111022c7cStimh while (count < 3 && readdir(dirp) != NULL) 82211022c7cStimh count++; 82311022c7cStimh (void) closedir(dirp); 82411022c7cStimh 82511022c7cStimh if (count > 2) { 82611022c7cStimh (void) fprintf(stderr, gettext("mountpoint " 82711022c7cStimh "'%s' exists and is not empty\n"), buf); 82811022c7cStimh (void) fprintf(stderr, gettext("use '-m' " 82911022c7cStimh "option to provide a " 83011022c7cStimh "different default\n")); 83111022c7cStimh goto errout; 83211022c7cStimh } 833fa9e4066Sahrens } 834fa9e4066Sahrens } 835fa9e4066Sahrens 836fa9e4066Sahrens if (dryrun) { 837fa9e4066Sahrens /* 838fa9e4066Sahrens * For a dry run invocation, print out a basic message and run 839fa9e4066Sahrens * through all the vdevs in the list and print out in an 840fa9e4066Sahrens * appropriate hierarchy. 841fa9e4066Sahrens */ 842fa9e4066Sahrens (void) printf(gettext("would create '%s' with the " 843fa9e4066Sahrens "following layout:\n\n"), poolname); 844fa9e4066Sahrens 8458654d025Sperrin print_vdev_tree(NULL, poolname, nvroot, 0, B_FALSE); 8468654d025Sperrin if (num_logs(nvroot) > 0) 8478654d025Sperrin print_vdev_tree(NULL, "logs", nvroot, 0, B_TRUE); 848fa9e4066Sahrens 849fa9e4066Sahrens ret = 0; 850fa9e4066Sahrens } else { 851fa9e4066Sahrens /* 852fa9e4066Sahrens * Hand off to libzfs. 853fa9e4066Sahrens */ 854ad135b5dSChristopher Siden if (enable_all_pool_feat) { 855ad135b5dSChristopher Siden int i; 856ad135b5dSChristopher Siden for (i = 0; i < SPA_FEATURES; i++) { 857ad135b5dSChristopher Siden char propname[MAXPATHLEN]; 858ad135b5dSChristopher Siden zfeature_info_t *feat = &spa_feature_table[i]; 859ad135b5dSChristopher Siden 860ad135b5dSChristopher Siden (void) snprintf(propname, sizeof (propname), 861ad135b5dSChristopher Siden "feature@%s", feat->fi_uname); 862ad135b5dSChristopher Siden 863ad135b5dSChristopher Siden /* 864ad135b5dSChristopher Siden * Skip feature if user specified it manually 865ad135b5dSChristopher Siden * on the command line. 866ad135b5dSChristopher Siden */ 867ad135b5dSChristopher Siden if (nvlist_exists(props, propname)) 868ad135b5dSChristopher Siden continue; 869ad135b5dSChristopher Siden 870ad135b5dSChristopher Siden if (add_prop_list(propname, ZFS_FEATURE_ENABLED, 871ad135b5dSChristopher Siden &props, B_TRUE) != 0) 872ad135b5dSChristopher Siden goto errout; 873ad135b5dSChristopher Siden } 874ad135b5dSChristopher Siden } 8750a48a24eStimh if (zpool_create(g_zfs, poolname, 8760a48a24eStimh nvroot, props, fsprops) == 0) { 87799653d4eSeschrock zfs_handle_t *pool = zfs_open(g_zfs, poolname, 878fa9e4066Sahrens ZFS_TYPE_FILESYSTEM); 879fa9e4066Sahrens if (pool != NULL) { 880fa9e4066Sahrens if (mountpoint != NULL) 881fa9e4066Sahrens verify(zfs_prop_set(pool, 882e9dbad6fSeschrock zfs_prop_to_name( 883e9dbad6fSeschrock ZFS_PROP_MOUNTPOINT), 884fa9e4066Sahrens mountpoint) == 0); 885fa9e4066Sahrens if (zfs_mount(pool, NULL, 0) == 0) 886da6c28aaSamw ret = zfs_shareall(pool); 887fa9e4066Sahrens zfs_close(pool); 888fa9e4066Sahrens } 88999653d4eSeschrock } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) { 89099653d4eSeschrock (void) fprintf(stderr, gettext("pool name may have " 89199653d4eSeschrock "been omitted\n")); 892fa9e4066Sahrens } 893fa9e4066Sahrens } 894fa9e4066Sahrens 895990b4856Slling errout: 8962f8aaab3Seschrock nvlist_free(nvroot); 8970a48a24eStimh nvlist_free(fsprops); 8982f8aaab3Seschrock nvlist_free(props); 899fa9e4066Sahrens return (ret); 900990b4856Slling badusage: 9010a48a24eStimh nvlist_free(fsprops); 902990b4856Slling nvlist_free(props); 903990b4856Slling usage(B_FALSE); 904990b4856Slling return (2); 905fa9e4066Sahrens } 906fa9e4066Sahrens 907fa9e4066Sahrens /* 908fa9e4066Sahrens * zpool destroy <pool> 909fa9e4066Sahrens * 910fa9e4066Sahrens * -f Forcefully unmount any datasets 911fa9e4066Sahrens * 912fa9e4066Sahrens * Destroy the given pool. Automatically unmounts any datasets in the pool. 913fa9e4066Sahrens */ 914fa9e4066Sahrens int 915fa9e4066Sahrens zpool_do_destroy(int argc, char **argv) 916fa9e4066Sahrens { 91799653d4eSeschrock boolean_t force = B_FALSE; 918fa9e4066Sahrens int c; 919fa9e4066Sahrens char *pool; 920fa9e4066Sahrens zpool_handle_t *zhp; 921fa9e4066Sahrens int ret; 922fa9e4066Sahrens 923fa9e4066Sahrens /* check options */ 924fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 925fa9e4066Sahrens switch (c) { 926fa9e4066Sahrens case 'f': 92799653d4eSeschrock force = B_TRUE; 928fa9e4066Sahrens break; 929fa9e4066Sahrens case '?': 930fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 931fa9e4066Sahrens optopt); 93299653d4eSeschrock usage(B_FALSE); 933fa9e4066Sahrens } 934fa9e4066Sahrens } 935fa9e4066Sahrens 936fa9e4066Sahrens argc -= optind; 937fa9e4066Sahrens argv += optind; 938fa9e4066Sahrens 939fa9e4066Sahrens /* check arguments */ 940fa9e4066Sahrens if (argc < 1) { 941fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 94299653d4eSeschrock usage(B_FALSE); 943fa9e4066Sahrens } 944fa9e4066Sahrens if (argc > 1) { 945fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 94699653d4eSeschrock usage(B_FALSE); 947fa9e4066Sahrens } 948fa9e4066Sahrens 949fa9e4066Sahrens pool = argv[0]; 950fa9e4066Sahrens 95199653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 952fa9e4066Sahrens /* 953fa9e4066Sahrens * As a special case, check for use of '/' in the name, and 954fa9e4066Sahrens * direct the user to use 'zfs destroy' instead. 955fa9e4066Sahrens */ 956fa9e4066Sahrens if (strchr(pool, '/') != NULL) 957fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy' to " 958fa9e4066Sahrens "destroy a dataset\n")); 959fa9e4066Sahrens return (1); 960fa9e4066Sahrens } 961fa9e4066Sahrens 962f3861e1aSahl if (zpool_disable_datasets(zhp, force) != 0) { 963fa9e4066Sahrens (void) fprintf(stderr, gettext("could not destroy '%s': " 964fa9e4066Sahrens "could not unmount datasets\n"), zpool_get_name(zhp)); 965fa9e4066Sahrens return (1); 966fa9e4066Sahrens } 967fa9e4066Sahrens 9684445fffbSMatthew Ahrens /* The history must be logged as part of the export */ 9694445fffbSMatthew Ahrens log_history = B_FALSE; 9704445fffbSMatthew Ahrens 9714445fffbSMatthew Ahrens ret = (zpool_destroy(zhp, history_str) != 0); 972fa9e4066Sahrens 973fa9e4066Sahrens zpool_close(zhp); 974fa9e4066Sahrens 975fa9e4066Sahrens return (ret); 976fa9e4066Sahrens } 977fa9e4066Sahrens 978fa9e4066Sahrens /* 979fa9e4066Sahrens * zpool export [-f] <pool> ... 980fa9e4066Sahrens * 981fa9e4066Sahrens * -f Forcefully unmount datasets 982fa9e4066Sahrens * 983b1b8ab34Slling * Export the given pools. By default, the command will attempt to cleanly 984fa9e4066Sahrens * unmount any active datasets within the pool. If the '-f' flag is specified, 985fa9e4066Sahrens * then the datasets will be forcefully unmounted. 986fa9e4066Sahrens */ 987fa9e4066Sahrens int 988fa9e4066Sahrens zpool_do_export(int argc, char **argv) 989fa9e4066Sahrens { 99099653d4eSeschrock boolean_t force = B_FALSE; 991394ab0cbSGeorge Wilson boolean_t hardforce = B_FALSE; 992fa9e4066Sahrens int c; 993fa9e4066Sahrens zpool_handle_t *zhp; 994fa9e4066Sahrens int ret; 995fa9e4066Sahrens int i; 996fa9e4066Sahrens 997fa9e4066Sahrens /* check options */ 998394ab0cbSGeorge Wilson while ((c = getopt(argc, argv, "fF")) != -1) { 999fa9e4066Sahrens switch (c) { 1000fa9e4066Sahrens case 'f': 100199653d4eSeschrock force = B_TRUE; 1002fa9e4066Sahrens break; 1003394ab0cbSGeorge Wilson case 'F': 1004394ab0cbSGeorge Wilson hardforce = B_TRUE; 1005394ab0cbSGeorge Wilson break; 1006fa9e4066Sahrens case '?': 1007fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1008fa9e4066Sahrens optopt); 100999653d4eSeschrock usage(B_FALSE); 1010fa9e4066Sahrens } 1011fa9e4066Sahrens } 1012fa9e4066Sahrens 1013fa9e4066Sahrens argc -= optind; 1014fa9e4066Sahrens argv += optind; 1015fa9e4066Sahrens 1016fa9e4066Sahrens /* check arguments */ 1017fa9e4066Sahrens if (argc < 1) { 1018fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 101999653d4eSeschrock usage(B_FALSE); 1020fa9e4066Sahrens } 1021fa9e4066Sahrens 1022fa9e4066Sahrens ret = 0; 1023fa9e4066Sahrens for (i = 0; i < argc; i++) { 102499653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, argv[i])) == NULL) { 1025fa9e4066Sahrens ret = 1; 1026fa9e4066Sahrens continue; 1027fa9e4066Sahrens } 1028fa9e4066Sahrens 1029f3861e1aSahl if (zpool_disable_datasets(zhp, force) != 0) { 1030fa9e4066Sahrens ret = 1; 1031fa9e4066Sahrens zpool_close(zhp); 1032fa9e4066Sahrens continue; 1033fa9e4066Sahrens } 1034fa9e4066Sahrens 10354445fffbSMatthew Ahrens /* The history must be logged as part of the export */ 10364445fffbSMatthew Ahrens log_history = B_FALSE; 10374445fffbSMatthew Ahrens 1038394ab0cbSGeorge Wilson if (hardforce) { 10394445fffbSMatthew Ahrens if (zpool_export_force(zhp, history_str) != 0) 1040394ab0cbSGeorge Wilson ret = 1; 10414445fffbSMatthew Ahrens } else if (zpool_export(zhp, force, history_str) != 0) { 1042fa9e4066Sahrens ret = 1; 1043394ab0cbSGeorge Wilson } 1044fa9e4066Sahrens 1045fa9e4066Sahrens zpool_close(zhp); 1046fa9e4066Sahrens } 1047fa9e4066Sahrens 1048fa9e4066Sahrens return (ret); 1049fa9e4066Sahrens } 1050fa9e4066Sahrens 1051fa9e4066Sahrens /* 1052fa9e4066Sahrens * Given a vdev configuration, determine the maximum width needed for the device 1053fa9e4066Sahrens * name column. 1054fa9e4066Sahrens */ 1055fa9e4066Sahrens static int 1056c67d9675Seschrock max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max) 1057fa9e4066Sahrens { 105888ecc943SGeorge Wilson char *name = zpool_vdev_name(g_zfs, zhp, nv, B_TRUE); 1059fa9e4066Sahrens nvlist_t **child; 1060fa9e4066Sahrens uint_t c, children; 1061fa9e4066Sahrens int ret; 1062fa9e4066Sahrens 1063fa9e4066Sahrens if (strlen(name) + depth > max) 1064fa9e4066Sahrens max = strlen(name) + depth; 1065fa9e4066Sahrens 1066afefbcddSeschrock free(name); 1067afefbcddSeschrock 106899653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 106999653d4eSeschrock &child, &children) == 0) { 107099653d4eSeschrock for (c = 0; c < children; c++) 107199653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 107299653d4eSeschrock max)) > max) 107399653d4eSeschrock max = ret; 107499653d4eSeschrock } 107599653d4eSeschrock 1076fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 1077fa94a07fSbrendan &child, &children) == 0) { 1078fa94a07fSbrendan for (c = 0; c < children; c++) 1079fa94a07fSbrendan if ((ret = max_width(zhp, child[c], depth + 2, 1080fa94a07fSbrendan max)) > max) 1081fa94a07fSbrendan max = ret; 1082fa94a07fSbrendan } 1083fa94a07fSbrendan 1084fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 108599653d4eSeschrock &child, &children) == 0) { 108699653d4eSeschrock for (c = 0; c < children; c++) 108799653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 108899653d4eSeschrock max)) > max) 108999653d4eSeschrock max = ret; 109099653d4eSeschrock } 1091fa9e4066Sahrens 1092fa9e4066Sahrens 1093fa9e4066Sahrens return (max); 1094fa9e4066Sahrens } 1095fa9e4066Sahrens 1096e6ca193dSGeorge Wilson typedef struct spare_cbdata { 1097e6ca193dSGeorge Wilson uint64_t cb_guid; 1098e6ca193dSGeorge Wilson zpool_handle_t *cb_zhp; 1099e6ca193dSGeorge Wilson } spare_cbdata_t; 1100e6ca193dSGeorge Wilson 1101e6ca193dSGeorge Wilson static boolean_t 1102e6ca193dSGeorge Wilson find_vdev(nvlist_t *nv, uint64_t search) 1103e6ca193dSGeorge Wilson { 1104e6ca193dSGeorge Wilson uint64_t guid; 1105e6ca193dSGeorge Wilson nvlist_t **child; 1106e6ca193dSGeorge Wilson uint_t c, children; 1107e6ca193dSGeorge Wilson 1108e6ca193dSGeorge Wilson if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 && 1109e6ca193dSGeorge Wilson search == guid) 1110e6ca193dSGeorge Wilson return (B_TRUE); 1111e6ca193dSGeorge Wilson 1112e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1113e6ca193dSGeorge Wilson &child, &children) == 0) { 1114e6ca193dSGeorge Wilson for (c = 0; c < children; c++) 1115e6ca193dSGeorge Wilson if (find_vdev(child[c], search)) 1116e6ca193dSGeorge Wilson return (B_TRUE); 1117e6ca193dSGeorge Wilson } 1118e6ca193dSGeorge Wilson 1119e6ca193dSGeorge Wilson return (B_FALSE); 1120e6ca193dSGeorge Wilson } 1121e6ca193dSGeorge Wilson 1122e6ca193dSGeorge Wilson static int 1123e6ca193dSGeorge Wilson find_spare(zpool_handle_t *zhp, void *data) 1124e6ca193dSGeorge Wilson { 1125e6ca193dSGeorge Wilson spare_cbdata_t *cbp = data; 1126e6ca193dSGeorge Wilson nvlist_t *config, *nvroot; 1127e6ca193dSGeorge Wilson 1128e6ca193dSGeorge Wilson config = zpool_get_config(zhp, NULL); 1129e6ca193dSGeorge Wilson verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1130e6ca193dSGeorge Wilson &nvroot) == 0); 1131e6ca193dSGeorge Wilson 1132e6ca193dSGeorge Wilson if (find_vdev(nvroot, cbp->cb_guid)) { 1133e6ca193dSGeorge Wilson cbp->cb_zhp = zhp; 1134e6ca193dSGeorge Wilson return (1); 1135e6ca193dSGeorge Wilson } 1136e6ca193dSGeorge Wilson 1137e6ca193dSGeorge Wilson zpool_close(zhp); 1138e6ca193dSGeorge Wilson return (0); 1139e6ca193dSGeorge Wilson } 1140e6ca193dSGeorge Wilson 1141e6ca193dSGeorge Wilson /* 1142e6ca193dSGeorge Wilson * Print out configuration state as requested by status_callback. 1143e6ca193dSGeorge Wilson */ 1144e6ca193dSGeorge Wilson void 1145e6ca193dSGeorge Wilson print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 1146e6ca193dSGeorge Wilson int namewidth, int depth, boolean_t isspare) 1147e6ca193dSGeorge Wilson { 1148e6ca193dSGeorge Wilson nvlist_t **child; 1149e6ca193dSGeorge Wilson uint_t c, children; 11503f9d6ad7SLin Ling pool_scan_stat_t *ps = NULL; 1151e6ca193dSGeorge Wilson vdev_stat_t *vs; 11523f9d6ad7SLin Ling char rbuf[6], wbuf[6], cbuf[6]; 1153e6ca193dSGeorge Wilson char *vname; 1154e6ca193dSGeorge Wilson uint64_t notpresent; 1155e6ca193dSGeorge Wilson spare_cbdata_t cb; 1156e6ca193dSGeorge Wilson char *state; 1157e6ca193dSGeorge Wilson 1158e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1159e6ca193dSGeorge Wilson &child, &children) != 0) 1160e6ca193dSGeorge Wilson children = 0; 1161e6ca193dSGeorge Wilson 11623f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 11633f9d6ad7SLin Ling (uint64_t **)&vs, &c) == 0); 11643f9d6ad7SLin Ling 1165e6ca193dSGeorge Wilson state = zpool_state_to_name(vs->vs_state, vs->vs_aux); 1166e6ca193dSGeorge Wilson if (isspare) { 1167e6ca193dSGeorge Wilson /* 1168e6ca193dSGeorge Wilson * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for 1169e6ca193dSGeorge Wilson * online drives. 1170e6ca193dSGeorge Wilson */ 1171e6ca193dSGeorge Wilson if (vs->vs_aux == VDEV_AUX_SPARED) 1172e6ca193dSGeorge Wilson state = "INUSE"; 1173e6ca193dSGeorge Wilson else if (vs->vs_state == VDEV_STATE_HEALTHY) 1174e6ca193dSGeorge Wilson state = "AVAIL"; 1175e6ca193dSGeorge Wilson } 1176e6ca193dSGeorge Wilson 1177e6ca193dSGeorge Wilson (void) printf("\t%*s%-*s %-8s", depth, "", namewidth - depth, 1178e6ca193dSGeorge Wilson name, state); 1179e6ca193dSGeorge Wilson 1180e6ca193dSGeorge Wilson if (!isspare) { 1181e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf)); 1182e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf)); 1183e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf)); 1184e6ca193dSGeorge Wilson (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf); 1185e6ca193dSGeorge Wilson } 1186e6ca193dSGeorge Wilson 1187e6ca193dSGeorge Wilson if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1188e6ca193dSGeorge Wilson ¬present) == 0) { 1189e6ca193dSGeorge Wilson char *path; 1190e6ca193dSGeorge Wilson verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1191e6ca193dSGeorge Wilson (void) printf(" was %s", path); 1192e6ca193dSGeorge Wilson } else if (vs->vs_aux != 0) { 1193e6ca193dSGeorge Wilson (void) printf(" "); 1194e6ca193dSGeorge Wilson 1195e6ca193dSGeorge Wilson switch (vs->vs_aux) { 1196e6ca193dSGeorge Wilson case VDEV_AUX_OPEN_FAILED: 1197e6ca193dSGeorge Wilson (void) printf(gettext("cannot open")); 1198e6ca193dSGeorge Wilson break; 1199e6ca193dSGeorge Wilson 1200e6ca193dSGeorge Wilson case VDEV_AUX_BAD_GUID_SUM: 1201e6ca193dSGeorge Wilson (void) printf(gettext("missing device")); 1202e6ca193dSGeorge Wilson break; 1203e6ca193dSGeorge Wilson 1204e6ca193dSGeorge Wilson case VDEV_AUX_NO_REPLICAS: 1205e6ca193dSGeorge Wilson (void) printf(gettext("insufficient replicas")); 1206e6ca193dSGeorge Wilson break; 1207e6ca193dSGeorge Wilson 1208e6ca193dSGeorge Wilson case VDEV_AUX_VERSION_NEWER: 1209e6ca193dSGeorge Wilson (void) printf(gettext("newer version")); 1210e6ca193dSGeorge Wilson break; 1211e6ca193dSGeorge Wilson 1212ad135b5dSChristopher Siden case VDEV_AUX_UNSUP_FEAT: 1213ad135b5dSChristopher Siden (void) printf(gettext("unsupported feature(s)")); 1214ad135b5dSChristopher Siden break; 1215ad135b5dSChristopher Siden 1216e6ca193dSGeorge Wilson case VDEV_AUX_SPARED: 1217e6ca193dSGeorge Wilson verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, 1218e6ca193dSGeorge Wilson &cb.cb_guid) == 0); 1219e6ca193dSGeorge Wilson if (zpool_iter(g_zfs, find_spare, &cb) == 1) { 1220e6ca193dSGeorge Wilson if (strcmp(zpool_get_name(cb.cb_zhp), 1221e6ca193dSGeorge Wilson zpool_get_name(zhp)) == 0) 1222e6ca193dSGeorge Wilson (void) printf(gettext("currently in " 1223e6ca193dSGeorge Wilson "use")); 1224e6ca193dSGeorge Wilson else 1225e6ca193dSGeorge Wilson (void) printf(gettext("in use by " 1226e6ca193dSGeorge Wilson "pool '%s'"), 1227e6ca193dSGeorge Wilson zpool_get_name(cb.cb_zhp)); 1228e6ca193dSGeorge Wilson zpool_close(cb.cb_zhp); 1229e6ca193dSGeorge Wilson } else { 1230e6ca193dSGeorge Wilson (void) printf(gettext("currently in use")); 1231e6ca193dSGeorge Wilson } 1232e6ca193dSGeorge Wilson break; 1233e6ca193dSGeorge Wilson 1234e6ca193dSGeorge Wilson case VDEV_AUX_ERR_EXCEEDED: 1235e6ca193dSGeorge Wilson (void) printf(gettext("too many errors")); 1236e6ca193dSGeorge Wilson break; 1237e6ca193dSGeorge Wilson 1238e6ca193dSGeorge Wilson case VDEV_AUX_IO_FAILURE: 1239e6ca193dSGeorge Wilson (void) printf(gettext("experienced I/O failures")); 1240e6ca193dSGeorge Wilson break; 1241e6ca193dSGeorge Wilson 1242e6ca193dSGeorge Wilson case VDEV_AUX_BAD_LOG: 1243e6ca193dSGeorge Wilson (void) printf(gettext("bad intent log")); 1244e6ca193dSGeorge Wilson break; 1245e6ca193dSGeorge Wilson 1246069f55e2SEric Schrock case VDEV_AUX_EXTERNAL: 1247069f55e2SEric Schrock (void) printf(gettext("external device fault")); 1248069f55e2SEric Schrock break; 1249069f55e2SEric Schrock 12501195e687SMark J Musante case VDEV_AUX_SPLIT_POOL: 12511195e687SMark J Musante (void) printf(gettext("split into new pool")); 12521195e687SMark J Musante break; 12531195e687SMark J Musante 1254e6ca193dSGeorge Wilson default: 1255e6ca193dSGeorge Wilson (void) printf(gettext("corrupted data")); 1256e6ca193dSGeorge Wilson break; 1257e6ca193dSGeorge Wilson } 12583f9d6ad7SLin Ling } 12593f9d6ad7SLin Ling 12603f9d6ad7SLin Ling (void) nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_SCAN_STATS, 12613f9d6ad7SLin Ling (uint64_t **)&ps, &c); 12623f9d6ad7SLin Ling 12633f9d6ad7SLin Ling if (ps && ps->pss_state == DSS_SCANNING && 12643f9d6ad7SLin Ling vs->vs_scan_processed != 0 && children == 0) { 12653f9d6ad7SLin Ling (void) printf(gettext(" (%s)"), 12663f9d6ad7SLin Ling (ps->pss_func == POOL_SCAN_RESILVER) ? 12673f9d6ad7SLin Ling "resilvering" : "repairing"); 1268e6ca193dSGeorge Wilson } 1269e6ca193dSGeorge Wilson 1270e6ca193dSGeorge Wilson (void) printf("\n"); 1271e6ca193dSGeorge Wilson 1272e6ca193dSGeorge Wilson for (c = 0; c < children; c++) { 127388ecc943SGeorge Wilson uint64_t islog = B_FALSE, ishole = B_FALSE; 1274e6ca193dSGeorge Wilson 127588ecc943SGeorge Wilson /* Don't print logs or holes here */ 1276e6ca193dSGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 127788ecc943SGeorge Wilson &islog); 127888ecc943SGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 127988ecc943SGeorge Wilson &ishole); 128088ecc943SGeorge Wilson if (islog || ishole) 1281e6ca193dSGeorge Wilson continue; 128288ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE); 1283e6ca193dSGeorge Wilson print_status_config(zhp, vname, child[c], 1284e6ca193dSGeorge Wilson namewidth, depth + 2, isspare); 1285e6ca193dSGeorge Wilson free(vname); 1286e6ca193dSGeorge Wilson } 1287e6ca193dSGeorge Wilson } 1288e6ca193dSGeorge Wilson 1289fa9e4066Sahrens 1290fa9e4066Sahrens /* 1291fa9e4066Sahrens * Print the configuration of an exported pool. Iterate over all vdevs in the 1292fa9e4066Sahrens * pool, printing out the name and status for each one. 1293fa9e4066Sahrens */ 1294fa9e4066Sahrens void 1295e6ca193dSGeorge Wilson print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth) 1296fa9e4066Sahrens { 1297fa9e4066Sahrens nvlist_t **child; 1298fa9e4066Sahrens uint_t c, children; 1299fa9e4066Sahrens vdev_stat_t *vs; 1300afefbcddSeschrock char *type, *vname; 1301fa9e4066Sahrens 1302fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 130388ecc943SGeorge Wilson if (strcmp(type, VDEV_TYPE_MISSING) == 0 || 130488ecc943SGeorge Wilson strcmp(type, VDEV_TYPE_HOLE) == 0) 1305fa9e4066Sahrens return; 1306fa9e4066Sahrens 13073f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 1308fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 1309fa9e4066Sahrens 1310fa9e4066Sahrens (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name); 1311990b4856Slling (void) printf(" %s", zpool_state_to_name(vs->vs_state, vs->vs_aux)); 1312fa9e4066Sahrens 1313fa9e4066Sahrens if (vs->vs_aux != 0) { 13143d7072f8Seschrock (void) printf(" "); 1315fa9e4066Sahrens 1316fa9e4066Sahrens switch (vs->vs_aux) { 1317fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 1318fa9e4066Sahrens (void) printf(gettext("cannot open")); 1319fa9e4066Sahrens break; 1320fa9e4066Sahrens 1321fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 1322fa9e4066Sahrens (void) printf(gettext("missing device")); 1323fa9e4066Sahrens break; 1324fa9e4066Sahrens 1325fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 1326fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 1327fa9e4066Sahrens break; 1328fa9e4066Sahrens 1329eaca9bbdSeschrock case VDEV_AUX_VERSION_NEWER: 1330eaca9bbdSeschrock (void) printf(gettext("newer version")); 1331eaca9bbdSeschrock break; 1332eaca9bbdSeschrock 1333ad135b5dSChristopher Siden case VDEV_AUX_UNSUP_FEAT: 1334ad135b5dSChristopher Siden (void) printf(gettext("unsupported feature(s)")); 1335ad135b5dSChristopher Siden break; 1336ad135b5dSChristopher Siden 13373d7072f8Seschrock case VDEV_AUX_ERR_EXCEEDED: 13383d7072f8Seschrock (void) printf(gettext("too many errors")); 13393d7072f8Seschrock break; 13403d7072f8Seschrock 1341fa9e4066Sahrens default: 1342fa9e4066Sahrens (void) printf(gettext("corrupted data")); 1343fa9e4066Sahrens break; 1344fa9e4066Sahrens } 1345fa9e4066Sahrens } 1346fa9e4066Sahrens (void) printf("\n"); 1347fa9e4066Sahrens 1348fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1349fa9e4066Sahrens &child, &children) != 0) 1350fa9e4066Sahrens return; 1351fa9e4066Sahrens 1352afefbcddSeschrock for (c = 0; c < children; c++) { 13538654d025Sperrin uint64_t is_log = B_FALSE; 13548654d025Sperrin 13558654d025Sperrin (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 13568654d025Sperrin &is_log); 1357e6ca193dSGeorge Wilson if (is_log) 13588654d025Sperrin continue; 13598654d025Sperrin 136088ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_TRUE); 1361e6ca193dSGeorge Wilson print_import_config(vname, child[c], namewidth, depth + 2); 1362afefbcddSeschrock free(vname); 1363afefbcddSeschrock } 136499653d4eSeschrock 1365fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 1366fa94a07fSbrendan &child, &children) == 0) { 1367fa94a07fSbrendan (void) printf(gettext("\tcache\n")); 1368fa94a07fSbrendan for (c = 0; c < children; c++) { 136988ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE); 1370fa94a07fSbrendan (void) printf("\t %s\n", vname); 1371fa94a07fSbrendan free(vname); 1372fa94a07fSbrendan } 1373fa94a07fSbrendan } 137499653d4eSeschrock 1375fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 1376fa94a07fSbrendan &child, &children) == 0) { 1377fa94a07fSbrendan (void) printf(gettext("\tspares\n")); 1378fa94a07fSbrendan for (c = 0; c < children; c++) { 137988ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE); 1380fa94a07fSbrendan (void) printf("\t %s\n", vname); 1381fa94a07fSbrendan free(vname); 1382fa94a07fSbrendan } 138399653d4eSeschrock } 1384fa9e4066Sahrens } 1385fa9e4066Sahrens 1386e6ca193dSGeorge Wilson /* 1387e6ca193dSGeorge Wilson * Print log vdevs. 1388e6ca193dSGeorge Wilson * Logs are recorded as top level vdevs in the main pool child array 1389e6ca193dSGeorge Wilson * but with "is_log" set to 1. We use either print_status_config() or 1390e6ca193dSGeorge Wilson * print_import_config() to print the top level logs then any log 1391e6ca193dSGeorge Wilson * children (eg mirrored slogs) are printed recursively - which 1392e6ca193dSGeorge Wilson * works because only the top level vdev is marked "is_log" 1393e6ca193dSGeorge Wilson */ 1394e6ca193dSGeorge Wilson static void 1395e6ca193dSGeorge Wilson print_logs(zpool_handle_t *zhp, nvlist_t *nv, int namewidth, boolean_t verbose) 1396e6ca193dSGeorge Wilson { 1397e6ca193dSGeorge Wilson uint_t c, children; 1398e6ca193dSGeorge Wilson nvlist_t **child; 1399e6ca193dSGeorge Wilson 1400e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child, 1401e6ca193dSGeorge Wilson &children) != 0) 1402e6ca193dSGeorge Wilson return; 1403e6ca193dSGeorge Wilson 1404e6ca193dSGeorge Wilson (void) printf(gettext("\tlogs\n")); 1405e6ca193dSGeorge Wilson 1406e6ca193dSGeorge Wilson for (c = 0; c < children; c++) { 1407e6ca193dSGeorge Wilson uint64_t is_log = B_FALSE; 1408e6ca193dSGeorge Wilson char *name; 1409e6ca193dSGeorge Wilson 1410e6ca193dSGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 1411e6ca193dSGeorge Wilson &is_log); 1412e6ca193dSGeorge Wilson if (!is_log) 1413e6ca193dSGeorge Wilson continue; 141488ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE); 1415e6ca193dSGeorge Wilson if (verbose) 1416e6ca193dSGeorge Wilson print_status_config(zhp, name, child[c], namewidth, 1417e6ca193dSGeorge Wilson 2, B_FALSE); 1418e6ca193dSGeorge Wilson else 1419e6ca193dSGeorge Wilson print_import_config(name, child[c], namewidth, 2); 1420e6ca193dSGeorge Wilson free(name); 1421e6ca193dSGeorge Wilson } 1422e6ca193dSGeorge Wilson } 1423468c413aSTim Haley 1424fa9e4066Sahrens /* 1425fa9e4066Sahrens * Display the status for the given pool. 1426fa9e4066Sahrens */ 1427fa9e4066Sahrens static void 1428fa9e4066Sahrens show_import(nvlist_t *config) 1429fa9e4066Sahrens { 1430fa9e4066Sahrens uint64_t pool_state; 1431fa9e4066Sahrens vdev_stat_t *vs; 1432fa9e4066Sahrens char *name; 1433fa9e4066Sahrens uint64_t guid; 1434fa9e4066Sahrens char *msgid; 1435fa9e4066Sahrens nvlist_t *nvroot; 1436fa9e4066Sahrens int reason; 143746657f8dSmmusante const char *health; 1438fa9e4066Sahrens uint_t vsc; 1439fa9e4066Sahrens int namewidth; 14408704186eSDan McDonald char *comment; 1441fa9e4066Sahrens 1442fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1443fa9e4066Sahrens &name) == 0); 1444fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 1445fa9e4066Sahrens &guid) == 0); 1446fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 1447fa9e4066Sahrens &pool_state) == 0); 1448fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1449fa9e4066Sahrens &nvroot) == 0); 1450fa9e4066Sahrens 14513f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 1452fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 1453990b4856Slling health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 1454fa9e4066Sahrens 1455fa9e4066Sahrens reason = zpool_import_status(config, &msgid); 1456fa9e4066Sahrens 14578704186eSDan McDonald (void) printf(gettext(" pool: %s\n"), name); 14588704186eSDan McDonald (void) printf(gettext(" id: %llu\n"), (u_longlong_t)guid); 14598704186eSDan McDonald (void) printf(gettext(" state: %s"), health); 14604c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 1461b1b8ab34Slling (void) printf(gettext(" (DESTROYED)")); 14624c58d714Sdarrenm (void) printf("\n"); 1463fa9e4066Sahrens 1464fa9e4066Sahrens switch (reason) { 1465fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 1466fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 1467fa9e4066Sahrens case ZPOOL_STATUS_BAD_GUID_SUM: 14688704186eSDan McDonald (void) printf(gettext(" status: One or more devices are " 14698704186eSDan McDonald "missing from the system.\n")); 1470fa9e4066Sahrens break; 1471fa9e4066Sahrens 1472fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 1473fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 14748704186eSDan McDonald (void) printf(gettext(" status: One or more devices contains " 1475fa9e4066Sahrens "corrupted data.\n")); 1476fa9e4066Sahrens break; 1477fa9e4066Sahrens 1478fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_DATA: 14798704186eSDan McDonald (void) printf( 14808704186eSDan McDonald gettext(" status: The pool data is corrupted.\n")); 1481fa9e4066Sahrens break; 1482fa9e4066Sahrens 1483441d80aaSlling case ZPOOL_STATUS_OFFLINE_DEV: 14848704186eSDan McDonald (void) printf(gettext(" status: One or more devices " 1485441d80aaSlling "are offlined.\n")); 1486441d80aaSlling break; 1487441d80aaSlling 1488ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 14898704186eSDan McDonald (void) printf(gettext(" status: The pool metadata is " 1490ea8dc4b6Seschrock "corrupted.\n")); 1491ea8dc4b6Seschrock break; 1492ea8dc4b6Seschrock 1493eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 1494*57221772SChristopher Siden (void) printf(gettext(" status: The pool is formatted using a " 1495*57221772SChristopher Siden "legacy on-disk version.\n")); 1496eaca9bbdSeschrock break; 1497eaca9bbdSeschrock 1498eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 14998704186eSDan McDonald (void) printf(gettext(" status: The pool is formatted using an " 1500eaca9bbdSeschrock "incompatible version.\n")); 1501eaca9bbdSeschrock break; 1502b87f3af3Sperrin 1503*57221772SChristopher Siden case ZPOOL_STATUS_FEAT_DISABLED: 1504*57221772SChristopher Siden (void) printf(gettext(" status: Some supported features are " 1505*57221772SChristopher Siden "not enabled on the pool.\n")); 1506*57221772SChristopher Siden break; 1507*57221772SChristopher Siden 1508ad135b5dSChristopher Siden case ZPOOL_STATUS_UNSUP_FEAT_READ: 1509ad135b5dSChristopher Siden (void) printf(gettext("status: The pool uses the following " 1510ad135b5dSChristopher Siden "feature(s) not supported on this sytem:\n")); 1511ad135b5dSChristopher Siden zpool_print_unsup_feat(config); 1512ad135b5dSChristopher Siden break; 1513ad135b5dSChristopher Siden 1514ad135b5dSChristopher Siden case ZPOOL_STATUS_UNSUP_FEAT_WRITE: 1515ad135b5dSChristopher Siden (void) printf(gettext("status: The pool can only be accessed " 1516ad135b5dSChristopher Siden "in read-only mode on this system. It\n\tcannot be " 1517ad135b5dSChristopher Siden "accessed in read-write mode because it uses the " 1518ad135b5dSChristopher Siden "following\n\tfeature(s) not supported on this system:\n")); 1519ad135b5dSChristopher Siden zpool_print_unsup_feat(config); 1520ad135b5dSChristopher Siden break; 1521ad135b5dSChristopher Siden 152295173954Sek case ZPOOL_STATUS_HOSTID_MISMATCH: 15238704186eSDan McDonald (void) printf(gettext(" status: The pool was last accessed by " 152495173954Sek "another system.\n")); 152595173954Sek break; 1526b87f3af3Sperrin 15273d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_R: 15283d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_NR: 15298704186eSDan McDonald (void) printf(gettext(" status: One or more devices are " 15303d7072f8Seschrock "faulted.\n")); 15313d7072f8Seschrock break; 15323d7072f8Seschrock 1533b87f3af3Sperrin case ZPOOL_STATUS_BAD_LOG: 15348704186eSDan McDonald (void) printf(gettext(" status: An intent log record cannot be " 1535b87f3af3Sperrin "read.\n")); 1536b87f3af3Sperrin break; 1537b87f3af3Sperrin 15383f9d6ad7SLin Ling case ZPOOL_STATUS_RESILVERING: 15398704186eSDan McDonald (void) printf(gettext(" status: One or more devices were being " 15403f9d6ad7SLin Ling "resilvered.\n")); 15413f9d6ad7SLin Ling break; 15423f9d6ad7SLin Ling 1543fa9e4066Sahrens default: 1544fa9e4066Sahrens /* 1545fa9e4066Sahrens * No other status can be seen when importing pools. 1546fa9e4066Sahrens */ 1547fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 1548fa9e4066Sahrens } 1549fa9e4066Sahrens 1550fa9e4066Sahrens /* 1551fa9e4066Sahrens * Print out an action according to the overall state of the pool. 1552fa9e4066Sahrens */ 155346657f8dSmmusante if (vs->vs_state == VDEV_STATE_HEALTHY) { 1554*57221772SChristopher Siden if (reason == ZPOOL_STATUS_VERSION_OLDER || 1555*57221772SChristopher Siden reason == ZPOOL_STATUS_FEAT_DISABLED) { 15568704186eSDan McDonald (void) printf(gettext(" action: The pool can be " 1557eaca9bbdSeschrock "imported using its name or numeric identifier, " 1558eaca9bbdSeschrock "though\n\tsome features will not be available " 1559eaca9bbdSeschrock "without an explicit 'zpool upgrade'.\n")); 1560*57221772SChristopher Siden } else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) { 15618704186eSDan McDonald (void) printf(gettext(" action: The pool can be " 156295173954Sek "imported using its name or numeric " 156395173954Sek "identifier and\n\tthe '-f' flag.\n")); 1564*57221772SChristopher Siden } else { 15658704186eSDan McDonald (void) printf(gettext(" action: The pool can be " 1566eaca9bbdSeschrock "imported using its name or numeric " 1567eaca9bbdSeschrock "identifier.\n")); 1568*57221772SChristopher Siden } 156946657f8dSmmusante } else if (vs->vs_state == VDEV_STATE_DEGRADED) { 15708704186eSDan McDonald (void) printf(gettext(" action: The pool can be imported " 1571fa9e4066Sahrens "despite missing or damaged devices. The\n\tfault " 1572eaca9bbdSeschrock "tolerance of the pool may be compromised if imported.\n")); 1573fa9e4066Sahrens } else { 1574eaca9bbdSeschrock switch (reason) { 1575eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 15768704186eSDan McDonald (void) printf(gettext(" action: The pool cannot be " 1577eaca9bbdSeschrock "imported. Access the pool on a system running " 1578eaca9bbdSeschrock "newer\n\tsoftware, or recreate the pool from " 1579eaca9bbdSeschrock "backup.\n")); 1580eaca9bbdSeschrock break; 1581ad135b5dSChristopher Siden case ZPOOL_STATUS_UNSUP_FEAT_READ: 1582ad135b5dSChristopher Siden (void) printf(gettext("action: The pool cannot be " 1583ad135b5dSChristopher Siden "imported. Access the pool on a system that " 1584ad135b5dSChristopher Siden "supports\n\tthe required feature(s), or recreate " 1585ad135b5dSChristopher Siden "the pool from backup.\n")); 1586ad135b5dSChristopher Siden break; 1587ad135b5dSChristopher Siden case ZPOOL_STATUS_UNSUP_FEAT_WRITE: 1588ad135b5dSChristopher Siden (void) printf(gettext("action: The pool cannot be " 1589ad135b5dSChristopher Siden "imported in read-write mode. Import the pool " 1590ad135b5dSChristopher Siden "with\n" 1591ad135b5dSChristopher Siden "\t\"-o readonly=on\", access the pool on a system " 1592ad135b5dSChristopher Siden "that supports the\n\trequired feature(s), or " 1593ad135b5dSChristopher Siden "recreate the pool from backup.\n")); 1594ad135b5dSChristopher Siden break; 1595eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_R: 1596eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_NR: 1597eaca9bbdSeschrock case ZPOOL_STATUS_BAD_GUID_SUM: 15988704186eSDan McDonald (void) printf(gettext(" action: The pool cannot be " 1599fa9e4066Sahrens "imported. Attach the missing\n\tdevices and try " 1600fa9e4066Sahrens "again.\n")); 1601eaca9bbdSeschrock break; 1602eaca9bbdSeschrock default: 16038704186eSDan McDonald (void) printf(gettext(" action: The pool cannot be " 1604fa9e4066Sahrens "imported due to damaged devices or data.\n")); 1605eaca9bbdSeschrock } 1606eaca9bbdSeschrock } 1607eaca9bbdSeschrock 16088704186eSDan McDonald /* Print the comment attached to the pool. */ 16098704186eSDan McDonald if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0) 16108704186eSDan McDonald (void) printf(gettext("comment: %s\n"), comment); 16118704186eSDan McDonald 161246657f8dSmmusante /* 161346657f8dSmmusante * If the state is "closed" or "can't open", and the aux state 161446657f8dSmmusante * is "corrupt data": 161546657f8dSmmusante */ 161646657f8dSmmusante if (((vs->vs_state == VDEV_STATE_CLOSED) || 161746657f8dSmmusante (vs->vs_state == VDEV_STATE_CANT_OPEN)) && 161846657f8dSmmusante (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) { 1619eaca9bbdSeschrock if (pool_state == POOL_STATE_DESTROYED) 1620eaca9bbdSeschrock (void) printf(gettext("\tThe pool was destroyed, " 1621eaca9bbdSeschrock "but can be imported using the '-Df' flags.\n")); 1622eaca9bbdSeschrock else if (pool_state != POOL_STATE_EXPORTED) 1623eaca9bbdSeschrock (void) printf(gettext("\tThe pool may be active on " 162418ce54dfSek "another system, but can be imported using\n\t" 1625eaca9bbdSeschrock "the '-f' flag.\n")); 1626fa9e4066Sahrens } 1627fa9e4066Sahrens 1628fa9e4066Sahrens if (msgid != NULL) 1629654b400cSJoshua M. Clulow (void) printf(gettext(" see: http://illumos.org/msg/%s\n"), 1630fa9e4066Sahrens msgid); 1631fa9e4066Sahrens 16328704186eSDan McDonald (void) printf(gettext(" config:\n\n")); 1633fa9e4066Sahrens 1634c67d9675Seschrock namewidth = max_width(NULL, nvroot, 0, 0); 1635fa9e4066Sahrens if (namewidth < 10) 1636fa9e4066Sahrens namewidth = 10; 16378654d025Sperrin 1638e6ca193dSGeorge Wilson print_import_config(name, nvroot, namewidth, 0); 1639e6ca193dSGeorge Wilson if (num_logs(nvroot) > 0) 1640e6ca193dSGeorge Wilson print_logs(NULL, nvroot, namewidth, B_FALSE); 1641fa9e4066Sahrens 1642fa9e4066Sahrens if (reason == ZPOOL_STATUS_BAD_GUID_SUM) { 164346657f8dSmmusante (void) printf(gettext("\n\tAdditional devices are known to " 1644fa9e4066Sahrens "be part of this pool, though their\n\texact " 164546657f8dSmmusante "configuration cannot be determined.\n")); 1646fa9e4066Sahrens } 1647fa9e4066Sahrens } 1648fa9e4066Sahrens 1649fa9e4066Sahrens /* 1650fa9e4066Sahrens * Perform the import for the given configuration. This passes the heavy 1651990b4856Slling * lifting off to zpool_import_props(), and then mounts the datasets contained 1652990b4856Slling * within the pool. 1653fa9e4066Sahrens */ 1654fa9e4066Sahrens static int 1655fa9e4066Sahrens do_import(nvlist_t *config, const char *newname, const char *mntopts, 16564b964adaSGeorge Wilson nvlist_t *props, int flags) 1657fa9e4066Sahrens { 1658fa9e4066Sahrens zpool_handle_t *zhp; 1659fa9e4066Sahrens char *name; 1660fa9e4066Sahrens uint64_t state; 1661eaca9bbdSeschrock uint64_t version; 1662fa9e4066Sahrens 1663fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1664fa9e4066Sahrens &name) == 0); 1665fa9e4066Sahrens 1666fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1667fa9e4066Sahrens ZPOOL_CONFIG_POOL_STATE, &state) == 0); 1668eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, 1669eaca9bbdSeschrock ZPOOL_CONFIG_VERSION, &version) == 0); 1670ad135b5dSChristopher Siden if (!SPA_VERSION_IS_SUPPORTED(version)) { 1671eaca9bbdSeschrock (void) fprintf(stderr, gettext("cannot import '%s': pool " 1672ad135b5dSChristopher Siden "is formatted using an unsupported ZFS version\n"), name); 1673eaca9bbdSeschrock return (1); 16744b964adaSGeorge Wilson } else if (state != POOL_STATE_EXPORTED && 16754b964adaSGeorge Wilson !(flags & ZFS_IMPORT_ANY_HOST)) { 167695173954Sek uint64_t hostid; 167795173954Sek 167895173954Sek if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, 167995173954Sek &hostid) == 0) { 168095173954Sek if ((unsigned long)hostid != gethostid()) { 168195173954Sek char *hostname; 168295173954Sek uint64_t timestamp; 168395173954Sek time_t t; 168495173954Sek 168595173954Sek verify(nvlist_lookup_string(config, 168695173954Sek ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); 168795173954Sek verify(nvlist_lookup_uint64(config, 168895173954Sek ZPOOL_CONFIG_TIMESTAMP, ×tamp) == 0); 168995173954Sek t = timestamp; 169095173954Sek (void) fprintf(stderr, gettext("cannot import " 169195173954Sek "'%s': pool may be in use from other " 169295173954Sek "system, it was last accessed by %s " 169395173954Sek "(hostid: 0x%lx) on %s"), name, hostname, 169495173954Sek (unsigned long)hostid, 169595173954Sek asctime(localtime(&t))); 169695173954Sek (void) fprintf(stderr, gettext("use '-f' to " 169795173954Sek "import anyway\n")); 169895173954Sek return (1); 169995173954Sek } 170095173954Sek } else { 170195173954Sek (void) fprintf(stderr, gettext("cannot import '%s': " 170295173954Sek "pool may be in use from other system\n"), name); 170395173954Sek (void) fprintf(stderr, gettext("use '-f' to import " 170495173954Sek "anyway\n")); 170595173954Sek return (1); 170695173954Sek } 1707fa9e4066Sahrens } 1708fa9e4066Sahrens 17094b964adaSGeorge Wilson if (zpool_import_props(g_zfs, config, newname, props, flags) != 0) 1710fa9e4066Sahrens return (1); 1711fa9e4066Sahrens 1712fa9e4066Sahrens if (newname != NULL) 1713fa9e4066Sahrens name = (char *)newname; 1714fa9e4066Sahrens 17154f0f5e5bSVictor Latushkin if ((zhp = zpool_open_canfail(g_zfs, name)) == NULL) 17164f0f5e5bSVictor Latushkin return (1); 1717fa9e4066Sahrens 1718379c004dSEric Schrock if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 1719f9af39baSGeorge Wilson !(flags & ZFS_IMPORT_ONLY) && 1720379c004dSEric Schrock zpool_enable_datasets(zhp, mntopts, 0) != 0) { 1721fa9e4066Sahrens zpool_close(zhp); 1722fa9e4066Sahrens return (1); 1723fa9e4066Sahrens } 1724fa9e4066Sahrens 1725fa9e4066Sahrens zpool_close(zhp); 1726468c413aSTim Haley return (0); 1727fa9e4066Sahrens } 1728fa9e4066Sahrens 1729fa9e4066Sahrens /* 17304c58d714Sdarrenm * zpool import [-d dir] [-D] 17312f8aaab3Seschrock * import [-o mntopts] [-o prop=value] ... [-R root] [-D] 17322f8aaab3Seschrock * [-d dir | -c cachefile] [-f] -a 17332f8aaab3Seschrock * import [-o mntopts] [-o prop=value] ... [-R root] [-D] 1734468c413aSTim Haley * [-d dir | -c cachefile] [-f] [-n] [-F] <pool | id> [newpool] 17352f8aaab3Seschrock * 17362f8aaab3Seschrock * -c Read pool information from a cachefile instead of searching 17372f8aaab3Seschrock * devices. 1738fa9e4066Sahrens * 1739fa9e4066Sahrens * -d Scan in a specific directory, other than /dev/dsk. More than 1740fa9e4066Sahrens * one directory can be specified using multiple '-d' options. 1741fa9e4066Sahrens * 17424c58d714Sdarrenm * -D Scan for previously destroyed pools or import all or only 17434c58d714Sdarrenm * specified destroyed pools. 17444c58d714Sdarrenm * 1745fa9e4066Sahrens * -R Temporarily import the pool, with all mountpoints relative to 1746fa9e4066Sahrens * the given root. The pool will remain exported when the machine 1747fa9e4066Sahrens * is rebooted. 1748fa9e4066Sahrens * 1749468c413aSTim Haley * -V Import even in the presence of faulted vdevs. This is an 1750c5904d13Seschrock * intentionally undocumented option for testing purposes, and 1751c5904d13Seschrock * treats the pool configuration as complete, leaving any bad 17524f0f5e5bSVictor Latushkin * vdevs in the FAULTED state. In other words, it does verbatim 17534f0f5e5bSVictor Latushkin * import. 1754c5904d13Seschrock * 1755468c413aSTim Haley * -f Force import, even if it appears that the pool is active. 1756468c413aSTim Haley * 1757468c413aSTim Haley * -F Attempt rewind if necessary. 1758468c413aSTim Haley * 1759468c413aSTim Haley * -n See if rewind would work, but don't actually rewind. 1760468c413aSTim Haley * 1761f9af39baSGeorge Wilson * -N Import the pool but don't mount datasets. 1762f9af39baSGeorge Wilson * 1763f9af39baSGeorge Wilson * -T Specify a starting txg to use for import. This option is 1764f9af39baSGeorge Wilson * intentionally undocumented option for testing purposes. 1765f9af39baSGeorge Wilson * 1766fa9e4066Sahrens * -a Import all pools found. 1767fa9e4066Sahrens * 1768990b4856Slling * -o Set property=value and/or temporary mount options (without '='). 1769ecd6cf80Smarks * 1770fa9e4066Sahrens * The import command scans for pools to import, and import pools based on pool 1771fa9e4066Sahrens * name and GUID. The pool can also be renamed as part of the import process. 1772fa9e4066Sahrens */ 1773fa9e4066Sahrens int 1774fa9e4066Sahrens zpool_do_import(int argc, char **argv) 1775fa9e4066Sahrens { 1776fa9e4066Sahrens char **searchdirs = NULL; 1777fa9e4066Sahrens int nsearch = 0; 1778fa9e4066Sahrens int c; 1779d41c4376SMark J Musante int err = 0; 17802f8aaab3Seschrock nvlist_t *pools = NULL; 178199653d4eSeschrock boolean_t do_all = B_FALSE; 178299653d4eSeschrock boolean_t do_destroyed = B_FALSE; 1783fa9e4066Sahrens char *mntopts = NULL; 1784fa9e4066Sahrens nvpair_t *elem; 1785fa9e4066Sahrens nvlist_t *config; 178624e697d4Sck uint64_t searchguid = 0; 178724e697d4Sck char *searchname = NULL; 1788990b4856Slling char *propval; 1789fa9e4066Sahrens nvlist_t *found_config; 1790468c413aSTim Haley nvlist_t *policy = NULL; 1791ecd6cf80Smarks nvlist_t *props = NULL; 179299653d4eSeschrock boolean_t first; 17934b964adaSGeorge Wilson int flags = ZFS_IMPORT_NORMAL; 1794468c413aSTim Haley uint32_t rewind_policy = ZPOOL_NO_REWIND; 1795468c413aSTim Haley boolean_t dryrun = B_FALSE; 1796468c413aSTim Haley boolean_t do_rewind = B_FALSE; 1797468c413aSTim Haley boolean_t xtreme_rewind = B_FALSE; 1798f9af39baSGeorge Wilson uint64_t pool_state, txg = -1ULL; 17992f8aaab3Seschrock char *cachefile = NULL; 1800d41c4376SMark J Musante importargs_t idata = { 0 }; 1801f9af39baSGeorge Wilson char *endptr; 1802fa9e4066Sahrens 1803fa9e4066Sahrens /* check options */ 1804f9af39baSGeorge Wilson while ((c = getopt(argc, argv, ":aCc:d:DEfFmnNo:rR:T:VX")) != -1) { 1805fa9e4066Sahrens switch (c) { 1806fa9e4066Sahrens case 'a': 180799653d4eSeschrock do_all = B_TRUE; 1808fa9e4066Sahrens break; 18092f8aaab3Seschrock case 'c': 18102f8aaab3Seschrock cachefile = optarg; 18112f8aaab3Seschrock break; 1812fa9e4066Sahrens case 'd': 1813fa9e4066Sahrens if (searchdirs == NULL) { 1814fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1815fa9e4066Sahrens } else { 1816fa9e4066Sahrens char **tmp = safe_malloc((nsearch + 1) * 1817fa9e4066Sahrens sizeof (char *)); 1818fa9e4066Sahrens bcopy(searchdirs, tmp, nsearch * 1819fa9e4066Sahrens sizeof (char *)); 1820fa9e4066Sahrens free(searchdirs); 1821fa9e4066Sahrens searchdirs = tmp; 1822fa9e4066Sahrens } 1823fa9e4066Sahrens searchdirs[nsearch++] = optarg; 1824fa9e4066Sahrens break; 18254c58d714Sdarrenm case 'D': 182699653d4eSeschrock do_destroyed = B_TRUE; 18274c58d714Sdarrenm break; 1828fa9e4066Sahrens case 'f': 18294b964adaSGeorge Wilson flags |= ZFS_IMPORT_ANY_HOST; 1830fa9e4066Sahrens break; 1831c5904d13Seschrock case 'F': 1832468c413aSTim Haley do_rewind = B_TRUE; 1833468c413aSTim Haley break; 18344b964adaSGeorge Wilson case 'm': 18354b964adaSGeorge Wilson flags |= ZFS_IMPORT_MISSING_LOG; 18364b964adaSGeorge Wilson break; 1837468c413aSTim Haley case 'n': 1838468c413aSTim Haley dryrun = B_TRUE; 1839c5904d13Seschrock break; 1840f9af39baSGeorge Wilson case 'N': 1841f9af39baSGeorge Wilson flags |= ZFS_IMPORT_ONLY; 1842f9af39baSGeorge Wilson break; 1843fa9e4066Sahrens case 'o': 1844990b4856Slling if ((propval = strchr(optarg, '=')) != NULL) { 1845990b4856Slling *propval = '\0'; 1846990b4856Slling propval++; 18470a48a24eStimh if (add_prop_list(optarg, propval, 18480a48a24eStimh &props, B_TRUE)) 1849990b4856Slling goto error; 1850990b4856Slling } else { 1851990b4856Slling mntopts = optarg; 1852990b4856Slling } 1853fa9e4066Sahrens break; 1854fa9e4066Sahrens case 'R': 1855990b4856Slling if (add_prop_list(zpool_prop_to_name( 18560a48a24eStimh ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 1857990b4856Slling goto error; 18582f8aaab3Seschrock if (nvlist_lookup_string(props, 18592f8aaab3Seschrock zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 18602f8aaab3Seschrock &propval) == 0) 18612f8aaab3Seschrock break; 1862990b4856Slling if (add_prop_list(zpool_prop_to_name( 18630a48a24eStimh ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE)) 1864990b4856Slling goto error; 1865fa9e4066Sahrens break; 1866f9af39baSGeorge Wilson case 'T': 1867f9af39baSGeorge Wilson errno = 0; 1868f9af39baSGeorge Wilson txg = strtoull(optarg, &endptr, 10); 1869f9af39baSGeorge Wilson if (errno != 0 || *endptr != '\0') { 1870f9af39baSGeorge Wilson (void) fprintf(stderr, 1871f9af39baSGeorge Wilson gettext("invalid txg value\n")); 1872f9af39baSGeorge Wilson usage(B_FALSE); 1873f9af39baSGeorge Wilson } 1874f9af39baSGeorge Wilson rewind_policy = ZPOOL_DO_REWIND | ZPOOL_EXTREME_REWIND; 1875f9af39baSGeorge Wilson break; 1876468c413aSTim Haley case 'V': 18774b964adaSGeorge Wilson flags |= ZFS_IMPORT_VERBATIM; 1878468c413aSTim Haley break; 1879468c413aSTim Haley case 'X': 1880468c413aSTim Haley xtreme_rewind = B_TRUE; 1881468c413aSTim Haley break; 1882fa9e4066Sahrens case ':': 1883fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1884fa9e4066Sahrens "'%c' option\n"), optopt); 188599653d4eSeschrock usage(B_FALSE); 1886fa9e4066Sahrens break; 1887fa9e4066Sahrens case '?': 1888fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1889fa9e4066Sahrens optopt); 189099653d4eSeschrock usage(B_FALSE); 1891fa9e4066Sahrens } 1892fa9e4066Sahrens } 1893fa9e4066Sahrens 1894fa9e4066Sahrens argc -= optind; 1895fa9e4066Sahrens argv += optind; 1896fa9e4066Sahrens 18972f8aaab3Seschrock if (cachefile && nsearch != 0) { 18982f8aaab3Seschrock (void) fprintf(stderr, gettext("-c is incompatible with -d\n")); 18992f8aaab3Seschrock usage(B_FALSE); 19002f8aaab3Seschrock } 19012f8aaab3Seschrock 1902468c413aSTim Haley if ((dryrun || xtreme_rewind) && !do_rewind) { 1903468c413aSTim Haley (void) fprintf(stderr, 1904468c413aSTim Haley gettext("-n or -X only meaningful with -F\n")); 1905468c413aSTim Haley usage(B_FALSE); 1906468c413aSTim Haley } 1907468c413aSTim Haley if (dryrun) 1908468c413aSTim Haley rewind_policy = ZPOOL_TRY_REWIND; 1909468c413aSTim Haley else if (do_rewind) 1910468c413aSTim Haley rewind_policy = ZPOOL_DO_REWIND; 1911468c413aSTim Haley if (xtreme_rewind) 1912468c413aSTim Haley rewind_policy |= ZPOOL_EXTREME_REWIND; 1913468c413aSTim Haley 1914468c413aSTim Haley /* In the future, we can capture further policy and include it here */ 1915468c413aSTim Haley if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 1916f9af39baSGeorge Wilson nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, txg) != 0 || 1917468c413aSTim Haley nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) 1918468c413aSTim Haley goto error; 1919468c413aSTim Haley 1920fa9e4066Sahrens if (searchdirs == NULL) { 1921fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1922fa9e4066Sahrens searchdirs[0] = "/dev/dsk"; 1923fa9e4066Sahrens nsearch = 1; 1924fa9e4066Sahrens } 1925fa9e4066Sahrens 1926fa9e4066Sahrens /* check argument count */ 1927fa9e4066Sahrens if (do_all) { 1928fa9e4066Sahrens if (argc != 0) { 1929fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 193099653d4eSeschrock usage(B_FALSE); 1931fa9e4066Sahrens } 1932fa9e4066Sahrens } else { 1933fa9e4066Sahrens if (argc > 2) { 1934fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 193599653d4eSeschrock usage(B_FALSE); 1936fa9e4066Sahrens } 1937fa9e4066Sahrens 1938fa9e4066Sahrens /* 1939fa9e4066Sahrens * Check for the SYS_CONFIG privilege. We do this explicitly 1940fa9e4066Sahrens * here because otherwise any attempt to discover pools will 1941fa9e4066Sahrens * silently fail. 1942fa9e4066Sahrens */ 1943fa9e4066Sahrens if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) { 1944fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1945fa9e4066Sahrens "discover pools: permission denied\n")); 194699653d4eSeschrock free(searchdirs); 1947468c413aSTim Haley nvlist_free(policy); 1948fa9e4066Sahrens return (1); 1949fa9e4066Sahrens } 1950fa9e4066Sahrens } 1951fa9e4066Sahrens 1952fa9e4066Sahrens /* 1953fa9e4066Sahrens * Depending on the arguments given, we do one of the following: 1954fa9e4066Sahrens * 1955fa9e4066Sahrens * <none> Iterate through all pools and display information about 1956fa9e4066Sahrens * each one. 1957fa9e4066Sahrens * 1958fa9e4066Sahrens * -a Iterate through all pools and try to import each one. 1959fa9e4066Sahrens * 1960fa9e4066Sahrens * <id> Find the pool that corresponds to the given GUID/pool 1961fa9e4066Sahrens * name and import that one. 19624c58d714Sdarrenm * 19634c58d714Sdarrenm * -D Above options applies only to destroyed pools. 1964fa9e4066Sahrens */ 1965fa9e4066Sahrens if (argc != 0) { 1966fa9e4066Sahrens char *endptr; 1967fa9e4066Sahrens 1968fa9e4066Sahrens errno = 0; 1969fa9e4066Sahrens searchguid = strtoull(argv[0], &endptr, 10); 1970fa9e4066Sahrens if (errno != 0 || *endptr != '\0') 1971fa9e4066Sahrens searchname = argv[0]; 1972fa9e4066Sahrens found_config = NULL; 1973fa9e4066Sahrens 197424e697d4Sck /* 1975d41c4376SMark J Musante * User specified a name or guid. Ensure it's unique. 197624e697d4Sck */ 1977d41c4376SMark J Musante idata.unique = B_TRUE; 197824e697d4Sck } 197924e697d4Sck 1980d41c4376SMark J Musante 1981d41c4376SMark J Musante idata.path = searchdirs; 1982d41c4376SMark J Musante idata.paths = nsearch; 1983d41c4376SMark J Musante idata.poolname = searchname; 1984d41c4376SMark J Musante idata.guid = searchguid; 1985d41c4376SMark J Musante idata.cachefile = cachefile; 1986d41c4376SMark J Musante 1987d41c4376SMark J Musante pools = zpool_search_import(g_zfs, &idata); 1988d41c4376SMark J Musante 1989d41c4376SMark J Musante if (pools != NULL && idata.exists && 1990d41c4376SMark J Musante (argc == 1 || strcmp(argv[0], argv[1]) == 0)) { 1991d41c4376SMark J Musante (void) fprintf(stderr, gettext("cannot import '%s': " 1992d41c4376SMark J Musante "a pool with that name already exists\n"), 1993d41c4376SMark J Musante argv[0]); 1994d41c4376SMark J Musante (void) fprintf(stderr, gettext("use the form '%s " 1995d41c4376SMark J Musante "<pool | id> <newpool>' to give it a new name\n"), 1996d41c4376SMark J Musante "zpool import"); 1997d41c4376SMark J Musante err = 1; 1998d41c4376SMark J Musante } else if (pools == NULL && idata.exists) { 1999d41c4376SMark J Musante (void) fprintf(stderr, gettext("cannot import '%s': " 2000d41c4376SMark J Musante "a pool with that name is already created/imported,\n"), 2001d41c4376SMark J Musante argv[0]); 2002d41c4376SMark J Musante (void) fprintf(stderr, gettext("and no additional pools " 2003d41c4376SMark J Musante "with that name were found\n")); 2004d41c4376SMark J Musante err = 1; 2005d41c4376SMark J Musante } else if (pools == NULL) { 200624e697d4Sck if (argc != 0) { 200724e697d4Sck (void) fprintf(stderr, gettext("cannot import '%s': " 200824e697d4Sck "no such pool available\n"), argv[0]); 200924e697d4Sck } 2010d41c4376SMark J Musante err = 1; 2011d41c4376SMark J Musante } 2012d41c4376SMark J Musante 2013d41c4376SMark J Musante if (err == 1) { 201424e697d4Sck free(searchdirs); 2015468c413aSTim Haley nvlist_free(policy); 201624e697d4Sck return (1); 201724e697d4Sck } 201824e697d4Sck 201924e697d4Sck /* 202024e697d4Sck * At this point we have a list of import candidate configs. Even if 202124e697d4Sck * we were searching by pool name or guid, we still need to 202224e697d4Sck * post-process the list to deal with pool state and possible 202324e697d4Sck * duplicate names. 202424e697d4Sck */ 2025fa9e4066Sahrens err = 0; 2026fa9e4066Sahrens elem = NULL; 202799653d4eSeschrock first = B_TRUE; 2028fa9e4066Sahrens while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { 2029fa9e4066Sahrens 2030fa9e4066Sahrens verify(nvpair_value_nvlist(elem, &config) == 0); 2031fa9e4066Sahrens 20324c58d714Sdarrenm verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 20334c58d714Sdarrenm &pool_state) == 0); 20344c58d714Sdarrenm if (!do_destroyed && pool_state == POOL_STATE_DESTROYED) 20354c58d714Sdarrenm continue; 20364c58d714Sdarrenm if (do_destroyed && pool_state != POOL_STATE_DESTROYED) 20374c58d714Sdarrenm continue; 20384c58d714Sdarrenm 2039468c413aSTim Haley verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY, 2040468c413aSTim Haley policy) == 0); 2041468c413aSTim Haley 2042fa9e4066Sahrens if (argc == 0) { 2043fa9e4066Sahrens if (first) 204499653d4eSeschrock first = B_FALSE; 20453bb79becSeschrock else if (!do_all) 2046fa9e4066Sahrens (void) printf("\n"); 2047fa9e4066Sahrens 2048468c413aSTim Haley if (do_all) { 2049fa9e4066Sahrens err |= do_import(config, NULL, mntopts, 20504b964adaSGeorge Wilson props, flags); 2051468c413aSTim Haley } else { 2052fa9e4066Sahrens show_import(config); 2053468c413aSTim Haley } 2054fa9e4066Sahrens } else if (searchname != NULL) { 2055fa9e4066Sahrens char *name; 2056fa9e4066Sahrens 2057fa9e4066Sahrens /* 2058fa9e4066Sahrens * We are searching for a pool based on name. 2059fa9e4066Sahrens */ 2060fa9e4066Sahrens verify(nvlist_lookup_string(config, 2061fa9e4066Sahrens ZPOOL_CONFIG_POOL_NAME, &name) == 0); 2062fa9e4066Sahrens 2063fa9e4066Sahrens if (strcmp(name, searchname) == 0) { 2064fa9e4066Sahrens if (found_config != NULL) { 2065fa9e4066Sahrens (void) fprintf(stderr, gettext( 2066fa9e4066Sahrens "cannot import '%s': more than " 2067fa9e4066Sahrens "one matching pool\n"), searchname); 2068fa9e4066Sahrens (void) fprintf(stderr, gettext( 2069fa9e4066Sahrens "import by numeric ID instead\n")); 207099653d4eSeschrock err = B_TRUE; 2071fa9e4066Sahrens } 2072fa9e4066Sahrens found_config = config; 2073fa9e4066Sahrens } 2074fa9e4066Sahrens } else { 2075fa9e4066Sahrens uint64_t guid; 2076fa9e4066Sahrens 2077fa9e4066Sahrens /* 2078fa9e4066Sahrens * Search for a pool by guid. 2079fa9e4066Sahrens */ 2080fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 2081fa9e4066Sahrens ZPOOL_CONFIG_POOL_GUID, &guid) == 0); 2082fa9e4066Sahrens 2083fa9e4066Sahrens if (guid == searchguid) 2084fa9e4066Sahrens found_config = config; 2085fa9e4066Sahrens } 2086fa9e4066Sahrens } 2087fa9e4066Sahrens 2088fa9e4066Sahrens /* 2089fa9e4066Sahrens * If we were searching for a specific pool, verify that we found a 2090fa9e4066Sahrens * pool, and then do the import. 2091fa9e4066Sahrens */ 2092fa9e4066Sahrens if (argc != 0 && err == 0) { 2093fa9e4066Sahrens if (found_config == NULL) { 2094fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': " 2095fa9e4066Sahrens "no such pool available\n"), argv[0]); 209699653d4eSeschrock err = B_TRUE; 2097fa9e4066Sahrens } else { 2098fa9e4066Sahrens err |= do_import(found_config, argc == 1 ? NULL : 20994b964adaSGeorge Wilson argv[1], mntopts, props, flags); 2100fa9e4066Sahrens } 2101fa9e4066Sahrens } 2102fa9e4066Sahrens 2103fa9e4066Sahrens /* 2104fa9e4066Sahrens * If we were just looking for pools, report an error if none were 2105fa9e4066Sahrens * found. 2106fa9e4066Sahrens */ 2107fa9e4066Sahrens if (argc == 0 && first) 2108fa9e4066Sahrens (void) fprintf(stderr, 2109fa9e4066Sahrens gettext("no pools available to import\n")); 2110fa9e4066Sahrens 2111ecd6cf80Smarks error: 21122f8aaab3Seschrock nvlist_free(props); 2113fa9e4066Sahrens nvlist_free(pools); 2114468c413aSTim Haley nvlist_free(policy); 211599653d4eSeschrock free(searchdirs); 2116fa9e4066Sahrens 2117fa9e4066Sahrens return (err ? 1 : 0); 2118fa9e4066Sahrens } 2119fa9e4066Sahrens 2120fa9e4066Sahrens typedef struct iostat_cbdata { 21214263d13fSGeorge Wilson boolean_t cb_verbose; 2122fa9e4066Sahrens int cb_namewidth; 21234263d13fSGeorge Wilson int cb_iteration; 21244263d13fSGeorge Wilson zpool_list_t *cb_list; 2125fa9e4066Sahrens } iostat_cbdata_t; 2126fa9e4066Sahrens 2127fa9e4066Sahrens static void 2128fa9e4066Sahrens print_iostat_separator(iostat_cbdata_t *cb) 2129fa9e4066Sahrens { 2130fa9e4066Sahrens int i = 0; 2131fa9e4066Sahrens 2132fa9e4066Sahrens for (i = 0; i < cb->cb_namewidth; i++) 2133fa9e4066Sahrens (void) printf("-"); 2134fa9e4066Sahrens (void) printf(" ----- ----- ----- ----- ----- -----\n"); 2135fa9e4066Sahrens } 2136fa9e4066Sahrens 2137fa9e4066Sahrens static void 2138fa9e4066Sahrens print_iostat_header(iostat_cbdata_t *cb) 2139fa9e4066Sahrens { 2140fa9e4066Sahrens (void) printf("%*s capacity operations bandwidth\n", 2141fa9e4066Sahrens cb->cb_namewidth, ""); 2142485bbbf5SGeorge Wilson (void) printf("%-*s alloc free read write read write\n", 2143fa9e4066Sahrens cb->cb_namewidth, "pool"); 2144fa9e4066Sahrens print_iostat_separator(cb); 2145fa9e4066Sahrens } 2146fa9e4066Sahrens 2147fa9e4066Sahrens /* 2148fa9e4066Sahrens * Display a single statistic. 2149fa9e4066Sahrens */ 2150990b4856Slling static void 2151fa9e4066Sahrens print_one_stat(uint64_t value) 2152fa9e4066Sahrens { 2153fa9e4066Sahrens char buf[64]; 2154fa9e4066Sahrens 2155fa9e4066Sahrens zfs_nicenum(value, buf, sizeof (buf)); 2156fa9e4066Sahrens (void) printf(" %5s", buf); 2157fa9e4066Sahrens } 2158fa9e4066Sahrens 2159fa9e4066Sahrens /* 2160fa9e4066Sahrens * Print out all the statistics for the given vdev. This can either be the 2161fa9e4066Sahrens * toplevel configuration, or called recursively. If 'name' is NULL, then this 2162fa9e4066Sahrens * is a verbose output, and we don't want to display the toplevel pool stats. 2163fa9e4066Sahrens */ 2164fa9e4066Sahrens void 2165c67d9675Seschrock print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, 2166c67d9675Seschrock nvlist_t *newnv, iostat_cbdata_t *cb, int depth) 2167fa9e4066Sahrens { 2168fa9e4066Sahrens nvlist_t **oldchild, **newchild; 2169fa9e4066Sahrens uint_t c, children; 2170fa9e4066Sahrens vdev_stat_t *oldvs, *newvs; 2171fa9e4066Sahrens vdev_stat_t zerovs = { 0 }; 2172fa9e4066Sahrens uint64_t tdelta; 2173fa9e4066Sahrens double scale; 2174afefbcddSeschrock char *vname; 2175fa9e4066Sahrens 2176fa9e4066Sahrens if (oldnv != NULL) { 21773f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(oldnv, 21783f9d6ad7SLin Ling ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&oldvs, &c) == 0); 2179fa9e4066Sahrens } else { 2180fa9e4066Sahrens oldvs = &zerovs; 2181fa9e4066Sahrens } 2182fa9e4066Sahrens 21833f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_VDEV_STATS, 2184fa9e4066Sahrens (uint64_t **)&newvs, &c) == 0); 2185fa9e4066Sahrens 2186fa9e4066Sahrens if (strlen(name) + depth > cb->cb_namewidth) 2187fa9e4066Sahrens (void) printf("%*s%s", depth, "", name); 2188fa9e4066Sahrens else 2189fa9e4066Sahrens (void) printf("%*s%s%*s", depth, "", name, 2190fa9e4066Sahrens (int)(cb->cb_namewidth - strlen(name) - depth), ""); 2191fa9e4066Sahrens 2192fa9e4066Sahrens tdelta = newvs->vs_timestamp - oldvs->vs_timestamp; 2193fa9e4066Sahrens 2194fa9e4066Sahrens if (tdelta == 0) 2195fa9e4066Sahrens scale = 1.0; 2196fa9e4066Sahrens else 2197fa9e4066Sahrens scale = (double)NANOSEC / tdelta; 2198fa9e4066Sahrens 2199fa9e4066Sahrens /* only toplevel vdevs have capacity stats */ 2200fa9e4066Sahrens if (newvs->vs_space == 0) { 2201fa9e4066Sahrens (void) printf(" - -"); 2202fa9e4066Sahrens } else { 2203fa9e4066Sahrens print_one_stat(newvs->vs_alloc); 2204fa9e4066Sahrens print_one_stat(newvs->vs_space - newvs->vs_alloc); 2205fa9e4066Sahrens } 2206fa9e4066Sahrens 2207fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] - 2208fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_READ]))); 2209fa9e4066Sahrens 2210fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] - 2211fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_WRITE]))); 2212fa9e4066Sahrens 2213fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] - 2214fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_READ]))); 2215fa9e4066Sahrens 2216fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] - 2217fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_WRITE]))); 2218fa9e4066Sahrens 2219fa9e4066Sahrens (void) printf("\n"); 2220fa9e4066Sahrens 2221fa9e4066Sahrens if (!cb->cb_verbose) 2222fa9e4066Sahrens return; 2223fa9e4066Sahrens 2224fa9e4066Sahrens if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN, 2225fa9e4066Sahrens &newchild, &children) != 0) 2226fa9e4066Sahrens return; 2227fa9e4066Sahrens 2228fa9e4066Sahrens if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN, 2229fa9e4066Sahrens &oldchild, &c) != 0) 2230fa9e4066Sahrens return; 2231fa9e4066Sahrens 2232afefbcddSeschrock for (c = 0; c < children; c++) { 22339d439f90SMike Harsch uint64_t ishole = B_FALSE, islog = B_FALSE; 22343f9d6ad7SLin Ling 22359d439f90SMike Harsch (void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_HOLE, 22369d439f90SMike Harsch &ishole); 22379d439f90SMike Harsch 22389d439f90SMike Harsch (void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_LOG, 22399d439f90SMike Harsch &islog); 22409d439f90SMike Harsch 22419d439f90SMike Harsch if (ishole || islog) 22423f9d6ad7SLin Ling continue; 22433f9d6ad7SLin Ling 224488ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, newchild[c], B_FALSE); 2245c67d9675Seschrock print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 2246afefbcddSeschrock newchild[c], cb, depth + 2); 2247afefbcddSeschrock free(vname); 2248afefbcddSeschrock } 2249fa94a07fSbrendan 22509d439f90SMike Harsch /* 22519d439f90SMike Harsch * Log device section 22529d439f90SMike Harsch */ 22539d439f90SMike Harsch 22549d439f90SMike Harsch if (num_logs(newnv) > 0) { 22559d439f90SMike Harsch (void) printf("%-*s - - - - - " 22569d439f90SMike Harsch "-\n", cb->cb_namewidth, "logs"); 22579d439f90SMike Harsch 22589d439f90SMike Harsch for (c = 0; c < children; c++) { 22599d439f90SMike Harsch uint64_t islog = B_FALSE; 22609d439f90SMike Harsch (void) nvlist_lookup_uint64(newchild[c], 22619d439f90SMike Harsch ZPOOL_CONFIG_IS_LOG, &islog); 22629d439f90SMike Harsch 22639d439f90SMike Harsch if (islog) { 22649d439f90SMike Harsch vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 22659d439f90SMike Harsch B_FALSE); 22669d439f90SMike Harsch print_vdev_stats(zhp, vname, oldnv ? 22679d439f90SMike Harsch oldchild[c] : NULL, newchild[c], 22689d439f90SMike Harsch cb, depth + 2); 22699d439f90SMike Harsch free(vname); 22709d439f90SMike Harsch } 22719d439f90SMike Harsch } 22729d439f90SMike Harsch 22739d439f90SMike Harsch } 22749d439f90SMike Harsch 2275fa94a07fSbrendan /* 2276fa94a07fSbrendan * Include level 2 ARC devices in iostat output 2277fa94a07fSbrendan */ 2278fa94a07fSbrendan if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE, 2279fa94a07fSbrendan &newchild, &children) != 0) 2280fa94a07fSbrendan return; 2281fa94a07fSbrendan 2282fa94a07fSbrendan if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE, 2283fa94a07fSbrendan &oldchild, &c) != 0) 2284fa94a07fSbrendan return; 2285fa94a07fSbrendan 2286fa94a07fSbrendan if (children > 0) { 2287fa94a07fSbrendan (void) printf("%-*s - - - - - " 2288fa94a07fSbrendan "-\n", cb->cb_namewidth, "cache"); 2289fa94a07fSbrendan for (c = 0; c < children; c++) { 229088ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 229188ecc943SGeorge Wilson B_FALSE); 2292fa94a07fSbrendan print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 2293fa94a07fSbrendan newchild[c], cb, depth + 2); 2294fa94a07fSbrendan free(vname); 2295fa94a07fSbrendan } 2296fa94a07fSbrendan } 2297fa9e4066Sahrens } 2298fa9e4066Sahrens 2299088e9d47Seschrock static int 2300088e9d47Seschrock refresh_iostat(zpool_handle_t *zhp, void *data) 2301088e9d47Seschrock { 2302088e9d47Seschrock iostat_cbdata_t *cb = data; 230394de1d4cSeschrock boolean_t missing; 2304088e9d47Seschrock 2305088e9d47Seschrock /* 2306088e9d47Seschrock * If the pool has disappeared, remove it from the list and continue. 2307088e9d47Seschrock */ 230894de1d4cSeschrock if (zpool_refresh_stats(zhp, &missing) != 0) 230994de1d4cSeschrock return (-1); 231094de1d4cSeschrock 231194de1d4cSeschrock if (missing) 2312088e9d47Seschrock pool_list_remove(cb->cb_list, zhp); 2313088e9d47Seschrock 2314088e9d47Seschrock return (0); 2315088e9d47Seschrock } 2316088e9d47Seschrock 2317fa9e4066Sahrens /* 2318fa9e4066Sahrens * Callback to print out the iostats for the given pool. 2319fa9e4066Sahrens */ 2320fa9e4066Sahrens int 2321fa9e4066Sahrens print_iostat(zpool_handle_t *zhp, void *data) 2322fa9e4066Sahrens { 2323fa9e4066Sahrens iostat_cbdata_t *cb = data; 2324fa9e4066Sahrens nvlist_t *oldconfig, *newconfig; 2325fa9e4066Sahrens nvlist_t *oldnvroot, *newnvroot; 2326fa9e4066Sahrens 2327088e9d47Seschrock newconfig = zpool_get_config(zhp, &oldconfig); 2328fa9e4066Sahrens 2329088e9d47Seschrock if (cb->cb_iteration == 1) 2330fa9e4066Sahrens oldconfig = NULL; 2331fa9e4066Sahrens 2332fa9e4066Sahrens verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE, 2333fa9e4066Sahrens &newnvroot) == 0); 2334fa9e4066Sahrens 2335088e9d47Seschrock if (oldconfig == NULL) 2336fa9e4066Sahrens oldnvroot = NULL; 2337088e9d47Seschrock else 2338088e9d47Seschrock verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE, 2339088e9d47Seschrock &oldnvroot) == 0); 2340fa9e4066Sahrens 2341fa9e4066Sahrens /* 2342fa9e4066Sahrens * Print out the statistics for the pool. 2343fa9e4066Sahrens */ 2344c67d9675Seschrock print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0); 2345fa9e4066Sahrens 2346fa9e4066Sahrens if (cb->cb_verbose) 2347fa9e4066Sahrens print_iostat_separator(cb); 2348fa9e4066Sahrens 2349fa9e4066Sahrens return (0); 2350fa9e4066Sahrens } 2351fa9e4066Sahrens 2352fa9e4066Sahrens int 2353fa9e4066Sahrens get_namewidth(zpool_handle_t *zhp, void *data) 2354fa9e4066Sahrens { 2355fa9e4066Sahrens iostat_cbdata_t *cb = data; 2356fa9e4066Sahrens nvlist_t *config, *nvroot; 2357fa9e4066Sahrens 2358088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) != NULL) { 2359fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2360fa9e4066Sahrens &nvroot) == 0); 2361fa9e4066Sahrens if (!cb->cb_verbose) 2362fa9e4066Sahrens cb->cb_namewidth = strlen(zpool_get_name(zhp)); 2363fa9e4066Sahrens else 2364e1d5e507SFrederik Wessels cb->cb_namewidth = max_width(zhp, nvroot, 0, 2365e1d5e507SFrederik Wessels cb->cb_namewidth); 2366fa9e4066Sahrens } 2367fa9e4066Sahrens 2368fa9e4066Sahrens /* 2369fa9e4066Sahrens * The width must fall into the range [10,38]. The upper limit is the 2370fa9e4066Sahrens * maximum we can have and still fit in 80 columns. 2371fa9e4066Sahrens */ 2372fa9e4066Sahrens if (cb->cb_namewidth < 10) 2373fa9e4066Sahrens cb->cb_namewidth = 10; 2374fa9e4066Sahrens if (cb->cb_namewidth > 38) 2375fa9e4066Sahrens cb->cb_namewidth = 38; 2376fa9e4066Sahrens 2377fa9e4066Sahrens return (0); 2378fa9e4066Sahrens } 2379fa9e4066Sahrens 2380fa9e4066Sahrens /* 23813f9d6ad7SLin Ling * Parse the input string, get the 'interval' and 'count' value if there is one. 2382fa9e4066Sahrens */ 23833f9d6ad7SLin Ling static void 23843f9d6ad7SLin Ling get_interval_count(int *argcp, char **argv, unsigned long *iv, 23853f9d6ad7SLin Ling unsigned long *cnt) 2386fa9e4066Sahrens { 2387fa9e4066Sahrens unsigned long interval = 0, count = 0; 23883f9d6ad7SLin Ling int argc = *argcp, errno; 2389fa9e4066Sahrens 2390fa9e4066Sahrens /* 2391fa9e4066Sahrens * Determine if the last argument is an integer or a pool name 2392fa9e4066Sahrens */ 2393fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 2394fa9e4066Sahrens char *end; 2395fa9e4066Sahrens 2396fa9e4066Sahrens errno = 0; 2397fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 2398fa9e4066Sahrens 2399fa9e4066Sahrens if (*end == '\0' && errno == 0) { 2400fa9e4066Sahrens if (interval == 0) { 2401fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 2402fa9e4066Sahrens "cannot be zero\n")); 240399653d4eSeschrock usage(B_FALSE); 2404fa9e4066Sahrens } 2405fa9e4066Sahrens /* 2406fa9e4066Sahrens * Ignore the last parameter 2407fa9e4066Sahrens */ 2408fa9e4066Sahrens argc--; 2409fa9e4066Sahrens } else { 2410fa9e4066Sahrens /* 2411fa9e4066Sahrens * If this is not a valid number, just plow on. The 2412fa9e4066Sahrens * user will get a more informative error message later 2413fa9e4066Sahrens * on. 2414fa9e4066Sahrens */ 2415fa9e4066Sahrens interval = 0; 2416fa9e4066Sahrens } 2417fa9e4066Sahrens } 2418fa9e4066Sahrens 2419fa9e4066Sahrens /* 2420fa9e4066Sahrens * If the last argument is also an integer, then we have both a count 24213f9d6ad7SLin Ling * and an interval. 2422fa9e4066Sahrens */ 2423fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 2424fa9e4066Sahrens char *end; 2425fa9e4066Sahrens 2426fa9e4066Sahrens errno = 0; 2427fa9e4066Sahrens count = interval; 2428fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 2429fa9e4066Sahrens 2430fa9e4066Sahrens if (*end == '\0' && errno == 0) { 2431fa9e4066Sahrens if (interval == 0) { 2432fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 2433fa9e4066Sahrens "cannot be zero\n")); 243499653d4eSeschrock usage(B_FALSE); 2435fa9e4066Sahrens } 2436fa9e4066Sahrens 2437fa9e4066Sahrens /* 2438fa9e4066Sahrens * Ignore the last parameter 2439fa9e4066Sahrens */ 2440fa9e4066Sahrens argc--; 2441fa9e4066Sahrens } else { 2442fa9e4066Sahrens interval = 0; 2443fa9e4066Sahrens } 2444fa9e4066Sahrens } 2445fa9e4066Sahrens 24463f9d6ad7SLin Ling *iv = interval; 24473f9d6ad7SLin Ling *cnt = count; 24483f9d6ad7SLin Ling *argcp = argc; 24493f9d6ad7SLin Ling } 24503f9d6ad7SLin Ling 24513f9d6ad7SLin Ling static void 24523f9d6ad7SLin Ling get_timestamp_arg(char c) 24533f9d6ad7SLin Ling { 24543f9d6ad7SLin Ling if (c == 'u') 24553f9d6ad7SLin Ling timestamp_fmt = UDATE; 24563f9d6ad7SLin Ling else if (c == 'd') 24573f9d6ad7SLin Ling timestamp_fmt = DDATE; 24583f9d6ad7SLin Ling else 24593f9d6ad7SLin Ling usage(B_FALSE); 24603f9d6ad7SLin Ling } 24613f9d6ad7SLin Ling 24623f9d6ad7SLin Ling /* 24633f9d6ad7SLin Ling * zpool iostat [-v] [-T d|u] [pool] ... [interval [count]] 24643f9d6ad7SLin Ling * 24653f9d6ad7SLin Ling * -v Display statistics for individual vdevs 24663f9d6ad7SLin Ling * -T Display a timestamp in date(1) or Unix format 24673f9d6ad7SLin Ling * 24683f9d6ad7SLin Ling * This command can be tricky because we want to be able to deal with pool 24693f9d6ad7SLin Ling * creation/destruction as well as vdev configuration changes. The bulk of this 24703f9d6ad7SLin Ling * processing is handled by the pool_list_* routines in zpool_iter.c. We rely 24713f9d6ad7SLin Ling * on pool_list_update() to detect the addition of new pools. Configuration 24723f9d6ad7SLin Ling * changes are all handled within libzfs. 24733f9d6ad7SLin Ling */ 24743f9d6ad7SLin Ling int 24753f9d6ad7SLin Ling zpool_do_iostat(int argc, char **argv) 24763f9d6ad7SLin Ling { 24773f9d6ad7SLin Ling int c; 24783f9d6ad7SLin Ling int ret; 24793f9d6ad7SLin Ling int npools; 24803f9d6ad7SLin Ling unsigned long interval = 0, count = 0; 24813f9d6ad7SLin Ling zpool_list_t *list; 24823f9d6ad7SLin Ling boolean_t verbose = B_FALSE; 24833f9d6ad7SLin Ling iostat_cbdata_t cb; 24843f9d6ad7SLin Ling 24853f9d6ad7SLin Ling /* check options */ 24863f9d6ad7SLin Ling while ((c = getopt(argc, argv, "T:v")) != -1) { 24873f9d6ad7SLin Ling switch (c) { 24883f9d6ad7SLin Ling case 'T': 24893f9d6ad7SLin Ling get_timestamp_arg(*optarg); 24903f9d6ad7SLin Ling break; 24913f9d6ad7SLin Ling case 'v': 24923f9d6ad7SLin Ling verbose = B_TRUE; 24933f9d6ad7SLin Ling break; 24943f9d6ad7SLin Ling case '?': 24953f9d6ad7SLin Ling (void) fprintf(stderr, gettext("invalid option '%c'\n"), 24963f9d6ad7SLin Ling optopt); 24973f9d6ad7SLin Ling usage(B_FALSE); 24983f9d6ad7SLin Ling } 24993f9d6ad7SLin Ling } 25003f9d6ad7SLin Ling 25013f9d6ad7SLin Ling argc -= optind; 25023f9d6ad7SLin Ling argv += optind; 25033f9d6ad7SLin Ling 25043f9d6ad7SLin Ling get_interval_count(&argc, argv, &interval, &count); 25053f9d6ad7SLin Ling 2506fa9e4066Sahrens /* 2507fa9e4066Sahrens * Construct the list of all interesting pools. 2508fa9e4066Sahrens */ 2509fa9e4066Sahrens ret = 0; 2510b1b8ab34Slling if ((list = pool_list_get(argc, argv, NULL, &ret)) == NULL) 2511fa9e4066Sahrens return (1); 2512fa9e4066Sahrens 251399653d4eSeschrock if (pool_list_count(list) == 0 && argc != 0) { 251499653d4eSeschrock pool_list_free(list); 2515fa9e4066Sahrens return (1); 251699653d4eSeschrock } 2517fa9e4066Sahrens 2518fa9e4066Sahrens if (pool_list_count(list) == 0 && interval == 0) { 251999653d4eSeschrock pool_list_free(list); 2520fa9e4066Sahrens (void) fprintf(stderr, gettext("no pools available\n")); 2521fa9e4066Sahrens return (1); 2522fa9e4066Sahrens } 2523fa9e4066Sahrens 2524fa9e4066Sahrens /* 2525fa9e4066Sahrens * Enter the main iostat loop. 2526fa9e4066Sahrens */ 2527fa9e4066Sahrens cb.cb_list = list; 2528fa9e4066Sahrens cb.cb_verbose = verbose; 2529fa9e4066Sahrens cb.cb_iteration = 0; 2530fa9e4066Sahrens cb.cb_namewidth = 0; 2531fa9e4066Sahrens 2532fa9e4066Sahrens for (;;) { 2533fa9e4066Sahrens pool_list_update(list); 2534fa9e4066Sahrens 2535fa9e4066Sahrens if ((npools = pool_list_count(list)) == 0) 2536fa9e4066Sahrens break; 2537fa9e4066Sahrens 2538088e9d47Seschrock /* 2539088e9d47Seschrock * Refresh all statistics. This is done as an explicit step 2540088e9d47Seschrock * before calculating the maximum name width, so that any 2541088e9d47Seschrock * configuration changes are properly accounted for. 2542088e9d47Seschrock */ 254399653d4eSeschrock (void) pool_list_iter(list, B_FALSE, refresh_iostat, &cb); 2544088e9d47Seschrock 2545fa9e4066Sahrens /* 2546fa9e4066Sahrens * Iterate over all pools to determine the maximum width 2547fa9e4066Sahrens * for the pool / device name column across all pools. 2548fa9e4066Sahrens */ 2549fa9e4066Sahrens cb.cb_namewidth = 0; 255099653d4eSeschrock (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb); 2551fa9e4066Sahrens 255226fd7700SKrishnendu Sadhukhan - Sun Microsystems if (timestamp_fmt != NODATE) 255326fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt); 255426fd7700SKrishnendu Sadhukhan - Sun Microsystems 2555fa9e4066Sahrens /* 2556fa9e4066Sahrens * If it's the first time, or verbose mode, print the header. 2557fa9e4066Sahrens */ 2558fa9e4066Sahrens if (++cb.cb_iteration == 1 || verbose) 2559fa9e4066Sahrens print_iostat_header(&cb); 2560fa9e4066Sahrens 256199653d4eSeschrock (void) pool_list_iter(list, B_FALSE, print_iostat, &cb); 2562fa9e4066Sahrens 2563fa9e4066Sahrens /* 2564fa9e4066Sahrens * If there's more than one pool, and we're not in verbose mode 2565fa9e4066Sahrens * (which prints a separator for us), then print a separator. 2566fa9e4066Sahrens */ 2567fa9e4066Sahrens if (npools > 1 && !verbose) 2568fa9e4066Sahrens print_iostat_separator(&cb); 2569fa9e4066Sahrens 2570fa9e4066Sahrens if (verbose) 2571fa9e4066Sahrens (void) printf("\n"); 2572fa9e4066Sahrens 257339c23413Seschrock /* 257439c23413Seschrock * Flush the output so that redirection to a file isn't buffered 257539c23413Seschrock * indefinitely. 257639c23413Seschrock */ 257739c23413Seschrock (void) fflush(stdout); 257839c23413Seschrock 2579fa9e4066Sahrens if (interval == 0) 2580fa9e4066Sahrens break; 2581fa9e4066Sahrens 2582fa9e4066Sahrens if (count != 0 && --count == 0) 2583fa9e4066Sahrens break; 2584fa9e4066Sahrens 2585fa9e4066Sahrens (void) sleep(interval); 2586fa9e4066Sahrens } 2587fa9e4066Sahrens 2588fa9e4066Sahrens pool_list_free(list); 2589fa9e4066Sahrens 2590fa9e4066Sahrens return (ret); 2591fa9e4066Sahrens } 2592fa9e4066Sahrens 2593fa9e4066Sahrens typedef struct list_cbdata { 25944263d13fSGeorge Wilson boolean_t cb_verbose; 25954263d13fSGeorge Wilson int cb_namewidth; 259699653d4eSeschrock boolean_t cb_scripted; 2597990b4856Slling zprop_list_t *cb_proplist; 2598fa9e4066Sahrens } list_cbdata_t; 2599fa9e4066Sahrens 2600fa9e4066Sahrens /* 2601fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 2602fa9e4066Sahrens */ 2603990b4856Slling static void 26044263d13fSGeorge Wilson print_header(list_cbdata_t *cb) 2605fa9e4066Sahrens { 26064263d13fSGeorge Wilson zprop_list_t *pl = cb->cb_proplist; 2607ad135b5dSChristopher Siden char headerbuf[ZPOOL_MAXPROPLEN]; 2608990b4856Slling const char *header; 2609990b4856Slling boolean_t first = B_TRUE; 2610990b4856Slling boolean_t right_justify; 26114263d13fSGeorge Wilson size_t width = 0; 2612990b4856Slling 2613990b4856Slling for (; pl != NULL; pl = pl->pl_next) { 26144263d13fSGeorge Wilson width = pl->pl_width; 26154263d13fSGeorge Wilson if (first && cb->cb_verbose) { 26164263d13fSGeorge Wilson /* 26174263d13fSGeorge Wilson * Reset the width to accommodate the verbose listing 26184263d13fSGeorge Wilson * of devices. 26194263d13fSGeorge Wilson */ 26204263d13fSGeorge Wilson width = cb->cb_namewidth; 26214263d13fSGeorge Wilson } 26224263d13fSGeorge Wilson 2623990b4856Slling if (!first) 2624fa9e4066Sahrens (void) printf(" "); 2625fa9e4066Sahrens else 2626990b4856Slling first = B_FALSE; 2627990b4856Slling 2628ad135b5dSChristopher Siden right_justify = B_FALSE; 2629ad135b5dSChristopher Siden if (pl->pl_prop != ZPROP_INVAL) { 2630ad135b5dSChristopher Siden header = zpool_prop_column_name(pl->pl_prop); 2631ad135b5dSChristopher Siden right_justify = zpool_prop_align_right(pl->pl_prop); 2632ad135b5dSChristopher Siden } else { 2633ad135b5dSChristopher Siden int i; 2634ad135b5dSChristopher Siden 2635ad135b5dSChristopher Siden for (i = 0; pl->pl_user_prop[i] != '\0'; i++) 2636ad135b5dSChristopher Siden headerbuf[i] = toupper(pl->pl_user_prop[i]); 2637ad135b5dSChristopher Siden headerbuf[i] = '\0'; 2638ad135b5dSChristopher Siden header = headerbuf; 2639ad135b5dSChristopher Siden } 2640fa9e4066Sahrens 2641990b4856Slling if (pl->pl_next == NULL && !right_justify) 2642990b4856Slling (void) printf("%s", header); 2643990b4856Slling else if (right_justify) 26444263d13fSGeorge Wilson (void) printf("%*s", width, header); 2645990b4856Slling else 26464263d13fSGeorge Wilson (void) printf("%-*s", width, header); 26474263d13fSGeorge Wilson 2648fa9e4066Sahrens } 2649fa9e4066Sahrens 2650fa9e4066Sahrens (void) printf("\n"); 2651fa9e4066Sahrens } 2652fa9e4066Sahrens 2653990b4856Slling /* 2654990b4856Slling * Given a pool and a list of properties, print out all the properties according 2655990b4856Slling * to the described layout. 2656990b4856Slling */ 2657990b4856Slling static void 26584263d13fSGeorge Wilson print_pool(zpool_handle_t *zhp, list_cbdata_t *cb) 2659fa9e4066Sahrens { 26604263d13fSGeorge Wilson zprop_list_t *pl = cb->cb_proplist; 2661990b4856Slling boolean_t first = B_TRUE; 2662990b4856Slling char property[ZPOOL_MAXPROPLEN]; 2663990b4856Slling char *propstr; 2664990b4856Slling boolean_t right_justify; 26654263d13fSGeorge Wilson size_t width; 2666990b4856Slling 2667990b4856Slling for (; pl != NULL; pl = pl->pl_next) { 26684263d13fSGeorge Wilson 26694263d13fSGeorge Wilson width = pl->pl_width; 26704263d13fSGeorge Wilson if (first && cb->cb_verbose) { 26714263d13fSGeorge Wilson /* 26724263d13fSGeorge Wilson * Reset the width to accommodate the verbose listing 26734263d13fSGeorge Wilson * of devices. 26744263d13fSGeorge Wilson */ 26754263d13fSGeorge Wilson width = cb->cb_namewidth; 26764263d13fSGeorge Wilson } 26774263d13fSGeorge Wilson 2678990b4856Slling if (!first) { 26794263d13fSGeorge Wilson if (cb->cb_scripted) 2680fa9e4066Sahrens (void) printf("\t"); 2681fa9e4066Sahrens else 2682fa9e4066Sahrens (void) printf(" "); 2683990b4856Slling } else { 2684990b4856Slling first = B_FALSE; 2685fa9e4066Sahrens } 2686fa9e4066Sahrens 2687990b4856Slling right_justify = B_FALSE; 2688990b4856Slling if (pl->pl_prop != ZPROP_INVAL) { 26894263d13fSGeorge Wilson if (pl->pl_prop == ZPOOL_PROP_EXPANDSZ && 26904263d13fSGeorge Wilson zpool_get_prop_int(zhp, pl->pl_prop, NULL) == 0) 26914263d13fSGeorge Wilson propstr = "-"; 26924263d13fSGeorge Wilson else if (zpool_get_prop(zhp, pl->pl_prop, property, 2693990b4856Slling sizeof (property), NULL) != 0) 2694990b4856Slling propstr = "-"; 2695fa9e4066Sahrens else 2696990b4856Slling propstr = property; 2697fa9e4066Sahrens 2698990b4856Slling right_justify = zpool_prop_align_right(pl->pl_prop); 2699ad135b5dSChristopher Siden } else if ((zpool_prop_feature(pl->pl_user_prop) || 2700ad135b5dSChristopher Siden zpool_prop_unsupported(pl->pl_user_prop)) && 2701ad135b5dSChristopher Siden zpool_prop_get_feature(zhp, pl->pl_user_prop, property, 2702ad135b5dSChristopher Siden sizeof (property)) == 0) { 2703ad135b5dSChristopher Siden propstr = property; 2704990b4856Slling } else { 2705990b4856Slling propstr = "-"; 2706990b4856Slling } 2707fa9e4066Sahrens 2708fa9e4066Sahrens 2709990b4856Slling /* 2710990b4856Slling * If this is being called in scripted mode, or if this is the 2711990b4856Slling * last column and it is left-justified, don't include a width 2712990b4856Slling * format specifier. 2713990b4856Slling */ 27144263d13fSGeorge Wilson if (cb->cb_scripted || (pl->pl_next == NULL && !right_justify)) 2715990b4856Slling (void) printf("%s", propstr); 2716990b4856Slling else if (right_justify) 2717990b4856Slling (void) printf("%*s", width, propstr); 2718990b4856Slling else 2719990b4856Slling (void) printf("%-*s", width, propstr); 2720990b4856Slling } 2721fa9e4066Sahrens 2722990b4856Slling (void) printf("\n"); 2723990b4856Slling } 2724fa9e4066Sahrens 27254263d13fSGeorge Wilson static void 27264263d13fSGeorge Wilson print_one_column(zpool_prop_t prop, uint64_t value, boolean_t scripted) 27274263d13fSGeorge Wilson { 27284263d13fSGeorge Wilson char propval[64]; 27294263d13fSGeorge Wilson boolean_t fixed; 27304263d13fSGeorge Wilson size_t width = zprop_width(prop, &fixed, ZFS_TYPE_POOL); 27314263d13fSGeorge Wilson 27324263d13fSGeorge Wilson zfs_nicenum(value, propval, sizeof (propval)); 27334263d13fSGeorge Wilson 27344263d13fSGeorge Wilson if (prop == ZPOOL_PROP_EXPANDSZ && value == 0) 27354263d13fSGeorge Wilson (void) strlcpy(propval, "-", sizeof (propval)); 27364263d13fSGeorge Wilson 27374263d13fSGeorge Wilson if (scripted) 27384263d13fSGeorge Wilson (void) printf("\t%s", propval); 27394263d13fSGeorge Wilson else 27404263d13fSGeorge Wilson (void) printf(" %*s", width, propval); 27414263d13fSGeorge Wilson } 27424263d13fSGeorge Wilson 27434263d13fSGeorge Wilson void 27444263d13fSGeorge Wilson print_list_stats(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 27454263d13fSGeorge Wilson list_cbdata_t *cb, int depth) 27464263d13fSGeorge Wilson { 27474263d13fSGeorge Wilson nvlist_t **child; 27484263d13fSGeorge Wilson vdev_stat_t *vs; 27494263d13fSGeorge Wilson uint_t c, children; 27504263d13fSGeorge Wilson char *vname; 27514263d13fSGeorge Wilson boolean_t scripted = cb->cb_scripted; 27524263d13fSGeorge Wilson 27534263d13fSGeorge Wilson verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 27544263d13fSGeorge Wilson (uint64_t **)&vs, &c) == 0); 27554263d13fSGeorge Wilson 27564263d13fSGeorge Wilson if (name != NULL) { 27574263d13fSGeorge Wilson if (scripted) 27584263d13fSGeorge Wilson (void) printf("\t%s", name); 27594263d13fSGeorge Wilson else if (strlen(name) + depth > cb->cb_namewidth) 27604263d13fSGeorge Wilson (void) printf("%*s%s", depth, "", name); 27614263d13fSGeorge Wilson else 27624263d13fSGeorge Wilson (void) printf("%*s%s%*s", depth, "", name, 27634263d13fSGeorge Wilson (int)(cb->cb_namewidth - strlen(name) - depth), ""); 27644263d13fSGeorge Wilson 27654263d13fSGeorge Wilson /* only toplevel vdevs have capacity stats */ 27664263d13fSGeorge Wilson if (vs->vs_space == 0) { 27674263d13fSGeorge Wilson if (scripted) 27684263d13fSGeorge Wilson (void) printf("\t-\t-\t-"); 27694263d13fSGeorge Wilson else 27704263d13fSGeorge Wilson (void) printf(" - - -"); 27714263d13fSGeorge Wilson } else { 27724263d13fSGeorge Wilson print_one_column(ZPOOL_PROP_SIZE, vs->vs_space, 27734263d13fSGeorge Wilson scripted); 27744263d13fSGeorge Wilson print_one_column(ZPOOL_PROP_CAPACITY, vs->vs_alloc, 27754263d13fSGeorge Wilson scripted); 27764263d13fSGeorge Wilson print_one_column(ZPOOL_PROP_FREE, 27774263d13fSGeorge Wilson vs->vs_space - vs->vs_alloc, scripted); 27784263d13fSGeorge Wilson } 27794263d13fSGeorge Wilson print_one_column(ZPOOL_PROP_EXPANDSZ, vs->vs_esize, 27804263d13fSGeorge Wilson scripted); 27814263d13fSGeorge Wilson (void) printf("\n"); 27824263d13fSGeorge Wilson } 27834263d13fSGeorge Wilson 27844263d13fSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 27854263d13fSGeorge Wilson &child, &children) != 0) 27864263d13fSGeorge Wilson return; 27874263d13fSGeorge Wilson 27884263d13fSGeorge Wilson for (c = 0; c < children; c++) { 27894263d13fSGeorge Wilson uint64_t ishole = B_FALSE; 27904263d13fSGeorge Wilson 27914263d13fSGeorge Wilson if (nvlist_lookup_uint64(child[c], 27924263d13fSGeorge Wilson ZPOOL_CONFIG_IS_HOLE, &ishole) == 0 && ishole) 27934263d13fSGeorge Wilson continue; 27944263d13fSGeorge Wilson 27954263d13fSGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE); 27964263d13fSGeorge Wilson print_list_stats(zhp, vname, child[c], cb, depth + 2); 27974263d13fSGeorge Wilson free(vname); 27984263d13fSGeorge Wilson } 27994263d13fSGeorge Wilson 28004263d13fSGeorge Wilson /* 28014263d13fSGeorge Wilson * Include level 2 ARC devices in iostat output 28024263d13fSGeorge Wilson */ 28034263d13fSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 28044263d13fSGeorge Wilson &child, &children) != 0) 28054263d13fSGeorge Wilson return; 28064263d13fSGeorge Wilson 28074263d13fSGeorge Wilson if (children > 0) { 28084263d13fSGeorge Wilson (void) printf("%-*s - - - - - " 28094263d13fSGeorge Wilson "-\n", cb->cb_namewidth, "cache"); 28104263d13fSGeorge Wilson for (c = 0; c < children; c++) { 28114263d13fSGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], 28124263d13fSGeorge Wilson B_FALSE); 28134263d13fSGeorge Wilson print_list_stats(zhp, vname, child[c], cb, depth + 2); 28144263d13fSGeorge Wilson free(vname); 28154263d13fSGeorge Wilson } 28164263d13fSGeorge Wilson } 28174263d13fSGeorge Wilson } 28184263d13fSGeorge Wilson 28194263d13fSGeorge Wilson 2820990b4856Slling /* 2821990b4856Slling * Generic callback function to list a pool. 2822990b4856Slling */ 2823990b4856Slling int 2824990b4856Slling list_callback(zpool_handle_t *zhp, void *data) 2825990b4856Slling { 2826990b4856Slling list_cbdata_t *cbp = data; 28274263d13fSGeorge Wilson nvlist_t *config; 28284263d13fSGeorge Wilson nvlist_t *nvroot; 2829fa9e4066Sahrens 28304263d13fSGeorge Wilson config = zpool_get_config(zhp, NULL); 2831fa9e4066Sahrens 28324263d13fSGeorge Wilson print_pool(zhp, cbp); 28334263d13fSGeorge Wilson if (!cbp->cb_verbose) 28344263d13fSGeorge Wilson return (0); 28354263d13fSGeorge Wilson 28364263d13fSGeorge Wilson verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 28374263d13fSGeorge Wilson &nvroot) == 0); 28384263d13fSGeorge Wilson print_list_stats(zhp, NULL, nvroot, cbp, 0); 2839fa9e4066Sahrens 2840fa9e4066Sahrens return (0); 2841fa9e4066Sahrens } 2842fa9e4066Sahrens 2843fa9e4066Sahrens /* 28443f9d6ad7SLin Ling * zpool list [-H] [-o prop[,prop]*] [-T d|u] [pool] ... [interval [count]] 2845fa9e4066Sahrens * 2846990b4856Slling * -H Scripted mode. Don't display headers, and separate properties 2847990b4856Slling * by a single tab. 2848990b4856Slling * -o List of properties to display. Defaults to 2849485bbbf5SGeorge Wilson * "name,size,allocated,free,capacity,health,altroot" 28503f9d6ad7SLin Ling * -T Display a timestamp in date(1) or Unix format 2851fa9e4066Sahrens * 2852fa9e4066Sahrens * List all pools in the system, whether or not they're healthy. Output space 2853fa9e4066Sahrens * statistics for each one, as well as health status summary. 2854fa9e4066Sahrens */ 2855fa9e4066Sahrens int 2856fa9e4066Sahrens zpool_do_list(int argc, char **argv) 2857fa9e4066Sahrens { 2858fa9e4066Sahrens int c; 2859fa9e4066Sahrens int ret; 2860fa9e4066Sahrens list_cbdata_t cb = { 0 }; 2861990b4856Slling static char default_props[] = 28624263d13fSGeorge Wilson "name,size,allocated,free,expandsize,capacity,dedupratio," 28634263d13fSGeorge Wilson "health,altroot"; 2864990b4856Slling char *props = default_props; 28653f9d6ad7SLin Ling unsigned long interval = 0, count = 0; 28664263d13fSGeorge Wilson zpool_list_t *list; 28674263d13fSGeorge Wilson boolean_t first = B_TRUE; 2868fa9e4066Sahrens 2869fa9e4066Sahrens /* check options */ 28704263d13fSGeorge Wilson while ((c = getopt(argc, argv, ":Ho:T:v")) != -1) { 2871fa9e4066Sahrens switch (c) { 2872fa9e4066Sahrens case 'H': 287399653d4eSeschrock cb.cb_scripted = B_TRUE; 2874fa9e4066Sahrens break; 2875fa9e4066Sahrens case 'o': 2876990b4856Slling props = optarg; 2877fa9e4066Sahrens break; 28783f9d6ad7SLin Ling case 'T': 28793f9d6ad7SLin Ling get_timestamp_arg(*optarg); 28803f9d6ad7SLin Ling break; 28814263d13fSGeorge Wilson case 'v': 28824263d13fSGeorge Wilson cb.cb_verbose = B_TRUE; 28834263d13fSGeorge Wilson break; 2884fa9e4066Sahrens case ':': 2885fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2886fa9e4066Sahrens "'%c' option\n"), optopt); 288799653d4eSeschrock usage(B_FALSE); 2888fa9e4066Sahrens break; 2889fa9e4066Sahrens case '?': 2890fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2891fa9e4066Sahrens optopt); 289299653d4eSeschrock usage(B_FALSE); 2893fa9e4066Sahrens } 2894fa9e4066Sahrens } 2895fa9e4066Sahrens 2896fa9e4066Sahrens argc -= optind; 2897fa9e4066Sahrens argv += optind; 2898fa9e4066Sahrens 28993f9d6ad7SLin Ling get_interval_count(&argc, argv, &interval, &count); 29003f9d6ad7SLin Ling 2901990b4856Slling if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0) 2902990b4856Slling usage(B_FALSE); 2903fa9e4066Sahrens 29044263d13fSGeorge Wilson if ((list = pool_list_get(argc, argv, &cb.cb_proplist, &ret)) == NULL) 29054263d13fSGeorge Wilson return (1); 29064263d13fSGeorge Wilson 29074263d13fSGeorge Wilson if (argc == 0 && !cb.cb_scripted && pool_list_count(list) == 0) { 29084263d13fSGeorge Wilson (void) printf(gettext("no pools available\n")); 29094263d13fSGeorge Wilson zprop_free_list(cb.cb_proplist); 29104263d13fSGeorge Wilson return (0); 29114263d13fSGeorge Wilson } 2912fa9e4066Sahrens 29133f9d6ad7SLin Ling for (;;) { 29144263d13fSGeorge Wilson pool_list_update(list); 29154263d13fSGeorge Wilson 29164263d13fSGeorge Wilson if (pool_list_count(list) == 0) 29174263d13fSGeorge Wilson break; 29184263d13fSGeorge Wilson 29194263d13fSGeorge Wilson cb.cb_namewidth = 0; 29204263d13fSGeorge Wilson (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb); 2921990b4856Slling 29223f9d6ad7SLin Ling if (timestamp_fmt != NODATE) 29233f9d6ad7SLin Ling print_timestamp(timestamp_fmt); 2924fa9e4066Sahrens 29254263d13fSGeorge Wilson if (!cb.cb_scripted && (first || cb.cb_verbose)) { 29264263d13fSGeorge Wilson print_header(&cb); 29274263d13fSGeorge Wilson first = B_FALSE; 29283f9d6ad7SLin Ling } 29294263d13fSGeorge Wilson ret = pool_list_iter(list, B_TRUE, list_callback, &cb); 29303f9d6ad7SLin Ling 29313f9d6ad7SLin Ling if (interval == 0) 29323f9d6ad7SLin Ling break; 29333f9d6ad7SLin Ling 29343f9d6ad7SLin Ling if (count != 0 && --count == 0) 29353f9d6ad7SLin Ling break; 29363f9d6ad7SLin Ling 29373f9d6ad7SLin Ling (void) sleep(interval); 2938fa9e4066Sahrens } 2939fa9e4066Sahrens 29403f9d6ad7SLin Ling zprop_free_list(cb.cb_proplist); 2941fa9e4066Sahrens return (ret); 2942fa9e4066Sahrens } 2943fa9e4066Sahrens 2944fa9e4066Sahrens static nvlist_t * 2945fa9e4066Sahrens zpool_get_vdev_by_name(nvlist_t *nv, char *name) 2946fa9e4066Sahrens { 2947fa9e4066Sahrens nvlist_t **child; 2948fa9e4066Sahrens uint_t c, children; 2949fa9e4066Sahrens nvlist_t *match; 2950fa9e4066Sahrens char *path; 2951fa9e4066Sahrens 2952fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2953fa9e4066Sahrens &child, &children) != 0) { 2954fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 2955fa9e4066Sahrens if (strncmp(name, "/dev/dsk/", 9) == 0) 2956fa9e4066Sahrens name += 9; 2957fa9e4066Sahrens if (strncmp(path, "/dev/dsk/", 9) == 0) 2958fa9e4066Sahrens path += 9; 2959fa9e4066Sahrens if (strcmp(name, path) == 0) 2960fa9e4066Sahrens return (nv); 2961fa9e4066Sahrens return (NULL); 2962fa9e4066Sahrens } 2963fa9e4066Sahrens 2964fa9e4066Sahrens for (c = 0; c < children; c++) 2965fa9e4066Sahrens if ((match = zpool_get_vdev_by_name(child[c], name)) != NULL) 2966fa9e4066Sahrens return (match); 2967fa9e4066Sahrens 2968fa9e4066Sahrens return (NULL); 2969fa9e4066Sahrens } 2970fa9e4066Sahrens 2971fa9e4066Sahrens static int 2972fa9e4066Sahrens zpool_do_attach_or_replace(int argc, char **argv, int replacing) 2973fa9e4066Sahrens { 297499653d4eSeschrock boolean_t force = B_FALSE; 2975fa9e4066Sahrens int c; 2976fa9e4066Sahrens nvlist_t *nvroot; 2977fa9e4066Sahrens char *poolname, *old_disk, *new_disk; 2978fa9e4066Sahrens zpool_handle_t *zhp; 297999653d4eSeschrock int ret; 2980fa9e4066Sahrens 2981fa9e4066Sahrens /* check options */ 2982fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2983fa9e4066Sahrens switch (c) { 2984fa9e4066Sahrens case 'f': 298599653d4eSeschrock force = B_TRUE; 2986fa9e4066Sahrens break; 2987fa9e4066Sahrens case '?': 2988fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2989fa9e4066Sahrens optopt); 299099653d4eSeschrock usage(B_FALSE); 2991fa9e4066Sahrens } 2992fa9e4066Sahrens } 2993fa9e4066Sahrens 2994fa9e4066Sahrens argc -= optind; 2995fa9e4066Sahrens argv += optind; 2996fa9e4066Sahrens 2997fa9e4066Sahrens /* get pool name and check number of arguments */ 2998fa9e4066Sahrens if (argc < 1) { 2999fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 300099653d4eSeschrock usage(B_FALSE); 3001fa9e4066Sahrens } 3002fa9e4066Sahrens 3003fa9e4066Sahrens poolname = argv[0]; 3004fa9e4066Sahrens 3005fa9e4066Sahrens if (argc < 2) { 3006fa9e4066Sahrens (void) fprintf(stderr, 3007fa9e4066Sahrens gettext("missing <device> specification\n")); 300899653d4eSeschrock usage(B_FALSE); 3009fa9e4066Sahrens } 3010fa9e4066Sahrens 3011fa9e4066Sahrens old_disk = argv[1]; 3012fa9e4066Sahrens 3013fa9e4066Sahrens if (argc < 3) { 3014fa9e4066Sahrens if (!replacing) { 3015fa9e4066Sahrens (void) fprintf(stderr, 3016fa9e4066Sahrens gettext("missing <new_device> specification\n")); 301799653d4eSeschrock usage(B_FALSE); 3018fa9e4066Sahrens } 3019fa9e4066Sahrens new_disk = old_disk; 3020fa9e4066Sahrens argc -= 1; 3021fa9e4066Sahrens argv += 1; 3022fa9e4066Sahrens } else { 3023fa9e4066Sahrens new_disk = argv[2]; 3024fa9e4066Sahrens argc -= 2; 3025fa9e4066Sahrens argv += 2; 3026fa9e4066Sahrens } 3027fa9e4066Sahrens 3028fa9e4066Sahrens if (argc > 1) { 3029fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 303099653d4eSeschrock usage(B_FALSE); 3031fa9e4066Sahrens } 3032fa9e4066Sahrens 303399653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 3034fa9e4066Sahrens return (1); 3035fa9e4066Sahrens 30368488aeb5Staylor if (zpool_get_config(zhp, NULL) == NULL) { 3037fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 3038fa9e4066Sahrens poolname); 3039fa9e4066Sahrens zpool_close(zhp); 3040fa9e4066Sahrens return (1); 3041fa9e4066Sahrens } 3042fa9e4066Sahrens 3043705040edSEric Taylor nvroot = make_root_vdev(zhp, force, B_FALSE, replacing, B_FALSE, 3044705040edSEric Taylor argc, argv); 3045fa9e4066Sahrens if (nvroot == NULL) { 3046fa9e4066Sahrens zpool_close(zhp); 3047fa9e4066Sahrens return (1); 3048fa9e4066Sahrens } 3049fa9e4066Sahrens 305099653d4eSeschrock ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing); 305199653d4eSeschrock 305299653d4eSeschrock nvlist_free(nvroot); 305399653d4eSeschrock zpool_close(zhp); 305499653d4eSeschrock 305599653d4eSeschrock return (ret); 3056fa9e4066Sahrens } 3057fa9e4066Sahrens 3058fa9e4066Sahrens /* 3059fa9e4066Sahrens * zpool replace [-f] <pool> <device> <new_device> 3060fa9e4066Sahrens * 3061fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 3062fa9e4066Sahrens * 3063fa9e4066Sahrens * Replace <device> with <new_device>. 3064fa9e4066Sahrens */ 3065fa9e4066Sahrens /* ARGSUSED */ 3066fa9e4066Sahrens int 3067fa9e4066Sahrens zpool_do_replace(int argc, char **argv) 3068fa9e4066Sahrens { 3069fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_TRUE)); 3070fa9e4066Sahrens } 3071fa9e4066Sahrens 3072fa9e4066Sahrens /* 3073fa9e4066Sahrens * zpool attach [-f] <pool> <device> <new_device> 3074fa9e4066Sahrens * 3075fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 3076fa9e4066Sahrens * 3077fa9e4066Sahrens * Attach <new_device> to the mirror containing <device>. If <device> is not 3078fa9e4066Sahrens * part of a mirror, then <device> will be transformed into a mirror of 3079fa9e4066Sahrens * <device> and <new_device>. In either case, <new_device> will begin life 3080fa9e4066Sahrens * with a DTL of [0, now], and will immediately begin to resilver itself. 3081fa9e4066Sahrens */ 3082fa9e4066Sahrens int 3083fa9e4066Sahrens zpool_do_attach(int argc, char **argv) 3084fa9e4066Sahrens { 3085fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_FALSE)); 3086fa9e4066Sahrens } 3087fa9e4066Sahrens 3088fa9e4066Sahrens /* 3089fa9e4066Sahrens * zpool detach [-f] <pool> <device> 3090fa9e4066Sahrens * 3091fa9e4066Sahrens * -f Force detach of <device>, even if DTLs argue against it 3092fa9e4066Sahrens * (not supported yet) 3093fa9e4066Sahrens * 3094fa9e4066Sahrens * Detach a device from a mirror. The operation will be refused if <device> 3095fa9e4066Sahrens * is the last device in the mirror, or if the DTLs indicate that this device 3096fa9e4066Sahrens * has the only valid copy of some data. 3097fa9e4066Sahrens */ 3098fa9e4066Sahrens /* ARGSUSED */ 3099fa9e4066Sahrens int 3100fa9e4066Sahrens zpool_do_detach(int argc, char **argv) 3101fa9e4066Sahrens { 3102fa9e4066Sahrens int c; 3103fa9e4066Sahrens char *poolname, *path; 3104fa9e4066Sahrens zpool_handle_t *zhp; 310599653d4eSeschrock int ret; 3106fa9e4066Sahrens 3107fa9e4066Sahrens /* check options */ 3108fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 3109fa9e4066Sahrens switch (c) { 3110fa9e4066Sahrens case 'f': 3111fa9e4066Sahrens case '?': 3112fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3113fa9e4066Sahrens optopt); 311499653d4eSeschrock usage(B_FALSE); 3115fa9e4066Sahrens } 3116fa9e4066Sahrens } 3117fa9e4066Sahrens 3118fa9e4066Sahrens argc -= optind; 3119fa9e4066Sahrens argv += optind; 3120fa9e4066Sahrens 3121fa9e4066Sahrens /* get pool name and check number of arguments */ 3122fa9e4066Sahrens if (argc < 1) { 3123fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 312499653d4eSeschrock usage(B_FALSE); 3125fa9e4066Sahrens } 3126fa9e4066Sahrens 3127fa9e4066Sahrens if (argc < 2) { 3128fa9e4066Sahrens (void) fprintf(stderr, 3129fa9e4066Sahrens gettext("missing <device> specification\n")); 313099653d4eSeschrock usage(B_FALSE); 3131fa9e4066Sahrens } 3132fa9e4066Sahrens 3133fa9e4066Sahrens poolname = argv[0]; 3134fa9e4066Sahrens path = argv[1]; 3135fa9e4066Sahrens 313699653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 3137fa9e4066Sahrens return (1); 3138fa9e4066Sahrens 313999653d4eSeschrock ret = zpool_vdev_detach(zhp, path); 314099653d4eSeschrock 314199653d4eSeschrock zpool_close(zhp); 314299653d4eSeschrock 314399653d4eSeschrock return (ret); 3144fa9e4066Sahrens } 3145fa9e4066Sahrens 31461195e687SMark J Musante /* 31471195e687SMark J Musante * zpool split [-n] [-o prop=val] ... 31481195e687SMark J Musante * [-o mntopt] ... 31491195e687SMark J Musante * [-R altroot] <pool> <newpool> [<device> ...] 31501195e687SMark J Musante * 31511195e687SMark J Musante * -n Do not split the pool, but display the resulting layout if 31521195e687SMark J Musante * it were to be split. 31531195e687SMark J Musante * -o Set property=value, or set mount options. 31541195e687SMark J Musante * -R Mount the split-off pool under an alternate root. 31551195e687SMark J Musante * 31561195e687SMark J Musante * Splits the named pool and gives it the new pool name. Devices to be split 31571195e687SMark J Musante * off may be listed, provided that no more than one device is specified 31581195e687SMark J Musante * per top-level vdev mirror. The newly split pool is left in an exported 31591195e687SMark J Musante * state unless -R is specified. 31601195e687SMark J Musante * 31611195e687SMark J Musante * Restrictions: the top-level of the pool pool must only be made up of 31621195e687SMark J Musante * mirrors; all devices in the pool must be healthy; no device may be 31631195e687SMark J Musante * undergoing a resilvering operation. 31641195e687SMark J Musante */ 31651195e687SMark J Musante int 31661195e687SMark J Musante zpool_do_split(int argc, char **argv) 31671195e687SMark J Musante { 31681195e687SMark J Musante char *srcpool, *newpool, *propval; 31691195e687SMark J Musante char *mntopts = NULL; 31701195e687SMark J Musante splitflags_t flags; 31711195e687SMark J Musante int c, ret = 0; 31721195e687SMark J Musante zpool_handle_t *zhp; 31731195e687SMark J Musante nvlist_t *config, *props = NULL; 31741195e687SMark J Musante 31751195e687SMark J Musante flags.dryrun = B_FALSE; 31761195e687SMark J Musante flags.import = B_FALSE; 31771195e687SMark J Musante 31781195e687SMark J Musante /* check options */ 31791195e687SMark J Musante while ((c = getopt(argc, argv, ":R:no:")) != -1) { 31801195e687SMark J Musante switch (c) { 31811195e687SMark J Musante case 'R': 31821195e687SMark J Musante flags.import = B_TRUE; 31831195e687SMark J Musante if (add_prop_list( 31841195e687SMark J Musante zpool_prop_to_name(ZPOOL_PROP_ALTROOT), optarg, 31851195e687SMark J Musante &props, B_TRUE) != 0) { 31861195e687SMark J Musante if (props) 31871195e687SMark J Musante nvlist_free(props); 31881195e687SMark J Musante usage(B_FALSE); 31891195e687SMark J Musante } 31901195e687SMark J Musante break; 31911195e687SMark J Musante case 'n': 31921195e687SMark J Musante flags.dryrun = B_TRUE; 31931195e687SMark J Musante break; 31941195e687SMark J Musante case 'o': 31951195e687SMark J Musante if ((propval = strchr(optarg, '=')) != NULL) { 31961195e687SMark J Musante *propval = '\0'; 31971195e687SMark J Musante propval++; 31981195e687SMark J Musante if (add_prop_list(optarg, propval, 31991195e687SMark J Musante &props, B_TRUE) != 0) { 32001195e687SMark J Musante if (props) 32011195e687SMark J Musante nvlist_free(props); 32021195e687SMark J Musante usage(B_FALSE); 32031195e687SMark J Musante } 32041195e687SMark J Musante } else { 32051195e687SMark J Musante mntopts = optarg; 32061195e687SMark J Musante } 32071195e687SMark J Musante break; 32081195e687SMark J Musante case ':': 32091195e687SMark J Musante (void) fprintf(stderr, gettext("missing argument for " 32101195e687SMark J Musante "'%c' option\n"), optopt); 32111195e687SMark J Musante usage(B_FALSE); 32121195e687SMark J Musante break; 32131195e687SMark J Musante case '?': 32141195e687SMark J Musante (void) fprintf(stderr, gettext("invalid option '%c'\n"), 32151195e687SMark J Musante optopt); 32161195e687SMark J Musante usage(B_FALSE); 32171195e687SMark J Musante break; 32181195e687SMark J Musante } 32191195e687SMark J Musante } 32201195e687SMark J Musante 32211195e687SMark J Musante if (!flags.import && mntopts != NULL) { 32221195e687SMark J Musante (void) fprintf(stderr, gettext("setting mntopts is only " 32231195e687SMark J Musante "valid when importing the pool\n")); 32241195e687SMark J Musante usage(B_FALSE); 32251195e687SMark J Musante } 32261195e687SMark J Musante 32271195e687SMark J Musante argc -= optind; 32281195e687SMark J Musante argv += optind; 32291195e687SMark J Musante 32301195e687SMark J Musante if (argc < 1) { 32311195e687SMark J Musante (void) fprintf(stderr, gettext("Missing pool name\n")); 32321195e687SMark J Musante usage(B_FALSE); 32331195e687SMark J Musante } 32341195e687SMark J Musante if (argc < 2) { 32351195e687SMark J Musante (void) fprintf(stderr, gettext("Missing new pool name\n")); 32361195e687SMark J Musante usage(B_FALSE); 32371195e687SMark J Musante } 32381195e687SMark J Musante 32391195e687SMark J Musante srcpool = argv[0]; 32401195e687SMark J Musante newpool = argv[1]; 32411195e687SMark J Musante 32421195e687SMark J Musante argc -= 2; 32431195e687SMark J Musante argv += 2; 32441195e687SMark J Musante 32451195e687SMark J Musante if ((zhp = zpool_open(g_zfs, srcpool)) == NULL) 32461195e687SMark J Musante return (1); 32471195e687SMark J Musante 32481195e687SMark J Musante config = split_mirror_vdev(zhp, newpool, props, flags, argc, argv); 32491195e687SMark J Musante if (config == NULL) { 32501195e687SMark J Musante ret = 1; 32511195e687SMark J Musante } else { 32521195e687SMark J Musante if (flags.dryrun) { 32531195e687SMark J Musante (void) printf(gettext("would create '%s' with the " 32541195e687SMark J Musante "following layout:\n\n"), newpool); 32551195e687SMark J Musante print_vdev_tree(NULL, newpool, config, 0, B_FALSE); 32561195e687SMark J Musante } 32571195e687SMark J Musante nvlist_free(config); 32581195e687SMark J Musante } 32591195e687SMark J Musante 32601195e687SMark J Musante zpool_close(zhp); 32611195e687SMark J Musante 32621195e687SMark J Musante if (ret != 0 || flags.dryrun || !flags.import) 32631195e687SMark J Musante return (ret); 32641195e687SMark J Musante 32651195e687SMark J Musante /* 32661195e687SMark J Musante * The split was successful. Now we need to open the new 32671195e687SMark J Musante * pool and import it. 32681195e687SMark J Musante */ 32691195e687SMark J Musante if ((zhp = zpool_open_canfail(g_zfs, newpool)) == NULL) 32701195e687SMark J Musante return (1); 32711195e687SMark J Musante if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 32721195e687SMark J Musante zpool_enable_datasets(zhp, mntopts, 0) != 0) { 32731195e687SMark J Musante ret = 1; 32741195e687SMark J Musante (void) fprintf(stderr, gettext("Split was succssful, but " 32751195e687SMark J Musante "the datasets could not all be mounted\n")); 32761195e687SMark J Musante (void) fprintf(stderr, gettext("Try doing '%s' with a " 32771195e687SMark J Musante "different altroot\n"), "zpool import"); 32781195e687SMark J Musante } 32791195e687SMark J Musante zpool_close(zhp); 32801195e687SMark J Musante 32811195e687SMark J Musante return (ret); 32821195e687SMark J Musante } 32831195e687SMark J Musante 32841195e687SMark J Musante 32851195e687SMark J Musante 3286fa9e4066Sahrens /* 3287441d80aaSlling * zpool online <pool> <device> ... 3288fa9e4066Sahrens */ 3289fa9e4066Sahrens int 3290fa9e4066Sahrens zpool_do_online(int argc, char **argv) 3291fa9e4066Sahrens { 3292fa9e4066Sahrens int c, i; 3293fa9e4066Sahrens char *poolname; 3294fa9e4066Sahrens zpool_handle_t *zhp; 3295fa9e4066Sahrens int ret = 0; 32963d7072f8Seschrock vdev_state_t newstate; 3297573ca77eSGeorge Wilson int flags = 0; 3298fa9e4066Sahrens 3299fa9e4066Sahrens /* check options */ 3300573ca77eSGeorge Wilson while ((c = getopt(argc, argv, "et")) != -1) { 3301fa9e4066Sahrens switch (c) { 3302573ca77eSGeorge Wilson case 'e': 3303573ca77eSGeorge Wilson flags |= ZFS_ONLINE_EXPAND; 3304573ca77eSGeorge Wilson break; 3305fa9e4066Sahrens case 't': 3306fa9e4066Sahrens case '?': 3307fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3308fa9e4066Sahrens optopt); 330999653d4eSeschrock usage(B_FALSE); 3310fa9e4066Sahrens } 3311fa9e4066Sahrens } 3312fa9e4066Sahrens 3313fa9e4066Sahrens argc -= optind; 3314fa9e4066Sahrens argv += optind; 3315fa9e4066Sahrens 3316fa9e4066Sahrens /* get pool name and check number of arguments */ 3317fa9e4066Sahrens if (argc < 1) { 3318fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 331999653d4eSeschrock usage(B_FALSE); 3320fa9e4066Sahrens } 3321fa9e4066Sahrens if (argc < 2) { 3322fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 332399653d4eSeschrock usage(B_FALSE); 3324fa9e4066Sahrens } 3325fa9e4066Sahrens 3326fa9e4066Sahrens poolname = argv[0]; 3327fa9e4066Sahrens 332899653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 3329fa9e4066Sahrens return (1); 3330fa9e4066Sahrens 33313d7072f8Seschrock for (i = 1; i < argc; i++) { 3332573ca77eSGeorge Wilson if (zpool_vdev_online(zhp, argv[i], flags, &newstate) == 0) { 33333d7072f8Seschrock if (newstate != VDEV_STATE_HEALTHY) { 33343d7072f8Seschrock (void) printf(gettext("warning: device '%s' " 33353d7072f8Seschrock "onlined, but remains in faulted state\n"), 33363d7072f8Seschrock argv[i]); 33373d7072f8Seschrock if (newstate == VDEV_STATE_FAULTED) 33383d7072f8Seschrock (void) printf(gettext("use 'zpool " 33393d7072f8Seschrock "clear' to restore a faulted " 33403d7072f8Seschrock "device\n")); 33413d7072f8Seschrock else 33423d7072f8Seschrock (void) printf(gettext("use 'zpool " 33433d7072f8Seschrock "replace' to replace devices " 33443d7072f8Seschrock "that are no longer present\n")); 33453d7072f8Seschrock } 33463d7072f8Seschrock } else { 3347fa9e4066Sahrens ret = 1; 33483d7072f8Seschrock } 33493d7072f8Seschrock } 3350fa9e4066Sahrens 335199653d4eSeschrock zpool_close(zhp); 335299653d4eSeschrock 3353fa9e4066Sahrens return (ret); 3354fa9e4066Sahrens } 3355fa9e4066Sahrens 3356fa9e4066Sahrens /* 3357441d80aaSlling * zpool offline [-ft] <pool> <device> ... 3358fa9e4066Sahrens * 3359fa9e4066Sahrens * -f Force the device into the offline state, even if doing 3360fa9e4066Sahrens * so would appear to compromise pool availability. 3361fa9e4066Sahrens * (not supported yet) 3362fa9e4066Sahrens * 3363fa9e4066Sahrens * -t Only take the device off-line temporarily. The offline 3364fa9e4066Sahrens * state will not be persistent across reboots. 3365fa9e4066Sahrens */ 3366fa9e4066Sahrens /* ARGSUSED */ 3367fa9e4066Sahrens int 3368fa9e4066Sahrens zpool_do_offline(int argc, char **argv) 3369fa9e4066Sahrens { 3370fa9e4066Sahrens int c, i; 3371fa9e4066Sahrens char *poolname; 3372fa9e4066Sahrens zpool_handle_t *zhp; 337399653d4eSeschrock int ret = 0; 337499653d4eSeschrock boolean_t istmp = B_FALSE; 3375fa9e4066Sahrens 3376fa9e4066Sahrens /* check options */ 3377fa9e4066Sahrens while ((c = getopt(argc, argv, "ft")) != -1) { 3378fa9e4066Sahrens switch (c) { 3379fa9e4066Sahrens case 't': 338099653d4eSeschrock istmp = B_TRUE; 3381441d80aaSlling break; 3382441d80aaSlling case 'f': 3383fa9e4066Sahrens case '?': 3384fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3385fa9e4066Sahrens optopt); 338699653d4eSeschrock usage(B_FALSE); 3387fa9e4066Sahrens } 3388fa9e4066Sahrens } 3389fa9e4066Sahrens 3390fa9e4066Sahrens argc -= optind; 3391fa9e4066Sahrens argv += optind; 3392fa9e4066Sahrens 3393fa9e4066Sahrens /* get pool name and check number of arguments */ 3394fa9e4066Sahrens if (argc < 1) { 3395fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 339699653d4eSeschrock usage(B_FALSE); 3397fa9e4066Sahrens } 3398fa9e4066Sahrens if (argc < 2) { 3399fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 340099653d4eSeschrock usage(B_FALSE); 3401fa9e4066Sahrens } 3402fa9e4066Sahrens 3403fa9e4066Sahrens poolname = argv[0]; 3404fa9e4066Sahrens 340599653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 3406fa9e4066Sahrens return (1); 3407fa9e4066Sahrens 34083d7072f8Seschrock for (i = 1; i < argc; i++) { 34093d7072f8Seschrock if (zpool_vdev_offline(zhp, argv[i], istmp) != 0) 3410fa9e4066Sahrens ret = 1; 34113d7072f8Seschrock } 3412fa9e4066Sahrens 341399653d4eSeschrock zpool_close(zhp); 341499653d4eSeschrock 3415fa9e4066Sahrens return (ret); 3416fa9e4066Sahrens } 3417fa9e4066Sahrens 3418ea8dc4b6Seschrock /* 3419ea8dc4b6Seschrock * zpool clear <pool> [device] 3420ea8dc4b6Seschrock * 3421ea8dc4b6Seschrock * Clear all errors associated with a pool or a particular device. 3422ea8dc4b6Seschrock */ 3423ea8dc4b6Seschrock int 3424ea8dc4b6Seschrock zpool_do_clear(int argc, char **argv) 3425ea8dc4b6Seschrock { 3426468c413aSTim Haley int c; 3427ea8dc4b6Seschrock int ret = 0; 3428468c413aSTim Haley boolean_t dryrun = B_FALSE; 3429468c413aSTim Haley boolean_t do_rewind = B_FALSE; 3430468c413aSTim Haley boolean_t xtreme_rewind = B_FALSE; 3431468c413aSTim Haley uint32_t rewind_policy = ZPOOL_NO_REWIND; 3432468c413aSTim Haley nvlist_t *policy = NULL; 3433ea8dc4b6Seschrock zpool_handle_t *zhp; 3434ea8dc4b6Seschrock char *pool, *device; 3435ea8dc4b6Seschrock 3436468c413aSTim Haley /* check options */ 3437468c413aSTim Haley while ((c = getopt(argc, argv, "FnX")) != -1) { 3438468c413aSTim Haley switch (c) { 3439468c413aSTim Haley case 'F': 3440468c413aSTim Haley do_rewind = B_TRUE; 3441468c413aSTim Haley break; 3442468c413aSTim Haley case 'n': 3443468c413aSTim Haley dryrun = B_TRUE; 3444468c413aSTim Haley break; 3445468c413aSTim Haley case 'X': 3446468c413aSTim Haley xtreme_rewind = B_TRUE; 3447468c413aSTim Haley break; 3448468c413aSTim Haley case '?': 3449468c413aSTim Haley (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3450468c413aSTim Haley optopt); 3451468c413aSTim Haley usage(B_FALSE); 3452468c413aSTim Haley } 3453468c413aSTim Haley } 3454468c413aSTim Haley 3455468c413aSTim Haley argc -= optind; 3456468c413aSTim Haley argv += optind; 3457468c413aSTim Haley 3458468c413aSTim Haley if (argc < 1) { 3459ea8dc4b6Seschrock (void) fprintf(stderr, gettext("missing pool name\n")); 346099653d4eSeschrock usage(B_FALSE); 3461ea8dc4b6Seschrock } 3462ea8dc4b6Seschrock 3463468c413aSTim Haley if (argc > 2) { 3464ea8dc4b6Seschrock (void) fprintf(stderr, gettext("too many arguments\n")); 346599653d4eSeschrock usage(B_FALSE); 3466ea8dc4b6Seschrock } 3467ea8dc4b6Seschrock 3468468c413aSTim Haley if ((dryrun || xtreme_rewind) && !do_rewind) { 3469468c413aSTim Haley (void) fprintf(stderr, 3470468c413aSTim Haley gettext("-n or -X only meaningful with -F\n")); 3471468c413aSTim Haley usage(B_FALSE); 3472468c413aSTim Haley } 3473468c413aSTim Haley if (dryrun) 3474468c413aSTim Haley rewind_policy = ZPOOL_TRY_REWIND; 3475468c413aSTim Haley else if (do_rewind) 3476468c413aSTim Haley rewind_policy = ZPOOL_DO_REWIND; 3477468c413aSTim Haley if (xtreme_rewind) 3478468c413aSTim Haley rewind_policy |= ZPOOL_EXTREME_REWIND; 3479468c413aSTim Haley 3480468c413aSTim Haley /* In future, further rewind policy choices can be passed along here */ 3481468c413aSTim Haley if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 3482468c413aSTim Haley nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) 3483468c413aSTim Haley return (1); 3484468c413aSTim Haley 3485468c413aSTim Haley pool = argv[0]; 3486468c413aSTim Haley device = argc == 2 ? argv[1] : NULL; 3487ea8dc4b6Seschrock 3488468c413aSTim Haley if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 3489468c413aSTim Haley nvlist_free(policy); 3490ea8dc4b6Seschrock return (1); 3491468c413aSTim Haley } 3492ea8dc4b6Seschrock 3493468c413aSTim Haley if (zpool_clear(zhp, device, policy) != 0) 3494ea8dc4b6Seschrock ret = 1; 3495ea8dc4b6Seschrock 3496ea8dc4b6Seschrock zpool_close(zhp); 3497ea8dc4b6Seschrock 3498468c413aSTim Haley nvlist_free(policy); 3499468c413aSTim Haley 3500ea8dc4b6Seschrock return (ret); 3501ea8dc4b6Seschrock } 3502ea8dc4b6Seschrock 3503e9103aaeSGarrett D'Amore /* 3504e9103aaeSGarrett D'Amore * zpool reguid <pool> 3505e9103aaeSGarrett D'Amore */ 3506e9103aaeSGarrett D'Amore int 3507e9103aaeSGarrett D'Amore zpool_do_reguid(int argc, char **argv) 3508e9103aaeSGarrett D'Amore { 3509e9103aaeSGarrett D'Amore int c; 3510e9103aaeSGarrett D'Amore char *poolname; 3511e9103aaeSGarrett D'Amore zpool_handle_t *zhp; 3512e9103aaeSGarrett D'Amore int ret = 0; 3513e9103aaeSGarrett D'Amore 3514e9103aaeSGarrett D'Amore /* check options */ 3515e9103aaeSGarrett D'Amore while ((c = getopt(argc, argv, "")) != -1) { 3516e9103aaeSGarrett D'Amore switch (c) { 3517e9103aaeSGarrett D'Amore case '?': 3518e9103aaeSGarrett D'Amore (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3519e9103aaeSGarrett D'Amore optopt); 3520e9103aaeSGarrett D'Amore usage(B_FALSE); 3521e9103aaeSGarrett D'Amore } 3522e9103aaeSGarrett D'Amore } 3523e9103aaeSGarrett D'Amore 3524e9103aaeSGarrett D'Amore argc -= optind; 3525e9103aaeSGarrett D'Amore argv += optind; 3526e9103aaeSGarrett D'Amore 3527e9103aaeSGarrett D'Amore /* get pool name and check number of arguments */ 3528e9103aaeSGarrett D'Amore if (argc < 1) { 3529e9103aaeSGarrett D'Amore (void) fprintf(stderr, gettext("missing pool name\n")); 3530e9103aaeSGarrett D'Amore usage(B_FALSE); 3531e9103aaeSGarrett D'Amore } 3532e9103aaeSGarrett D'Amore 3533e9103aaeSGarrett D'Amore if (argc > 1) { 3534e9103aaeSGarrett D'Amore (void) fprintf(stderr, gettext("too many arguments\n")); 3535e9103aaeSGarrett D'Amore usage(B_FALSE); 3536e9103aaeSGarrett D'Amore } 3537e9103aaeSGarrett D'Amore 3538e9103aaeSGarrett D'Amore poolname = argv[0]; 3539e9103aaeSGarrett D'Amore if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 3540e9103aaeSGarrett D'Amore return (1); 3541e9103aaeSGarrett D'Amore 3542e9103aaeSGarrett D'Amore ret = zpool_reguid(zhp); 3543e9103aaeSGarrett D'Amore 3544e9103aaeSGarrett D'Amore zpool_close(zhp); 3545e9103aaeSGarrett D'Amore return (ret); 3546e9103aaeSGarrett D'Amore } 3547e9103aaeSGarrett D'Amore 3548e9103aaeSGarrett D'Amore 35494263d13fSGeorge Wilson /* 35504263d13fSGeorge Wilson * zpool reopen <pool> 35514263d13fSGeorge Wilson * 35524263d13fSGeorge Wilson * Reopen the pool so that the kernel can update the sizes of all vdevs. 35534263d13fSGeorge Wilson * 35544263d13fSGeorge Wilson * NOTE: This command is currently undocumented. If the command is ever 35554263d13fSGeorge Wilson * exposed then the appropriate usage() messages will need to be made. 35564263d13fSGeorge Wilson */ 35574263d13fSGeorge Wilson int 35584263d13fSGeorge Wilson zpool_do_reopen(int argc, char **argv) 35594263d13fSGeorge Wilson { 35604263d13fSGeorge Wilson int ret = 0; 35614263d13fSGeorge Wilson zpool_handle_t *zhp; 35624263d13fSGeorge Wilson char *pool; 35634263d13fSGeorge Wilson 35644263d13fSGeorge Wilson argc--; 35654263d13fSGeorge Wilson argv++; 35664263d13fSGeorge Wilson 35674263d13fSGeorge Wilson if (argc != 1) 35684263d13fSGeorge Wilson return (2); 35694263d13fSGeorge Wilson 35704263d13fSGeorge Wilson pool = argv[0]; 35714263d13fSGeorge Wilson if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) 35724263d13fSGeorge Wilson return (1); 35734263d13fSGeorge Wilson 35744263d13fSGeorge Wilson ret = zpool_reopen(zhp); 35754263d13fSGeorge Wilson zpool_close(zhp); 35764263d13fSGeorge Wilson return (ret); 35774263d13fSGeorge Wilson } 35784263d13fSGeorge Wilson 3579fa9e4066Sahrens typedef struct scrub_cbdata { 3580fa9e4066Sahrens int cb_type; 358106eeb2adSek int cb_argc; 358206eeb2adSek char **cb_argv; 3583fa9e4066Sahrens } scrub_cbdata_t; 3584fa9e4066Sahrens 3585fa9e4066Sahrens int 3586fa9e4066Sahrens scrub_callback(zpool_handle_t *zhp, void *data) 3587fa9e4066Sahrens { 3588fa9e4066Sahrens scrub_cbdata_t *cb = data; 358906eeb2adSek int err; 3590fa9e4066Sahrens 3591ea8dc4b6Seschrock /* 3592ea8dc4b6Seschrock * Ignore faulted pools. 3593ea8dc4b6Seschrock */ 3594ea8dc4b6Seschrock if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 3595ea8dc4b6Seschrock (void) fprintf(stderr, gettext("cannot scrub '%s': pool is " 3596ea8dc4b6Seschrock "currently unavailable\n"), zpool_get_name(zhp)); 3597ea8dc4b6Seschrock return (1); 3598ea8dc4b6Seschrock } 3599ea8dc4b6Seschrock 36003f9d6ad7SLin Ling err = zpool_scan(zhp, cb->cb_type); 360106eeb2adSek 360206eeb2adSek return (err != 0); 3603fa9e4066Sahrens } 3604fa9e4066Sahrens 3605fa9e4066Sahrens /* 3606fa9e4066Sahrens * zpool scrub [-s] <pool> ... 3607fa9e4066Sahrens * 3608fa9e4066Sahrens * -s Stop. Stops any in-progress scrub. 3609fa9e4066Sahrens */ 3610fa9e4066Sahrens int 3611fa9e4066Sahrens zpool_do_scrub(int argc, char **argv) 3612fa9e4066Sahrens { 3613fa9e4066Sahrens int c; 3614fa9e4066Sahrens scrub_cbdata_t cb; 3615fa9e4066Sahrens 36163f9d6ad7SLin Ling cb.cb_type = POOL_SCAN_SCRUB; 3617fa9e4066Sahrens 3618fa9e4066Sahrens /* check options */ 3619fa9e4066Sahrens while ((c = getopt(argc, argv, "s")) != -1) { 3620fa9e4066Sahrens switch (c) { 3621fa9e4066Sahrens case 's': 36223f9d6ad7SLin Ling cb.cb_type = POOL_SCAN_NONE; 3623fa9e4066Sahrens break; 3624fa9e4066Sahrens case '?': 3625fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3626fa9e4066Sahrens optopt); 362799653d4eSeschrock usage(B_FALSE); 3628fa9e4066Sahrens } 3629fa9e4066Sahrens } 3630fa9e4066Sahrens 363106eeb2adSek cb.cb_argc = argc; 363206eeb2adSek cb.cb_argv = argv; 3633fa9e4066Sahrens argc -= optind; 3634fa9e4066Sahrens argv += optind; 3635fa9e4066Sahrens 3636fa9e4066Sahrens if (argc < 1) { 3637fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 363899653d4eSeschrock usage(B_FALSE); 3639fa9e4066Sahrens } 3640fa9e4066Sahrens 3641b1b8ab34Slling return (for_each_pool(argc, argv, B_TRUE, NULL, scrub_callback, &cb)); 3642fa9e4066Sahrens } 3643fa9e4066Sahrens 3644fa9e4066Sahrens typedef struct status_cbdata { 364599653d4eSeschrock int cb_count; 3646e9dbad6fSeschrock boolean_t cb_allpools; 364799653d4eSeschrock boolean_t cb_verbose; 364899653d4eSeschrock boolean_t cb_explain; 364999653d4eSeschrock boolean_t cb_first; 36509eb19f4dSGeorge Wilson boolean_t cb_dedup_stats; 3651fa9e4066Sahrens } status_cbdata_t; 3652fa9e4066Sahrens 3653fa9e4066Sahrens /* 3654fa9e4066Sahrens * Print out detailed scrub status. 3655fa9e4066Sahrens */ 3656fa9e4066Sahrens void 36573f9d6ad7SLin Ling print_scan_status(pool_scan_stat_t *ps) 3658fa9e4066Sahrens { 36593f9d6ad7SLin Ling time_t start, end; 366073d314ceSLin Ling uint64_t elapsed, mins_left, hours_left; 36613f9d6ad7SLin Ling uint64_t pass_exam, examined, total; 36623f9d6ad7SLin Ling uint_t rate; 3663fa9e4066Sahrens double fraction_done; 36643f9d6ad7SLin Ling char processed_buf[7], examined_buf[7], total_buf[7], rate_buf[7]; 3665fa9e4066Sahrens 3666ce72e614SYuri Pankov (void) printf(gettext(" scan: ")); 3667fa9e4066Sahrens 36683f9d6ad7SLin Ling /* If there's never been a scan, there's not much to say. */ 36693f9d6ad7SLin Ling if (ps == NULL || ps->pss_func == POOL_SCAN_NONE || 36703f9d6ad7SLin Ling ps->pss_func >= POOL_SCAN_FUNCS) { 3671fa9e4066Sahrens (void) printf(gettext("none requested\n")); 3672fa9e4066Sahrens return; 3673fa9e4066Sahrens } 3674fa9e4066Sahrens 36753f9d6ad7SLin Ling start = ps->pss_start_time; 36763f9d6ad7SLin Ling end = ps->pss_end_time; 36773f9d6ad7SLin Ling zfs_nicenum(ps->pss_processed, processed_buf, sizeof (processed_buf)); 3678fa9e4066Sahrens 36793f9d6ad7SLin Ling assert(ps->pss_func == POOL_SCAN_SCRUB || 36803f9d6ad7SLin Ling ps->pss_func == POOL_SCAN_RESILVER); 36813f9d6ad7SLin Ling /* 36823f9d6ad7SLin Ling * Scan is finished or canceled. 36833f9d6ad7SLin Ling */ 36843f9d6ad7SLin Ling if (ps->pss_state == DSS_FINISHED) { 36853f9d6ad7SLin Ling uint64_t minutes_taken = (end - start) / 60; 36863f9d6ad7SLin Ling char *fmt; 36873f9d6ad7SLin Ling 36883f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_SCRUB) { 36893f9d6ad7SLin Ling fmt = gettext("scrub repaired %s in %lluh%um with " 36903f9d6ad7SLin Ling "%llu errors on %s"); 36913f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_RESILVER) { 36923f9d6ad7SLin Ling fmt = gettext("resilvered %s in %lluh%um with " 36933f9d6ad7SLin Ling "%llu errors on %s"); 36943f9d6ad7SLin Ling } 36953f9d6ad7SLin Ling /* LINTED */ 36963f9d6ad7SLin Ling (void) printf(fmt, processed_buf, 369718ce54dfSek (u_longlong_t)(minutes_taken / 60), 369818ce54dfSek (uint_t)(minutes_taken % 60), 36993f9d6ad7SLin Ling (u_longlong_t)ps->pss_errors, 37003f9d6ad7SLin Ling ctime((time_t *)&end)); 37013f9d6ad7SLin Ling return; 37023f9d6ad7SLin Ling } else if (ps->pss_state == DSS_CANCELED) { 37033f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_SCRUB) { 37043f9d6ad7SLin Ling (void) printf(gettext("scrub canceled on %s"), 37053f9d6ad7SLin Ling ctime(&end)); 37063f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_RESILVER) { 37073f9d6ad7SLin Ling (void) printf(gettext("resilver canceled on %s"), 37083f9d6ad7SLin Ling ctime(&end)); 37093f9d6ad7SLin Ling } 3710fa9e4066Sahrens return; 3711fa9e4066Sahrens } 3712fa9e4066Sahrens 37133f9d6ad7SLin Ling assert(ps->pss_state == DSS_SCANNING); 37143f9d6ad7SLin Ling 37153f9d6ad7SLin Ling /* 37163f9d6ad7SLin Ling * Scan is in progress. 37173f9d6ad7SLin Ling */ 37183f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_SCRUB) { 37193f9d6ad7SLin Ling (void) printf(gettext("scrub in progress since %s"), 37203f9d6ad7SLin Ling ctime(&start)); 37213f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_RESILVER) { 37223f9d6ad7SLin Ling (void) printf(gettext("resilver in progress since %s"), 37233f9d6ad7SLin Ling ctime(&start)); 37243f9d6ad7SLin Ling } 3725fa9e4066Sahrens 37263f9d6ad7SLin Ling examined = ps->pss_examined ? ps->pss_examined : 1; 37273f9d6ad7SLin Ling total = ps->pss_to_examine; 3728fa9e4066Sahrens fraction_done = (double)examined / total; 37293f9d6ad7SLin Ling 37303f9d6ad7SLin Ling /* elapsed time for this pass */ 37313f9d6ad7SLin Ling elapsed = time(NULL) - ps->pss_pass_start; 37323f9d6ad7SLin Ling elapsed = elapsed ? elapsed : 1; 37333f9d6ad7SLin Ling pass_exam = ps->pss_pass_exam ? ps->pss_pass_exam : 1; 37343f9d6ad7SLin Ling rate = pass_exam / elapsed; 37353f9d6ad7SLin Ling rate = rate ? rate : 1; 37363f9d6ad7SLin Ling mins_left = ((total - examined) / rate) / 60; 373773d314ceSLin Ling hours_left = mins_left / 60; 37383f9d6ad7SLin Ling 37393f9d6ad7SLin Ling zfs_nicenum(examined, examined_buf, sizeof (examined_buf)); 37403f9d6ad7SLin Ling zfs_nicenum(total, total_buf, sizeof (total_buf)); 37413f9d6ad7SLin Ling zfs_nicenum(rate, rate_buf, sizeof (rate_buf)); 37423f9d6ad7SLin Ling 374373d314ceSLin Ling /* 374473d314ceSLin Ling * do not print estimated time if hours_left is more than 30 days 374573d314ceSLin Ling */ 374673d314ceSLin Ling (void) printf(gettext(" %s scanned out of %s at %s/s"), 374773d314ceSLin Ling examined_buf, total_buf, rate_buf); 374873d314ceSLin Ling if (hours_left < (30 * 24)) { 374973d314ceSLin Ling (void) printf(gettext(", %lluh%um to go\n"), 375073d314ceSLin Ling (u_longlong_t)hours_left, (uint_t)(mins_left % 60)); 375173d314ceSLin Ling } else { 375273d314ceSLin Ling (void) printf(gettext( 375373d314ceSLin Ling ", (scan is slow, no estimated time)\n")); 375473d314ceSLin Ling } 37553f9d6ad7SLin Ling 37563f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_RESILVER) { 37573f9d6ad7SLin Ling (void) printf(gettext(" %s resilvered, %.2f%% done\n"), 37583f9d6ad7SLin Ling processed_buf, 100 * fraction_done); 37593f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_SCRUB) { 37603f9d6ad7SLin Ling (void) printf(gettext(" %s repaired, %.2f%% done\n"), 37613f9d6ad7SLin Ling processed_buf, 100 * fraction_done); 37623f9d6ad7SLin Ling } 3763fa9e4066Sahrens } 3764fa9e4066Sahrens 3765ea8dc4b6Seschrock static void 3766ea8dc4b6Seschrock print_error_log(zpool_handle_t *zhp) 3767ea8dc4b6Seschrock { 376875519f38Sek nvlist_t *nverrlist = NULL; 376955434c77Sek nvpair_t *elem; 377055434c77Sek char *pathname; 377155434c77Sek size_t len = MAXPATHLEN * 2; 3772ea8dc4b6Seschrock 377355434c77Sek if (zpool_get_errlog(zhp, &nverrlist) != 0) { 3774ea8dc4b6Seschrock (void) printf("errors: List of errors unavailable " 3775ea8dc4b6Seschrock "(insufficient privileges)\n"); 3776ea8dc4b6Seschrock return; 3777ea8dc4b6Seschrock } 3778ea8dc4b6Seschrock 377955434c77Sek (void) printf("errors: Permanent errors have been " 378055434c77Sek "detected in the following files:\n\n"); 3781ea8dc4b6Seschrock 378255434c77Sek pathname = safe_malloc(len); 378355434c77Sek elem = NULL; 378455434c77Sek while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) { 378555434c77Sek nvlist_t *nv; 378655434c77Sek uint64_t dsobj, obj; 378755434c77Sek 378855434c77Sek verify(nvpair_value_nvlist(elem, &nv) == 0); 378955434c77Sek verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET, 379055434c77Sek &dsobj) == 0); 379155434c77Sek verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT, 379255434c77Sek &obj) == 0); 379355434c77Sek zpool_obj_to_path(zhp, dsobj, obj, pathname, len); 379455434c77Sek (void) printf("%7s %s\n", "", pathname); 379555434c77Sek } 379655434c77Sek free(pathname); 379755434c77Sek nvlist_free(nverrlist); 3798ea8dc4b6Seschrock } 3799ea8dc4b6Seschrock 380099653d4eSeschrock static void 380199653d4eSeschrock print_spares(zpool_handle_t *zhp, nvlist_t **spares, uint_t nspares, 380299653d4eSeschrock int namewidth) 380399653d4eSeschrock { 380499653d4eSeschrock uint_t i; 380599653d4eSeschrock char *name; 380699653d4eSeschrock 380799653d4eSeschrock if (nspares == 0) 380899653d4eSeschrock return; 380999653d4eSeschrock 381099653d4eSeschrock (void) printf(gettext("\tspares\n")); 381199653d4eSeschrock 381299653d4eSeschrock for (i = 0; i < nspares; i++) { 381388ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, spares[i], B_FALSE); 381499653d4eSeschrock print_status_config(zhp, name, spares[i], 3815aa8cf21aSNeil Perrin namewidth, 2, B_TRUE); 381699653d4eSeschrock free(name); 381799653d4eSeschrock } 381899653d4eSeschrock } 381999653d4eSeschrock 3820fa94a07fSbrendan static void 3821fa94a07fSbrendan print_l2cache(zpool_handle_t *zhp, nvlist_t **l2cache, uint_t nl2cache, 3822fa94a07fSbrendan int namewidth) 3823fa94a07fSbrendan { 3824fa94a07fSbrendan uint_t i; 3825fa94a07fSbrendan char *name; 3826fa94a07fSbrendan 3827fa94a07fSbrendan if (nl2cache == 0) 3828fa94a07fSbrendan return; 3829fa94a07fSbrendan 3830fa94a07fSbrendan (void) printf(gettext("\tcache\n")); 3831fa94a07fSbrendan 3832fa94a07fSbrendan for (i = 0; i < nl2cache; i++) { 383388ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, l2cache[i], B_FALSE); 3834fa94a07fSbrendan print_status_config(zhp, name, l2cache[i], 3835aa8cf21aSNeil Perrin namewidth, 2, B_FALSE); 3836aa8cf21aSNeil Perrin free(name); 3837aa8cf21aSNeil Perrin } 3838aa8cf21aSNeil Perrin } 3839aa8cf21aSNeil Perrin 38409eb19f4dSGeorge Wilson static void 38419eb19f4dSGeorge Wilson print_dedup_stats(nvlist_t *config) 38429eb19f4dSGeorge Wilson { 38439eb19f4dSGeorge Wilson ddt_histogram_t *ddh; 38449eb19f4dSGeorge Wilson ddt_stat_t *dds; 38459eb19f4dSGeorge Wilson ddt_object_t *ddo; 38469eb19f4dSGeorge Wilson uint_t c; 38479eb19f4dSGeorge Wilson 38489eb19f4dSGeorge Wilson /* 38499eb19f4dSGeorge Wilson * If the pool was faulted then we may not have been able to 38502384d9f8SGeorge Wilson * obtain the config. Otherwise, if we have anything in the dedup 38519eb19f4dSGeorge Wilson * table continue processing the stats. 38529eb19f4dSGeorge Wilson */ 38539eb19f4dSGeorge Wilson if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_OBJ_STATS, 3854ce72e614SYuri Pankov (uint64_t **)&ddo, &c) != 0) 38559eb19f4dSGeorge Wilson return; 38569eb19f4dSGeorge Wilson 38579eb19f4dSGeorge Wilson (void) printf("\n"); 3858ce72e614SYuri Pankov (void) printf(gettext(" dedup: ")); 3859ce72e614SYuri Pankov if (ddo->ddo_count == 0) { 3860ce72e614SYuri Pankov (void) printf(gettext("no DDT entries\n")); 3861ce72e614SYuri Pankov return; 3862ce72e614SYuri Pankov } 3863ce72e614SYuri Pankov 38649eb19f4dSGeorge Wilson (void) printf("DDT entries %llu, size %llu on disk, %llu in core\n", 38659eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_count, 38669eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_dspace, 38679eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_mspace); 38689eb19f4dSGeorge Wilson 38699eb19f4dSGeorge Wilson verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS, 38709eb19f4dSGeorge Wilson (uint64_t **)&dds, &c) == 0); 38719eb19f4dSGeorge Wilson verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_HISTOGRAM, 38729eb19f4dSGeorge Wilson (uint64_t **)&ddh, &c) == 0); 38739eb19f4dSGeorge Wilson zpool_dump_ddt(dds, ddh); 38749eb19f4dSGeorge Wilson } 38759eb19f4dSGeorge Wilson 3876fa9e4066Sahrens /* 3877fa9e4066Sahrens * Display a summary of pool status. Displays a summary such as: 3878fa9e4066Sahrens * 3879fa9e4066Sahrens * pool: tank 3880fa9e4066Sahrens * status: DEGRADED 3881fa9e4066Sahrens * reason: One or more devices ... 3882654b400cSJoshua M. Clulow * see: http://illumos.org/msg/ZFS-xxxx-01 3883fa9e4066Sahrens * config: 3884fa9e4066Sahrens * mirror DEGRADED 3885fa9e4066Sahrens * c1t0d0 OK 3886ea8dc4b6Seschrock * c2t0d0 UNAVAIL 3887fa9e4066Sahrens * 3888fa9e4066Sahrens * When given the '-v' option, we print out the complete config. If the '-e' 3889fa9e4066Sahrens * option is specified, then we print out error rate information as well. 3890fa9e4066Sahrens */ 3891fa9e4066Sahrens int 3892fa9e4066Sahrens status_callback(zpool_handle_t *zhp, void *data) 3893fa9e4066Sahrens { 3894fa9e4066Sahrens status_cbdata_t *cbp = data; 3895fa9e4066Sahrens nvlist_t *config, *nvroot; 3896fa9e4066Sahrens char *msgid; 3897fa9e4066Sahrens int reason; 389846657f8dSmmusante const char *health; 389946657f8dSmmusante uint_t c; 390046657f8dSmmusante vdev_stat_t *vs; 3901fa9e4066Sahrens 3902088e9d47Seschrock config = zpool_get_config(zhp, NULL); 3903fa9e4066Sahrens reason = zpool_get_status(zhp, &msgid); 3904fa9e4066Sahrens 3905fa9e4066Sahrens cbp->cb_count++; 3906fa9e4066Sahrens 3907fa9e4066Sahrens /* 3908fa9e4066Sahrens * If we were given 'zpool status -x', only report those pools with 3909fa9e4066Sahrens * problems. 3910fa9e4066Sahrens */ 3911e9dbad6fSeschrock if (reason == ZPOOL_STATUS_OK && cbp->cb_explain) { 3912e9dbad6fSeschrock if (!cbp->cb_allpools) { 3913e9dbad6fSeschrock (void) printf(gettext("pool '%s' is healthy\n"), 3914e9dbad6fSeschrock zpool_get_name(zhp)); 3915e9dbad6fSeschrock if (cbp->cb_first) 3916e9dbad6fSeschrock cbp->cb_first = B_FALSE; 3917e9dbad6fSeschrock } 3918fa9e4066Sahrens return (0); 3919e9dbad6fSeschrock } 3920fa9e4066Sahrens 3921fa9e4066Sahrens if (cbp->cb_first) 392299653d4eSeschrock cbp->cb_first = B_FALSE; 3923fa9e4066Sahrens else 3924fa9e4066Sahrens (void) printf("\n"); 3925fa9e4066Sahrens 392646657f8dSmmusante verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 392746657f8dSmmusante &nvroot) == 0); 39283f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 392946657f8dSmmusante (uint64_t **)&vs, &c) == 0); 3930990b4856Slling health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 3931fa9e4066Sahrens 3932fa9e4066Sahrens (void) printf(gettext(" pool: %s\n"), zpool_get_name(zhp)); 3933fa9e4066Sahrens (void) printf(gettext(" state: %s\n"), health); 3934fa9e4066Sahrens 3935fa9e4066Sahrens switch (reason) { 3936fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 3937fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3938fa9e4066Sahrens "be opened. Sufficient replicas exist for\n\tthe pool to " 3939fa9e4066Sahrens "continue functioning in a degraded state.\n")); 3940fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 3941fa9e4066Sahrens "online it using 'zpool online'.\n")); 3942fa9e4066Sahrens break; 3943fa9e4066Sahrens 3944fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 3945fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3946fa9e4066Sahrens "be opened. There are insufficient\n\treplicas for the " 3947fa9e4066Sahrens "pool to continue functioning.\n")); 3948fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 3949fa9e4066Sahrens "online it using 'zpool online'.\n")); 3950fa9e4066Sahrens break; 3951fa9e4066Sahrens 3952fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 3953fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3954fa9e4066Sahrens "be used because the label is missing or\n\tinvalid. " 3955fa9e4066Sahrens "Sufficient replicas exist for the pool to continue\n\t" 3956fa9e4066Sahrens "functioning in a degraded state.\n")); 3957fa9e4066Sahrens (void) printf(gettext("action: Replace the device using " 3958fa9e4066Sahrens "'zpool replace'.\n")); 3959fa9e4066Sahrens break; 3960fa9e4066Sahrens 3961fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 3962fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3963b1b8ab34Slling "be used because the label is missing \n\tor invalid. " 3964fa9e4066Sahrens "There are insufficient replicas for the pool to " 3965fa9e4066Sahrens "continue\n\tfunctioning.\n")); 3966468c413aSTim Haley zpool_explain_recover(zpool_get_handle(zhp), 3967468c413aSTim Haley zpool_get_name(zhp), reason, config); 3968fa9e4066Sahrens break; 3969fa9e4066Sahrens 3970fa9e4066Sahrens case ZPOOL_STATUS_FAILING_DEV: 3971fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 3972fa9e4066Sahrens "experienced an unrecoverable error. An\n\tattempt was " 3973fa9e4066Sahrens "made to correct the error. Applications are " 3974fa9e4066Sahrens "unaffected.\n")); 3975fa9e4066Sahrens (void) printf(gettext("action: Determine if the device needs " 3976fa9e4066Sahrens "to be replaced, and clear the errors\n\tusing " 3977ea8dc4b6Seschrock "'zpool clear' or replace the device with 'zpool " 3978fa9e4066Sahrens "replace'.\n")); 3979fa9e4066Sahrens break; 3980fa9e4066Sahrens 3981fa9e4066Sahrens case ZPOOL_STATUS_OFFLINE_DEV: 3982fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 3983d7d4af51Smmusante "been taken offline by the administrator.\n\tSufficient " 3984fa9e4066Sahrens "replicas exist for the pool to continue functioning in " 3985fa9e4066Sahrens "a\n\tdegraded state.\n")); 3986fa9e4066Sahrens (void) printf(gettext("action: Online the device using " 3987fa9e4066Sahrens "'zpool online' or replace the device with\n\t'zpool " 3988fa9e4066Sahrens "replace'.\n")); 3989fa9e4066Sahrens break; 3990fa9e4066Sahrens 3991c25309d4SGeorge Wilson case ZPOOL_STATUS_REMOVED_DEV: 3992c25309d4SGeorge Wilson (void) printf(gettext("status: One or more devices has " 3993c25309d4SGeorge Wilson "been removed by the administrator.\n\tSufficient " 3994c25309d4SGeorge Wilson "replicas exist for the pool to continue functioning in " 3995c25309d4SGeorge Wilson "a\n\tdegraded state.\n")); 3996c25309d4SGeorge Wilson (void) printf(gettext("action: Online the device using " 3997c25309d4SGeorge Wilson "'zpool online' or replace the device with\n\t'zpool " 3998c25309d4SGeorge Wilson "replace'.\n")); 3999c25309d4SGeorge Wilson break; 4000c25309d4SGeorge Wilson 4001fa9e4066Sahrens case ZPOOL_STATUS_RESILVERING: 4002fa9e4066Sahrens (void) printf(gettext("status: One or more devices is " 4003fa9e4066Sahrens "currently being resilvered. The pool will\n\tcontinue " 4004fa9e4066Sahrens "to function, possibly in a degraded state.\n")); 4005fa9e4066Sahrens (void) printf(gettext("action: Wait for the resilver to " 4006fa9e4066Sahrens "complete.\n")); 4007fa9e4066Sahrens break; 4008fa9e4066Sahrens 4009ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_DATA: 4010ea8dc4b6Seschrock (void) printf(gettext("status: One or more devices has " 4011ea8dc4b6Seschrock "experienced an error resulting in data\n\tcorruption. " 4012ea8dc4b6Seschrock "Applications may be affected.\n")); 4013ea8dc4b6Seschrock (void) printf(gettext("action: Restore the file in question " 4014ea8dc4b6Seschrock "if possible. Otherwise restore the\n\tentire pool from " 4015ea8dc4b6Seschrock "backup.\n")); 4016ea8dc4b6Seschrock break; 4017ea8dc4b6Seschrock 4018ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 4019ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is corrupted " 4020ea8dc4b6Seschrock "and the pool cannot be opened.\n")); 4021468c413aSTim Haley zpool_explain_recover(zpool_get_handle(zhp), 4022468c413aSTim Haley zpool_get_name(zhp), reason, config); 4023ea8dc4b6Seschrock break; 4024ea8dc4b6Seschrock 4025eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 4026*57221772SChristopher Siden (void) printf(gettext("status: The pool is formatted using a " 4027*57221772SChristopher Siden "legacy on-disk format. The pool can\n\tstill be used, " 4028*57221772SChristopher Siden "but some features are unavailable.\n")); 4029eaca9bbdSeschrock (void) printf(gettext("action: Upgrade the pool using 'zpool " 4030eaca9bbdSeschrock "upgrade'. Once this is done, the\n\tpool will no longer " 4031*57221772SChristopher Siden "be accessible on software that does not support feature\n" 4032*57221772SChristopher Siden "\tflags.\n")); 4033eaca9bbdSeschrock break; 4034eaca9bbdSeschrock 4035eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 4036eaca9bbdSeschrock (void) printf(gettext("status: The pool has been upgraded to a " 4037eaca9bbdSeschrock "newer, incompatible on-disk version.\n\tThe pool cannot " 4038eaca9bbdSeschrock "be accessed on this system.\n")); 4039eaca9bbdSeschrock (void) printf(gettext("action: Access the pool from a system " 4040eaca9bbdSeschrock "running more recent software, or\n\trestore the pool from " 4041eaca9bbdSeschrock "backup.\n")); 4042eaca9bbdSeschrock break; 4043eaca9bbdSeschrock 4044*57221772SChristopher Siden case ZPOOL_STATUS_FEAT_DISABLED: 4045*57221772SChristopher Siden (void) printf(gettext("status: Some supported features are not " 4046*57221772SChristopher Siden "enabled on the pool. The pool can\n\tstill be used, but " 4047*57221772SChristopher Siden "some features are unavailable.\n")); 4048*57221772SChristopher Siden (void) printf(gettext("action: Enable all features using " 4049*57221772SChristopher Siden "'zpool upgrade'. Once this is done,\n\tthe pool may no " 4050*57221772SChristopher Siden "longer be accessible by software that does not support\n\t" 4051*57221772SChristopher Siden "the features. See zpool-features(5) for details.\n")); 4052*57221772SChristopher Siden break; 4053*57221772SChristopher Siden 4054ad135b5dSChristopher Siden case ZPOOL_STATUS_UNSUP_FEAT_READ: 4055ad135b5dSChristopher Siden (void) printf(gettext("status: The pool cannot be accessed on " 4056ad135b5dSChristopher Siden "this system because it uses the\n\tfollowing feature(s) " 4057ad135b5dSChristopher Siden "not supported on this system:\n")); 4058ad135b5dSChristopher Siden zpool_print_unsup_feat(config); 4059ad135b5dSChristopher Siden (void) printf("\n"); 4060ad135b5dSChristopher Siden (void) printf(gettext("action: Access the pool from a system " 4061ad135b5dSChristopher Siden "that supports the required feature(s),\n\tor restore the " 4062ad135b5dSChristopher Siden "pool from backup.\n")); 4063ad135b5dSChristopher Siden break; 4064ad135b5dSChristopher Siden 4065ad135b5dSChristopher Siden case ZPOOL_STATUS_UNSUP_FEAT_WRITE: 4066ad135b5dSChristopher Siden (void) printf(gettext("status: The pool can only be accessed " 4067ad135b5dSChristopher Siden "in read-only mode on this system. It\n\tcannot be " 4068ad135b5dSChristopher Siden "accessed in read-write mode because it uses the " 4069ad135b5dSChristopher Siden "following\n\tfeature(s) not supported on this system:\n")); 4070ad135b5dSChristopher Siden zpool_print_unsup_feat(config); 4071ad135b5dSChristopher Siden (void) printf("\n"); 4072ad135b5dSChristopher Siden (void) printf(gettext("action: The pool cannot be accessed in " 4073ad135b5dSChristopher Siden "read-write mode. Import the pool with\n" 4074ad135b5dSChristopher Siden "\t\"-o readonly=on\", access the pool from a system that " 4075ad135b5dSChristopher Siden "supports the\n\trequired feature(s), or restore the " 4076ad135b5dSChristopher Siden "pool from backup.\n")); 4077ad135b5dSChristopher Siden break; 4078ad135b5dSChristopher Siden 40793d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_R: 40803d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 40813d7072f8Seschrock "faulted in response to persistent errors.\n\tSufficient " 40823d7072f8Seschrock "replicas exist for the pool to continue functioning " 40833d7072f8Seschrock "in a\n\tdegraded state.\n")); 40843d7072f8Seschrock (void) printf(gettext("action: Replace the faulted device, " 40853d7072f8Seschrock "or use 'zpool clear' to mark the device\n\trepaired.\n")); 40863d7072f8Seschrock break; 40873d7072f8Seschrock 40883d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_NR: 40893d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 40903d7072f8Seschrock "faulted in response to persistent errors. There are " 40913d7072f8Seschrock "insufficient replicas for the pool to\n\tcontinue " 40923d7072f8Seschrock "functioning.\n")); 40933d7072f8Seschrock (void) printf(gettext("action: Destroy and re-create the pool " 40943d7072f8Seschrock "from a backup source. Manually marking the device\n" 40953d7072f8Seschrock "\trepaired using 'zpool clear' may allow some data " 40963d7072f8Seschrock "to be recovered.\n")); 40973d7072f8Seschrock break; 40983d7072f8Seschrock 409932b87932Sek case ZPOOL_STATUS_IO_FAILURE_WAIT: 410032b87932Sek case ZPOOL_STATUS_IO_FAILURE_CONTINUE: 410132b87932Sek (void) printf(gettext("status: One or more devices are " 41028a79c1b5Sek "faulted in response to IO failures.\n")); 410332b87932Sek (void) printf(gettext("action: Make sure the affected devices " 410432b87932Sek "are connected, then run 'zpool clear'.\n")); 410532b87932Sek break; 410632b87932Sek 4107b87f3af3Sperrin case ZPOOL_STATUS_BAD_LOG: 4108b87f3af3Sperrin (void) printf(gettext("status: An intent log record " 4109b87f3af3Sperrin "could not be read.\n" 4110b87f3af3Sperrin "\tWaiting for adminstrator intervention to fix the " 4111b87f3af3Sperrin "faulted pool.\n")); 4112b87f3af3Sperrin (void) printf(gettext("action: Either restore the affected " 4113b87f3af3Sperrin "device(s) and run 'zpool online',\n" 4114b87f3af3Sperrin "\tor ignore the intent log records by running " 4115b87f3af3Sperrin "'zpool clear'.\n")); 4116b87f3af3Sperrin break; 4117b87f3af3Sperrin 4118fa9e4066Sahrens default: 4119fa9e4066Sahrens /* 4120fa9e4066Sahrens * The remaining errors can't actually be generated, yet. 4121fa9e4066Sahrens */ 4122fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 4123fa9e4066Sahrens } 4124fa9e4066Sahrens 4125fa9e4066Sahrens if (msgid != NULL) 4126654b400cSJoshua M. Clulow (void) printf(gettext(" see: http://illumos.org/msg/%s\n"), 4127fa9e4066Sahrens msgid); 4128fa9e4066Sahrens 4129fa9e4066Sahrens if (config != NULL) { 4130fa9e4066Sahrens int namewidth; 4131ea8dc4b6Seschrock uint64_t nerr; 4132fa94a07fSbrendan nvlist_t **spares, **l2cache; 4133fa94a07fSbrendan uint_t nspares, nl2cache; 41343f9d6ad7SLin Ling pool_scan_stat_t *ps = NULL; 4135fa9e4066Sahrens 41363f9d6ad7SLin Ling (void) nvlist_lookup_uint64_array(nvroot, 41373f9d6ad7SLin Ling ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &c); 41383f9d6ad7SLin Ling print_scan_status(ps); 4139fa9e4066Sahrens 4140c67d9675Seschrock namewidth = max_width(zhp, nvroot, 0, 0); 4141fa9e4066Sahrens if (namewidth < 10) 4142fa9e4066Sahrens namewidth = 10; 4143fa9e4066Sahrens 4144fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 4145fa9e4066Sahrens (void) printf(gettext("\t%-*s %-8s %5s %5s %5s\n"), namewidth, 4146fa9e4066Sahrens "NAME", "STATE", "READ", "WRITE", "CKSUM"); 4147c67d9675Seschrock print_status_config(zhp, zpool_get_name(zhp), nvroot, 4148aa8cf21aSNeil Perrin namewidth, 0, B_FALSE); 414999653d4eSeschrock 41504dea40f0SNeil Perrin if (num_logs(nvroot) > 0) 4151e6ca193dSGeorge Wilson print_logs(zhp, nvroot, namewidth, B_TRUE); 4152fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 4153fa94a07fSbrendan &l2cache, &nl2cache) == 0) 4154fa94a07fSbrendan print_l2cache(zhp, l2cache, nl2cache, namewidth); 4155fa94a07fSbrendan 415699653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 415799653d4eSeschrock &spares, &nspares) == 0) 415899653d4eSeschrock print_spares(zhp, spares, nspares, namewidth); 4159ea8dc4b6Seschrock 4160ea8dc4b6Seschrock if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT, 4161ea8dc4b6Seschrock &nerr) == 0) { 416255434c77Sek nvlist_t *nverrlist = NULL; 416355434c77Sek 4164ea8dc4b6Seschrock /* 4165ea8dc4b6Seschrock * If the approximate error count is small, get a 4166ea8dc4b6Seschrock * precise count by fetching the entire log and 4167ea8dc4b6Seschrock * uniquifying the results. 4168ea8dc4b6Seschrock */ 416975519f38Sek if (nerr > 0 && nerr < 100 && !cbp->cb_verbose && 417055434c77Sek zpool_get_errlog(zhp, &nverrlist) == 0) { 417155434c77Sek nvpair_t *elem; 417255434c77Sek 417355434c77Sek elem = NULL; 417455434c77Sek nerr = 0; 417555434c77Sek while ((elem = nvlist_next_nvpair(nverrlist, 417655434c77Sek elem)) != NULL) { 417755434c77Sek nerr++; 417855434c77Sek } 417955434c77Sek } 418055434c77Sek nvlist_free(nverrlist); 4181ea8dc4b6Seschrock 4182ea8dc4b6Seschrock (void) printf("\n"); 418399653d4eSeschrock 4184ea8dc4b6Seschrock if (nerr == 0) 4185ea8dc4b6Seschrock (void) printf(gettext("errors: No known data " 4186ea8dc4b6Seschrock "errors\n")); 4187ea8dc4b6Seschrock else if (!cbp->cb_verbose) 4188e9dbad6fSeschrock (void) printf(gettext("errors: %llu data " 41895ad82045Snd "errors, use '-v' for a list\n"), 41905ad82045Snd (u_longlong_t)nerr); 4191ea8dc4b6Seschrock else 4192ea8dc4b6Seschrock print_error_log(zhp); 4193ea8dc4b6Seschrock } 41949eb19f4dSGeorge Wilson 41959eb19f4dSGeorge Wilson if (cbp->cb_dedup_stats) 41969eb19f4dSGeorge Wilson print_dedup_stats(config); 4197fa9e4066Sahrens } else { 4198fa9e4066Sahrens (void) printf(gettext("config: The configuration cannot be " 4199fa9e4066Sahrens "determined.\n")); 4200fa9e4066Sahrens } 4201fa9e4066Sahrens 4202fa9e4066Sahrens return (0); 4203fa9e4066Sahrens } 4204fa9e4066Sahrens 4205fa9e4066Sahrens /* 42063f9d6ad7SLin Ling * zpool status [-vx] [-T d|u] [pool] ... [interval [count]] 4207fa9e4066Sahrens * 4208fa9e4066Sahrens * -v Display complete error logs 4209fa9e4066Sahrens * -x Display only pools with potential problems 42109eb19f4dSGeorge Wilson * -D Display dedup status (undocumented) 42113f9d6ad7SLin Ling * -T Display a timestamp in date(1) or Unix format 4212fa9e4066Sahrens * 4213fa9e4066Sahrens * Describes the health status of all pools or some subset. 4214fa9e4066Sahrens */ 4215fa9e4066Sahrens int 4216fa9e4066Sahrens zpool_do_status(int argc, char **argv) 4217fa9e4066Sahrens { 4218fa9e4066Sahrens int c; 4219fa9e4066Sahrens int ret; 42203f9d6ad7SLin Ling unsigned long interval = 0, count = 0; 4221fa9e4066Sahrens status_cbdata_t cb = { 0 }; 4222fa9e4066Sahrens 4223fa9e4066Sahrens /* check options */ 42243f9d6ad7SLin Ling while ((c = getopt(argc, argv, "vxDT:")) != -1) { 4225fa9e4066Sahrens switch (c) { 4226fa9e4066Sahrens case 'v': 422799653d4eSeschrock cb.cb_verbose = B_TRUE; 4228fa9e4066Sahrens break; 4229fa9e4066Sahrens case 'x': 423099653d4eSeschrock cb.cb_explain = B_TRUE; 4231fa9e4066Sahrens break; 42329eb19f4dSGeorge Wilson case 'D': 42339eb19f4dSGeorge Wilson cb.cb_dedup_stats = B_TRUE; 42349eb19f4dSGeorge Wilson break; 42353f9d6ad7SLin Ling case 'T': 42363f9d6ad7SLin Ling get_timestamp_arg(*optarg); 42373f9d6ad7SLin Ling break; 4238fa9e4066Sahrens case '?': 4239fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4240fa9e4066Sahrens optopt); 424199653d4eSeschrock usage(B_FALSE); 4242fa9e4066Sahrens } 4243fa9e4066Sahrens } 4244fa9e4066Sahrens 4245fa9e4066Sahrens argc -= optind; 4246fa9e4066Sahrens argv += optind; 4247fa9e4066Sahrens 42483f9d6ad7SLin Ling get_interval_count(&argc, argv, &interval, &count); 4249fa9e4066Sahrens 4250e9dbad6fSeschrock if (argc == 0) 4251e9dbad6fSeschrock cb.cb_allpools = B_TRUE; 4252e9dbad6fSeschrock 42533f9d6ad7SLin Ling cb.cb_first = B_TRUE; 4254fa9e4066Sahrens 42553f9d6ad7SLin Ling for (;;) { 42563f9d6ad7SLin Ling if (timestamp_fmt != NODATE) 42573f9d6ad7SLin Ling print_timestamp(timestamp_fmt); 4258fa9e4066Sahrens 42593f9d6ad7SLin Ling ret = for_each_pool(argc, argv, B_TRUE, NULL, 42603f9d6ad7SLin Ling status_callback, &cb); 42613f9d6ad7SLin Ling 42623f9d6ad7SLin Ling if (argc == 0 && cb.cb_count == 0) 42633f9d6ad7SLin Ling (void) printf(gettext("no pools available\n")); 42643f9d6ad7SLin Ling else if (cb.cb_explain && cb.cb_first && cb.cb_allpools) 42653f9d6ad7SLin Ling (void) printf(gettext("all pools are healthy\n")); 42663f9d6ad7SLin Ling 42673f9d6ad7SLin Ling if (ret != 0) 42683f9d6ad7SLin Ling return (ret); 42693f9d6ad7SLin Ling 42703f9d6ad7SLin Ling if (interval == 0) 42713f9d6ad7SLin Ling break; 42723f9d6ad7SLin Ling 42733f9d6ad7SLin Ling if (count != 0 && --count == 0) 42743f9d6ad7SLin Ling break; 42753f9d6ad7SLin Ling 42763f9d6ad7SLin Ling (void) sleep(interval); 42773f9d6ad7SLin Ling } 42783f9d6ad7SLin Ling 42793f9d6ad7SLin Ling return (0); 4280fa9e4066Sahrens } 4281fa9e4066Sahrens 4282eaca9bbdSeschrock typedef struct upgrade_cbdata { 4283eaca9bbdSeschrock int cb_first; 428406eeb2adSek int cb_argc; 4285990b4856Slling uint64_t cb_version; 428606eeb2adSek char **cb_argv; 4287eaca9bbdSeschrock } upgrade_cbdata_t; 4288eaca9bbdSeschrock 4289*57221772SChristopher Siden static int 4290*57221772SChristopher Siden upgrade_version(zpool_handle_t *zhp, uint64_t version) 4291*57221772SChristopher Siden { 4292*57221772SChristopher Siden int ret; 4293*57221772SChristopher Siden nvlist_t *config; 4294*57221772SChristopher Siden uint64_t oldversion; 4295*57221772SChristopher Siden 4296*57221772SChristopher Siden config = zpool_get_config(zhp, NULL); 4297*57221772SChristopher Siden verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 4298*57221772SChristopher Siden &oldversion) == 0); 4299*57221772SChristopher Siden 4300*57221772SChristopher Siden assert(SPA_VERSION_IS_SUPPORTED(oldversion)); 4301*57221772SChristopher Siden assert(oldversion < version); 4302*57221772SChristopher Siden 4303*57221772SChristopher Siden ret = zpool_upgrade(zhp, version); 4304*57221772SChristopher Siden if (ret != 0) 4305*57221772SChristopher Siden return (ret); 4306*57221772SChristopher Siden 4307*57221772SChristopher Siden if (version >= SPA_VERSION_FEATURES) { 4308*57221772SChristopher Siden (void) printf(gettext("Successfully upgraded " 4309*57221772SChristopher Siden "'%s' from version %llu to feature flags.\n"), 4310*57221772SChristopher Siden zpool_get_name(zhp), oldversion); 4311*57221772SChristopher Siden } else { 4312*57221772SChristopher Siden (void) printf(gettext("Successfully upgraded " 4313*57221772SChristopher Siden "'%s' from version %llu to version %llu.\n"), 4314*57221772SChristopher Siden zpool_get_name(zhp), oldversion, version); 4315*57221772SChristopher Siden } 4316*57221772SChristopher Siden 4317*57221772SChristopher Siden return (0); 4318*57221772SChristopher Siden } 4319*57221772SChristopher Siden 4320*57221772SChristopher Siden static int 4321*57221772SChristopher Siden upgrade_enable_all(zpool_handle_t *zhp, int *countp) 4322*57221772SChristopher Siden { 4323*57221772SChristopher Siden int i, ret, count; 4324*57221772SChristopher Siden boolean_t firstff = B_TRUE; 4325*57221772SChristopher Siden nvlist_t *enabled = zpool_get_features(zhp); 4326*57221772SChristopher Siden 4327*57221772SChristopher Siden count = 0; 4328*57221772SChristopher Siden for (i = 0; i < SPA_FEATURES; i++) { 4329*57221772SChristopher Siden const char *fname = spa_feature_table[i].fi_uname; 4330*57221772SChristopher Siden const char *fguid = spa_feature_table[i].fi_guid; 4331*57221772SChristopher Siden if (!nvlist_exists(enabled, fguid)) { 4332*57221772SChristopher Siden char *propname; 4333*57221772SChristopher Siden verify(-1 != asprintf(&propname, "feature@%s", fname)); 4334*57221772SChristopher Siden ret = zpool_set_prop(zhp, propname, 4335*57221772SChristopher Siden ZFS_FEATURE_ENABLED); 4336*57221772SChristopher Siden if (ret != 0) { 4337*57221772SChristopher Siden free(propname); 4338*57221772SChristopher Siden return (ret); 4339*57221772SChristopher Siden } 4340*57221772SChristopher Siden count++; 4341*57221772SChristopher Siden 4342*57221772SChristopher Siden if (firstff) { 4343*57221772SChristopher Siden (void) printf(gettext("Enabled the " 4344*57221772SChristopher Siden "following features on '%s':\n"), 4345*57221772SChristopher Siden zpool_get_name(zhp)); 4346*57221772SChristopher Siden firstff = B_FALSE; 4347*57221772SChristopher Siden } 4348*57221772SChristopher Siden (void) printf(gettext(" %s\n"), fname); 4349*57221772SChristopher Siden free(propname); 4350*57221772SChristopher Siden } 4351*57221772SChristopher Siden } 4352*57221772SChristopher Siden 4353*57221772SChristopher Siden if (countp != NULL) 4354*57221772SChristopher Siden *countp = count; 4355*57221772SChristopher Siden return (0); 4356*57221772SChristopher Siden } 4357*57221772SChristopher Siden 4358eaca9bbdSeschrock static int 4359eaca9bbdSeschrock upgrade_cb(zpool_handle_t *zhp, void *arg) 4360eaca9bbdSeschrock { 4361eaca9bbdSeschrock upgrade_cbdata_t *cbp = arg; 4362eaca9bbdSeschrock nvlist_t *config; 4363eaca9bbdSeschrock uint64_t version; 4364*57221772SChristopher Siden boolean_t printnl = B_FALSE; 4365*57221772SChristopher Siden int ret; 4366eaca9bbdSeschrock 4367eaca9bbdSeschrock config = zpool_get_config(zhp, NULL); 4368eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 4369eaca9bbdSeschrock &version) == 0); 4370eaca9bbdSeschrock 4371*57221772SChristopher Siden assert(SPA_VERSION_IS_SUPPORTED(version)); 4372eaca9bbdSeschrock 4373*57221772SChristopher Siden if (version < cbp->cb_version) { 4374*57221772SChristopher Siden cbp->cb_first = B_FALSE; 4375*57221772SChristopher Siden ret = upgrade_version(zhp, cbp->cb_version); 4376*57221772SChristopher Siden if (ret != 0) 4377*57221772SChristopher Siden return (ret); 4378*57221772SChristopher Siden printnl = B_TRUE; 4379*57221772SChristopher Siden 4380*57221772SChristopher Siden /* 4381*57221772SChristopher Siden * If they did "zpool upgrade -a", then we could 4382*57221772SChristopher Siden * be doing ioctls to different pools. We need 4383*57221772SChristopher Siden * to log this history once to each pool, and bypass 4384*57221772SChristopher Siden * the normal history logging that happens in main(). 4385*57221772SChristopher Siden */ 4386*57221772SChristopher Siden (void) zpool_log_history(g_zfs, history_str); 4387*57221772SChristopher Siden log_history = B_FALSE; 4388*57221772SChristopher Siden } 4389*57221772SChristopher Siden 4390*57221772SChristopher Siden if (cbp->cb_version >= SPA_VERSION_FEATURES) { 4391*57221772SChristopher Siden int count; 4392*57221772SChristopher Siden ret = upgrade_enable_all(zhp, &count); 4393*57221772SChristopher Siden if (ret != 0) 4394*57221772SChristopher Siden return (ret); 4395*57221772SChristopher Siden 4396*57221772SChristopher Siden if (count > 0) { 439799653d4eSeschrock cbp->cb_first = B_FALSE; 4398*57221772SChristopher Siden printnl = B_TRUE; 4399eaca9bbdSeschrock } 4400*57221772SChristopher Siden } 4401eaca9bbdSeschrock 4402*57221772SChristopher Siden if (printnl) { 4403*57221772SChristopher Siden (void) printf(gettext("\n")); 4404*57221772SChristopher Siden } 4405*57221772SChristopher Siden 4406*57221772SChristopher Siden return (0); 4407*57221772SChristopher Siden } 4408*57221772SChristopher Siden 4409*57221772SChristopher Siden static int 4410*57221772SChristopher Siden upgrade_list_older_cb(zpool_handle_t *zhp, void *arg) 4411*57221772SChristopher Siden { 4412*57221772SChristopher Siden upgrade_cbdata_t *cbp = arg; 4413*57221772SChristopher Siden nvlist_t *config; 4414*57221772SChristopher Siden uint64_t version; 4415*57221772SChristopher Siden 4416*57221772SChristopher Siden config = zpool_get_config(zhp, NULL); 4417*57221772SChristopher Siden verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 4418*57221772SChristopher Siden &version) == 0); 4419*57221772SChristopher Siden 4420*57221772SChristopher Siden assert(SPA_VERSION_IS_SUPPORTED(version)); 4421*57221772SChristopher Siden 4422*57221772SChristopher Siden if (version < SPA_VERSION_FEATURES) { 4423eaca9bbdSeschrock if (cbp->cb_first) { 4424eaca9bbdSeschrock (void) printf(gettext("The following pools are " 4425*57221772SChristopher Siden "formatted with legacy version numbers and can\n" 4426*57221772SChristopher Siden "be upgraded to use feature flags. After " 4427*57221772SChristopher Siden "being upgraded, these pools\nwill no " 4428*57221772SChristopher Siden "longer be accessible by software that does not " 4429*57221772SChristopher Siden "support feature\nflags.\n\n")); 4430eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 4431eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 443299653d4eSeschrock cbp->cb_first = B_FALSE; 4433eaca9bbdSeschrock } 4434eaca9bbdSeschrock 44355ad82045Snd (void) printf("%2llu %s\n", (u_longlong_t)version, 4436eaca9bbdSeschrock zpool_get_name(zhp)); 4437eaca9bbdSeschrock } 4438eaca9bbdSeschrock 4439*57221772SChristopher Siden return (0); 4440*57221772SChristopher Siden } 4441*57221772SChristopher Siden 4442*57221772SChristopher Siden static int 4443*57221772SChristopher Siden upgrade_list_disabled_cb(zpool_handle_t *zhp, void *arg) 4444*57221772SChristopher Siden { 4445*57221772SChristopher Siden upgrade_cbdata_t *cbp = arg; 4446*57221772SChristopher Siden nvlist_t *config; 4447*57221772SChristopher Siden uint64_t version; 4448*57221772SChristopher Siden 4449*57221772SChristopher Siden config = zpool_get_config(zhp, NULL); 4450*57221772SChristopher Siden verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 4451*57221772SChristopher Siden &version) == 0); 4452*57221772SChristopher Siden 4453*57221772SChristopher Siden if (version >= SPA_VERSION_FEATURES) { 4454*57221772SChristopher Siden int i; 4455*57221772SChristopher Siden boolean_t poolfirst = B_TRUE; 4456*57221772SChristopher Siden nvlist_t *enabled = zpool_get_features(zhp); 4457*57221772SChristopher Siden 4458*57221772SChristopher Siden for (i = 0; i < SPA_FEATURES; i++) { 4459*57221772SChristopher Siden const char *fguid = spa_feature_table[i].fi_guid; 4460*57221772SChristopher Siden const char *fname = spa_feature_table[i].fi_uname; 4461*57221772SChristopher Siden if (!nvlist_exists(enabled, fguid)) { 4462*57221772SChristopher Siden if (cbp->cb_first) { 4463*57221772SChristopher Siden (void) printf(gettext("\nSome " 4464*57221772SChristopher Siden "supported features are not " 4465*57221772SChristopher Siden "enabled on the following pools. " 4466*57221772SChristopher Siden "Once a\nfeature is enabled the " 4467*57221772SChristopher Siden "pool may become incompatible with " 4468*57221772SChristopher Siden "software\nthat does not support " 4469*57221772SChristopher Siden "the feature. See " 4470*57221772SChristopher Siden "zpool-features(5) for " 4471*57221772SChristopher Siden "details.\n\n")); 4472*57221772SChristopher Siden (void) printf(gettext("POOL " 4473*57221772SChristopher Siden "FEATURE\n")); 4474*57221772SChristopher Siden (void) printf(gettext("------" 4475*57221772SChristopher Siden "---------\n")); 4476*57221772SChristopher Siden cbp->cb_first = B_FALSE; 4477*57221772SChristopher Siden } 4478*57221772SChristopher Siden 4479*57221772SChristopher Siden if (poolfirst) { 4480*57221772SChristopher Siden (void) printf(gettext("%s\n"), 4481*57221772SChristopher Siden zpool_get_name(zhp)); 4482*57221772SChristopher Siden poolfirst = B_FALSE; 4483*57221772SChristopher Siden } 4484*57221772SChristopher Siden 4485*57221772SChristopher Siden (void) printf(gettext(" %s\n"), fname); 4486*57221772SChristopher Siden } 4487*57221772SChristopher Siden } 4488*57221772SChristopher Siden } 4489*57221772SChristopher Siden 4490*57221772SChristopher Siden return (0); 4491eaca9bbdSeschrock } 4492eaca9bbdSeschrock 4493eaca9bbdSeschrock /* ARGSUSED */ 4494eaca9bbdSeschrock static int 449506eeb2adSek upgrade_one(zpool_handle_t *zhp, void *data) 4496eaca9bbdSeschrock { 4497*57221772SChristopher Siden boolean_t printnl = B_FALSE; 4498990b4856Slling upgrade_cbdata_t *cbp = data; 4499990b4856Slling uint64_t cur_version; 4500eaca9bbdSeschrock int ret; 4501eaca9bbdSeschrock 45028654d025Sperrin if (strcmp("log", zpool_get_name(zhp)) == 0) { 45038654d025Sperrin (void) printf(gettext("'log' is now a reserved word\n" 45048654d025Sperrin "Pool 'log' must be renamed using export and import" 45058654d025Sperrin " to upgrade.\n")); 45068654d025Sperrin return (1); 45078654d025Sperrin } 4508990b4856Slling 4509990b4856Slling cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 4510e6c728e1Sbrendan if (cur_version > cbp->cb_version) { 4511eaca9bbdSeschrock (void) printf(gettext("Pool '%s' is already formatted " 4512*57221772SChristopher Siden "using more current version '%llu'.\n\n"), 4513e6c728e1Sbrendan zpool_get_name(zhp), cur_version); 4514e6c728e1Sbrendan return (0); 4515e6c728e1Sbrendan } 4516*57221772SChristopher Siden 4517*57221772SChristopher Siden if (cbp->cb_version != SPA_VERSION && cur_version == cbp->cb_version) { 4518e6c728e1Sbrendan (void) printf(gettext("Pool '%s' is already formatted " 4519*57221772SChristopher Siden "using version %llu.\n\n"), zpool_get_name(zhp), 4520*57221772SChristopher Siden cbp->cb_version); 4521eaca9bbdSeschrock return (0); 4522eaca9bbdSeschrock } 4523eaca9bbdSeschrock 4524*57221772SChristopher Siden if (cur_version != cbp->cb_version) { 4525*57221772SChristopher Siden printnl = B_TRUE; 4526*57221772SChristopher Siden ret = upgrade_version(zhp, cbp->cb_version); 4527*57221772SChristopher Siden if (ret != 0) 4528*57221772SChristopher Siden return (ret); 4529*57221772SChristopher Siden } 453006eeb2adSek 4531*57221772SChristopher Siden if (cbp->cb_version >= SPA_VERSION_FEATURES) { 4532*57221772SChristopher Siden int count = 0; 4533*57221772SChristopher Siden ret = upgrade_enable_all(zhp, &count); 4534*57221772SChristopher Siden if (ret != 0) 4535*57221772SChristopher Siden return (ret); 4536*57221772SChristopher Siden 4537*57221772SChristopher Siden if (count != 0) { 4538*57221772SChristopher Siden printnl = B_TRUE; 4539*57221772SChristopher Siden } else if (cur_version == SPA_VERSION) { 4540*57221772SChristopher Siden (void) printf(gettext("Pool '%s' already has all " 4541*57221772SChristopher Siden "supported features enabled.\n"), 4542*57221772SChristopher Siden zpool_get_name(zhp)); 4543*57221772SChristopher Siden } 4544*57221772SChristopher Siden } 4545*57221772SChristopher Siden 4546*57221772SChristopher Siden if (printnl) { 4547*57221772SChristopher Siden (void) printf(gettext("\n")); 454806eeb2adSek } 4549eaca9bbdSeschrock 4550*57221772SChristopher Siden return (0); 4551eaca9bbdSeschrock } 4552eaca9bbdSeschrock 4553eaca9bbdSeschrock /* 4554eaca9bbdSeschrock * zpool upgrade 4555eaca9bbdSeschrock * zpool upgrade -v 4556990b4856Slling * zpool upgrade [-V version] <-a | pool ...> 4557eaca9bbdSeschrock * 4558eaca9bbdSeschrock * With no arguments, display downrev'd ZFS pool available for upgrade. 4559eaca9bbdSeschrock * Individual pools can be upgraded by specifying the pool, and '-a' will 4560eaca9bbdSeschrock * upgrade all pools. 4561eaca9bbdSeschrock */ 4562eaca9bbdSeschrock int 4563eaca9bbdSeschrock zpool_do_upgrade(int argc, char **argv) 4564eaca9bbdSeschrock { 4565eaca9bbdSeschrock int c; 4566eaca9bbdSeschrock upgrade_cbdata_t cb = { 0 }; 4567eaca9bbdSeschrock int ret = 0; 4568eaca9bbdSeschrock boolean_t showversions = B_FALSE; 4569*57221772SChristopher Siden boolean_t upgradeall = B_FALSE; 4570990b4856Slling char *end; 4571990b4856Slling 4572eaca9bbdSeschrock 4573eaca9bbdSeschrock /* check options */ 4574478ed9adSEric Taylor while ((c = getopt(argc, argv, ":avV:")) != -1) { 4575eaca9bbdSeschrock switch (c) { 4576eaca9bbdSeschrock case 'a': 4577*57221772SChristopher Siden upgradeall = B_TRUE; 4578eaca9bbdSeschrock break; 4579eaca9bbdSeschrock case 'v': 4580eaca9bbdSeschrock showversions = B_TRUE; 4581eaca9bbdSeschrock break; 4582990b4856Slling case 'V': 4583990b4856Slling cb.cb_version = strtoll(optarg, &end, 10); 4584ad135b5dSChristopher Siden if (*end != '\0' || 4585ad135b5dSChristopher Siden !SPA_VERSION_IS_SUPPORTED(cb.cb_version)) { 4586990b4856Slling (void) fprintf(stderr, 4587990b4856Slling gettext("invalid version '%s'\n"), optarg); 4588990b4856Slling usage(B_FALSE); 4589990b4856Slling } 4590990b4856Slling break; 4591478ed9adSEric Taylor case ':': 4592478ed9adSEric Taylor (void) fprintf(stderr, gettext("missing argument for " 4593478ed9adSEric Taylor "'%c' option\n"), optopt); 4594478ed9adSEric Taylor usage(B_FALSE); 4595478ed9adSEric Taylor break; 4596eaca9bbdSeschrock case '?': 4597eaca9bbdSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4598eaca9bbdSeschrock optopt); 459999653d4eSeschrock usage(B_FALSE); 4600eaca9bbdSeschrock } 4601eaca9bbdSeschrock } 4602eaca9bbdSeschrock 460306eeb2adSek cb.cb_argc = argc; 460406eeb2adSek cb.cb_argv = argv; 4605eaca9bbdSeschrock argc -= optind; 4606eaca9bbdSeschrock argv += optind; 4607eaca9bbdSeschrock 4608351420b3Slling if (cb.cb_version == 0) { 4609351420b3Slling cb.cb_version = SPA_VERSION; 4610*57221772SChristopher Siden } else if (!upgradeall && argc == 0) { 4611351420b3Slling (void) fprintf(stderr, gettext("-V option is " 4612351420b3Slling "incompatible with other arguments\n")); 4613351420b3Slling usage(B_FALSE); 4614351420b3Slling } 4615351420b3Slling 4616eaca9bbdSeschrock if (showversions) { 4617*57221772SChristopher Siden if (upgradeall || argc != 0) { 4618eaca9bbdSeschrock (void) fprintf(stderr, gettext("-v option is " 4619eaca9bbdSeschrock "incompatible with other arguments\n")); 462099653d4eSeschrock usage(B_FALSE); 4621eaca9bbdSeschrock } 4622*57221772SChristopher Siden } else if (upgradeall) { 4623eaca9bbdSeschrock if (argc != 0) { 4624351420b3Slling (void) fprintf(stderr, gettext("-a option should not " 4625351420b3Slling "be used along with a pool name\n")); 462699653d4eSeschrock usage(B_FALSE); 4627eaca9bbdSeschrock } 4628eaca9bbdSeschrock } 4629eaca9bbdSeschrock 4630ad135b5dSChristopher Siden (void) printf(gettext("This system supports ZFS pool feature " 4631ad135b5dSChristopher Siden "flags.\n\n")); 4632eaca9bbdSeschrock if (showversions) { 4633*57221772SChristopher Siden int i; 4634*57221772SChristopher Siden 4635*57221772SChristopher Siden (void) printf(gettext("The following features are " 4636*57221772SChristopher Siden "supported:\n\n")); 4637*57221772SChristopher Siden (void) printf(gettext("FEAT DESCRIPTION\n")); 4638*57221772SChristopher Siden (void) printf("----------------------------------------------" 4639*57221772SChristopher Siden "---------------\n"); 4640*57221772SChristopher Siden for (i = 0; i < SPA_FEATURES; i++) { 4641*57221772SChristopher Siden zfeature_info_t *fi = &spa_feature_table[i]; 4642*57221772SChristopher Siden const char *ro = fi->fi_can_readonly ? 4643*57221772SChristopher Siden " (read-only compatible)" : ""; 4644*57221772SChristopher Siden 4645*57221772SChristopher Siden (void) printf("%-37s%s\n", fi->fi_uname, ro); 4646*57221772SChristopher Siden (void) printf(" %s\n", fi->fi_desc); 4647*57221772SChristopher Siden } 4648*57221772SChristopher Siden (void) printf("\n"); 4649*57221772SChristopher Siden 4650*57221772SChristopher Siden (void) printf(gettext("The following legacy versions are also " 4651d7d4af51Smmusante "supported:\n\n")); 4652eaca9bbdSeschrock (void) printf(gettext("VER DESCRIPTION\n")); 4653eaca9bbdSeschrock (void) printf("--- -----------------------------------------" 4654eaca9bbdSeschrock "---------------\n"); 465599653d4eSeschrock (void) printf(gettext(" 1 Initial ZFS version\n")); 465644cd46caSbillm (void) printf(gettext(" 2 Ditto blocks " 465744cd46caSbillm "(replicated metadata)\n")); 465899653d4eSeschrock (void) printf(gettext(" 3 Hot spares and double parity " 465999653d4eSeschrock "RAID-Z\n")); 4660d7306b64Sek (void) printf(gettext(" 4 zpool history\n")); 4661c9431fa1Sahl (void) printf(gettext(" 5 Compression using the gzip " 4662c9431fa1Sahl "algorithm\n")); 4663990b4856Slling (void) printf(gettext(" 6 bootfs pool property\n")); 46648654d025Sperrin (void) printf(gettext(" 7 Separate intent log devices\n")); 4665ecd6cf80Smarks (void) printf(gettext(" 8 Delegated administration\n")); 46668eed72d4Sck (void) printf(gettext(" 9 refquota and refreservation " 4667a9799022Sck "properties\n")); 4668fa94a07fSbrendan (void) printf(gettext(" 10 Cache devices\n")); 4669088f3894Sahrens (void) printf(gettext(" 11 Improved scrub performance\n")); 4670bb0ade09Sahrens (void) printf(gettext(" 12 Snapshot properties\n")); 467174e7dc98SMatthew Ahrens (void) printf(gettext(" 13 snapused property\n")); 467214843421SMatthew Ahrens (void) printf(gettext(" 14 passthrough-x aclinherit\n")); 467314843421SMatthew Ahrens (void) printf(gettext(" 15 user/group space accounting\n")); 4674478ed9adSEric Taylor (void) printf(gettext(" 16 stmf property support\n")); 46757aeab329SAdam Leventhal (void) printf(gettext(" 17 Triple-parity RAID-Z\n")); 4676b24ab676SJeff Bonwick (void) printf(gettext(" 18 Snapshot user holds\n")); 467788ecc943SGeorge Wilson (void) printf(gettext(" 19 Log device removal\n")); 4678b24ab676SJeff Bonwick (void) printf(gettext(" 20 Compression using zle " 4679b24ab676SJeff Bonwick "(zero-length encoding)\n")); 4680b24ab676SJeff Bonwick (void) printf(gettext(" 21 Deduplication\n")); 468192241e0bSTom Erickson (void) printf(gettext(" 22 Received properties\n")); 46826e1f5caaSNeil Perrin (void) printf(gettext(" 23 Slim ZIL\n")); 46830a586ceaSMark Shellenbaum (void) printf(gettext(" 24 System attributes\n")); 46843f9d6ad7SLin Ling (void) printf(gettext(" 25 Improved scrub stats\n")); 4685cde58dbcSMatthew Ahrens (void) printf(gettext(" 26 Improved snapshot deletion " 4686cde58dbcSMatthew Ahrens "performance\n")); 46876e0cbcaaSMatthew Ahrens (void) printf(gettext(" 27 Improved snapshot creation " 46886e0cbcaaSMatthew Ahrens "performance\n")); 4689cb04b873SMark J Musante (void) printf(gettext(" 28 Multiple vdev replacements\n")); 4690b24ab676SJeff Bonwick (void) printf(gettext("\nFor more information on a particular " 46919a8685acSstephanie scheffler "version, including supported releases,\n")); 46929a8685acSstephanie scheffler (void) printf(gettext("see the ZFS Administration Guide.\n\n")); 4693*57221772SChristopher Siden } else if (argc == 0 && upgradeall) { 4694*57221772SChristopher Siden cb.cb_first = B_TRUE; 469599653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 4696*57221772SChristopher Siden if (ret == 0 && cb.cb_first) { 4697*57221772SChristopher Siden if (cb.cb_version == SPA_VERSION) { 4698*57221772SChristopher Siden (void) printf(gettext("All pools are already " 4699*57221772SChristopher Siden "formatted using feature flags.\n\n")); 4700*57221772SChristopher Siden (void) printf(gettext("Every feature flags " 4701*57221772SChristopher Siden "pool already has all supported features " 4702*57221772SChristopher Siden "enabled.\n")); 4703*57221772SChristopher Siden } else { 4704*57221772SChristopher Siden (void) printf(gettext("All pools are already " 4705*57221772SChristopher Siden "formatted with version %llu or higher.\n"), 4706*57221772SChristopher Siden cb.cb_version); 4707eaca9bbdSeschrock } 4708eaca9bbdSeschrock } 4709*57221772SChristopher Siden } else if (argc == 0) { 4710*57221772SChristopher Siden cb.cb_first = B_TRUE; 4711*57221772SChristopher Siden ret = zpool_iter(g_zfs, upgrade_list_older_cb, &cb); 4712*57221772SChristopher Siden assert(ret == 0); 4713eaca9bbdSeschrock 4714*57221772SChristopher Siden if (cb.cb_first) { 4715*57221772SChristopher Siden (void) printf(gettext("All pools are formatted " 4716*57221772SChristopher Siden "using feature flags.\n\n")); 4717*57221772SChristopher Siden } else { 4718*57221772SChristopher Siden (void) printf(gettext("\nUse 'zpool upgrade -v' " 4719*57221772SChristopher Siden "for a list of available legacy versions.\n")); 4720*57221772SChristopher Siden } 4721*57221772SChristopher Siden 4722*57221772SChristopher Siden cb.cb_first = B_TRUE; 4723*57221772SChristopher Siden ret = zpool_iter(g_zfs, upgrade_list_disabled_cb, &cb); 4724*57221772SChristopher Siden assert(ret == 0); 4725*57221772SChristopher Siden 4726*57221772SChristopher Siden if (cb.cb_first) { 4727*57221772SChristopher Siden (void) printf(gettext("Every feature flags pool has " 4728*57221772SChristopher Siden "all supported features enabled.\n")); 4729*57221772SChristopher Siden } else { 4730*57221772SChristopher Siden (void) printf(gettext("\n")); 4731eaca9bbdSeschrock } 4732eaca9bbdSeschrock } else { 4733b1b8ab34Slling ret = for_each_pool(argc, argv, B_FALSE, NULL, 4734b1b8ab34Slling upgrade_one, &cb); 473506eeb2adSek } 473606eeb2adSek 473706eeb2adSek return (ret); 473806eeb2adSek } 473906eeb2adSek 4740ecd6cf80Smarks typedef struct hist_cbdata { 4741ecd6cf80Smarks boolean_t first; 47424445fffbSMatthew Ahrens boolean_t longfmt; 47434445fffbSMatthew Ahrens boolean_t internal; 4744ecd6cf80Smarks } hist_cbdata_t; 4745ecd6cf80Smarks 474606eeb2adSek /* 474706eeb2adSek * Print out the command history for a specific pool. 474806eeb2adSek */ 474906eeb2adSek static int 475006eeb2adSek get_history_one(zpool_handle_t *zhp, void *data) 475106eeb2adSek { 475206eeb2adSek nvlist_t *nvhis; 475306eeb2adSek nvlist_t **records; 475406eeb2adSek uint_t numrecords; 475506eeb2adSek int ret, i; 4756ecd6cf80Smarks hist_cbdata_t *cb = (hist_cbdata_t *)data; 475706eeb2adSek 4758ecd6cf80Smarks cb->first = B_FALSE; 475906eeb2adSek 476006eeb2adSek (void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp)); 476106eeb2adSek 476206eeb2adSek if ((ret = zpool_get_history(zhp, &nvhis)) != 0) 476306eeb2adSek return (ret); 476406eeb2adSek 476506eeb2adSek verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD, 476606eeb2adSek &records, &numrecords) == 0); 476706eeb2adSek for (i = 0; i < numrecords; i++) { 47684445fffbSMatthew Ahrens nvlist_t *rec = records[i]; 47694445fffbSMatthew Ahrens char tbuf[30] = ""; 4770ecd6cf80Smarks 47714445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_TIME)) { 47724445fffbSMatthew Ahrens time_t tsec; 47734445fffbSMatthew Ahrens struct tm t; 47744445fffbSMatthew Ahrens 47754445fffbSMatthew Ahrens tsec = fnvlist_lookup_uint64(records[i], 47764445fffbSMatthew Ahrens ZPOOL_HIST_TIME); 47774445fffbSMatthew Ahrens (void) localtime_r(&tsec, &t); 47784445fffbSMatthew Ahrens (void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t); 47794445fffbSMatthew Ahrens } 4780ecd6cf80Smarks 47814445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_CMD)) { 47824445fffbSMatthew Ahrens (void) printf("%s %s", tbuf, 47834445fffbSMatthew Ahrens fnvlist_lookup_string(rec, ZPOOL_HIST_CMD)); 47844445fffbSMatthew Ahrens } else if (nvlist_exists(rec, ZPOOL_HIST_INT_EVENT)) { 47854445fffbSMatthew Ahrens int ievent = 47864445fffbSMatthew Ahrens fnvlist_lookup_uint64(rec, ZPOOL_HIST_INT_EVENT); 47874445fffbSMatthew Ahrens if (!cb->internal) 47884445fffbSMatthew Ahrens continue; 47894445fffbSMatthew Ahrens if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS) { 47904445fffbSMatthew Ahrens (void) printf("%s unrecognized record:\n", 47914445fffbSMatthew Ahrens tbuf); 47924445fffbSMatthew Ahrens dump_nvlist(rec, 4); 47934445fffbSMatthew Ahrens continue; 47944445fffbSMatthew Ahrens } 47954445fffbSMatthew Ahrens (void) printf("%s [internal %s txg:%lld] %s", tbuf, 47964445fffbSMatthew Ahrens zfs_history_event_names[ievent], 47974445fffbSMatthew Ahrens fnvlist_lookup_uint64(rec, ZPOOL_HIST_TXG), 47984445fffbSMatthew Ahrens fnvlist_lookup_string(rec, ZPOOL_HIST_INT_STR)); 47994445fffbSMatthew Ahrens } else if (nvlist_exists(rec, ZPOOL_HIST_INT_NAME)) { 48004445fffbSMatthew Ahrens if (!cb->internal) 4801ecd6cf80Smarks continue; 48024445fffbSMatthew Ahrens (void) printf("%s [txg:%lld] %s", tbuf, 48034445fffbSMatthew Ahrens fnvlist_lookup_uint64(rec, ZPOOL_HIST_TXG), 48044445fffbSMatthew Ahrens fnvlist_lookup_string(rec, ZPOOL_HIST_INT_NAME)); 48054445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_DSNAME)) { 48064445fffbSMatthew Ahrens (void) printf(" %s (%llu)", 48074445fffbSMatthew Ahrens fnvlist_lookup_string(rec, 48084445fffbSMatthew Ahrens ZPOOL_HIST_DSNAME), 48094445fffbSMatthew Ahrens fnvlist_lookup_uint64(rec, 48104445fffbSMatthew Ahrens ZPOOL_HIST_DSID)); 48114445fffbSMatthew Ahrens } 48124445fffbSMatthew Ahrens (void) printf(" %s", fnvlist_lookup_string(rec, 48134445fffbSMatthew Ahrens ZPOOL_HIST_INT_STR)); 48144445fffbSMatthew Ahrens } else if (nvlist_exists(rec, ZPOOL_HIST_IOCTL)) { 48154445fffbSMatthew Ahrens if (!cb->internal) 48164445fffbSMatthew Ahrens continue; 48174445fffbSMatthew Ahrens (void) printf("%s ioctl %s\n", tbuf, 48184445fffbSMatthew Ahrens fnvlist_lookup_string(rec, ZPOOL_HIST_IOCTL)); 48194445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_INPUT_NVL)) { 48204445fffbSMatthew Ahrens (void) printf(" input:\n"); 48214445fffbSMatthew Ahrens dump_nvlist(fnvlist_lookup_nvlist(rec, 48224445fffbSMatthew Ahrens ZPOOL_HIST_INPUT_NVL), 8); 48234445fffbSMatthew Ahrens } 48244445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_OUTPUT_NVL)) { 48254445fffbSMatthew Ahrens (void) printf(" output:\n"); 48264445fffbSMatthew Ahrens dump_nvlist(fnvlist_lookup_nvlist(rec, 48274445fffbSMatthew Ahrens ZPOOL_HIST_OUTPUT_NVL), 8); 48284445fffbSMatthew Ahrens } 48294445fffbSMatthew Ahrens } else { 48304445fffbSMatthew Ahrens if (!cb->internal) 4831ecd6cf80Smarks continue; 48324445fffbSMatthew Ahrens (void) printf("%s unrecognized record:\n", tbuf); 48334445fffbSMatthew Ahrens dump_nvlist(rec, 4); 483406eeb2adSek } 4835ecd6cf80Smarks 4836ecd6cf80Smarks if (!cb->longfmt) { 4837ecd6cf80Smarks (void) printf("\n"); 4838ecd6cf80Smarks continue; 4839ecd6cf80Smarks } 4840ecd6cf80Smarks (void) printf(" ["); 48414445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_WHO)) { 48424445fffbSMatthew Ahrens uid_t who = fnvlist_lookup_uint64(rec, ZPOOL_HIST_WHO); 48434445fffbSMatthew Ahrens struct passwd *pwd = getpwuid(who); 48444445fffbSMatthew Ahrens (void) printf("user %d ", (int)who); 48454445fffbSMatthew Ahrens if (pwd != NULL) 48464445fffbSMatthew Ahrens (void) printf("(%s) ", pwd->pw_name); 4847ecd6cf80Smarks } 48484445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_HOST)) { 48494445fffbSMatthew Ahrens (void) printf("on %s", 48504445fffbSMatthew Ahrens fnvlist_lookup_string(rec, ZPOOL_HIST_HOST)); 4851ecd6cf80Smarks } 48524445fffbSMatthew Ahrens if (nvlist_exists(rec, ZPOOL_HIST_ZONE)) { 48534445fffbSMatthew Ahrens (void) printf(":%s", 48544445fffbSMatthew Ahrens fnvlist_lookup_string(rec, ZPOOL_HIST_ZONE)); 4855ecd6cf80Smarks } 4856ecd6cf80Smarks (void) printf("]"); 4857ecd6cf80Smarks (void) printf("\n"); 485806eeb2adSek } 485906eeb2adSek (void) printf("\n"); 486006eeb2adSek nvlist_free(nvhis); 486106eeb2adSek 486206eeb2adSek return (ret); 486306eeb2adSek } 486406eeb2adSek 486506eeb2adSek /* 486606eeb2adSek * zpool history <pool> 486706eeb2adSek * 486806eeb2adSek * Displays the history of commands that modified pools. 486906eeb2adSek */ 487006eeb2adSek int 487106eeb2adSek zpool_do_history(int argc, char **argv) 487206eeb2adSek { 4873ecd6cf80Smarks hist_cbdata_t cbdata = { 0 }; 487406eeb2adSek int ret; 4875ecd6cf80Smarks int c; 487606eeb2adSek 4877ecd6cf80Smarks cbdata.first = B_TRUE; 4878ecd6cf80Smarks /* check options */ 4879ecd6cf80Smarks while ((c = getopt(argc, argv, "li")) != -1) { 4880ecd6cf80Smarks switch (c) { 4881ecd6cf80Smarks case 'l': 48824445fffbSMatthew Ahrens cbdata.longfmt = B_TRUE; 4883ecd6cf80Smarks break; 4884ecd6cf80Smarks case 'i': 48854445fffbSMatthew Ahrens cbdata.internal = B_TRUE; 4886ecd6cf80Smarks break; 4887ecd6cf80Smarks case '?': 4888ecd6cf80Smarks (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4889ecd6cf80Smarks optopt); 4890ecd6cf80Smarks usage(B_FALSE); 4891ecd6cf80Smarks } 4892ecd6cf80Smarks } 489306eeb2adSek argc -= optind; 489406eeb2adSek argv += optind; 489506eeb2adSek 4896b1b8ab34Slling ret = for_each_pool(argc, argv, B_FALSE, NULL, get_history_one, 4897ecd6cf80Smarks &cbdata); 489806eeb2adSek 4899ecd6cf80Smarks if (argc == 0 && cbdata.first == B_TRUE) { 490006eeb2adSek (void) printf(gettext("no pools available\n")); 490106eeb2adSek return (0); 4902eaca9bbdSeschrock } 4903eaca9bbdSeschrock 4904eaca9bbdSeschrock return (ret); 4905eaca9bbdSeschrock } 4906eaca9bbdSeschrock 4907b1b8ab34Slling static int 4908b1b8ab34Slling get_callback(zpool_handle_t *zhp, void *data) 4909b1b8ab34Slling { 4910990b4856Slling zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 4911b1b8ab34Slling char value[MAXNAMELEN]; 4912990b4856Slling zprop_source_t srctype; 4913990b4856Slling zprop_list_t *pl; 4914b1b8ab34Slling 4915b1b8ab34Slling for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) { 4916b1b8ab34Slling 4917b1b8ab34Slling /* 4918990b4856Slling * Skip the special fake placeholder. This will also skip 4919990b4856Slling * over the name property when 'all' is specified. 4920b1b8ab34Slling */ 4921990b4856Slling if (pl->pl_prop == ZPOOL_PROP_NAME && 4922b1b8ab34Slling pl == cbp->cb_proplist) 4923b1b8ab34Slling continue; 4924b1b8ab34Slling 4925ad135b5dSChristopher Siden if (pl->pl_prop == ZPROP_INVAL && 4926ad135b5dSChristopher Siden (zpool_prop_feature(pl->pl_user_prop) || 4927ad135b5dSChristopher Siden zpool_prop_unsupported(pl->pl_user_prop))) { 4928ad135b5dSChristopher Siden srctype = ZPROP_SRC_LOCAL; 4929b1b8ab34Slling 4930ad135b5dSChristopher Siden if (zpool_prop_get_feature(zhp, pl->pl_user_prop, 4931ad135b5dSChristopher Siden value, sizeof (value)) == 0) { 4932ad135b5dSChristopher Siden zprop_print_one_property(zpool_get_name(zhp), 4933ad135b5dSChristopher Siden cbp, pl->pl_user_prop, value, srctype, 4934ad135b5dSChristopher Siden NULL, NULL); 4935ad135b5dSChristopher Siden } 4936ad135b5dSChristopher Siden } else { 4937ad135b5dSChristopher Siden if (zpool_get_prop(zhp, pl->pl_prop, value, 4938ad135b5dSChristopher Siden sizeof (value), &srctype) != 0) 4939ad135b5dSChristopher Siden continue; 4940ad135b5dSChristopher Siden 4941ad135b5dSChristopher Siden zprop_print_one_property(zpool_get_name(zhp), cbp, 4942ad135b5dSChristopher Siden zpool_prop_to_name(pl->pl_prop), value, srctype, 4943ad135b5dSChristopher Siden NULL, NULL); 4944ad135b5dSChristopher Siden } 4945b1b8ab34Slling } 4946b1b8ab34Slling return (0); 4947b1b8ab34Slling } 4948b1b8ab34Slling 4949b1b8ab34Slling int 4950b1b8ab34Slling zpool_do_get(int argc, char **argv) 4951b1b8ab34Slling { 4952990b4856Slling zprop_get_cbdata_t cb = { 0 }; 4953990b4856Slling zprop_list_t fake_name = { 0 }; 4954b1b8ab34Slling int ret; 4955b1b8ab34Slling 4956ad135b5dSChristopher Siden if (argc < 2) { 4957ad135b5dSChristopher Siden (void) fprintf(stderr, gettext("missing property " 4958ad135b5dSChristopher Siden "argument\n")); 4959b1b8ab34Slling usage(B_FALSE); 4960ad135b5dSChristopher Siden } 4961b1b8ab34Slling 4962b1b8ab34Slling cb.cb_first = B_TRUE; 4963990b4856Slling cb.cb_sources = ZPROP_SRC_ALL; 4964b1b8ab34Slling cb.cb_columns[0] = GET_COL_NAME; 4965b1b8ab34Slling cb.cb_columns[1] = GET_COL_PROPERTY; 4966b1b8ab34Slling cb.cb_columns[2] = GET_COL_VALUE; 4967b1b8ab34Slling cb.cb_columns[3] = GET_COL_SOURCE; 4968990b4856Slling cb.cb_type = ZFS_TYPE_POOL; 4969b1b8ab34Slling 4970ad135b5dSChristopher Siden if (zprop_get_list(g_zfs, argv[1], &cb.cb_proplist, 4971990b4856Slling ZFS_TYPE_POOL) != 0) 4972b1b8ab34Slling usage(B_FALSE); 4973b1b8ab34Slling 4974b1b8ab34Slling if (cb.cb_proplist != NULL) { 4975990b4856Slling fake_name.pl_prop = ZPOOL_PROP_NAME; 4976b1b8ab34Slling fake_name.pl_width = strlen(gettext("NAME")); 4977b1b8ab34Slling fake_name.pl_next = cb.cb_proplist; 4978b1b8ab34Slling cb.cb_proplist = &fake_name; 4979b1b8ab34Slling } 4980b1b8ab34Slling 4981b1b8ab34Slling ret = for_each_pool(argc - 2, argv + 2, B_TRUE, &cb.cb_proplist, 4982b1b8ab34Slling get_callback, &cb); 4983b1b8ab34Slling 4984b1b8ab34Slling if (cb.cb_proplist == &fake_name) 4985990b4856Slling zprop_free_list(fake_name.pl_next); 4986b1b8ab34Slling else 4987990b4856Slling zprop_free_list(cb.cb_proplist); 4988b1b8ab34Slling 4989b1b8ab34Slling return (ret); 4990b1b8ab34Slling } 4991b1b8ab34Slling 4992b1b8ab34Slling typedef struct set_cbdata { 4993b1b8ab34Slling char *cb_propname; 4994b1b8ab34Slling char *cb_value; 4995b1b8ab34Slling boolean_t cb_any_successful; 4996b1b8ab34Slling } set_cbdata_t; 4997b1b8ab34Slling 4998b1b8ab34Slling int 4999b1b8ab34Slling set_callback(zpool_handle_t *zhp, void *data) 5000b1b8ab34Slling { 5001b1b8ab34Slling int error; 5002b1b8ab34Slling set_cbdata_t *cb = (set_cbdata_t *)data; 5003b1b8ab34Slling 5004b1b8ab34Slling error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value); 5005b1b8ab34Slling 5006b1b8ab34Slling if (!error) 5007b1b8ab34Slling cb->cb_any_successful = B_TRUE; 5008b1b8ab34Slling 5009b1b8ab34Slling return (error); 5010b1b8ab34Slling } 5011b1b8ab34Slling 5012b1b8ab34Slling int 5013b1b8ab34Slling zpool_do_set(int argc, char **argv) 5014b1b8ab34Slling { 5015b1b8ab34Slling set_cbdata_t cb = { 0 }; 5016b1b8ab34Slling int error; 5017b1b8ab34Slling 5018b1b8ab34Slling if (argc > 1 && argv[1][0] == '-') { 5019b1b8ab34Slling (void) fprintf(stderr, gettext("invalid option '%c'\n"), 5020b1b8ab34Slling argv[1][1]); 5021b1b8ab34Slling usage(B_FALSE); 5022b1b8ab34Slling } 5023b1b8ab34Slling 5024b1b8ab34Slling if (argc < 2) { 5025b1b8ab34Slling (void) fprintf(stderr, gettext("missing property=value " 5026b1b8ab34Slling "argument\n")); 5027b1b8ab34Slling usage(B_FALSE); 5028b1b8ab34Slling } 5029b1b8ab34Slling 5030b1b8ab34Slling if (argc < 3) { 5031b1b8ab34Slling (void) fprintf(stderr, gettext("missing pool name\n")); 5032b1b8ab34Slling usage(B_FALSE); 5033b1b8ab34Slling } 5034b1b8ab34Slling 5035b1b8ab34Slling if (argc > 3) { 5036b1b8ab34Slling (void) fprintf(stderr, gettext("too many pool names\n")); 5037b1b8ab34Slling usage(B_FALSE); 5038b1b8ab34Slling } 5039b1b8ab34Slling 5040b1b8ab34Slling cb.cb_propname = argv[1]; 5041b1b8ab34Slling cb.cb_value = strchr(cb.cb_propname, '='); 5042b1b8ab34Slling if (cb.cb_value == NULL) { 5043b1b8ab34Slling (void) fprintf(stderr, gettext("missing value in " 5044b1b8ab34Slling "property=value argument\n")); 5045b1b8ab34Slling usage(B_FALSE); 5046b1b8ab34Slling } 5047b1b8ab34Slling 5048b1b8ab34Slling *(cb.cb_value) = '\0'; 5049b1b8ab34Slling cb.cb_value++; 5050b1b8ab34Slling 5051b1b8ab34Slling error = for_each_pool(argc - 2, argv + 2, B_TRUE, NULL, 5052b1b8ab34Slling set_callback, &cb); 5053b1b8ab34Slling 5054b1b8ab34Slling return (error); 5055b1b8ab34Slling } 5056b1b8ab34Slling 5057b1b8ab34Slling static int 5058b1b8ab34Slling find_command_idx(char *command, int *idx) 5059b1b8ab34Slling { 5060b1b8ab34Slling int i; 5061b1b8ab34Slling 5062b1b8ab34Slling for (i = 0; i < NCOMMAND; i++) { 5063b1b8ab34Slling if (command_table[i].name == NULL) 5064b1b8ab34Slling continue; 5065b1b8ab34Slling 5066b1b8ab34Slling if (strcmp(command, command_table[i].name) == 0) { 5067b1b8ab34Slling *idx = i; 5068b1b8ab34Slling return (0); 5069b1b8ab34Slling } 5070b1b8ab34Slling } 5071b1b8ab34Slling return (1); 5072b1b8ab34Slling } 5073b1b8ab34Slling 5074fa9e4066Sahrens int 5075fa9e4066Sahrens main(int argc, char **argv) 5076fa9e4066Sahrens { 5077fa9e4066Sahrens int ret; 5078fa9e4066Sahrens int i; 5079fa9e4066Sahrens char *cmdname; 5080fa9e4066Sahrens 5081fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 5082fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 5083fa9e4066Sahrens 508499653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 508599653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to " 5086203a47d8Snd "initialize ZFS library\n")); 508799653d4eSeschrock return (1); 508899653d4eSeschrock } 508999653d4eSeschrock 509099653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE); 509199653d4eSeschrock 5092fa9e4066Sahrens opterr = 0; 5093fa9e4066Sahrens 5094fa9e4066Sahrens /* 5095fa9e4066Sahrens * Make sure the user has specified some command. 5096fa9e4066Sahrens */ 5097fa9e4066Sahrens if (argc < 2) { 5098fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 509999653d4eSeschrock usage(B_FALSE); 5100fa9e4066Sahrens } 5101fa9e4066Sahrens 5102fa9e4066Sahrens cmdname = argv[1]; 5103fa9e4066Sahrens 5104fa9e4066Sahrens /* 5105fa9e4066Sahrens * Special case '-?' 5106fa9e4066Sahrens */ 5107fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 510899653d4eSeschrock usage(B_TRUE); 5109fa9e4066Sahrens 51104445fffbSMatthew Ahrens zfs_save_arguments(argc, argv, history_str, sizeof (history_str)); 51112a6b87f0Sek 5112fa9e4066Sahrens /* 5113fa9e4066Sahrens * Run the appropriate command. 5114fa9e4066Sahrens */ 5115b1b8ab34Slling if (find_command_idx(cmdname, &i) == 0) { 5116b1b8ab34Slling current_command = &command_table[i]; 5117b1b8ab34Slling ret = command_table[i].func(argc - 1, argv + 1); 511891ebeef5Sahrens } else if (strchr(cmdname, '=')) { 511991ebeef5Sahrens verify(find_command_idx("set", &i) == 0); 512091ebeef5Sahrens current_command = &command_table[i]; 512191ebeef5Sahrens ret = command_table[i].func(argc, argv); 512291ebeef5Sahrens } else if (strcmp(cmdname, "freeze") == 0 && argc == 3) { 512391ebeef5Sahrens /* 512491ebeef5Sahrens * 'freeze' is a vile debugging abomination, so we treat 512591ebeef5Sahrens * it as such. 512691ebeef5Sahrens */ 5127ea8dc4b6Seschrock char buf[16384]; 5128ea8dc4b6Seschrock int fd = open(ZFS_DEV, O_RDWR); 5129fa9e4066Sahrens (void) strcpy((void *)buf, argv[2]); 5130fa9e4066Sahrens return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf)); 513191ebeef5Sahrens } else { 5132fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 5133fa9e4066Sahrens "command '%s'\n"), cmdname); 513499653d4eSeschrock usage(B_FALSE); 5135fa9e4066Sahrens } 5136fa9e4066Sahrens 51374445fffbSMatthew Ahrens if (ret == 0 && log_history) 51384445fffbSMatthew Ahrens (void) zpool_log_history(g_zfs, history_str); 51394445fffbSMatthew Ahrens 514099653d4eSeschrock libzfs_fini(g_zfs); 514199653d4eSeschrock 5142fa9e4066Sahrens /* 5143fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 5144fa9e4066Sahrens * for the purposes of running ::findleaks. 5145fa9e4066Sahrens */ 5146fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 5147fa9e4066Sahrens (void) printf("dumping core by request\n"); 5148fa9e4066Sahrens abort(); 5149fa9e4066Sahrens } 5150fa9e4066Sahrens 5151fa9e4066Sahrens return (ret); 5152fa9e4066Sahrens } 5153