1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5441d80aaSlling * Common Development and Distribution License (the "License"). 6441d80aaSlling * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 2199653d4eSeschrock 22fa9e4066Sahrens /* 23*3f9d6ad7SLin Ling * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens #include <assert.h> 27fa9e4066Sahrens #include <ctype.h> 28fa9e4066Sahrens #include <dirent.h> 29fa9e4066Sahrens #include <errno.h> 30fa9e4066Sahrens #include <fcntl.h> 31fa9e4066Sahrens #include <libgen.h> 32fa9e4066Sahrens #include <libintl.h> 33fa9e4066Sahrens #include <libuutil.h> 34fa9e4066Sahrens #include <locale.h> 35fa9e4066Sahrens #include <stdio.h> 36fa9e4066Sahrens #include <stdlib.h> 37fa9e4066Sahrens #include <string.h> 38fa9e4066Sahrens #include <strings.h> 39fa9e4066Sahrens #include <unistd.h> 40fa9e4066Sahrens #include <priv.h> 41ecd6cf80Smarks #include <pwd.h> 42ecd6cf80Smarks #include <zone.h> 43b1b8ab34Slling #include <sys/fs/zfs.h> 44fa9e4066Sahrens #include <sys/stat.h> 45fa9e4066Sahrens 46fa9e4066Sahrens #include <libzfs.h> 47fa9e4066Sahrens 48fa9e4066Sahrens #include "zpool_util.h" 49b7b97454Sperrin #include "zfs_comutil.h" 50fa9e4066Sahrens 5126fd7700SKrishnendu Sadhukhan - Sun Microsystems #include "statcommon.h" 5226fd7700SKrishnendu Sadhukhan - Sun Microsystems 53fa9e4066Sahrens static int zpool_do_create(int, char **); 54fa9e4066Sahrens static int zpool_do_destroy(int, char **); 55fa9e4066Sahrens 56fa9e4066Sahrens static int zpool_do_add(int, char **); 5799653d4eSeschrock static int zpool_do_remove(int, char **); 58fa9e4066Sahrens 59fa9e4066Sahrens static int zpool_do_list(int, char **); 60fa9e4066Sahrens static int zpool_do_iostat(int, char **); 61fa9e4066Sahrens static int zpool_do_status(int, char **); 62fa9e4066Sahrens 63fa9e4066Sahrens static int zpool_do_online(int, char **); 64fa9e4066Sahrens static int zpool_do_offline(int, char **); 65ea8dc4b6Seschrock static int zpool_do_clear(int, char **); 66fa9e4066Sahrens 67fa9e4066Sahrens static int zpool_do_attach(int, char **); 68fa9e4066Sahrens static int zpool_do_detach(int, char **); 69fa9e4066Sahrens static int zpool_do_replace(int, char **); 701195e687SMark J Musante static int zpool_do_split(int, char **); 71fa9e4066Sahrens 72fa9e4066Sahrens static int zpool_do_scrub(int, char **); 73fa9e4066Sahrens 74fa9e4066Sahrens static int zpool_do_import(int, char **); 75fa9e4066Sahrens static int zpool_do_export(int, char **); 76fa9e4066Sahrens 77eaca9bbdSeschrock static int zpool_do_upgrade(int, char **); 78eaca9bbdSeschrock 7906eeb2adSek static int zpool_do_history(int, char **); 8006eeb2adSek 81b1b8ab34Slling static int zpool_do_get(int, char **); 82b1b8ab34Slling static int zpool_do_set(int, char **); 83b1b8ab34Slling 84fa9e4066Sahrens /* 85fa9e4066Sahrens * These libumem hooks provide a reasonable set of defaults for the allocator's 86fa9e4066Sahrens * debugging facilities. 87fa9e4066Sahrens */ 8829ab75c9Srm 8929ab75c9Srm #ifdef DEBUG 90fa9e4066Sahrens const char * 9199653d4eSeschrock _umem_debug_init(void) 92fa9e4066Sahrens { 93fa9e4066Sahrens return ("default,verbose"); /* $UMEM_DEBUG setting */ 94fa9e4066Sahrens } 95fa9e4066Sahrens 96fa9e4066Sahrens const char * 97fa9e4066Sahrens _umem_logging_init(void) 98fa9e4066Sahrens { 99fa9e4066Sahrens return ("fail,contents"); /* $UMEM_LOGGING setting */ 100fa9e4066Sahrens } 10129ab75c9Srm #endif 102fa9e4066Sahrens 10365cd9f28Seschrock typedef enum { 10465cd9f28Seschrock HELP_ADD, 10565cd9f28Seschrock HELP_ATTACH, 106ea8dc4b6Seschrock HELP_CLEAR, 10765cd9f28Seschrock HELP_CREATE, 10865cd9f28Seschrock HELP_DESTROY, 10965cd9f28Seschrock HELP_DETACH, 11065cd9f28Seschrock HELP_EXPORT, 11106eeb2adSek HELP_HISTORY, 11265cd9f28Seschrock HELP_IMPORT, 11365cd9f28Seschrock HELP_IOSTAT, 11465cd9f28Seschrock HELP_LIST, 11565cd9f28Seschrock HELP_OFFLINE, 11665cd9f28Seschrock HELP_ONLINE, 11765cd9f28Seschrock HELP_REPLACE, 11899653d4eSeschrock HELP_REMOVE, 11965cd9f28Seschrock HELP_SCRUB, 120eaca9bbdSeschrock HELP_STATUS, 121b1b8ab34Slling HELP_UPGRADE, 122b1b8ab34Slling HELP_GET, 1231195e687SMark J Musante HELP_SET, 1241195e687SMark J Musante HELP_SPLIT 12565cd9f28Seschrock } zpool_help_t; 12665cd9f28Seschrock 12765cd9f28Seschrock 128fa9e4066Sahrens typedef struct zpool_command { 129fa9e4066Sahrens const char *name; 130fa9e4066Sahrens int (*func)(int, char **); 13165cd9f28Seschrock zpool_help_t usage; 132fa9e4066Sahrens } zpool_command_t; 133fa9e4066Sahrens 134fa9e4066Sahrens /* 135fa9e4066Sahrens * Master command table. Each ZFS command has a name, associated function, and 136ea8dc4b6Seschrock * usage message. The usage messages need to be internationalized, so we have 137ea8dc4b6Seschrock * to have a function to return the usage message based on a command index. 13865cd9f28Seschrock * 13965cd9f28Seschrock * These commands are organized according to how they are displayed in the usage 14065cd9f28Seschrock * message. An empty command (one with a NULL name) indicates an empty line in 14165cd9f28Seschrock * the generic usage message. 142fa9e4066Sahrens */ 143fa9e4066Sahrens static zpool_command_t command_table[] = { 14465cd9f28Seschrock { "create", zpool_do_create, HELP_CREATE }, 14565cd9f28Seschrock { "destroy", zpool_do_destroy, HELP_DESTROY }, 146fa9e4066Sahrens { NULL }, 14765cd9f28Seschrock { "add", zpool_do_add, HELP_ADD }, 14899653d4eSeschrock { "remove", zpool_do_remove, HELP_REMOVE }, 149fa9e4066Sahrens { NULL }, 15065cd9f28Seschrock { "list", zpool_do_list, HELP_LIST }, 15165cd9f28Seschrock { "iostat", zpool_do_iostat, HELP_IOSTAT }, 15265cd9f28Seschrock { "status", zpool_do_status, HELP_STATUS }, 153fa9e4066Sahrens { NULL }, 15465cd9f28Seschrock { "online", zpool_do_online, HELP_ONLINE }, 15565cd9f28Seschrock { "offline", zpool_do_offline, HELP_OFFLINE }, 156ea8dc4b6Seschrock { "clear", zpool_do_clear, HELP_CLEAR }, 157fa9e4066Sahrens { NULL }, 15865cd9f28Seschrock { "attach", zpool_do_attach, HELP_ATTACH }, 15965cd9f28Seschrock { "detach", zpool_do_detach, HELP_DETACH }, 16065cd9f28Seschrock { "replace", zpool_do_replace, HELP_REPLACE }, 1611195e687SMark J Musante { "split", zpool_do_split, HELP_SPLIT }, 162fa9e4066Sahrens { NULL }, 16365cd9f28Seschrock { "scrub", zpool_do_scrub, HELP_SCRUB }, 164fa9e4066Sahrens { NULL }, 16565cd9f28Seschrock { "import", zpool_do_import, HELP_IMPORT }, 16665cd9f28Seschrock { "export", zpool_do_export, HELP_EXPORT }, 16706eeb2adSek { "upgrade", zpool_do_upgrade, HELP_UPGRADE }, 16806eeb2adSek { NULL }, 169b1b8ab34Slling { "history", zpool_do_history, HELP_HISTORY }, 170b1b8ab34Slling { "get", zpool_do_get, HELP_GET }, 171b1b8ab34Slling { "set", zpool_do_set, HELP_SET }, 172fa9e4066Sahrens }; 173fa9e4066Sahrens 174fa9e4066Sahrens #define NCOMMAND (sizeof (command_table) / sizeof (command_table[0])) 175fa9e4066Sahrens 176fa9e4066Sahrens zpool_command_t *current_command; 1772a6b87f0Sek static char history_str[HIS_MAX_RECORD_LEN]; 178fa9e4066Sahrens 17926fd7700SKrishnendu Sadhukhan - Sun Microsystems static uint_t timestamp_fmt = NODATE; 18026fd7700SKrishnendu Sadhukhan - Sun Microsystems 18165cd9f28Seschrock static const char * 18265cd9f28Seschrock get_usage(zpool_help_t idx) { 18365cd9f28Seschrock switch (idx) { 18465cd9f28Seschrock case HELP_ADD: 18565cd9f28Seschrock return (gettext("\tadd [-fn] <pool> <vdev> ...\n")); 18665cd9f28Seschrock case HELP_ATTACH: 18765cd9f28Seschrock return (gettext("\tattach [-f] <pool> <device> " 188e45ce728Sahrens "<new-device>\n")); 189ea8dc4b6Seschrock case HELP_CLEAR: 190468c413aSTim Haley return (gettext("\tclear [-nF] <pool> [device]\n")); 19165cd9f28Seschrock case HELP_CREATE: 192990b4856Slling return (gettext("\tcreate [-fn] [-o property=value] ... \n" 1930a48a24eStimh "\t [-O file-system-property=value] ... \n" 194990b4856Slling "\t [-m mountpoint] [-R root] <pool> <vdev> ...\n")); 19565cd9f28Seschrock case HELP_DESTROY: 19665cd9f28Seschrock return (gettext("\tdestroy [-f] <pool>\n")); 19765cd9f28Seschrock case HELP_DETACH: 19865cd9f28Seschrock return (gettext("\tdetach <pool> <device>\n")); 19965cd9f28Seschrock case HELP_EXPORT: 20065cd9f28Seschrock return (gettext("\texport [-f] <pool> ...\n")); 20106eeb2adSek case HELP_HISTORY: 202ecd6cf80Smarks return (gettext("\thistory [-il] [<pool>] ...\n")); 20365cd9f28Seschrock case HELP_IMPORT: 2044c58d714Sdarrenm return (gettext("\timport [-d dir] [-D]\n" 205468c413aSTim Haley "\timport [-d dir | -c cachefile] [-n] -F <pool | id>\n" 2062f8aaab3Seschrock "\timport [-o mntopts] [-o property=value] ... \n" 2072f8aaab3Seschrock "\t [-d dir | -c cachefile] [-D] [-f] [-R root] -a\n" 2082f8aaab3Seschrock "\timport [-o mntopts] [-o property=value] ... \n" 2092f8aaab3Seschrock "\t [-d dir | -c cachefile] [-D] [-f] [-R root] " 2102f8aaab3Seschrock "<pool | id> [newpool]\n")); 21165cd9f28Seschrock case HELP_IOSTAT: 21226fd7700SKrishnendu Sadhukhan - Sun Microsystems return (gettext("\tiostat [-v] [-T d|u] [pool] ... [interval " 21365cd9f28Seschrock "[count]]\n")); 21465cd9f28Seschrock case HELP_LIST: 215990b4856Slling return (gettext("\tlist [-H] [-o property[,...]] " 216*3f9d6ad7SLin Ling "[-T d|u] [pool] ... [interval [count]]\n")); 21765cd9f28Seschrock case HELP_OFFLINE: 218441d80aaSlling return (gettext("\toffline [-t] <pool> <device> ...\n")); 21965cd9f28Seschrock case HELP_ONLINE: 220441d80aaSlling return (gettext("\tonline <pool> <device> ...\n")); 22165cd9f28Seschrock case HELP_REPLACE: 22265cd9f28Seschrock return (gettext("\treplace [-f] <pool> <device> " 223e45ce728Sahrens "[new-device]\n")); 22499653d4eSeschrock case HELP_REMOVE: 225fa94a07fSbrendan return (gettext("\tremove <pool> <device> ...\n")); 22665cd9f28Seschrock case HELP_SCRUB: 22765cd9f28Seschrock return (gettext("\tscrub [-s] <pool> ...\n")); 22865cd9f28Seschrock case HELP_STATUS: 229*3f9d6ad7SLin Ling return (gettext("\tstatus [-vx] [-T d|u] [pool] ... [interval " 230*3f9d6ad7SLin Ling "[count]]\n")); 231eaca9bbdSeschrock case HELP_UPGRADE: 232eaca9bbdSeschrock return (gettext("\tupgrade\n" 233eaca9bbdSeschrock "\tupgrade -v\n" 234990b4856Slling "\tupgrade [-V version] <-a | pool ...>\n")); 235b1b8ab34Slling case HELP_GET: 236e45ce728Sahrens return (gettext("\tget <\"all\" | property[,...]> " 237b1b8ab34Slling "<pool> ...\n")); 238b1b8ab34Slling case HELP_SET: 239b1b8ab34Slling return (gettext("\tset <property=value> <pool> \n")); 2401195e687SMark J Musante case HELP_SPLIT: 2411195e687SMark J Musante return (gettext("\tsplit [-n] [-R altroot] [-o mntopts]\n" 2421195e687SMark J Musante "\t [-o property=value] <pool> <newpool> " 2431195e687SMark J Musante "[<device> ...]\n")); 24465cd9f28Seschrock } 24565cd9f28Seschrock 24665cd9f28Seschrock abort(); 24765cd9f28Seschrock /* NOTREACHED */ 24865cd9f28Seschrock } 24965cd9f28Seschrock 250fa9e4066Sahrens 251b1b8ab34Slling /* 252b1b8ab34Slling * Callback routine that will print out a pool property value. 253b1b8ab34Slling */ 254990b4856Slling static int 255990b4856Slling print_prop_cb(int prop, void *cb) 256b1b8ab34Slling { 257b1b8ab34Slling FILE *fp = cb; 258b1b8ab34Slling 259b24ab676SJeff Bonwick (void) fprintf(fp, "\t%-15s ", zpool_prop_to_name(prop)); 260b1b8ab34Slling 261990b4856Slling if (zpool_prop_readonly(prop)) 262990b4856Slling (void) fprintf(fp, " NO "); 263990b4856Slling else 264b24ab676SJeff Bonwick (void) fprintf(fp, " YES "); 265990b4856Slling 266b1b8ab34Slling if (zpool_prop_values(prop) == NULL) 267b1b8ab34Slling (void) fprintf(fp, "-\n"); 268b1b8ab34Slling else 269b1b8ab34Slling (void) fprintf(fp, "%s\n", zpool_prop_values(prop)); 270b1b8ab34Slling 271990b4856Slling return (ZPROP_CONT); 272b1b8ab34Slling } 273b1b8ab34Slling 274fa9e4066Sahrens /* 275fa9e4066Sahrens * Display usage message. If we're inside a command, display only the usage for 276fa9e4066Sahrens * that command. Otherwise, iterate over the entire command table and display 277fa9e4066Sahrens * a complete usage message. 278fa9e4066Sahrens */ 279fa9e4066Sahrens void 28099653d4eSeschrock usage(boolean_t requested) 281fa9e4066Sahrens { 282fa9e4066Sahrens FILE *fp = requested ? stdout : stderr; 283fa9e4066Sahrens 284fa9e4066Sahrens if (current_command == NULL) { 285fa9e4066Sahrens int i; 286fa9e4066Sahrens 287fa9e4066Sahrens (void) fprintf(fp, gettext("usage: zpool command args ...\n")); 288fa9e4066Sahrens (void) fprintf(fp, 289fa9e4066Sahrens gettext("where 'command' is one of the following:\n\n")); 290fa9e4066Sahrens 291fa9e4066Sahrens for (i = 0; i < NCOMMAND; i++) { 292fa9e4066Sahrens if (command_table[i].name == NULL) 293fa9e4066Sahrens (void) fprintf(fp, "\n"); 294fa9e4066Sahrens else 295fa9e4066Sahrens (void) fprintf(fp, "%s", 29665cd9f28Seschrock get_usage(command_table[i].usage)); 297fa9e4066Sahrens } 298fa9e4066Sahrens } else { 299fa9e4066Sahrens (void) fprintf(fp, gettext("usage:\n")); 30065cd9f28Seschrock (void) fprintf(fp, "%s", get_usage(current_command->usage)); 301fa9e4066Sahrens } 302fa9e4066Sahrens 303b1b8ab34Slling if (current_command != NULL && 304b1b8ab34Slling ((strcmp(current_command->name, "set") == 0) || 305990b4856Slling (strcmp(current_command->name, "get") == 0) || 306990b4856Slling (strcmp(current_command->name, "list") == 0))) { 307b1b8ab34Slling 308b1b8ab34Slling (void) fprintf(fp, 309b1b8ab34Slling gettext("\nthe following properties are supported:\n")); 310b1b8ab34Slling 311b24ab676SJeff Bonwick (void) fprintf(fp, "\n\t%-15s %s %s\n\n", 312990b4856Slling "PROPERTY", "EDIT", "VALUES"); 313b1b8ab34Slling 314b1b8ab34Slling /* Iterate over all properties */ 315990b4856Slling (void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE, 316990b4856Slling ZFS_TYPE_POOL); 317b1b8ab34Slling } 318b1b8ab34Slling 319e9dbad6fSeschrock /* 320e9dbad6fSeschrock * See comments at end of main(). 321e9dbad6fSeschrock */ 322e9dbad6fSeschrock if (getenv("ZFS_ABORT") != NULL) { 323e9dbad6fSeschrock (void) printf("dumping core by request\n"); 324e9dbad6fSeschrock abort(); 325e9dbad6fSeschrock } 326e9dbad6fSeschrock 327fa9e4066Sahrens exit(requested ? 0 : 2); 328fa9e4066Sahrens } 329fa9e4066Sahrens 330fa9e4066Sahrens void 3318654d025Sperrin print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent, 3328654d025Sperrin boolean_t print_logs) 333fa9e4066Sahrens { 334fa9e4066Sahrens nvlist_t **child; 335fa9e4066Sahrens uint_t c, children; 336afefbcddSeschrock char *vname; 337fa9e4066Sahrens 338fa9e4066Sahrens if (name != NULL) 339fa9e4066Sahrens (void) printf("\t%*s%s\n", indent, "", name); 340fa9e4066Sahrens 341fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 342fa9e4066Sahrens &child, &children) != 0) 343fa9e4066Sahrens return; 344fa9e4066Sahrens 345afefbcddSeschrock for (c = 0; c < children; c++) { 3468654d025Sperrin uint64_t is_log = B_FALSE; 3478654d025Sperrin 3488654d025Sperrin (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 3498654d025Sperrin &is_log); 3508654d025Sperrin if ((is_log && !print_logs) || (!is_log && print_logs)) 3518654d025Sperrin continue; 3528654d025Sperrin 35388ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_FALSE); 3548654d025Sperrin print_vdev_tree(zhp, vname, child[c], indent + 2, 3558654d025Sperrin B_FALSE); 356afefbcddSeschrock free(vname); 357afefbcddSeschrock } 358fa9e4066Sahrens } 359fa9e4066Sahrens 360990b4856Slling /* 361990b4856Slling * Add a property pair (name, string-value) into a property nvlist. 362990b4856Slling */ 363990b4856Slling static int 3640a48a24eStimh add_prop_list(const char *propname, char *propval, nvlist_t **props, 3650a48a24eStimh boolean_t poolprop) 366990b4856Slling { 3670a48a24eStimh zpool_prop_t prop = ZPROP_INVAL; 3680a48a24eStimh zfs_prop_t fprop; 369990b4856Slling nvlist_t *proplist; 3700a48a24eStimh const char *normnm; 3710a48a24eStimh char *strval; 372990b4856Slling 373990b4856Slling if (*props == NULL && 374990b4856Slling nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) { 375990b4856Slling (void) fprintf(stderr, 376990b4856Slling gettext("internal error: out of memory\n")); 377990b4856Slling return (1); 378990b4856Slling } 379990b4856Slling 380990b4856Slling proplist = *props; 381990b4856Slling 3820a48a24eStimh if (poolprop) { 3830a48a24eStimh if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL) { 3840a48a24eStimh (void) fprintf(stderr, gettext("property '%s' is " 3850a48a24eStimh "not a valid pool property\n"), propname); 3860a48a24eStimh return (2); 3870a48a24eStimh } 3880a48a24eStimh normnm = zpool_prop_to_name(prop); 3890a48a24eStimh } else { 39014843421SMatthew Ahrens if ((fprop = zfs_name_to_prop(propname)) != ZPROP_INVAL) { 39114843421SMatthew Ahrens normnm = zfs_prop_to_name(fprop); 39214843421SMatthew Ahrens } else { 39314843421SMatthew Ahrens normnm = propname; 3940a48a24eStimh } 395990b4856Slling } 396990b4856Slling 3970a48a24eStimh if (nvlist_lookup_string(proplist, normnm, &strval) == 0 && 3980a48a24eStimh prop != ZPOOL_PROP_CACHEFILE) { 399990b4856Slling (void) fprintf(stderr, gettext("property '%s' " 400990b4856Slling "specified multiple times\n"), propname); 401990b4856Slling return (2); 402990b4856Slling } 403990b4856Slling 4040a48a24eStimh if (nvlist_add_string(proplist, normnm, propval) != 0) { 405990b4856Slling (void) fprintf(stderr, gettext("internal " 406990b4856Slling "error: out of memory\n")); 407990b4856Slling return (1); 408990b4856Slling } 409990b4856Slling 410990b4856Slling return (0); 411990b4856Slling } 412990b4856Slling 413fa9e4066Sahrens /* 414fa9e4066Sahrens * zpool add [-fn] <pool> <vdev> ... 415fa9e4066Sahrens * 416fa9e4066Sahrens * -f Force addition of devices, even if they appear in use 417fa9e4066Sahrens * -n Do not add the devices, but display the resulting layout if 418fa9e4066Sahrens * they were to be added. 419fa9e4066Sahrens * 420fa9e4066Sahrens * Adds the given vdevs to 'pool'. As with create, the bulk of this work is 421fa9e4066Sahrens * handled by get_vdev_spec(), which constructs the nvlist needed to pass to 422fa9e4066Sahrens * libzfs. 423fa9e4066Sahrens */ 424fa9e4066Sahrens int 425fa9e4066Sahrens zpool_do_add(int argc, char **argv) 426fa9e4066Sahrens { 42799653d4eSeschrock boolean_t force = B_FALSE; 42899653d4eSeschrock boolean_t dryrun = B_FALSE; 429fa9e4066Sahrens int c; 430fa9e4066Sahrens nvlist_t *nvroot; 431fa9e4066Sahrens char *poolname; 432fa9e4066Sahrens int ret; 433fa9e4066Sahrens zpool_handle_t *zhp; 434fa9e4066Sahrens nvlist_t *config; 435fa9e4066Sahrens 436fa9e4066Sahrens /* check options */ 437fa9e4066Sahrens while ((c = getopt(argc, argv, "fn")) != -1) { 438fa9e4066Sahrens switch (c) { 439fa9e4066Sahrens case 'f': 44099653d4eSeschrock force = B_TRUE; 441fa9e4066Sahrens break; 442fa9e4066Sahrens case 'n': 44399653d4eSeschrock dryrun = B_TRUE; 444fa9e4066Sahrens break; 445fa9e4066Sahrens case '?': 446fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 447fa9e4066Sahrens optopt); 44899653d4eSeschrock usage(B_FALSE); 449fa9e4066Sahrens } 450fa9e4066Sahrens } 451fa9e4066Sahrens 452fa9e4066Sahrens argc -= optind; 453fa9e4066Sahrens argv += optind; 454fa9e4066Sahrens 455fa9e4066Sahrens /* get pool name and check number of arguments */ 456fa9e4066Sahrens if (argc < 1) { 457fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 45899653d4eSeschrock usage(B_FALSE); 459fa9e4066Sahrens } 460fa9e4066Sahrens if (argc < 2) { 461fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 46299653d4eSeschrock usage(B_FALSE); 463fa9e4066Sahrens } 464fa9e4066Sahrens 465fa9e4066Sahrens poolname = argv[0]; 466fa9e4066Sahrens 467fa9e4066Sahrens argc--; 468fa9e4066Sahrens argv++; 469fa9e4066Sahrens 47099653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 471fa9e4066Sahrens return (1); 472fa9e4066Sahrens 473088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) == NULL) { 474fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 475fa9e4066Sahrens poolname); 476fa9e4066Sahrens zpool_close(zhp); 477fa9e4066Sahrens return (1); 478fa9e4066Sahrens } 479fa9e4066Sahrens 480fa9e4066Sahrens /* pass off to get_vdev_spec for processing */ 481705040edSEric Taylor nvroot = make_root_vdev(zhp, force, !force, B_FALSE, dryrun, 482705040edSEric Taylor argc, argv); 483fa9e4066Sahrens if (nvroot == NULL) { 484fa9e4066Sahrens zpool_close(zhp); 485fa9e4066Sahrens return (1); 486fa9e4066Sahrens } 487fa9e4066Sahrens 488fa9e4066Sahrens if (dryrun) { 489fa9e4066Sahrens nvlist_t *poolnvroot; 490fa9e4066Sahrens 491fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 492fa9e4066Sahrens &poolnvroot) == 0); 493fa9e4066Sahrens 494fa9e4066Sahrens (void) printf(gettext("would update '%s' to the following " 495fa9e4066Sahrens "configuration:\n"), zpool_get_name(zhp)); 496fa9e4066Sahrens 4978654d025Sperrin /* print original main pool and new tree */ 4988654d025Sperrin print_vdev_tree(zhp, poolname, poolnvroot, 0, B_FALSE); 4998654d025Sperrin print_vdev_tree(zhp, NULL, nvroot, 0, B_FALSE); 5008654d025Sperrin 5018654d025Sperrin /* Do the same for the logs */ 5028654d025Sperrin if (num_logs(poolnvroot) > 0) { 5038654d025Sperrin print_vdev_tree(zhp, "logs", poolnvroot, 0, B_TRUE); 5048654d025Sperrin print_vdev_tree(zhp, NULL, nvroot, 0, B_TRUE); 5058654d025Sperrin } else if (num_logs(nvroot) > 0) { 5068654d025Sperrin print_vdev_tree(zhp, "logs", nvroot, 0, B_TRUE); 5078654d025Sperrin } 508fa9e4066Sahrens 509fa9e4066Sahrens ret = 0; 510fa9e4066Sahrens } else { 511fa9e4066Sahrens ret = (zpool_add(zhp, nvroot) != 0); 512fa9e4066Sahrens } 513fa9e4066Sahrens 51499653d4eSeschrock nvlist_free(nvroot); 51599653d4eSeschrock zpool_close(zhp); 51699653d4eSeschrock 51799653d4eSeschrock return (ret); 51899653d4eSeschrock } 51999653d4eSeschrock 52099653d4eSeschrock /* 521*3f9d6ad7SLin Ling * zpool remove <pool> <vdev> ... 52299653d4eSeschrock * 523*3f9d6ad7SLin Ling * Removes the given vdev from the pool. Currently, this supports removing 524*3f9d6ad7SLin Ling * spares, cache, and log devices from the pool. 52599653d4eSeschrock */ 52699653d4eSeschrock int 52799653d4eSeschrock zpool_do_remove(int argc, char **argv) 52899653d4eSeschrock { 52999653d4eSeschrock char *poolname; 530fa94a07fSbrendan int i, ret = 0; 53199653d4eSeschrock zpool_handle_t *zhp; 53299653d4eSeschrock 53399653d4eSeschrock argc--; 53499653d4eSeschrock argv++; 53599653d4eSeschrock 53699653d4eSeschrock /* get pool name and check number of arguments */ 53799653d4eSeschrock if (argc < 1) { 53899653d4eSeschrock (void) fprintf(stderr, gettext("missing pool name argument\n")); 53999653d4eSeschrock usage(B_FALSE); 54099653d4eSeschrock } 54199653d4eSeschrock if (argc < 2) { 54299653d4eSeschrock (void) fprintf(stderr, gettext("missing device\n")); 54399653d4eSeschrock usage(B_FALSE); 54499653d4eSeschrock } 54599653d4eSeschrock 54699653d4eSeschrock poolname = argv[0]; 54799653d4eSeschrock 54899653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 54999653d4eSeschrock return (1); 55099653d4eSeschrock 551fa94a07fSbrendan for (i = 1; i < argc; i++) { 552fa94a07fSbrendan if (zpool_vdev_remove(zhp, argv[i]) != 0) 553fa94a07fSbrendan ret = 1; 554fa94a07fSbrendan } 55599653d4eSeschrock 556fa9e4066Sahrens return (ret); 557fa9e4066Sahrens } 558fa9e4066Sahrens 559fa9e4066Sahrens /* 5600a48a24eStimh * zpool create [-fn] [-o property=value] ... 5610a48a24eStimh * [-O file-system-property=value] ... 5620a48a24eStimh * [-R root] [-m mountpoint] <pool> <dev> ... 563fa9e4066Sahrens * 564fa9e4066Sahrens * -f Force creation, even if devices appear in use 565fa9e4066Sahrens * -n Do not create the pool, but display the resulting layout if it 566fa9e4066Sahrens * were to be created. 567fa9e4066Sahrens * -R Create a pool under an alternate root 568fa9e4066Sahrens * -m Set default mountpoint for the root dataset. By default it's 569fa9e4066Sahrens * '/<pool>' 570990b4856Slling * -o Set property=value. 5710a48a24eStimh * -O Set fsproperty=value in the pool's root file system 572fa9e4066Sahrens * 573b1b8ab34Slling * Creates the named pool according to the given vdev specification. The 574fa9e4066Sahrens * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once 575fa9e4066Sahrens * we get the nvlist back from get_vdev_spec(), we either print out the contents 576fa9e4066Sahrens * (if '-n' was specified), or pass it to libzfs to do the creation. 577fa9e4066Sahrens */ 578fa9e4066Sahrens int 579fa9e4066Sahrens zpool_do_create(int argc, char **argv) 580fa9e4066Sahrens { 58199653d4eSeschrock boolean_t force = B_FALSE; 58299653d4eSeschrock boolean_t dryrun = B_FALSE; 583fa9e4066Sahrens int c; 584990b4856Slling nvlist_t *nvroot = NULL; 585fa9e4066Sahrens char *poolname; 586990b4856Slling int ret = 1; 587fa9e4066Sahrens char *altroot = NULL; 588fa9e4066Sahrens char *mountpoint = NULL; 5890a48a24eStimh nvlist_t *fsprops = NULL; 590990b4856Slling nvlist_t *props = NULL; 5912f8aaab3Seschrock char *propval; 592fa9e4066Sahrens 593fa9e4066Sahrens /* check options */ 5940a48a24eStimh while ((c = getopt(argc, argv, ":fnR:m:o:O:")) != -1) { 595fa9e4066Sahrens switch (c) { 596fa9e4066Sahrens case 'f': 59799653d4eSeschrock force = B_TRUE; 598fa9e4066Sahrens break; 599fa9e4066Sahrens case 'n': 60099653d4eSeschrock dryrun = B_TRUE; 601fa9e4066Sahrens break; 602fa9e4066Sahrens case 'R': 603fa9e4066Sahrens altroot = optarg; 604990b4856Slling if (add_prop_list(zpool_prop_to_name( 6050a48a24eStimh ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 606990b4856Slling goto errout; 6072f8aaab3Seschrock if (nvlist_lookup_string(props, 6082f8aaab3Seschrock zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 6092f8aaab3Seschrock &propval) == 0) 6102f8aaab3Seschrock break; 611990b4856Slling if (add_prop_list(zpool_prop_to_name( 6120a48a24eStimh ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE)) 613990b4856Slling goto errout; 614fa9e4066Sahrens break; 615fa9e4066Sahrens case 'm': 616fa9e4066Sahrens mountpoint = optarg; 617fa9e4066Sahrens break; 618990b4856Slling case 'o': 619990b4856Slling if ((propval = strchr(optarg, '=')) == NULL) { 620990b4856Slling (void) fprintf(stderr, gettext("missing " 621990b4856Slling "'=' for -o option\n")); 622990b4856Slling goto errout; 623990b4856Slling } 624990b4856Slling *propval = '\0'; 625990b4856Slling propval++; 626990b4856Slling 6270a48a24eStimh if (add_prop_list(optarg, propval, &props, B_TRUE)) 6280a48a24eStimh goto errout; 6290a48a24eStimh break; 6300a48a24eStimh case 'O': 6310a48a24eStimh if ((propval = strchr(optarg, '=')) == NULL) { 6320a48a24eStimh (void) fprintf(stderr, gettext("missing " 6330a48a24eStimh "'=' for -O option\n")); 6340a48a24eStimh goto errout; 6350a48a24eStimh } 6360a48a24eStimh *propval = '\0'; 6370a48a24eStimh propval++; 6380a48a24eStimh 6390a48a24eStimh if (add_prop_list(optarg, propval, &fsprops, B_FALSE)) 640990b4856Slling goto errout; 641990b4856Slling break; 642fa9e4066Sahrens case ':': 643fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 644fa9e4066Sahrens "'%c' option\n"), optopt); 645990b4856Slling goto badusage; 646fa9e4066Sahrens case '?': 647fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 648fa9e4066Sahrens optopt); 649990b4856Slling goto badusage; 650fa9e4066Sahrens } 651fa9e4066Sahrens } 652fa9e4066Sahrens 653fa9e4066Sahrens argc -= optind; 654fa9e4066Sahrens argv += optind; 655fa9e4066Sahrens 656fa9e4066Sahrens /* get pool name and check number of arguments */ 657fa9e4066Sahrens if (argc < 1) { 658fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 659990b4856Slling goto badusage; 660fa9e4066Sahrens } 661fa9e4066Sahrens if (argc < 2) { 662fa9e4066Sahrens (void) fprintf(stderr, gettext("missing vdev specification\n")); 663990b4856Slling goto badusage; 664fa9e4066Sahrens } 665fa9e4066Sahrens 666fa9e4066Sahrens poolname = argv[0]; 667fa9e4066Sahrens 668fa9e4066Sahrens /* 669fa9e4066Sahrens * As a special case, check for use of '/' in the name, and direct the 670fa9e4066Sahrens * user to use 'zfs create' instead. 671fa9e4066Sahrens */ 672fa9e4066Sahrens if (strchr(poolname, '/') != NULL) { 673fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot create '%s': invalid " 674fa9e4066Sahrens "character '/' in pool name\n"), poolname); 675fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs create' to " 676fa9e4066Sahrens "create a dataset\n")); 677990b4856Slling goto errout; 678fa9e4066Sahrens } 679fa9e4066Sahrens 680fa9e4066Sahrens /* pass off to get_vdev_spec for bulk processing */ 681705040edSEric Taylor nvroot = make_root_vdev(NULL, force, !force, B_FALSE, dryrun, 682705040edSEric Taylor argc - 1, argv + 1); 683fa9e4066Sahrens if (nvroot == NULL) 6840a48a24eStimh goto errout; 685fa9e4066Sahrens 68699653d4eSeschrock /* make_root_vdev() allows 0 toplevel children if there are spares */ 687b7b97454Sperrin if (!zfs_allocatable_devs(nvroot)) { 68899653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev " 68999653d4eSeschrock "specification: at least one toplevel vdev must be " 69099653d4eSeschrock "specified\n")); 691990b4856Slling goto errout; 69299653d4eSeschrock } 69399653d4eSeschrock 69499653d4eSeschrock 695fa9e4066Sahrens if (altroot != NULL && altroot[0] != '/') { 696fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid alternate root '%s': " 697e9dbad6fSeschrock "must be an absolute path\n"), altroot); 698990b4856Slling goto errout; 699fa9e4066Sahrens } 700fa9e4066Sahrens 701fa9e4066Sahrens /* 702fa9e4066Sahrens * Check the validity of the mountpoint and direct the user to use the 703fa9e4066Sahrens * '-m' mountpoint option if it looks like its in use. 704fa9e4066Sahrens */ 705fa9e4066Sahrens if (mountpoint == NULL || 706fa9e4066Sahrens (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 && 707fa9e4066Sahrens strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) { 708fa9e4066Sahrens char buf[MAXPATHLEN]; 70911022c7cStimh DIR *dirp; 710fa9e4066Sahrens 711fa9e4066Sahrens if (mountpoint && mountpoint[0] != '/') { 712fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid mountpoint " 713fa9e4066Sahrens "'%s': must be an absolute path, 'legacy', or " 714fa9e4066Sahrens "'none'\n"), mountpoint); 715990b4856Slling goto errout; 716fa9e4066Sahrens } 717fa9e4066Sahrens 718fa9e4066Sahrens if (mountpoint == NULL) { 719fa9e4066Sahrens if (altroot != NULL) 720fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s/%s", 721fa9e4066Sahrens altroot, poolname); 722fa9e4066Sahrens else 723fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "/%s", 724fa9e4066Sahrens poolname); 725fa9e4066Sahrens } else { 726fa9e4066Sahrens if (altroot != NULL) 727fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s%s", 728fa9e4066Sahrens altroot, mountpoint); 729fa9e4066Sahrens else 730fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%s", 731fa9e4066Sahrens mountpoint); 732fa9e4066Sahrens } 733fa9e4066Sahrens 73411022c7cStimh if ((dirp = opendir(buf)) == NULL && errno != ENOENT) { 73511022c7cStimh (void) fprintf(stderr, gettext("mountpoint '%s' : " 73611022c7cStimh "%s\n"), buf, strerror(errno)); 737fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-m' " 738fa9e4066Sahrens "option to provide a different default\n")); 739990b4856Slling goto errout; 74011022c7cStimh } else if (dirp) { 74111022c7cStimh int count = 0; 74211022c7cStimh 74311022c7cStimh while (count < 3 && readdir(dirp) != NULL) 74411022c7cStimh count++; 74511022c7cStimh (void) closedir(dirp); 74611022c7cStimh 74711022c7cStimh if (count > 2) { 74811022c7cStimh (void) fprintf(stderr, gettext("mountpoint " 74911022c7cStimh "'%s' exists and is not empty\n"), buf); 75011022c7cStimh (void) fprintf(stderr, gettext("use '-m' " 75111022c7cStimh "option to provide a " 75211022c7cStimh "different default\n")); 75311022c7cStimh goto errout; 75411022c7cStimh } 755fa9e4066Sahrens } 756fa9e4066Sahrens } 757fa9e4066Sahrens 758fa9e4066Sahrens if (dryrun) { 759fa9e4066Sahrens /* 760fa9e4066Sahrens * For a dry run invocation, print out a basic message and run 761fa9e4066Sahrens * through all the vdevs in the list and print out in an 762fa9e4066Sahrens * appropriate hierarchy. 763fa9e4066Sahrens */ 764fa9e4066Sahrens (void) printf(gettext("would create '%s' with the " 765fa9e4066Sahrens "following layout:\n\n"), poolname); 766fa9e4066Sahrens 7678654d025Sperrin print_vdev_tree(NULL, poolname, nvroot, 0, B_FALSE); 7688654d025Sperrin if (num_logs(nvroot) > 0) 7698654d025Sperrin print_vdev_tree(NULL, "logs", nvroot, 0, B_TRUE); 770fa9e4066Sahrens 771fa9e4066Sahrens ret = 0; 772fa9e4066Sahrens } else { 773fa9e4066Sahrens /* 774fa9e4066Sahrens * Hand off to libzfs. 775fa9e4066Sahrens */ 7760a48a24eStimh if (zpool_create(g_zfs, poolname, 7770a48a24eStimh nvroot, props, fsprops) == 0) { 77899653d4eSeschrock zfs_handle_t *pool = zfs_open(g_zfs, poolname, 779fa9e4066Sahrens ZFS_TYPE_FILESYSTEM); 780fa9e4066Sahrens if (pool != NULL) { 781fa9e4066Sahrens if (mountpoint != NULL) 782fa9e4066Sahrens verify(zfs_prop_set(pool, 783e9dbad6fSeschrock zfs_prop_to_name( 784e9dbad6fSeschrock ZFS_PROP_MOUNTPOINT), 785fa9e4066Sahrens mountpoint) == 0); 786fa9e4066Sahrens if (zfs_mount(pool, NULL, 0) == 0) 787da6c28aaSamw ret = zfs_shareall(pool); 788fa9e4066Sahrens zfs_close(pool); 789fa9e4066Sahrens } 79099653d4eSeschrock } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) { 79199653d4eSeschrock (void) fprintf(stderr, gettext("pool name may have " 79299653d4eSeschrock "been omitted\n")); 793fa9e4066Sahrens } 794fa9e4066Sahrens } 795fa9e4066Sahrens 796990b4856Slling errout: 7972f8aaab3Seschrock nvlist_free(nvroot); 7980a48a24eStimh nvlist_free(fsprops); 7992f8aaab3Seschrock nvlist_free(props); 800fa9e4066Sahrens return (ret); 801990b4856Slling badusage: 8020a48a24eStimh nvlist_free(fsprops); 803990b4856Slling nvlist_free(props); 804990b4856Slling usage(B_FALSE); 805990b4856Slling return (2); 806fa9e4066Sahrens } 807fa9e4066Sahrens 808fa9e4066Sahrens /* 809fa9e4066Sahrens * zpool destroy <pool> 810fa9e4066Sahrens * 811fa9e4066Sahrens * -f Forcefully unmount any datasets 812fa9e4066Sahrens * 813fa9e4066Sahrens * Destroy the given pool. Automatically unmounts any datasets in the pool. 814fa9e4066Sahrens */ 815fa9e4066Sahrens int 816fa9e4066Sahrens zpool_do_destroy(int argc, char **argv) 817fa9e4066Sahrens { 81899653d4eSeschrock boolean_t force = B_FALSE; 819fa9e4066Sahrens int c; 820fa9e4066Sahrens char *pool; 821fa9e4066Sahrens zpool_handle_t *zhp; 822fa9e4066Sahrens int ret; 823fa9e4066Sahrens 824fa9e4066Sahrens /* check options */ 825fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 826fa9e4066Sahrens switch (c) { 827fa9e4066Sahrens case 'f': 82899653d4eSeschrock force = B_TRUE; 829fa9e4066Sahrens break; 830fa9e4066Sahrens case '?': 831fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 832fa9e4066Sahrens optopt); 83399653d4eSeschrock usage(B_FALSE); 834fa9e4066Sahrens } 835fa9e4066Sahrens } 836fa9e4066Sahrens 837fa9e4066Sahrens argc -= optind; 838fa9e4066Sahrens argv += optind; 839fa9e4066Sahrens 840fa9e4066Sahrens /* check arguments */ 841fa9e4066Sahrens if (argc < 1) { 842fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 84399653d4eSeschrock usage(B_FALSE); 844fa9e4066Sahrens } 845fa9e4066Sahrens if (argc > 1) { 846fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 84799653d4eSeschrock usage(B_FALSE); 848fa9e4066Sahrens } 849fa9e4066Sahrens 850fa9e4066Sahrens pool = argv[0]; 851fa9e4066Sahrens 85299653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 853fa9e4066Sahrens /* 854fa9e4066Sahrens * As a special case, check for use of '/' in the name, and 855fa9e4066Sahrens * direct the user to use 'zfs destroy' instead. 856fa9e4066Sahrens */ 857fa9e4066Sahrens if (strchr(pool, '/') != NULL) 858fa9e4066Sahrens (void) fprintf(stderr, gettext("use 'zfs destroy' to " 859fa9e4066Sahrens "destroy a dataset\n")); 860fa9e4066Sahrens return (1); 861fa9e4066Sahrens } 862fa9e4066Sahrens 863f3861e1aSahl if (zpool_disable_datasets(zhp, force) != 0) { 864fa9e4066Sahrens (void) fprintf(stderr, gettext("could not destroy '%s': " 865fa9e4066Sahrens "could not unmount datasets\n"), zpool_get_name(zhp)); 866fa9e4066Sahrens return (1); 867fa9e4066Sahrens } 868fa9e4066Sahrens 869fa9e4066Sahrens ret = (zpool_destroy(zhp) != 0); 870fa9e4066Sahrens 871fa9e4066Sahrens zpool_close(zhp); 872fa9e4066Sahrens 873fa9e4066Sahrens return (ret); 874fa9e4066Sahrens } 875fa9e4066Sahrens 876fa9e4066Sahrens /* 877fa9e4066Sahrens * zpool export [-f] <pool> ... 878fa9e4066Sahrens * 879fa9e4066Sahrens * -f Forcefully unmount datasets 880fa9e4066Sahrens * 881b1b8ab34Slling * Export the given pools. By default, the command will attempt to cleanly 882fa9e4066Sahrens * unmount any active datasets within the pool. If the '-f' flag is specified, 883fa9e4066Sahrens * then the datasets will be forcefully unmounted. 884fa9e4066Sahrens */ 885fa9e4066Sahrens int 886fa9e4066Sahrens zpool_do_export(int argc, char **argv) 887fa9e4066Sahrens { 88899653d4eSeschrock boolean_t force = B_FALSE; 889394ab0cbSGeorge Wilson boolean_t hardforce = B_FALSE; 890fa9e4066Sahrens int c; 891fa9e4066Sahrens zpool_handle_t *zhp; 892fa9e4066Sahrens int ret; 893fa9e4066Sahrens int i; 894fa9e4066Sahrens 895fa9e4066Sahrens /* check options */ 896394ab0cbSGeorge Wilson while ((c = getopt(argc, argv, "fF")) != -1) { 897fa9e4066Sahrens switch (c) { 898fa9e4066Sahrens case 'f': 89999653d4eSeschrock force = B_TRUE; 900fa9e4066Sahrens break; 901394ab0cbSGeorge Wilson case 'F': 902394ab0cbSGeorge Wilson hardforce = B_TRUE; 903394ab0cbSGeorge Wilson break; 904fa9e4066Sahrens case '?': 905fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 906fa9e4066Sahrens optopt); 90799653d4eSeschrock usage(B_FALSE); 908fa9e4066Sahrens } 909fa9e4066Sahrens } 910fa9e4066Sahrens 911fa9e4066Sahrens argc -= optind; 912fa9e4066Sahrens argv += optind; 913fa9e4066Sahrens 914fa9e4066Sahrens /* check arguments */ 915fa9e4066Sahrens if (argc < 1) { 916fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool argument\n")); 91799653d4eSeschrock usage(B_FALSE); 918fa9e4066Sahrens } 919fa9e4066Sahrens 920fa9e4066Sahrens ret = 0; 921fa9e4066Sahrens for (i = 0; i < argc; i++) { 92299653d4eSeschrock if ((zhp = zpool_open_canfail(g_zfs, argv[i])) == NULL) { 923fa9e4066Sahrens ret = 1; 924fa9e4066Sahrens continue; 925fa9e4066Sahrens } 926fa9e4066Sahrens 927f3861e1aSahl if (zpool_disable_datasets(zhp, force) != 0) { 928fa9e4066Sahrens ret = 1; 929fa9e4066Sahrens zpool_close(zhp); 930fa9e4066Sahrens continue; 931fa9e4066Sahrens } 932fa9e4066Sahrens 933394ab0cbSGeorge Wilson if (hardforce) { 934394ab0cbSGeorge Wilson if (zpool_export_force(zhp) != 0) 935394ab0cbSGeorge Wilson ret = 1; 936394ab0cbSGeorge Wilson } else if (zpool_export(zhp, force) != 0) { 937fa9e4066Sahrens ret = 1; 938394ab0cbSGeorge Wilson } 939fa9e4066Sahrens 940fa9e4066Sahrens zpool_close(zhp); 941fa9e4066Sahrens } 942fa9e4066Sahrens 943fa9e4066Sahrens return (ret); 944fa9e4066Sahrens } 945fa9e4066Sahrens 946fa9e4066Sahrens /* 947fa9e4066Sahrens * Given a vdev configuration, determine the maximum width needed for the device 948fa9e4066Sahrens * name column. 949fa9e4066Sahrens */ 950fa9e4066Sahrens static int 951c67d9675Seschrock max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max) 952fa9e4066Sahrens { 95388ecc943SGeorge Wilson char *name = zpool_vdev_name(g_zfs, zhp, nv, B_TRUE); 954fa9e4066Sahrens nvlist_t **child; 955fa9e4066Sahrens uint_t c, children; 956fa9e4066Sahrens int ret; 957fa9e4066Sahrens 958fa9e4066Sahrens if (strlen(name) + depth > max) 959fa9e4066Sahrens max = strlen(name) + depth; 960fa9e4066Sahrens 961afefbcddSeschrock free(name); 962afefbcddSeschrock 96399653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 96499653d4eSeschrock &child, &children) == 0) { 96599653d4eSeschrock for (c = 0; c < children; c++) 96699653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 96799653d4eSeschrock max)) > max) 96899653d4eSeschrock max = ret; 96999653d4eSeschrock } 97099653d4eSeschrock 971fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 972fa94a07fSbrendan &child, &children) == 0) { 973fa94a07fSbrendan for (c = 0; c < children; c++) 974fa94a07fSbrendan if ((ret = max_width(zhp, child[c], depth + 2, 975fa94a07fSbrendan max)) > max) 976fa94a07fSbrendan max = ret; 977fa94a07fSbrendan } 978fa94a07fSbrendan 979fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 98099653d4eSeschrock &child, &children) == 0) { 98199653d4eSeschrock for (c = 0; c < children; c++) 98299653d4eSeschrock if ((ret = max_width(zhp, child[c], depth + 2, 98399653d4eSeschrock max)) > max) 98499653d4eSeschrock max = ret; 98599653d4eSeschrock } 986fa9e4066Sahrens 987fa9e4066Sahrens 988fa9e4066Sahrens return (max); 989fa9e4066Sahrens } 990fa9e4066Sahrens 991e6ca193dSGeorge Wilson typedef struct spare_cbdata { 992e6ca193dSGeorge Wilson uint64_t cb_guid; 993e6ca193dSGeorge Wilson zpool_handle_t *cb_zhp; 994e6ca193dSGeorge Wilson } spare_cbdata_t; 995e6ca193dSGeorge Wilson 996e6ca193dSGeorge Wilson static boolean_t 997e6ca193dSGeorge Wilson find_vdev(nvlist_t *nv, uint64_t search) 998e6ca193dSGeorge Wilson { 999e6ca193dSGeorge Wilson uint64_t guid; 1000e6ca193dSGeorge Wilson nvlist_t **child; 1001e6ca193dSGeorge Wilson uint_t c, children; 1002e6ca193dSGeorge Wilson 1003e6ca193dSGeorge Wilson if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 && 1004e6ca193dSGeorge Wilson search == guid) 1005e6ca193dSGeorge Wilson return (B_TRUE); 1006e6ca193dSGeorge Wilson 1007e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1008e6ca193dSGeorge Wilson &child, &children) == 0) { 1009e6ca193dSGeorge Wilson for (c = 0; c < children; c++) 1010e6ca193dSGeorge Wilson if (find_vdev(child[c], search)) 1011e6ca193dSGeorge Wilson return (B_TRUE); 1012e6ca193dSGeorge Wilson } 1013e6ca193dSGeorge Wilson 1014e6ca193dSGeorge Wilson return (B_FALSE); 1015e6ca193dSGeorge Wilson } 1016e6ca193dSGeorge Wilson 1017e6ca193dSGeorge Wilson static int 1018e6ca193dSGeorge Wilson find_spare(zpool_handle_t *zhp, void *data) 1019e6ca193dSGeorge Wilson { 1020e6ca193dSGeorge Wilson spare_cbdata_t *cbp = data; 1021e6ca193dSGeorge Wilson nvlist_t *config, *nvroot; 1022e6ca193dSGeorge Wilson 1023e6ca193dSGeorge Wilson config = zpool_get_config(zhp, NULL); 1024e6ca193dSGeorge Wilson verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1025e6ca193dSGeorge Wilson &nvroot) == 0); 1026e6ca193dSGeorge Wilson 1027e6ca193dSGeorge Wilson if (find_vdev(nvroot, cbp->cb_guid)) { 1028e6ca193dSGeorge Wilson cbp->cb_zhp = zhp; 1029e6ca193dSGeorge Wilson return (1); 1030e6ca193dSGeorge Wilson } 1031e6ca193dSGeorge Wilson 1032e6ca193dSGeorge Wilson zpool_close(zhp); 1033e6ca193dSGeorge Wilson return (0); 1034e6ca193dSGeorge Wilson } 1035e6ca193dSGeorge Wilson 1036e6ca193dSGeorge Wilson /* 1037e6ca193dSGeorge Wilson * Print out configuration state as requested by status_callback. 1038e6ca193dSGeorge Wilson */ 1039e6ca193dSGeorge Wilson void 1040e6ca193dSGeorge Wilson print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 1041e6ca193dSGeorge Wilson int namewidth, int depth, boolean_t isspare) 1042e6ca193dSGeorge Wilson { 1043e6ca193dSGeorge Wilson nvlist_t **child; 1044e6ca193dSGeorge Wilson uint_t c, children; 1045*3f9d6ad7SLin Ling pool_scan_stat_t *ps = NULL; 1046e6ca193dSGeorge Wilson vdev_stat_t *vs; 1047*3f9d6ad7SLin Ling char rbuf[6], wbuf[6], cbuf[6]; 1048e6ca193dSGeorge Wilson char *vname; 1049e6ca193dSGeorge Wilson uint64_t notpresent; 1050e6ca193dSGeorge Wilson spare_cbdata_t cb; 1051e6ca193dSGeorge Wilson char *state; 1052e6ca193dSGeorge Wilson 1053e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1054e6ca193dSGeorge Wilson &child, &children) != 0) 1055e6ca193dSGeorge Wilson children = 0; 1056e6ca193dSGeorge Wilson 1057*3f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 1058*3f9d6ad7SLin Ling (uint64_t **)&vs, &c) == 0); 1059*3f9d6ad7SLin Ling 1060e6ca193dSGeorge Wilson state = zpool_state_to_name(vs->vs_state, vs->vs_aux); 1061e6ca193dSGeorge Wilson if (isspare) { 1062e6ca193dSGeorge Wilson /* 1063e6ca193dSGeorge Wilson * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for 1064e6ca193dSGeorge Wilson * online drives. 1065e6ca193dSGeorge Wilson */ 1066e6ca193dSGeorge Wilson if (vs->vs_aux == VDEV_AUX_SPARED) 1067e6ca193dSGeorge Wilson state = "INUSE"; 1068e6ca193dSGeorge Wilson else if (vs->vs_state == VDEV_STATE_HEALTHY) 1069e6ca193dSGeorge Wilson state = "AVAIL"; 1070e6ca193dSGeorge Wilson } 1071e6ca193dSGeorge Wilson 1072e6ca193dSGeorge Wilson (void) printf("\t%*s%-*s %-8s", depth, "", namewidth - depth, 1073e6ca193dSGeorge Wilson name, state); 1074e6ca193dSGeorge Wilson 1075e6ca193dSGeorge Wilson if (!isspare) { 1076e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf)); 1077e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf)); 1078e6ca193dSGeorge Wilson zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf)); 1079e6ca193dSGeorge Wilson (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf); 1080e6ca193dSGeorge Wilson } 1081e6ca193dSGeorge Wilson 1082e6ca193dSGeorge Wilson if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1083e6ca193dSGeorge Wilson ¬present) == 0) { 1084e6ca193dSGeorge Wilson char *path; 1085e6ca193dSGeorge Wilson verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1086e6ca193dSGeorge Wilson (void) printf(" was %s", path); 1087e6ca193dSGeorge Wilson } else if (vs->vs_aux != 0) { 1088e6ca193dSGeorge Wilson (void) printf(" "); 1089e6ca193dSGeorge Wilson 1090e6ca193dSGeorge Wilson switch (vs->vs_aux) { 1091e6ca193dSGeorge Wilson case VDEV_AUX_OPEN_FAILED: 1092e6ca193dSGeorge Wilson (void) printf(gettext("cannot open")); 1093e6ca193dSGeorge Wilson break; 1094e6ca193dSGeorge Wilson 1095e6ca193dSGeorge Wilson case VDEV_AUX_BAD_GUID_SUM: 1096e6ca193dSGeorge Wilson (void) printf(gettext("missing device")); 1097e6ca193dSGeorge Wilson break; 1098e6ca193dSGeorge Wilson 1099e6ca193dSGeorge Wilson case VDEV_AUX_NO_REPLICAS: 1100e6ca193dSGeorge Wilson (void) printf(gettext("insufficient replicas")); 1101e6ca193dSGeorge Wilson break; 1102e6ca193dSGeorge Wilson 1103e6ca193dSGeorge Wilson case VDEV_AUX_VERSION_NEWER: 1104e6ca193dSGeorge Wilson (void) printf(gettext("newer version")); 1105e6ca193dSGeorge Wilson break; 1106e6ca193dSGeorge Wilson 1107e6ca193dSGeorge Wilson case VDEV_AUX_SPARED: 1108e6ca193dSGeorge Wilson verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, 1109e6ca193dSGeorge Wilson &cb.cb_guid) == 0); 1110e6ca193dSGeorge Wilson if (zpool_iter(g_zfs, find_spare, &cb) == 1) { 1111e6ca193dSGeorge Wilson if (strcmp(zpool_get_name(cb.cb_zhp), 1112e6ca193dSGeorge Wilson zpool_get_name(zhp)) == 0) 1113e6ca193dSGeorge Wilson (void) printf(gettext("currently in " 1114e6ca193dSGeorge Wilson "use")); 1115e6ca193dSGeorge Wilson else 1116e6ca193dSGeorge Wilson (void) printf(gettext("in use by " 1117e6ca193dSGeorge Wilson "pool '%s'"), 1118e6ca193dSGeorge Wilson zpool_get_name(cb.cb_zhp)); 1119e6ca193dSGeorge Wilson zpool_close(cb.cb_zhp); 1120e6ca193dSGeorge Wilson } else { 1121e6ca193dSGeorge Wilson (void) printf(gettext("currently in use")); 1122e6ca193dSGeorge Wilson } 1123e6ca193dSGeorge Wilson break; 1124e6ca193dSGeorge Wilson 1125e6ca193dSGeorge Wilson case VDEV_AUX_ERR_EXCEEDED: 1126e6ca193dSGeorge Wilson (void) printf(gettext("too many errors")); 1127e6ca193dSGeorge Wilson break; 1128e6ca193dSGeorge Wilson 1129e6ca193dSGeorge Wilson case VDEV_AUX_IO_FAILURE: 1130e6ca193dSGeorge Wilson (void) printf(gettext("experienced I/O failures")); 1131e6ca193dSGeorge Wilson break; 1132e6ca193dSGeorge Wilson 1133e6ca193dSGeorge Wilson case VDEV_AUX_BAD_LOG: 1134e6ca193dSGeorge Wilson (void) printf(gettext("bad intent log")); 1135e6ca193dSGeorge Wilson break; 1136e6ca193dSGeorge Wilson 1137069f55e2SEric Schrock case VDEV_AUX_EXTERNAL: 1138069f55e2SEric Schrock (void) printf(gettext("external device fault")); 1139069f55e2SEric Schrock break; 1140069f55e2SEric Schrock 11411195e687SMark J Musante case VDEV_AUX_SPLIT_POOL: 11421195e687SMark J Musante (void) printf(gettext("split into new pool")); 11431195e687SMark J Musante break; 11441195e687SMark J Musante 1145e6ca193dSGeorge Wilson default: 1146e6ca193dSGeorge Wilson (void) printf(gettext("corrupted data")); 1147e6ca193dSGeorge Wilson break; 1148e6ca193dSGeorge Wilson } 1149*3f9d6ad7SLin Ling } 1150*3f9d6ad7SLin Ling 1151*3f9d6ad7SLin Ling (void) nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_SCAN_STATS, 1152*3f9d6ad7SLin Ling (uint64_t **)&ps, &c); 1153*3f9d6ad7SLin Ling 1154*3f9d6ad7SLin Ling if (ps && ps->pss_state == DSS_SCANNING && 1155*3f9d6ad7SLin Ling vs->vs_scan_processed != 0 && children == 0) { 1156*3f9d6ad7SLin Ling (void) printf(gettext(" (%s)"), 1157*3f9d6ad7SLin Ling (ps->pss_func == POOL_SCAN_RESILVER) ? 1158*3f9d6ad7SLin Ling "resilvering" : "repairing"); 1159e6ca193dSGeorge Wilson } 1160e6ca193dSGeorge Wilson 1161e6ca193dSGeorge Wilson (void) printf("\n"); 1162e6ca193dSGeorge Wilson 1163e6ca193dSGeorge Wilson for (c = 0; c < children; c++) { 116488ecc943SGeorge Wilson uint64_t islog = B_FALSE, ishole = B_FALSE; 1165e6ca193dSGeorge Wilson 116688ecc943SGeorge Wilson /* Don't print logs or holes here */ 1167e6ca193dSGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 116888ecc943SGeorge Wilson &islog); 116988ecc943SGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 117088ecc943SGeorge Wilson &ishole); 117188ecc943SGeorge Wilson if (islog || ishole) 1172e6ca193dSGeorge Wilson continue; 117388ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE); 1174e6ca193dSGeorge Wilson print_status_config(zhp, vname, child[c], 1175e6ca193dSGeorge Wilson namewidth, depth + 2, isspare); 1176e6ca193dSGeorge Wilson free(vname); 1177e6ca193dSGeorge Wilson } 1178e6ca193dSGeorge Wilson } 1179e6ca193dSGeorge Wilson 1180fa9e4066Sahrens 1181fa9e4066Sahrens /* 1182fa9e4066Sahrens * Print the configuration of an exported pool. Iterate over all vdevs in the 1183fa9e4066Sahrens * pool, printing out the name and status for each one. 1184fa9e4066Sahrens */ 1185fa9e4066Sahrens void 1186e6ca193dSGeorge Wilson print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth) 1187fa9e4066Sahrens { 1188fa9e4066Sahrens nvlist_t **child; 1189fa9e4066Sahrens uint_t c, children; 1190fa9e4066Sahrens vdev_stat_t *vs; 1191afefbcddSeschrock char *type, *vname; 1192fa9e4066Sahrens 1193fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 119488ecc943SGeorge Wilson if (strcmp(type, VDEV_TYPE_MISSING) == 0 || 119588ecc943SGeorge Wilson strcmp(type, VDEV_TYPE_HOLE) == 0) 1196fa9e4066Sahrens return; 1197fa9e4066Sahrens 1198*3f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 1199fa9e4066Sahrens (uint64_t **)&vs, &c) == 0); 1200fa9e4066Sahrens 1201fa9e4066Sahrens (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name); 1202990b4856Slling (void) printf(" %s", zpool_state_to_name(vs->vs_state, vs->vs_aux)); 1203fa9e4066Sahrens 1204fa9e4066Sahrens if (vs->vs_aux != 0) { 12053d7072f8Seschrock (void) printf(" "); 1206fa9e4066Sahrens 1207fa9e4066Sahrens switch (vs->vs_aux) { 1208fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED: 1209fa9e4066Sahrens (void) printf(gettext("cannot open")); 1210fa9e4066Sahrens break; 1211fa9e4066Sahrens 1212fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM: 1213fa9e4066Sahrens (void) printf(gettext("missing device")); 1214fa9e4066Sahrens break; 1215fa9e4066Sahrens 1216fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS: 1217fa9e4066Sahrens (void) printf(gettext("insufficient replicas")); 1218fa9e4066Sahrens break; 1219fa9e4066Sahrens 1220eaca9bbdSeschrock case VDEV_AUX_VERSION_NEWER: 1221eaca9bbdSeschrock (void) printf(gettext("newer version")); 1222eaca9bbdSeschrock break; 1223eaca9bbdSeschrock 12243d7072f8Seschrock case VDEV_AUX_ERR_EXCEEDED: 12253d7072f8Seschrock (void) printf(gettext("too many errors")); 12263d7072f8Seschrock break; 12273d7072f8Seschrock 1228fa9e4066Sahrens default: 1229fa9e4066Sahrens (void) printf(gettext("corrupted data")); 1230fa9e4066Sahrens break; 1231fa9e4066Sahrens } 1232fa9e4066Sahrens } 1233fa9e4066Sahrens (void) printf("\n"); 1234fa9e4066Sahrens 1235fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1236fa9e4066Sahrens &child, &children) != 0) 1237fa9e4066Sahrens return; 1238fa9e4066Sahrens 1239afefbcddSeschrock for (c = 0; c < children; c++) { 12408654d025Sperrin uint64_t is_log = B_FALSE; 12418654d025Sperrin 12428654d025Sperrin (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 12438654d025Sperrin &is_log); 1244e6ca193dSGeorge Wilson if (is_log) 12458654d025Sperrin continue; 12468654d025Sperrin 124788ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_TRUE); 1248e6ca193dSGeorge Wilson print_import_config(vname, child[c], namewidth, depth + 2); 1249afefbcddSeschrock free(vname); 1250afefbcddSeschrock } 125199653d4eSeschrock 1252fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 1253fa94a07fSbrendan &child, &children) == 0) { 1254fa94a07fSbrendan (void) printf(gettext("\tcache\n")); 1255fa94a07fSbrendan for (c = 0; c < children; c++) { 125688ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE); 1257fa94a07fSbrendan (void) printf("\t %s\n", vname); 1258fa94a07fSbrendan free(vname); 1259fa94a07fSbrendan } 1260fa94a07fSbrendan } 126199653d4eSeschrock 1262fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 1263fa94a07fSbrendan &child, &children) == 0) { 1264fa94a07fSbrendan (void) printf(gettext("\tspares\n")); 1265fa94a07fSbrendan for (c = 0; c < children; c++) { 126688ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, NULL, child[c], B_FALSE); 1267fa94a07fSbrendan (void) printf("\t %s\n", vname); 1268fa94a07fSbrendan free(vname); 1269fa94a07fSbrendan } 127099653d4eSeschrock } 1271fa9e4066Sahrens } 1272fa9e4066Sahrens 1273e6ca193dSGeorge Wilson /* 1274e6ca193dSGeorge Wilson * Print log vdevs. 1275e6ca193dSGeorge Wilson * Logs are recorded as top level vdevs in the main pool child array 1276e6ca193dSGeorge Wilson * but with "is_log" set to 1. We use either print_status_config() or 1277e6ca193dSGeorge Wilson * print_import_config() to print the top level logs then any log 1278e6ca193dSGeorge Wilson * children (eg mirrored slogs) are printed recursively - which 1279e6ca193dSGeorge Wilson * works because only the top level vdev is marked "is_log" 1280e6ca193dSGeorge Wilson */ 1281e6ca193dSGeorge Wilson static void 1282e6ca193dSGeorge Wilson print_logs(zpool_handle_t *zhp, nvlist_t *nv, int namewidth, boolean_t verbose) 1283e6ca193dSGeorge Wilson { 1284e6ca193dSGeorge Wilson uint_t c, children; 1285e6ca193dSGeorge Wilson nvlist_t **child; 1286e6ca193dSGeorge Wilson 1287e6ca193dSGeorge Wilson if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child, 1288e6ca193dSGeorge Wilson &children) != 0) 1289e6ca193dSGeorge Wilson return; 1290e6ca193dSGeorge Wilson 1291e6ca193dSGeorge Wilson (void) printf(gettext("\tlogs\n")); 1292e6ca193dSGeorge Wilson 1293e6ca193dSGeorge Wilson for (c = 0; c < children; c++) { 1294e6ca193dSGeorge Wilson uint64_t is_log = B_FALSE; 1295e6ca193dSGeorge Wilson char *name; 1296e6ca193dSGeorge Wilson 1297e6ca193dSGeorge Wilson (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 1298e6ca193dSGeorge Wilson &is_log); 1299e6ca193dSGeorge Wilson if (!is_log) 1300e6ca193dSGeorge Wilson continue; 130188ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, child[c], B_TRUE); 1302e6ca193dSGeorge Wilson if (verbose) 1303e6ca193dSGeorge Wilson print_status_config(zhp, name, child[c], namewidth, 1304e6ca193dSGeorge Wilson 2, B_FALSE); 1305e6ca193dSGeorge Wilson else 1306e6ca193dSGeorge Wilson print_import_config(name, child[c], namewidth, 2); 1307e6ca193dSGeorge Wilson free(name); 1308e6ca193dSGeorge Wilson } 1309e6ca193dSGeorge Wilson } 1310468c413aSTim Haley 1311fa9e4066Sahrens /* 1312fa9e4066Sahrens * Display the status for the given pool. 1313fa9e4066Sahrens */ 1314fa9e4066Sahrens static void 1315fa9e4066Sahrens show_import(nvlist_t *config) 1316fa9e4066Sahrens { 1317fa9e4066Sahrens uint64_t pool_state; 1318fa9e4066Sahrens vdev_stat_t *vs; 1319fa9e4066Sahrens char *name; 1320fa9e4066Sahrens uint64_t guid; 1321fa9e4066Sahrens char *msgid; 1322fa9e4066Sahrens nvlist_t *nvroot; 1323fa9e4066Sahrens int reason; 132446657f8dSmmusante const char *health; 1325fa9e4066Sahrens uint_t vsc; 1326fa9e4066Sahrens int namewidth; 1327fa9e4066Sahrens 1328fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1329fa9e4066Sahrens &name) == 0); 1330fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 1331fa9e4066Sahrens &guid) == 0); 1332fa9e4066Sahrens verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 1333fa9e4066Sahrens &pool_state) == 0); 1334fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1335fa9e4066Sahrens &nvroot) == 0); 1336fa9e4066Sahrens 1337*3f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 1338fa9e4066Sahrens (uint64_t **)&vs, &vsc) == 0); 1339990b4856Slling health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 1340fa9e4066Sahrens 1341fa9e4066Sahrens reason = zpool_import_status(config, &msgid); 1342fa9e4066Sahrens 134346657f8dSmmusante (void) printf(gettext(" pool: %s\n"), name); 134446657f8dSmmusante (void) printf(gettext(" id: %llu\n"), (u_longlong_t)guid); 134546657f8dSmmusante (void) printf(gettext(" state: %s"), health); 13464c58d714Sdarrenm if (pool_state == POOL_STATE_DESTROYED) 1347b1b8ab34Slling (void) printf(gettext(" (DESTROYED)")); 13484c58d714Sdarrenm (void) printf("\n"); 1349fa9e4066Sahrens 1350fa9e4066Sahrens switch (reason) { 1351fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 1352fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 1353fa9e4066Sahrens case ZPOOL_STATUS_BAD_GUID_SUM: 1354fa9e4066Sahrens (void) printf(gettext("status: One or more devices are missing " 1355fa9e4066Sahrens "from the system.\n")); 1356fa9e4066Sahrens break; 1357fa9e4066Sahrens 1358fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 1359fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 1360fa9e4066Sahrens (void) printf(gettext("status: One or more devices contains " 1361fa9e4066Sahrens "corrupted data.\n")); 1362fa9e4066Sahrens break; 1363fa9e4066Sahrens 1364fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_DATA: 1365fa9e4066Sahrens (void) printf(gettext("status: The pool data is corrupted.\n")); 1366fa9e4066Sahrens break; 1367fa9e4066Sahrens 1368441d80aaSlling case ZPOOL_STATUS_OFFLINE_DEV: 1369441d80aaSlling (void) printf(gettext("status: One or more devices " 1370441d80aaSlling "are offlined.\n")); 1371441d80aaSlling break; 1372441d80aaSlling 1373ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 1374ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is " 1375ea8dc4b6Seschrock "corrupted.\n")); 1376ea8dc4b6Seschrock break; 1377ea8dc4b6Seschrock 1378eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 1379eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 1380eaca9bbdSeschrock "older on-disk version.\n")); 1381eaca9bbdSeschrock break; 1382eaca9bbdSeschrock 1383eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 1384eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 1385eaca9bbdSeschrock "incompatible version.\n")); 1386eaca9bbdSeschrock break; 1387b87f3af3Sperrin 138895173954Sek case ZPOOL_STATUS_HOSTID_MISMATCH: 138995173954Sek (void) printf(gettext("status: The pool was last accessed by " 139095173954Sek "another system.\n")); 139195173954Sek break; 1392b87f3af3Sperrin 13933d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_R: 13943d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_NR: 13953d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 13963d7072f8Seschrock "faulted.\n")); 13973d7072f8Seschrock break; 13983d7072f8Seschrock 1399b87f3af3Sperrin case ZPOOL_STATUS_BAD_LOG: 1400b87f3af3Sperrin (void) printf(gettext("status: An intent log record cannot be " 1401b87f3af3Sperrin "read.\n")); 1402b87f3af3Sperrin break; 1403b87f3af3Sperrin 1404*3f9d6ad7SLin Ling case ZPOOL_STATUS_RESILVERING: 1405*3f9d6ad7SLin Ling (void) printf(gettext("status: One or more devices were being " 1406*3f9d6ad7SLin Ling "resilvered.\n")); 1407*3f9d6ad7SLin Ling break; 1408*3f9d6ad7SLin Ling 1409fa9e4066Sahrens default: 1410fa9e4066Sahrens /* 1411fa9e4066Sahrens * No other status can be seen when importing pools. 1412fa9e4066Sahrens */ 1413fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 1414fa9e4066Sahrens } 1415fa9e4066Sahrens 1416fa9e4066Sahrens /* 1417fa9e4066Sahrens * Print out an action according to the overall state of the pool. 1418fa9e4066Sahrens */ 141946657f8dSmmusante if (vs->vs_state == VDEV_STATE_HEALTHY) { 1420eaca9bbdSeschrock if (reason == ZPOOL_STATUS_VERSION_OLDER) 1421eaca9bbdSeschrock (void) printf(gettext("action: The pool can be " 1422eaca9bbdSeschrock "imported using its name or numeric identifier, " 1423eaca9bbdSeschrock "though\n\tsome features will not be available " 1424eaca9bbdSeschrock "without an explicit 'zpool upgrade'.\n")); 142595173954Sek else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) 142695173954Sek (void) printf(gettext("action: The pool can be " 142795173954Sek "imported using its name or numeric " 142895173954Sek "identifier and\n\tthe '-f' flag.\n")); 1429fa9e4066Sahrens else 1430eaca9bbdSeschrock (void) printf(gettext("action: The pool can be " 1431eaca9bbdSeschrock "imported using its name or numeric " 1432eaca9bbdSeschrock "identifier.\n")); 143346657f8dSmmusante } else if (vs->vs_state == VDEV_STATE_DEGRADED) { 1434fa9e4066Sahrens (void) printf(gettext("action: The pool can be imported " 1435fa9e4066Sahrens "despite missing or damaged devices. The\n\tfault " 1436eaca9bbdSeschrock "tolerance of the pool may be compromised if imported.\n")); 1437fa9e4066Sahrens } else { 1438eaca9bbdSeschrock switch (reason) { 1439eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 1440eaca9bbdSeschrock (void) printf(gettext("action: The pool cannot be " 1441eaca9bbdSeschrock "imported. Access the pool on a system running " 1442eaca9bbdSeschrock "newer\n\tsoftware, or recreate the pool from " 1443eaca9bbdSeschrock "backup.\n")); 1444eaca9bbdSeschrock break; 1445eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_R: 1446eaca9bbdSeschrock case ZPOOL_STATUS_MISSING_DEV_NR: 1447eaca9bbdSeschrock case ZPOOL_STATUS_BAD_GUID_SUM: 1448fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 1449fa9e4066Sahrens "imported. Attach the missing\n\tdevices and try " 1450fa9e4066Sahrens "again.\n")); 1451eaca9bbdSeschrock break; 1452eaca9bbdSeschrock default: 1453fa9e4066Sahrens (void) printf(gettext("action: The pool cannot be " 1454fa9e4066Sahrens "imported due to damaged devices or data.\n")); 1455eaca9bbdSeschrock } 1456eaca9bbdSeschrock } 1457eaca9bbdSeschrock 145846657f8dSmmusante /* 145946657f8dSmmusante * If the state is "closed" or "can't open", and the aux state 146046657f8dSmmusante * is "corrupt data": 146146657f8dSmmusante */ 146246657f8dSmmusante if (((vs->vs_state == VDEV_STATE_CLOSED) || 146346657f8dSmmusante (vs->vs_state == VDEV_STATE_CANT_OPEN)) && 146446657f8dSmmusante (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) { 1465eaca9bbdSeschrock if (pool_state == POOL_STATE_DESTROYED) 1466eaca9bbdSeschrock (void) printf(gettext("\tThe pool was destroyed, " 1467eaca9bbdSeschrock "but can be imported using the '-Df' flags.\n")); 1468eaca9bbdSeschrock else if (pool_state != POOL_STATE_EXPORTED) 1469eaca9bbdSeschrock (void) printf(gettext("\tThe pool may be active on " 147018ce54dfSek "another system, but can be imported using\n\t" 1471eaca9bbdSeschrock "the '-f' flag.\n")); 1472fa9e4066Sahrens } 1473fa9e4066Sahrens 1474fa9e4066Sahrens if (msgid != NULL) 1475fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 1476fa9e4066Sahrens msgid); 1477fa9e4066Sahrens 1478fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 1479fa9e4066Sahrens 1480c67d9675Seschrock namewidth = max_width(NULL, nvroot, 0, 0); 1481fa9e4066Sahrens if (namewidth < 10) 1482fa9e4066Sahrens namewidth = 10; 14838654d025Sperrin 1484e6ca193dSGeorge Wilson print_import_config(name, nvroot, namewidth, 0); 1485e6ca193dSGeorge Wilson if (num_logs(nvroot) > 0) 1486e6ca193dSGeorge Wilson print_logs(NULL, nvroot, namewidth, B_FALSE); 1487fa9e4066Sahrens 1488fa9e4066Sahrens if (reason == ZPOOL_STATUS_BAD_GUID_SUM) { 148946657f8dSmmusante (void) printf(gettext("\n\tAdditional devices are known to " 1490fa9e4066Sahrens "be part of this pool, though their\n\texact " 149146657f8dSmmusante "configuration cannot be determined.\n")); 1492fa9e4066Sahrens } 1493fa9e4066Sahrens } 1494fa9e4066Sahrens 1495fa9e4066Sahrens /* 1496fa9e4066Sahrens * Perform the import for the given configuration. This passes the heavy 1497990b4856Slling * lifting off to zpool_import_props(), and then mounts the datasets contained 1498990b4856Slling * within the pool. 1499fa9e4066Sahrens */ 1500fa9e4066Sahrens static int 1501fa9e4066Sahrens do_import(nvlist_t *config, const char *newname, const char *mntopts, 15024f0f5e5bSVictor Latushkin int force, nvlist_t *props, boolean_t do_verbatim) 1503fa9e4066Sahrens { 1504fa9e4066Sahrens zpool_handle_t *zhp; 1505fa9e4066Sahrens char *name; 1506fa9e4066Sahrens uint64_t state; 1507eaca9bbdSeschrock uint64_t version; 1508fa9e4066Sahrens 1509fa9e4066Sahrens verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 1510fa9e4066Sahrens &name) == 0); 1511fa9e4066Sahrens 1512fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1513fa9e4066Sahrens ZPOOL_CONFIG_POOL_STATE, &state) == 0); 1514eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, 1515eaca9bbdSeschrock ZPOOL_CONFIG_VERSION, &version) == 0); 1516e7437265Sahrens if (version > SPA_VERSION) { 1517eaca9bbdSeschrock (void) fprintf(stderr, gettext("cannot import '%s': pool " 1518eaca9bbdSeschrock "is formatted using a newer ZFS version\n"), name); 1519eaca9bbdSeschrock return (1); 1520eaca9bbdSeschrock } else if (state != POOL_STATE_EXPORTED && !force) { 152195173954Sek uint64_t hostid; 152295173954Sek 152395173954Sek if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, 152495173954Sek &hostid) == 0) { 152595173954Sek if ((unsigned long)hostid != gethostid()) { 152695173954Sek char *hostname; 152795173954Sek uint64_t timestamp; 152895173954Sek time_t t; 152995173954Sek 153095173954Sek verify(nvlist_lookup_string(config, 153195173954Sek ZPOOL_CONFIG_HOSTNAME, &hostname) == 0); 153295173954Sek verify(nvlist_lookup_uint64(config, 153395173954Sek ZPOOL_CONFIG_TIMESTAMP, ×tamp) == 0); 153495173954Sek t = timestamp; 153595173954Sek (void) fprintf(stderr, gettext("cannot import " 153695173954Sek "'%s': pool may be in use from other " 153795173954Sek "system, it was last accessed by %s " 153895173954Sek "(hostid: 0x%lx) on %s"), name, hostname, 153995173954Sek (unsigned long)hostid, 154095173954Sek asctime(localtime(&t))); 154195173954Sek (void) fprintf(stderr, gettext("use '-f' to " 154295173954Sek "import anyway\n")); 154395173954Sek return (1); 154495173954Sek } 154595173954Sek } else { 154695173954Sek (void) fprintf(stderr, gettext("cannot import '%s': " 154795173954Sek "pool may be in use from other system\n"), name); 154895173954Sek (void) fprintf(stderr, gettext("use '-f' to import " 154995173954Sek "anyway\n")); 155095173954Sek return (1); 155195173954Sek } 1552fa9e4066Sahrens } 1553fa9e4066Sahrens 15544f0f5e5bSVictor Latushkin if (zpool_import_props(g_zfs, config, newname, props, do_verbatim) != 0) 1555fa9e4066Sahrens return (1); 1556fa9e4066Sahrens 1557fa9e4066Sahrens if (newname != NULL) 1558fa9e4066Sahrens name = (char *)newname; 1559fa9e4066Sahrens 15604f0f5e5bSVictor Latushkin if ((zhp = zpool_open_canfail(g_zfs, name)) == NULL) 15614f0f5e5bSVictor Latushkin return (1); 1562fa9e4066Sahrens 1563379c004dSEric Schrock if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 1564379c004dSEric Schrock zpool_enable_datasets(zhp, mntopts, 0) != 0) { 1565fa9e4066Sahrens zpool_close(zhp); 1566fa9e4066Sahrens return (1); 1567fa9e4066Sahrens } 1568fa9e4066Sahrens 1569fa9e4066Sahrens zpool_close(zhp); 1570468c413aSTim Haley return (0); 1571fa9e4066Sahrens } 1572fa9e4066Sahrens 1573fa9e4066Sahrens /* 15744c58d714Sdarrenm * zpool import [-d dir] [-D] 15752f8aaab3Seschrock * import [-o mntopts] [-o prop=value] ... [-R root] [-D] 15762f8aaab3Seschrock * [-d dir | -c cachefile] [-f] -a 15772f8aaab3Seschrock * import [-o mntopts] [-o prop=value] ... [-R root] [-D] 1578468c413aSTim Haley * [-d dir | -c cachefile] [-f] [-n] [-F] <pool | id> [newpool] 15792f8aaab3Seschrock * 15802f8aaab3Seschrock * -c Read pool information from a cachefile instead of searching 15812f8aaab3Seschrock * devices. 1582fa9e4066Sahrens * 1583fa9e4066Sahrens * -d Scan in a specific directory, other than /dev/dsk. More than 1584fa9e4066Sahrens * one directory can be specified using multiple '-d' options. 1585fa9e4066Sahrens * 15864c58d714Sdarrenm * -D Scan for previously destroyed pools or import all or only 15874c58d714Sdarrenm * specified destroyed pools. 15884c58d714Sdarrenm * 1589fa9e4066Sahrens * -R Temporarily import the pool, with all mountpoints relative to 1590fa9e4066Sahrens * the given root. The pool will remain exported when the machine 1591fa9e4066Sahrens * is rebooted. 1592fa9e4066Sahrens * 1593468c413aSTim Haley * -V Import even in the presence of faulted vdevs. This is an 1594c5904d13Seschrock * intentionally undocumented option for testing purposes, and 1595c5904d13Seschrock * treats the pool configuration as complete, leaving any bad 15964f0f5e5bSVictor Latushkin * vdevs in the FAULTED state. In other words, it does verbatim 15974f0f5e5bSVictor Latushkin * import. 1598c5904d13Seschrock * 1599468c413aSTim Haley * -f Force import, even if it appears that the pool is active. 1600468c413aSTim Haley * 1601468c413aSTim Haley * -F Attempt rewind if necessary. 1602468c413aSTim Haley * 1603468c413aSTim Haley * -n See if rewind would work, but don't actually rewind. 1604468c413aSTim Haley * 1605fa9e4066Sahrens * -a Import all pools found. 1606fa9e4066Sahrens * 1607990b4856Slling * -o Set property=value and/or temporary mount options (without '='). 1608ecd6cf80Smarks * 1609fa9e4066Sahrens * The import command scans for pools to import, and import pools based on pool 1610fa9e4066Sahrens * name and GUID. The pool can also be renamed as part of the import process. 1611fa9e4066Sahrens */ 1612fa9e4066Sahrens int 1613fa9e4066Sahrens zpool_do_import(int argc, char **argv) 1614fa9e4066Sahrens { 1615fa9e4066Sahrens char **searchdirs = NULL; 1616fa9e4066Sahrens int nsearch = 0; 1617fa9e4066Sahrens int c; 1618d41c4376SMark J Musante int err = 0; 16192f8aaab3Seschrock nvlist_t *pools = NULL; 162099653d4eSeschrock boolean_t do_all = B_FALSE; 162199653d4eSeschrock boolean_t do_destroyed = B_FALSE; 1622fa9e4066Sahrens char *mntopts = NULL; 162399653d4eSeschrock boolean_t do_force = B_FALSE; 1624fa9e4066Sahrens nvpair_t *elem; 1625fa9e4066Sahrens nvlist_t *config; 162624e697d4Sck uint64_t searchguid = 0; 162724e697d4Sck char *searchname = NULL; 1628990b4856Slling char *propval; 1629fa9e4066Sahrens nvlist_t *found_config; 1630468c413aSTim Haley nvlist_t *policy = NULL; 1631ecd6cf80Smarks nvlist_t *props = NULL; 163299653d4eSeschrock boolean_t first; 16334f0f5e5bSVictor Latushkin boolean_t do_verbatim = B_FALSE; 1634468c413aSTim Haley uint32_t rewind_policy = ZPOOL_NO_REWIND; 1635468c413aSTim Haley boolean_t dryrun = B_FALSE; 1636468c413aSTim Haley boolean_t do_rewind = B_FALSE; 1637468c413aSTim Haley boolean_t xtreme_rewind = B_FALSE; 16384c58d714Sdarrenm uint64_t pool_state; 16392f8aaab3Seschrock char *cachefile = NULL; 1640d41c4376SMark J Musante importargs_t idata = { 0 }; 1641fa9e4066Sahrens 1642fa9e4066Sahrens /* check options */ 16431195e687SMark J Musante while ((c = getopt(argc, argv, ":aCc:d:DEfFno:rR:VX")) != -1) { 1644fa9e4066Sahrens switch (c) { 1645fa9e4066Sahrens case 'a': 164699653d4eSeschrock do_all = B_TRUE; 1647fa9e4066Sahrens break; 16482f8aaab3Seschrock case 'c': 16492f8aaab3Seschrock cachefile = optarg; 16502f8aaab3Seschrock break; 1651fa9e4066Sahrens case 'd': 1652fa9e4066Sahrens if (searchdirs == NULL) { 1653fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1654fa9e4066Sahrens } else { 1655fa9e4066Sahrens char **tmp = safe_malloc((nsearch + 1) * 1656fa9e4066Sahrens sizeof (char *)); 1657fa9e4066Sahrens bcopy(searchdirs, tmp, nsearch * 1658fa9e4066Sahrens sizeof (char *)); 1659fa9e4066Sahrens free(searchdirs); 1660fa9e4066Sahrens searchdirs = tmp; 1661fa9e4066Sahrens } 1662fa9e4066Sahrens searchdirs[nsearch++] = optarg; 1663fa9e4066Sahrens break; 16644c58d714Sdarrenm case 'D': 166599653d4eSeschrock do_destroyed = B_TRUE; 16664c58d714Sdarrenm break; 1667fa9e4066Sahrens case 'f': 166899653d4eSeschrock do_force = B_TRUE; 1669fa9e4066Sahrens break; 1670c5904d13Seschrock case 'F': 1671468c413aSTim Haley do_rewind = B_TRUE; 1672468c413aSTim Haley break; 1673468c413aSTim Haley case 'n': 1674468c413aSTim Haley dryrun = B_TRUE; 1675c5904d13Seschrock break; 1676fa9e4066Sahrens case 'o': 1677990b4856Slling if ((propval = strchr(optarg, '=')) != NULL) { 1678990b4856Slling *propval = '\0'; 1679990b4856Slling propval++; 16800a48a24eStimh if (add_prop_list(optarg, propval, 16810a48a24eStimh &props, B_TRUE)) 1682990b4856Slling goto error; 1683990b4856Slling } else { 1684990b4856Slling mntopts = optarg; 1685990b4856Slling } 1686fa9e4066Sahrens break; 1687fa9e4066Sahrens case 'R': 1688990b4856Slling if (add_prop_list(zpool_prop_to_name( 16890a48a24eStimh ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 1690990b4856Slling goto error; 16912f8aaab3Seschrock if (nvlist_lookup_string(props, 16922f8aaab3Seschrock zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), 16932f8aaab3Seschrock &propval) == 0) 16942f8aaab3Seschrock break; 1695990b4856Slling if (add_prop_list(zpool_prop_to_name( 16960a48a24eStimh ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE)) 1697990b4856Slling goto error; 1698fa9e4066Sahrens break; 1699468c413aSTim Haley case 'V': 1700468c413aSTim Haley do_verbatim = B_TRUE; 1701468c413aSTim Haley break; 1702468c413aSTim Haley case 'X': 1703468c413aSTim Haley xtreme_rewind = B_TRUE; 1704468c413aSTim Haley break; 1705fa9e4066Sahrens case ':': 1706fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 1707fa9e4066Sahrens "'%c' option\n"), optopt); 170899653d4eSeschrock usage(B_FALSE); 1709fa9e4066Sahrens break; 1710fa9e4066Sahrens case '?': 1711fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1712fa9e4066Sahrens optopt); 171399653d4eSeschrock usage(B_FALSE); 1714fa9e4066Sahrens } 1715fa9e4066Sahrens } 1716fa9e4066Sahrens 1717fa9e4066Sahrens argc -= optind; 1718fa9e4066Sahrens argv += optind; 1719fa9e4066Sahrens 17202f8aaab3Seschrock if (cachefile && nsearch != 0) { 17212f8aaab3Seschrock (void) fprintf(stderr, gettext("-c is incompatible with -d\n")); 17222f8aaab3Seschrock usage(B_FALSE); 17232f8aaab3Seschrock } 17242f8aaab3Seschrock 1725468c413aSTim Haley if ((dryrun || xtreme_rewind) && !do_rewind) { 1726468c413aSTim Haley (void) fprintf(stderr, 1727468c413aSTim Haley gettext("-n or -X only meaningful with -F\n")); 1728468c413aSTim Haley usage(B_FALSE); 1729468c413aSTim Haley } 1730468c413aSTim Haley if (dryrun) 1731468c413aSTim Haley rewind_policy = ZPOOL_TRY_REWIND; 1732468c413aSTim Haley else if (do_rewind) 1733468c413aSTim Haley rewind_policy = ZPOOL_DO_REWIND; 1734468c413aSTim Haley if (xtreme_rewind) 1735468c413aSTim Haley rewind_policy |= ZPOOL_EXTREME_REWIND; 1736468c413aSTim Haley 1737468c413aSTim Haley /* In the future, we can capture further policy and include it here */ 1738468c413aSTim Haley if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 1739468c413aSTim Haley nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) 1740468c413aSTim Haley goto error; 1741468c413aSTim Haley 1742fa9e4066Sahrens if (searchdirs == NULL) { 1743fa9e4066Sahrens searchdirs = safe_malloc(sizeof (char *)); 1744fa9e4066Sahrens searchdirs[0] = "/dev/dsk"; 1745fa9e4066Sahrens nsearch = 1; 1746fa9e4066Sahrens } 1747fa9e4066Sahrens 1748fa9e4066Sahrens /* check argument count */ 1749fa9e4066Sahrens if (do_all) { 1750fa9e4066Sahrens if (argc != 0) { 1751fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 175299653d4eSeschrock usage(B_FALSE); 1753fa9e4066Sahrens } 1754fa9e4066Sahrens } else { 1755fa9e4066Sahrens if (argc > 2) { 1756fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 175799653d4eSeschrock usage(B_FALSE); 1758fa9e4066Sahrens } 1759fa9e4066Sahrens 1760fa9e4066Sahrens /* 1761fa9e4066Sahrens * Check for the SYS_CONFIG privilege. We do this explicitly 1762fa9e4066Sahrens * here because otherwise any attempt to discover pools will 1763fa9e4066Sahrens * silently fail. 1764fa9e4066Sahrens */ 1765fa9e4066Sahrens if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) { 1766fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot " 1767fa9e4066Sahrens "discover pools: permission denied\n")); 176899653d4eSeschrock free(searchdirs); 1769468c413aSTim Haley nvlist_free(policy); 1770fa9e4066Sahrens return (1); 1771fa9e4066Sahrens } 1772fa9e4066Sahrens } 1773fa9e4066Sahrens 1774fa9e4066Sahrens /* 1775fa9e4066Sahrens * Depending on the arguments given, we do one of the following: 1776fa9e4066Sahrens * 1777fa9e4066Sahrens * <none> Iterate through all pools and display information about 1778fa9e4066Sahrens * each one. 1779fa9e4066Sahrens * 1780fa9e4066Sahrens * -a Iterate through all pools and try to import each one. 1781fa9e4066Sahrens * 1782fa9e4066Sahrens * <id> Find the pool that corresponds to the given GUID/pool 1783fa9e4066Sahrens * name and import that one. 17844c58d714Sdarrenm * 17854c58d714Sdarrenm * -D Above options applies only to destroyed pools. 1786fa9e4066Sahrens */ 1787fa9e4066Sahrens if (argc != 0) { 1788fa9e4066Sahrens char *endptr; 1789fa9e4066Sahrens 1790fa9e4066Sahrens errno = 0; 1791fa9e4066Sahrens searchguid = strtoull(argv[0], &endptr, 10); 1792fa9e4066Sahrens if (errno != 0 || *endptr != '\0') 1793fa9e4066Sahrens searchname = argv[0]; 1794fa9e4066Sahrens found_config = NULL; 1795fa9e4066Sahrens 179624e697d4Sck /* 1797d41c4376SMark J Musante * User specified a name or guid. Ensure it's unique. 179824e697d4Sck */ 1799d41c4376SMark J Musante idata.unique = B_TRUE; 180024e697d4Sck } 180124e697d4Sck 1802d41c4376SMark J Musante 1803d41c4376SMark J Musante idata.path = searchdirs; 1804d41c4376SMark J Musante idata.paths = nsearch; 1805d41c4376SMark J Musante idata.poolname = searchname; 1806d41c4376SMark J Musante idata.guid = searchguid; 1807d41c4376SMark J Musante idata.cachefile = cachefile; 1808d41c4376SMark J Musante 1809d41c4376SMark J Musante pools = zpool_search_import(g_zfs, &idata); 1810d41c4376SMark J Musante 1811d41c4376SMark J Musante if (pools != NULL && idata.exists && 1812d41c4376SMark J Musante (argc == 1 || strcmp(argv[0], argv[1]) == 0)) { 1813d41c4376SMark J Musante (void) fprintf(stderr, gettext("cannot import '%s': " 1814d41c4376SMark J Musante "a pool with that name already exists\n"), 1815d41c4376SMark J Musante argv[0]); 1816d41c4376SMark J Musante (void) fprintf(stderr, gettext("use the form '%s " 1817d41c4376SMark J Musante "<pool | id> <newpool>' to give it a new name\n"), 1818d41c4376SMark J Musante "zpool import"); 1819d41c4376SMark J Musante err = 1; 1820d41c4376SMark J Musante } else if (pools == NULL && idata.exists) { 1821d41c4376SMark J Musante (void) fprintf(stderr, gettext("cannot import '%s': " 1822d41c4376SMark J Musante "a pool with that name is already created/imported,\n"), 1823d41c4376SMark J Musante argv[0]); 1824d41c4376SMark J Musante (void) fprintf(stderr, gettext("and no additional pools " 1825d41c4376SMark J Musante "with that name were found\n")); 1826d41c4376SMark J Musante err = 1; 1827d41c4376SMark J Musante } else if (pools == NULL) { 182824e697d4Sck if (argc != 0) { 182924e697d4Sck (void) fprintf(stderr, gettext("cannot import '%s': " 183024e697d4Sck "no such pool available\n"), argv[0]); 183124e697d4Sck } 1832d41c4376SMark J Musante err = 1; 1833d41c4376SMark J Musante } 1834d41c4376SMark J Musante 1835d41c4376SMark J Musante if (err == 1) { 183624e697d4Sck free(searchdirs); 1837468c413aSTim Haley nvlist_free(policy); 183824e697d4Sck return (1); 183924e697d4Sck } 184024e697d4Sck 184124e697d4Sck /* 184224e697d4Sck * At this point we have a list of import candidate configs. Even if 184324e697d4Sck * we were searching by pool name or guid, we still need to 184424e697d4Sck * post-process the list to deal with pool state and possible 184524e697d4Sck * duplicate names. 184624e697d4Sck */ 1847fa9e4066Sahrens err = 0; 1848fa9e4066Sahrens elem = NULL; 184999653d4eSeschrock first = B_TRUE; 1850fa9e4066Sahrens while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { 1851fa9e4066Sahrens 1852fa9e4066Sahrens verify(nvpair_value_nvlist(elem, &config) == 0); 1853fa9e4066Sahrens 18544c58d714Sdarrenm verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 18554c58d714Sdarrenm &pool_state) == 0); 18564c58d714Sdarrenm if (!do_destroyed && pool_state == POOL_STATE_DESTROYED) 18574c58d714Sdarrenm continue; 18584c58d714Sdarrenm if (do_destroyed && pool_state != POOL_STATE_DESTROYED) 18594c58d714Sdarrenm continue; 18604c58d714Sdarrenm 1861468c413aSTim Haley verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY, 1862468c413aSTim Haley policy) == 0); 1863468c413aSTim Haley 1864fa9e4066Sahrens if (argc == 0) { 1865fa9e4066Sahrens if (first) 186699653d4eSeschrock first = B_FALSE; 18673bb79becSeschrock else if (!do_all) 1868fa9e4066Sahrens (void) printf("\n"); 1869fa9e4066Sahrens 1870468c413aSTim Haley if (do_all) { 1871fa9e4066Sahrens err |= do_import(config, NULL, mntopts, 18724f0f5e5bSVictor Latushkin do_force, props, do_verbatim); 1873468c413aSTim Haley } else { 1874fa9e4066Sahrens show_import(config); 1875468c413aSTim Haley } 1876fa9e4066Sahrens } else if (searchname != NULL) { 1877fa9e4066Sahrens char *name; 1878fa9e4066Sahrens 1879fa9e4066Sahrens /* 1880fa9e4066Sahrens * We are searching for a pool based on name. 1881fa9e4066Sahrens */ 1882fa9e4066Sahrens verify(nvlist_lookup_string(config, 1883fa9e4066Sahrens ZPOOL_CONFIG_POOL_NAME, &name) == 0); 1884fa9e4066Sahrens 1885fa9e4066Sahrens if (strcmp(name, searchname) == 0) { 1886fa9e4066Sahrens if (found_config != NULL) { 1887fa9e4066Sahrens (void) fprintf(stderr, gettext( 1888fa9e4066Sahrens "cannot import '%s': more than " 1889fa9e4066Sahrens "one matching pool\n"), searchname); 1890fa9e4066Sahrens (void) fprintf(stderr, gettext( 1891fa9e4066Sahrens "import by numeric ID instead\n")); 189299653d4eSeschrock err = B_TRUE; 1893fa9e4066Sahrens } 1894fa9e4066Sahrens found_config = config; 1895fa9e4066Sahrens } 1896fa9e4066Sahrens } else { 1897fa9e4066Sahrens uint64_t guid; 1898fa9e4066Sahrens 1899fa9e4066Sahrens /* 1900fa9e4066Sahrens * Search for a pool by guid. 1901fa9e4066Sahrens */ 1902fa9e4066Sahrens verify(nvlist_lookup_uint64(config, 1903fa9e4066Sahrens ZPOOL_CONFIG_POOL_GUID, &guid) == 0); 1904fa9e4066Sahrens 1905fa9e4066Sahrens if (guid == searchguid) 1906fa9e4066Sahrens found_config = config; 1907fa9e4066Sahrens } 1908fa9e4066Sahrens } 1909fa9e4066Sahrens 1910fa9e4066Sahrens /* 1911fa9e4066Sahrens * If we were searching for a specific pool, verify that we found a 1912fa9e4066Sahrens * pool, and then do the import. 1913fa9e4066Sahrens */ 1914fa9e4066Sahrens if (argc != 0 && err == 0) { 1915fa9e4066Sahrens if (found_config == NULL) { 1916fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot import '%s': " 1917fa9e4066Sahrens "no such pool available\n"), argv[0]); 191899653d4eSeschrock err = B_TRUE; 1919fa9e4066Sahrens } else { 1920fa9e4066Sahrens err |= do_import(found_config, argc == 1 ? NULL : 19214f0f5e5bSVictor Latushkin argv[1], mntopts, do_force, props, do_verbatim); 1922fa9e4066Sahrens } 1923fa9e4066Sahrens } 1924fa9e4066Sahrens 1925fa9e4066Sahrens /* 1926fa9e4066Sahrens * If we were just looking for pools, report an error if none were 1927fa9e4066Sahrens * found. 1928fa9e4066Sahrens */ 1929fa9e4066Sahrens if (argc == 0 && first) 1930fa9e4066Sahrens (void) fprintf(stderr, 1931fa9e4066Sahrens gettext("no pools available to import\n")); 1932fa9e4066Sahrens 1933ecd6cf80Smarks error: 19342f8aaab3Seschrock nvlist_free(props); 1935fa9e4066Sahrens nvlist_free(pools); 1936468c413aSTim Haley nvlist_free(policy); 193799653d4eSeschrock free(searchdirs); 1938fa9e4066Sahrens 1939fa9e4066Sahrens return (err ? 1 : 0); 1940fa9e4066Sahrens } 1941fa9e4066Sahrens 1942fa9e4066Sahrens typedef struct iostat_cbdata { 1943fa9e4066Sahrens zpool_list_t *cb_list; 1944fa9e4066Sahrens int cb_verbose; 1945fa9e4066Sahrens int cb_iteration; 1946fa9e4066Sahrens int cb_namewidth; 1947fa9e4066Sahrens } iostat_cbdata_t; 1948fa9e4066Sahrens 1949fa9e4066Sahrens static void 1950fa9e4066Sahrens print_iostat_separator(iostat_cbdata_t *cb) 1951fa9e4066Sahrens { 1952fa9e4066Sahrens int i = 0; 1953fa9e4066Sahrens 1954fa9e4066Sahrens for (i = 0; i < cb->cb_namewidth; i++) 1955fa9e4066Sahrens (void) printf("-"); 1956fa9e4066Sahrens (void) printf(" ----- ----- ----- ----- ----- -----\n"); 1957fa9e4066Sahrens } 1958fa9e4066Sahrens 1959fa9e4066Sahrens static void 1960fa9e4066Sahrens print_iostat_header(iostat_cbdata_t *cb) 1961fa9e4066Sahrens { 1962fa9e4066Sahrens (void) printf("%*s capacity operations bandwidth\n", 1963fa9e4066Sahrens cb->cb_namewidth, ""); 1964485bbbf5SGeorge Wilson (void) printf("%-*s alloc free read write read write\n", 1965fa9e4066Sahrens cb->cb_namewidth, "pool"); 1966fa9e4066Sahrens print_iostat_separator(cb); 1967fa9e4066Sahrens } 1968fa9e4066Sahrens 1969fa9e4066Sahrens /* 1970fa9e4066Sahrens * Display a single statistic. 1971fa9e4066Sahrens */ 1972990b4856Slling static void 1973fa9e4066Sahrens print_one_stat(uint64_t value) 1974fa9e4066Sahrens { 1975fa9e4066Sahrens char buf[64]; 1976fa9e4066Sahrens 1977fa9e4066Sahrens zfs_nicenum(value, buf, sizeof (buf)); 1978fa9e4066Sahrens (void) printf(" %5s", buf); 1979fa9e4066Sahrens } 1980fa9e4066Sahrens 1981fa9e4066Sahrens /* 1982fa9e4066Sahrens * Print out all the statistics for the given vdev. This can either be the 1983fa9e4066Sahrens * toplevel configuration, or called recursively. If 'name' is NULL, then this 1984fa9e4066Sahrens * is a verbose output, and we don't want to display the toplevel pool stats. 1985fa9e4066Sahrens */ 1986fa9e4066Sahrens void 1987c67d9675Seschrock print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, 1988c67d9675Seschrock nvlist_t *newnv, iostat_cbdata_t *cb, int depth) 1989fa9e4066Sahrens { 1990fa9e4066Sahrens nvlist_t **oldchild, **newchild; 1991fa9e4066Sahrens uint_t c, children; 1992fa9e4066Sahrens vdev_stat_t *oldvs, *newvs; 1993fa9e4066Sahrens vdev_stat_t zerovs = { 0 }; 1994fa9e4066Sahrens uint64_t tdelta; 1995fa9e4066Sahrens double scale; 1996afefbcddSeschrock char *vname; 1997fa9e4066Sahrens 1998fa9e4066Sahrens if (oldnv != NULL) { 1999*3f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(oldnv, 2000*3f9d6ad7SLin Ling ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&oldvs, &c) == 0); 2001fa9e4066Sahrens } else { 2002fa9e4066Sahrens oldvs = &zerovs; 2003fa9e4066Sahrens } 2004fa9e4066Sahrens 2005*3f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_VDEV_STATS, 2006fa9e4066Sahrens (uint64_t **)&newvs, &c) == 0); 2007fa9e4066Sahrens 2008fa9e4066Sahrens if (strlen(name) + depth > cb->cb_namewidth) 2009fa9e4066Sahrens (void) printf("%*s%s", depth, "", name); 2010fa9e4066Sahrens else 2011fa9e4066Sahrens (void) printf("%*s%s%*s", depth, "", name, 2012fa9e4066Sahrens (int)(cb->cb_namewidth - strlen(name) - depth), ""); 2013fa9e4066Sahrens 2014fa9e4066Sahrens tdelta = newvs->vs_timestamp - oldvs->vs_timestamp; 2015fa9e4066Sahrens 2016fa9e4066Sahrens if (tdelta == 0) 2017fa9e4066Sahrens scale = 1.0; 2018fa9e4066Sahrens else 2019fa9e4066Sahrens scale = (double)NANOSEC / tdelta; 2020fa9e4066Sahrens 2021fa9e4066Sahrens /* only toplevel vdevs have capacity stats */ 2022fa9e4066Sahrens if (newvs->vs_space == 0) { 2023fa9e4066Sahrens (void) printf(" - -"); 2024fa9e4066Sahrens } else { 2025fa9e4066Sahrens print_one_stat(newvs->vs_alloc); 2026fa9e4066Sahrens print_one_stat(newvs->vs_space - newvs->vs_alloc); 2027fa9e4066Sahrens } 2028fa9e4066Sahrens 2029fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] - 2030fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_READ]))); 2031fa9e4066Sahrens 2032fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] - 2033fa9e4066Sahrens oldvs->vs_ops[ZIO_TYPE_WRITE]))); 2034fa9e4066Sahrens 2035fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] - 2036fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_READ]))); 2037fa9e4066Sahrens 2038fa9e4066Sahrens print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] - 2039fa9e4066Sahrens oldvs->vs_bytes[ZIO_TYPE_WRITE]))); 2040fa9e4066Sahrens 2041fa9e4066Sahrens (void) printf("\n"); 2042fa9e4066Sahrens 2043fa9e4066Sahrens if (!cb->cb_verbose) 2044fa9e4066Sahrens return; 2045fa9e4066Sahrens 2046fa9e4066Sahrens if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN, 2047fa9e4066Sahrens &newchild, &children) != 0) 2048fa9e4066Sahrens return; 2049fa9e4066Sahrens 2050fa9e4066Sahrens if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN, 2051fa9e4066Sahrens &oldchild, &c) != 0) 2052fa9e4066Sahrens return; 2053fa9e4066Sahrens 2054afefbcddSeschrock for (c = 0; c < children; c++) { 2055*3f9d6ad7SLin Ling uint64_t ishole = B_FALSE; 2056*3f9d6ad7SLin Ling 2057*3f9d6ad7SLin Ling if (nvlist_lookup_uint64(newchild[c], 2058*3f9d6ad7SLin Ling ZPOOL_CONFIG_IS_HOLE, &ishole) == 0 && ishole) 2059*3f9d6ad7SLin Ling continue; 2060*3f9d6ad7SLin Ling 206188ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, newchild[c], B_FALSE); 2062c67d9675Seschrock print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 2063afefbcddSeschrock newchild[c], cb, depth + 2); 2064afefbcddSeschrock free(vname); 2065afefbcddSeschrock } 2066fa94a07fSbrendan 2067fa94a07fSbrendan /* 2068fa94a07fSbrendan * Include level 2 ARC devices in iostat output 2069fa94a07fSbrendan */ 2070fa94a07fSbrendan if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE, 2071fa94a07fSbrendan &newchild, &children) != 0) 2072fa94a07fSbrendan return; 2073fa94a07fSbrendan 2074fa94a07fSbrendan if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE, 2075fa94a07fSbrendan &oldchild, &c) != 0) 2076fa94a07fSbrendan return; 2077fa94a07fSbrendan 2078fa94a07fSbrendan if (children > 0) { 2079fa94a07fSbrendan (void) printf("%-*s - - - - - " 2080fa94a07fSbrendan "-\n", cb->cb_namewidth, "cache"); 2081fa94a07fSbrendan for (c = 0; c < children; c++) { 208288ecc943SGeorge Wilson vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 208388ecc943SGeorge Wilson B_FALSE); 2084fa94a07fSbrendan print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 2085fa94a07fSbrendan newchild[c], cb, depth + 2); 2086fa94a07fSbrendan free(vname); 2087fa94a07fSbrendan } 2088fa94a07fSbrendan } 2089fa9e4066Sahrens } 2090fa9e4066Sahrens 2091088e9d47Seschrock static int 2092088e9d47Seschrock refresh_iostat(zpool_handle_t *zhp, void *data) 2093088e9d47Seschrock { 2094088e9d47Seschrock iostat_cbdata_t *cb = data; 209594de1d4cSeschrock boolean_t missing; 2096088e9d47Seschrock 2097088e9d47Seschrock /* 2098088e9d47Seschrock * If the pool has disappeared, remove it from the list and continue. 2099088e9d47Seschrock */ 210094de1d4cSeschrock if (zpool_refresh_stats(zhp, &missing) != 0) 210194de1d4cSeschrock return (-1); 210294de1d4cSeschrock 210394de1d4cSeschrock if (missing) 2104088e9d47Seschrock pool_list_remove(cb->cb_list, zhp); 2105088e9d47Seschrock 2106088e9d47Seschrock return (0); 2107088e9d47Seschrock } 2108088e9d47Seschrock 2109fa9e4066Sahrens /* 2110fa9e4066Sahrens * Callback to print out the iostats for the given pool. 2111fa9e4066Sahrens */ 2112fa9e4066Sahrens int 2113fa9e4066Sahrens print_iostat(zpool_handle_t *zhp, void *data) 2114fa9e4066Sahrens { 2115fa9e4066Sahrens iostat_cbdata_t *cb = data; 2116fa9e4066Sahrens nvlist_t *oldconfig, *newconfig; 2117fa9e4066Sahrens nvlist_t *oldnvroot, *newnvroot; 2118fa9e4066Sahrens 2119088e9d47Seschrock newconfig = zpool_get_config(zhp, &oldconfig); 2120fa9e4066Sahrens 2121088e9d47Seschrock if (cb->cb_iteration == 1) 2122fa9e4066Sahrens oldconfig = NULL; 2123fa9e4066Sahrens 2124fa9e4066Sahrens verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE, 2125fa9e4066Sahrens &newnvroot) == 0); 2126fa9e4066Sahrens 2127088e9d47Seschrock if (oldconfig == NULL) 2128fa9e4066Sahrens oldnvroot = NULL; 2129088e9d47Seschrock else 2130088e9d47Seschrock verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE, 2131088e9d47Seschrock &oldnvroot) == 0); 2132fa9e4066Sahrens 2133fa9e4066Sahrens /* 2134fa9e4066Sahrens * Print out the statistics for the pool. 2135fa9e4066Sahrens */ 2136c67d9675Seschrock print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0); 2137fa9e4066Sahrens 2138fa9e4066Sahrens if (cb->cb_verbose) 2139fa9e4066Sahrens print_iostat_separator(cb); 2140fa9e4066Sahrens 2141fa9e4066Sahrens return (0); 2142fa9e4066Sahrens } 2143fa9e4066Sahrens 2144fa9e4066Sahrens int 2145fa9e4066Sahrens get_namewidth(zpool_handle_t *zhp, void *data) 2146fa9e4066Sahrens { 2147fa9e4066Sahrens iostat_cbdata_t *cb = data; 2148fa9e4066Sahrens nvlist_t *config, *nvroot; 2149fa9e4066Sahrens 2150088e9d47Seschrock if ((config = zpool_get_config(zhp, NULL)) != NULL) { 2151fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2152fa9e4066Sahrens &nvroot) == 0); 2153fa9e4066Sahrens if (!cb->cb_verbose) 2154fa9e4066Sahrens cb->cb_namewidth = strlen(zpool_get_name(zhp)); 2155fa9e4066Sahrens else 2156c67d9675Seschrock cb->cb_namewidth = max_width(zhp, nvroot, 0, 0); 2157fa9e4066Sahrens } 2158fa9e4066Sahrens 2159fa9e4066Sahrens /* 2160fa9e4066Sahrens * The width must fall into the range [10,38]. The upper limit is the 2161fa9e4066Sahrens * maximum we can have and still fit in 80 columns. 2162fa9e4066Sahrens */ 2163fa9e4066Sahrens if (cb->cb_namewidth < 10) 2164fa9e4066Sahrens cb->cb_namewidth = 10; 2165fa9e4066Sahrens if (cb->cb_namewidth > 38) 2166fa9e4066Sahrens cb->cb_namewidth = 38; 2167fa9e4066Sahrens 2168fa9e4066Sahrens return (0); 2169fa9e4066Sahrens } 2170fa9e4066Sahrens 2171fa9e4066Sahrens /* 2172*3f9d6ad7SLin Ling * Parse the input string, get the 'interval' and 'count' value if there is one. 2173fa9e4066Sahrens */ 2174*3f9d6ad7SLin Ling static void 2175*3f9d6ad7SLin Ling get_interval_count(int *argcp, char **argv, unsigned long *iv, 2176*3f9d6ad7SLin Ling unsigned long *cnt) 2177fa9e4066Sahrens { 2178fa9e4066Sahrens unsigned long interval = 0, count = 0; 2179*3f9d6ad7SLin Ling int argc = *argcp, errno; 2180fa9e4066Sahrens 2181fa9e4066Sahrens /* 2182fa9e4066Sahrens * Determine if the last argument is an integer or a pool name 2183fa9e4066Sahrens */ 2184fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 2185fa9e4066Sahrens char *end; 2186fa9e4066Sahrens 2187fa9e4066Sahrens errno = 0; 2188fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 2189fa9e4066Sahrens 2190fa9e4066Sahrens if (*end == '\0' && errno == 0) { 2191fa9e4066Sahrens if (interval == 0) { 2192fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 2193fa9e4066Sahrens "cannot be zero\n")); 219499653d4eSeschrock usage(B_FALSE); 2195fa9e4066Sahrens } 2196fa9e4066Sahrens /* 2197fa9e4066Sahrens * Ignore the last parameter 2198fa9e4066Sahrens */ 2199fa9e4066Sahrens argc--; 2200fa9e4066Sahrens } else { 2201fa9e4066Sahrens /* 2202fa9e4066Sahrens * If this is not a valid number, just plow on. The 2203fa9e4066Sahrens * user will get a more informative error message later 2204fa9e4066Sahrens * on. 2205fa9e4066Sahrens */ 2206fa9e4066Sahrens interval = 0; 2207fa9e4066Sahrens } 2208fa9e4066Sahrens } 2209fa9e4066Sahrens 2210fa9e4066Sahrens /* 2211fa9e4066Sahrens * If the last argument is also an integer, then we have both a count 2212*3f9d6ad7SLin Ling * and an interval. 2213fa9e4066Sahrens */ 2214fa9e4066Sahrens if (argc > 0 && isdigit(argv[argc - 1][0])) { 2215fa9e4066Sahrens char *end; 2216fa9e4066Sahrens 2217fa9e4066Sahrens errno = 0; 2218fa9e4066Sahrens count = interval; 2219fa9e4066Sahrens interval = strtoul(argv[argc - 1], &end, 10); 2220fa9e4066Sahrens 2221fa9e4066Sahrens if (*end == '\0' && errno == 0) { 2222fa9e4066Sahrens if (interval == 0) { 2223fa9e4066Sahrens (void) fprintf(stderr, gettext("interval " 2224fa9e4066Sahrens "cannot be zero\n")); 222599653d4eSeschrock usage(B_FALSE); 2226fa9e4066Sahrens } 2227fa9e4066Sahrens 2228fa9e4066Sahrens /* 2229fa9e4066Sahrens * Ignore the last parameter 2230fa9e4066Sahrens */ 2231fa9e4066Sahrens argc--; 2232fa9e4066Sahrens } else { 2233fa9e4066Sahrens interval = 0; 2234fa9e4066Sahrens } 2235fa9e4066Sahrens } 2236fa9e4066Sahrens 2237*3f9d6ad7SLin Ling *iv = interval; 2238*3f9d6ad7SLin Ling *cnt = count; 2239*3f9d6ad7SLin Ling *argcp = argc; 2240*3f9d6ad7SLin Ling } 2241*3f9d6ad7SLin Ling 2242*3f9d6ad7SLin Ling static void 2243*3f9d6ad7SLin Ling get_timestamp_arg(char c) 2244*3f9d6ad7SLin Ling { 2245*3f9d6ad7SLin Ling if (c == 'u') 2246*3f9d6ad7SLin Ling timestamp_fmt = UDATE; 2247*3f9d6ad7SLin Ling else if (c == 'd') 2248*3f9d6ad7SLin Ling timestamp_fmt = DDATE; 2249*3f9d6ad7SLin Ling else 2250*3f9d6ad7SLin Ling usage(B_FALSE); 2251*3f9d6ad7SLin Ling } 2252*3f9d6ad7SLin Ling 2253*3f9d6ad7SLin Ling /* 2254*3f9d6ad7SLin Ling * zpool iostat [-v] [-T d|u] [pool] ... [interval [count]] 2255*3f9d6ad7SLin Ling * 2256*3f9d6ad7SLin Ling * -v Display statistics for individual vdevs 2257*3f9d6ad7SLin Ling * -T Display a timestamp in date(1) or Unix format 2258*3f9d6ad7SLin Ling * 2259*3f9d6ad7SLin Ling * This command can be tricky because we want to be able to deal with pool 2260*3f9d6ad7SLin Ling * creation/destruction as well as vdev configuration changes. The bulk of this 2261*3f9d6ad7SLin Ling * processing is handled by the pool_list_* routines in zpool_iter.c. We rely 2262*3f9d6ad7SLin Ling * on pool_list_update() to detect the addition of new pools. Configuration 2263*3f9d6ad7SLin Ling * changes are all handled within libzfs. 2264*3f9d6ad7SLin Ling */ 2265*3f9d6ad7SLin Ling int 2266*3f9d6ad7SLin Ling zpool_do_iostat(int argc, char **argv) 2267*3f9d6ad7SLin Ling { 2268*3f9d6ad7SLin Ling int c; 2269*3f9d6ad7SLin Ling int ret; 2270*3f9d6ad7SLin Ling int npools; 2271*3f9d6ad7SLin Ling unsigned long interval = 0, count = 0; 2272*3f9d6ad7SLin Ling zpool_list_t *list; 2273*3f9d6ad7SLin Ling boolean_t verbose = B_FALSE; 2274*3f9d6ad7SLin Ling iostat_cbdata_t cb; 2275*3f9d6ad7SLin Ling 2276*3f9d6ad7SLin Ling /* check options */ 2277*3f9d6ad7SLin Ling while ((c = getopt(argc, argv, "T:v")) != -1) { 2278*3f9d6ad7SLin Ling switch (c) { 2279*3f9d6ad7SLin Ling case 'T': 2280*3f9d6ad7SLin Ling get_timestamp_arg(*optarg); 2281*3f9d6ad7SLin Ling break; 2282*3f9d6ad7SLin Ling case 'v': 2283*3f9d6ad7SLin Ling verbose = B_TRUE; 2284*3f9d6ad7SLin Ling break; 2285*3f9d6ad7SLin Ling case '?': 2286*3f9d6ad7SLin Ling (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2287*3f9d6ad7SLin Ling optopt); 2288*3f9d6ad7SLin Ling usage(B_FALSE); 2289*3f9d6ad7SLin Ling } 2290*3f9d6ad7SLin Ling } 2291*3f9d6ad7SLin Ling 2292*3f9d6ad7SLin Ling argc -= optind; 2293*3f9d6ad7SLin Ling argv += optind; 2294*3f9d6ad7SLin Ling 2295*3f9d6ad7SLin Ling get_interval_count(&argc, argv, &interval, &count); 2296*3f9d6ad7SLin Ling 2297fa9e4066Sahrens /* 2298fa9e4066Sahrens * Construct the list of all interesting pools. 2299fa9e4066Sahrens */ 2300fa9e4066Sahrens ret = 0; 2301b1b8ab34Slling if ((list = pool_list_get(argc, argv, NULL, &ret)) == NULL) 2302fa9e4066Sahrens return (1); 2303fa9e4066Sahrens 230499653d4eSeschrock if (pool_list_count(list) == 0 && argc != 0) { 230599653d4eSeschrock pool_list_free(list); 2306fa9e4066Sahrens return (1); 230799653d4eSeschrock } 2308fa9e4066Sahrens 2309fa9e4066Sahrens if (pool_list_count(list) == 0 && interval == 0) { 231099653d4eSeschrock pool_list_free(list); 2311fa9e4066Sahrens (void) fprintf(stderr, gettext("no pools available\n")); 2312fa9e4066Sahrens return (1); 2313fa9e4066Sahrens } 2314fa9e4066Sahrens 2315fa9e4066Sahrens /* 2316fa9e4066Sahrens * Enter the main iostat loop. 2317fa9e4066Sahrens */ 2318fa9e4066Sahrens cb.cb_list = list; 2319fa9e4066Sahrens cb.cb_verbose = verbose; 2320fa9e4066Sahrens cb.cb_iteration = 0; 2321fa9e4066Sahrens cb.cb_namewidth = 0; 2322fa9e4066Sahrens 2323fa9e4066Sahrens for (;;) { 2324fa9e4066Sahrens pool_list_update(list); 2325fa9e4066Sahrens 2326fa9e4066Sahrens if ((npools = pool_list_count(list)) == 0) 2327fa9e4066Sahrens break; 2328fa9e4066Sahrens 2329088e9d47Seschrock /* 2330088e9d47Seschrock * Refresh all statistics. This is done as an explicit step 2331088e9d47Seschrock * before calculating the maximum name width, so that any 2332088e9d47Seschrock * configuration changes are properly accounted for. 2333088e9d47Seschrock */ 233499653d4eSeschrock (void) pool_list_iter(list, B_FALSE, refresh_iostat, &cb); 2335088e9d47Seschrock 2336fa9e4066Sahrens /* 2337fa9e4066Sahrens * Iterate over all pools to determine the maximum width 2338fa9e4066Sahrens * for the pool / device name column across all pools. 2339fa9e4066Sahrens */ 2340fa9e4066Sahrens cb.cb_namewidth = 0; 234199653d4eSeschrock (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb); 2342fa9e4066Sahrens 234326fd7700SKrishnendu Sadhukhan - Sun Microsystems if (timestamp_fmt != NODATE) 234426fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt); 234526fd7700SKrishnendu Sadhukhan - Sun Microsystems 2346fa9e4066Sahrens /* 2347fa9e4066Sahrens * If it's the first time, or verbose mode, print the header. 2348fa9e4066Sahrens */ 2349fa9e4066Sahrens if (++cb.cb_iteration == 1 || verbose) 2350fa9e4066Sahrens print_iostat_header(&cb); 2351fa9e4066Sahrens 235299653d4eSeschrock (void) pool_list_iter(list, B_FALSE, print_iostat, &cb); 2353fa9e4066Sahrens 2354fa9e4066Sahrens /* 2355fa9e4066Sahrens * If there's more than one pool, and we're not in verbose mode 2356fa9e4066Sahrens * (which prints a separator for us), then print a separator. 2357fa9e4066Sahrens */ 2358fa9e4066Sahrens if (npools > 1 && !verbose) 2359fa9e4066Sahrens print_iostat_separator(&cb); 2360fa9e4066Sahrens 2361fa9e4066Sahrens if (verbose) 2362fa9e4066Sahrens (void) printf("\n"); 2363fa9e4066Sahrens 236439c23413Seschrock /* 236539c23413Seschrock * Flush the output so that redirection to a file isn't buffered 236639c23413Seschrock * indefinitely. 236739c23413Seschrock */ 236839c23413Seschrock (void) fflush(stdout); 236939c23413Seschrock 2370fa9e4066Sahrens if (interval == 0) 2371fa9e4066Sahrens break; 2372fa9e4066Sahrens 2373fa9e4066Sahrens if (count != 0 && --count == 0) 2374fa9e4066Sahrens break; 2375fa9e4066Sahrens 2376fa9e4066Sahrens (void) sleep(interval); 2377fa9e4066Sahrens } 2378fa9e4066Sahrens 2379fa9e4066Sahrens pool_list_free(list); 2380fa9e4066Sahrens 2381fa9e4066Sahrens return (ret); 2382fa9e4066Sahrens } 2383fa9e4066Sahrens 2384fa9e4066Sahrens typedef struct list_cbdata { 238599653d4eSeschrock boolean_t cb_scripted; 238699653d4eSeschrock boolean_t cb_first; 2387990b4856Slling zprop_list_t *cb_proplist; 2388fa9e4066Sahrens } list_cbdata_t; 2389fa9e4066Sahrens 2390fa9e4066Sahrens /* 2391fa9e4066Sahrens * Given a list of columns to display, output appropriate headers for each one. 2392fa9e4066Sahrens */ 2393990b4856Slling static void 2394990b4856Slling print_header(zprop_list_t *pl) 2395fa9e4066Sahrens { 2396990b4856Slling const char *header; 2397990b4856Slling boolean_t first = B_TRUE; 2398990b4856Slling boolean_t right_justify; 2399990b4856Slling 2400990b4856Slling for (; pl != NULL; pl = pl->pl_next) { 2401990b4856Slling if (pl->pl_prop == ZPROP_INVAL) 2402990b4856Slling continue; 2403fa9e4066Sahrens 2404990b4856Slling if (!first) 2405fa9e4066Sahrens (void) printf(" "); 2406fa9e4066Sahrens else 2407990b4856Slling first = B_FALSE; 2408990b4856Slling 2409990b4856Slling header = zpool_prop_column_name(pl->pl_prop); 2410990b4856Slling right_justify = zpool_prop_align_right(pl->pl_prop); 2411fa9e4066Sahrens 2412990b4856Slling if (pl->pl_next == NULL && !right_justify) 2413990b4856Slling (void) printf("%s", header); 2414990b4856Slling else if (right_justify) 2415990b4856Slling (void) printf("%*s", pl->pl_width, header); 2416990b4856Slling else 2417990b4856Slling (void) printf("%-*s", pl->pl_width, header); 2418fa9e4066Sahrens } 2419fa9e4066Sahrens 2420fa9e4066Sahrens (void) printf("\n"); 2421fa9e4066Sahrens } 2422fa9e4066Sahrens 2423990b4856Slling /* 2424990b4856Slling * Given a pool and a list of properties, print out all the properties according 2425990b4856Slling * to the described layout. 2426990b4856Slling */ 2427990b4856Slling static void 2428990b4856Slling print_pool(zpool_handle_t *zhp, zprop_list_t *pl, int scripted) 2429fa9e4066Sahrens { 2430990b4856Slling boolean_t first = B_TRUE; 2431990b4856Slling char property[ZPOOL_MAXPROPLEN]; 2432990b4856Slling char *propstr; 2433990b4856Slling boolean_t right_justify; 2434990b4856Slling int width; 2435990b4856Slling 2436990b4856Slling for (; pl != NULL; pl = pl->pl_next) { 2437990b4856Slling if (!first) { 2438990b4856Slling if (scripted) 2439fa9e4066Sahrens (void) printf("\t"); 2440fa9e4066Sahrens else 2441fa9e4066Sahrens (void) printf(" "); 2442990b4856Slling } else { 2443990b4856Slling first = B_FALSE; 2444fa9e4066Sahrens } 2445fa9e4066Sahrens 2446990b4856Slling right_justify = B_FALSE; 2447990b4856Slling if (pl->pl_prop != ZPROP_INVAL) { 2448990b4856Slling if (zpool_get_prop(zhp, pl->pl_prop, property, 2449990b4856Slling sizeof (property), NULL) != 0) 2450990b4856Slling propstr = "-"; 2451fa9e4066Sahrens else 2452990b4856Slling propstr = property; 2453fa9e4066Sahrens 2454990b4856Slling right_justify = zpool_prop_align_right(pl->pl_prop); 2455990b4856Slling } else { 2456990b4856Slling propstr = "-"; 2457990b4856Slling } 2458fa9e4066Sahrens 2459990b4856Slling width = pl->pl_width; 2460fa9e4066Sahrens 2461990b4856Slling /* 2462990b4856Slling * If this is being called in scripted mode, or if this is the 2463990b4856Slling * last column and it is left-justified, don't include a width 2464990b4856Slling * format specifier. 2465990b4856Slling */ 2466990b4856Slling if (scripted || (pl->pl_next == NULL && !right_justify)) 2467990b4856Slling (void) printf("%s", propstr); 2468990b4856Slling else if (right_justify) 2469990b4856Slling (void) printf("%*s", width, propstr); 2470990b4856Slling else 2471990b4856Slling (void) printf("%-*s", width, propstr); 2472990b4856Slling } 2473fa9e4066Sahrens 2474990b4856Slling (void) printf("\n"); 2475990b4856Slling } 2476fa9e4066Sahrens 2477990b4856Slling /* 2478990b4856Slling * Generic callback function to list a pool. 2479990b4856Slling */ 2480990b4856Slling int 2481990b4856Slling list_callback(zpool_handle_t *zhp, void *data) 2482990b4856Slling { 2483990b4856Slling list_cbdata_t *cbp = data; 2484fa9e4066Sahrens 2485990b4856Slling if (cbp->cb_first) { 2486990b4856Slling if (!cbp->cb_scripted) 2487990b4856Slling print_header(cbp->cb_proplist); 2488990b4856Slling cbp->cb_first = B_FALSE; 2489fa9e4066Sahrens } 2490fa9e4066Sahrens 2491990b4856Slling print_pool(zhp, cbp->cb_proplist, cbp->cb_scripted); 2492fa9e4066Sahrens 2493fa9e4066Sahrens return (0); 2494fa9e4066Sahrens } 2495fa9e4066Sahrens 2496fa9e4066Sahrens /* 2497*3f9d6ad7SLin Ling * zpool list [-H] [-o prop[,prop]*] [-T d|u] [pool] ... [interval [count]] 2498fa9e4066Sahrens * 2499990b4856Slling * -H Scripted mode. Don't display headers, and separate properties 2500990b4856Slling * by a single tab. 2501990b4856Slling * -o List of properties to display. Defaults to 2502485bbbf5SGeorge Wilson * "name,size,allocated,free,capacity,health,altroot" 2503*3f9d6ad7SLin Ling * -T Display a timestamp in date(1) or Unix format 2504fa9e4066Sahrens * 2505fa9e4066Sahrens * List all pools in the system, whether or not they're healthy. Output space 2506fa9e4066Sahrens * statistics for each one, as well as health status summary. 2507fa9e4066Sahrens */ 2508fa9e4066Sahrens int 2509fa9e4066Sahrens zpool_do_list(int argc, char **argv) 2510fa9e4066Sahrens { 2511fa9e4066Sahrens int c; 2512fa9e4066Sahrens int ret; 2513fa9e4066Sahrens list_cbdata_t cb = { 0 }; 2514990b4856Slling static char default_props[] = 2515485bbbf5SGeorge Wilson "name,size,allocated,free,capacity,dedupratio,health,altroot"; 2516990b4856Slling char *props = default_props; 2517*3f9d6ad7SLin Ling unsigned long interval = 0, count = 0; 2518fa9e4066Sahrens 2519fa9e4066Sahrens /* check options */ 2520*3f9d6ad7SLin Ling while ((c = getopt(argc, argv, ":Ho:T:")) != -1) { 2521fa9e4066Sahrens switch (c) { 2522fa9e4066Sahrens case 'H': 252399653d4eSeschrock cb.cb_scripted = B_TRUE; 2524fa9e4066Sahrens break; 2525fa9e4066Sahrens case 'o': 2526990b4856Slling props = optarg; 2527fa9e4066Sahrens break; 2528*3f9d6ad7SLin Ling case 'T': 2529*3f9d6ad7SLin Ling get_timestamp_arg(*optarg); 2530*3f9d6ad7SLin Ling break; 2531fa9e4066Sahrens case ':': 2532fa9e4066Sahrens (void) fprintf(stderr, gettext("missing argument for " 2533fa9e4066Sahrens "'%c' option\n"), optopt); 253499653d4eSeschrock usage(B_FALSE); 2535fa9e4066Sahrens break; 2536fa9e4066Sahrens case '?': 2537fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2538fa9e4066Sahrens optopt); 253999653d4eSeschrock usage(B_FALSE); 2540fa9e4066Sahrens } 2541fa9e4066Sahrens } 2542fa9e4066Sahrens 2543fa9e4066Sahrens argc -= optind; 2544fa9e4066Sahrens argv += optind; 2545fa9e4066Sahrens 2546*3f9d6ad7SLin Ling get_interval_count(&argc, argv, &interval, &count); 2547*3f9d6ad7SLin Ling 2548990b4856Slling if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0) 2549990b4856Slling usage(B_FALSE); 2550fa9e4066Sahrens 255199653d4eSeschrock cb.cb_first = B_TRUE; 2552fa9e4066Sahrens 2553*3f9d6ad7SLin Ling for (;;) { 2554990b4856Slling 2555*3f9d6ad7SLin Ling if (timestamp_fmt != NODATE) 2556*3f9d6ad7SLin Ling print_timestamp(timestamp_fmt); 2557fa9e4066Sahrens 2558*3f9d6ad7SLin Ling ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist, 2559*3f9d6ad7SLin Ling list_callback, &cb); 2560*3f9d6ad7SLin Ling 2561*3f9d6ad7SLin Ling if (argc == 0 && cb.cb_first && !cb.cb_scripted) { 2562*3f9d6ad7SLin Ling (void) printf(gettext("no pools available\n")); 2563*3f9d6ad7SLin Ling zprop_free_list(cb.cb_proplist); 2564*3f9d6ad7SLin Ling return (0); 2565*3f9d6ad7SLin Ling } 2566*3f9d6ad7SLin Ling 2567*3f9d6ad7SLin Ling if (interval == 0) 2568*3f9d6ad7SLin Ling break; 2569*3f9d6ad7SLin Ling 2570*3f9d6ad7SLin Ling if (count != 0 && --count == 0) 2571*3f9d6ad7SLin Ling break; 2572*3f9d6ad7SLin Ling 2573*3f9d6ad7SLin Ling (void) sleep(interval); 2574fa9e4066Sahrens } 2575fa9e4066Sahrens 2576*3f9d6ad7SLin Ling zprop_free_list(cb.cb_proplist); 2577fa9e4066Sahrens return (ret); 2578fa9e4066Sahrens } 2579fa9e4066Sahrens 2580fa9e4066Sahrens static nvlist_t * 2581fa9e4066Sahrens zpool_get_vdev_by_name(nvlist_t *nv, char *name) 2582fa9e4066Sahrens { 2583fa9e4066Sahrens nvlist_t **child; 2584fa9e4066Sahrens uint_t c, children; 2585fa9e4066Sahrens nvlist_t *match; 2586fa9e4066Sahrens char *path; 2587fa9e4066Sahrens 2588fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2589fa9e4066Sahrens &child, &children) != 0) { 2590fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 2591fa9e4066Sahrens if (strncmp(name, "/dev/dsk/", 9) == 0) 2592fa9e4066Sahrens name += 9; 2593fa9e4066Sahrens if (strncmp(path, "/dev/dsk/", 9) == 0) 2594fa9e4066Sahrens path += 9; 2595fa9e4066Sahrens if (strcmp(name, path) == 0) 2596fa9e4066Sahrens return (nv); 2597fa9e4066Sahrens return (NULL); 2598fa9e4066Sahrens } 2599fa9e4066Sahrens 2600fa9e4066Sahrens for (c = 0; c < children; c++) 2601fa9e4066Sahrens if ((match = zpool_get_vdev_by_name(child[c], name)) != NULL) 2602fa9e4066Sahrens return (match); 2603fa9e4066Sahrens 2604fa9e4066Sahrens return (NULL); 2605fa9e4066Sahrens } 2606fa9e4066Sahrens 2607fa9e4066Sahrens static int 2608fa9e4066Sahrens zpool_do_attach_or_replace(int argc, char **argv, int replacing) 2609fa9e4066Sahrens { 261099653d4eSeschrock boolean_t force = B_FALSE; 2611fa9e4066Sahrens int c; 2612fa9e4066Sahrens nvlist_t *nvroot; 2613fa9e4066Sahrens char *poolname, *old_disk, *new_disk; 2614fa9e4066Sahrens zpool_handle_t *zhp; 261599653d4eSeschrock int ret; 2616fa9e4066Sahrens 2617fa9e4066Sahrens /* check options */ 2618fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2619fa9e4066Sahrens switch (c) { 2620fa9e4066Sahrens case 'f': 262199653d4eSeschrock force = B_TRUE; 2622fa9e4066Sahrens break; 2623fa9e4066Sahrens case '?': 2624fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2625fa9e4066Sahrens optopt); 262699653d4eSeschrock usage(B_FALSE); 2627fa9e4066Sahrens } 2628fa9e4066Sahrens } 2629fa9e4066Sahrens 2630fa9e4066Sahrens argc -= optind; 2631fa9e4066Sahrens argv += optind; 2632fa9e4066Sahrens 2633fa9e4066Sahrens /* get pool name and check number of arguments */ 2634fa9e4066Sahrens if (argc < 1) { 2635fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 263699653d4eSeschrock usage(B_FALSE); 2637fa9e4066Sahrens } 2638fa9e4066Sahrens 2639fa9e4066Sahrens poolname = argv[0]; 2640fa9e4066Sahrens 2641fa9e4066Sahrens if (argc < 2) { 2642fa9e4066Sahrens (void) fprintf(stderr, 2643fa9e4066Sahrens gettext("missing <device> specification\n")); 264499653d4eSeschrock usage(B_FALSE); 2645fa9e4066Sahrens } 2646fa9e4066Sahrens 2647fa9e4066Sahrens old_disk = argv[1]; 2648fa9e4066Sahrens 2649fa9e4066Sahrens if (argc < 3) { 2650fa9e4066Sahrens if (!replacing) { 2651fa9e4066Sahrens (void) fprintf(stderr, 2652fa9e4066Sahrens gettext("missing <new_device> specification\n")); 265399653d4eSeschrock usage(B_FALSE); 2654fa9e4066Sahrens } 2655fa9e4066Sahrens new_disk = old_disk; 2656fa9e4066Sahrens argc -= 1; 2657fa9e4066Sahrens argv += 1; 2658fa9e4066Sahrens } else { 2659fa9e4066Sahrens new_disk = argv[2]; 2660fa9e4066Sahrens argc -= 2; 2661fa9e4066Sahrens argv += 2; 2662fa9e4066Sahrens } 2663fa9e4066Sahrens 2664fa9e4066Sahrens if (argc > 1) { 2665fa9e4066Sahrens (void) fprintf(stderr, gettext("too many arguments\n")); 266699653d4eSeschrock usage(B_FALSE); 2667fa9e4066Sahrens } 2668fa9e4066Sahrens 266999653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2670fa9e4066Sahrens return (1); 2671fa9e4066Sahrens 26728488aeb5Staylor if (zpool_get_config(zhp, NULL) == NULL) { 2673fa9e4066Sahrens (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 2674fa9e4066Sahrens poolname); 2675fa9e4066Sahrens zpool_close(zhp); 2676fa9e4066Sahrens return (1); 2677fa9e4066Sahrens } 2678fa9e4066Sahrens 2679705040edSEric Taylor nvroot = make_root_vdev(zhp, force, B_FALSE, replacing, B_FALSE, 2680705040edSEric Taylor argc, argv); 2681fa9e4066Sahrens if (nvroot == NULL) { 2682fa9e4066Sahrens zpool_close(zhp); 2683fa9e4066Sahrens return (1); 2684fa9e4066Sahrens } 2685fa9e4066Sahrens 268699653d4eSeschrock ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing); 268799653d4eSeschrock 268899653d4eSeschrock nvlist_free(nvroot); 268999653d4eSeschrock zpool_close(zhp); 269099653d4eSeschrock 269199653d4eSeschrock return (ret); 2692fa9e4066Sahrens } 2693fa9e4066Sahrens 2694fa9e4066Sahrens /* 2695fa9e4066Sahrens * zpool replace [-f] <pool> <device> <new_device> 2696fa9e4066Sahrens * 2697fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 2698fa9e4066Sahrens * 2699fa9e4066Sahrens * Replace <device> with <new_device>. 2700fa9e4066Sahrens */ 2701fa9e4066Sahrens /* ARGSUSED */ 2702fa9e4066Sahrens int 2703fa9e4066Sahrens zpool_do_replace(int argc, char **argv) 2704fa9e4066Sahrens { 2705fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_TRUE)); 2706fa9e4066Sahrens } 2707fa9e4066Sahrens 2708fa9e4066Sahrens /* 2709fa9e4066Sahrens * zpool attach [-f] <pool> <device> <new_device> 2710fa9e4066Sahrens * 2711fa9e4066Sahrens * -f Force attach, even if <new_device> appears to be in use. 2712fa9e4066Sahrens * 2713fa9e4066Sahrens * Attach <new_device> to the mirror containing <device>. If <device> is not 2714fa9e4066Sahrens * part of a mirror, then <device> will be transformed into a mirror of 2715fa9e4066Sahrens * <device> and <new_device>. In either case, <new_device> will begin life 2716fa9e4066Sahrens * with a DTL of [0, now], and will immediately begin to resilver itself. 2717fa9e4066Sahrens */ 2718fa9e4066Sahrens int 2719fa9e4066Sahrens zpool_do_attach(int argc, char **argv) 2720fa9e4066Sahrens { 2721fa9e4066Sahrens return (zpool_do_attach_or_replace(argc, argv, B_FALSE)); 2722fa9e4066Sahrens } 2723fa9e4066Sahrens 2724fa9e4066Sahrens /* 2725fa9e4066Sahrens * zpool detach [-f] <pool> <device> 2726fa9e4066Sahrens * 2727fa9e4066Sahrens * -f Force detach of <device>, even if DTLs argue against it 2728fa9e4066Sahrens * (not supported yet) 2729fa9e4066Sahrens * 2730fa9e4066Sahrens * Detach a device from a mirror. The operation will be refused if <device> 2731fa9e4066Sahrens * is the last device in the mirror, or if the DTLs indicate that this device 2732fa9e4066Sahrens * has the only valid copy of some data. 2733fa9e4066Sahrens */ 2734fa9e4066Sahrens /* ARGSUSED */ 2735fa9e4066Sahrens int 2736fa9e4066Sahrens zpool_do_detach(int argc, char **argv) 2737fa9e4066Sahrens { 2738fa9e4066Sahrens int c; 2739fa9e4066Sahrens char *poolname, *path; 2740fa9e4066Sahrens zpool_handle_t *zhp; 274199653d4eSeschrock int ret; 2742fa9e4066Sahrens 2743fa9e4066Sahrens /* check options */ 2744fa9e4066Sahrens while ((c = getopt(argc, argv, "f")) != -1) { 2745fa9e4066Sahrens switch (c) { 2746fa9e4066Sahrens case 'f': 2747fa9e4066Sahrens case '?': 2748fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2749fa9e4066Sahrens optopt); 275099653d4eSeschrock usage(B_FALSE); 2751fa9e4066Sahrens } 2752fa9e4066Sahrens } 2753fa9e4066Sahrens 2754fa9e4066Sahrens argc -= optind; 2755fa9e4066Sahrens argv += optind; 2756fa9e4066Sahrens 2757fa9e4066Sahrens /* get pool name and check number of arguments */ 2758fa9e4066Sahrens if (argc < 1) { 2759fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 276099653d4eSeschrock usage(B_FALSE); 2761fa9e4066Sahrens } 2762fa9e4066Sahrens 2763fa9e4066Sahrens if (argc < 2) { 2764fa9e4066Sahrens (void) fprintf(stderr, 2765fa9e4066Sahrens gettext("missing <device> specification\n")); 276699653d4eSeschrock usage(B_FALSE); 2767fa9e4066Sahrens } 2768fa9e4066Sahrens 2769fa9e4066Sahrens poolname = argv[0]; 2770fa9e4066Sahrens path = argv[1]; 2771fa9e4066Sahrens 277299653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2773fa9e4066Sahrens return (1); 2774fa9e4066Sahrens 277599653d4eSeschrock ret = zpool_vdev_detach(zhp, path); 277699653d4eSeschrock 277799653d4eSeschrock zpool_close(zhp); 277899653d4eSeschrock 277999653d4eSeschrock return (ret); 2780fa9e4066Sahrens } 2781fa9e4066Sahrens 27821195e687SMark J Musante /* 27831195e687SMark J Musante * zpool split [-n] [-o prop=val] ... 27841195e687SMark J Musante * [-o mntopt] ... 27851195e687SMark J Musante * [-R altroot] <pool> <newpool> [<device> ...] 27861195e687SMark J Musante * 27871195e687SMark J Musante * -n Do not split the pool, but display the resulting layout if 27881195e687SMark J Musante * it were to be split. 27891195e687SMark J Musante * -o Set property=value, or set mount options. 27901195e687SMark J Musante * -R Mount the split-off pool under an alternate root. 27911195e687SMark J Musante * 27921195e687SMark J Musante * Splits the named pool and gives it the new pool name. Devices to be split 27931195e687SMark J Musante * off may be listed, provided that no more than one device is specified 27941195e687SMark J Musante * per top-level vdev mirror. The newly split pool is left in an exported 27951195e687SMark J Musante * state unless -R is specified. 27961195e687SMark J Musante * 27971195e687SMark J Musante * Restrictions: the top-level of the pool pool must only be made up of 27981195e687SMark J Musante * mirrors; all devices in the pool must be healthy; no device may be 27991195e687SMark J Musante * undergoing a resilvering operation. 28001195e687SMark J Musante */ 28011195e687SMark J Musante int 28021195e687SMark J Musante zpool_do_split(int argc, char **argv) 28031195e687SMark J Musante { 28041195e687SMark J Musante char *srcpool, *newpool, *propval; 28051195e687SMark J Musante char *mntopts = NULL; 28061195e687SMark J Musante splitflags_t flags; 28071195e687SMark J Musante int c, ret = 0; 28081195e687SMark J Musante zpool_handle_t *zhp; 28091195e687SMark J Musante nvlist_t *config, *props = NULL; 28101195e687SMark J Musante 28111195e687SMark J Musante flags.dryrun = B_FALSE; 28121195e687SMark J Musante flags.import = B_FALSE; 28131195e687SMark J Musante 28141195e687SMark J Musante /* check options */ 28151195e687SMark J Musante while ((c = getopt(argc, argv, ":R:no:")) != -1) { 28161195e687SMark J Musante switch (c) { 28171195e687SMark J Musante case 'R': 28181195e687SMark J Musante flags.import = B_TRUE; 28191195e687SMark J Musante if (add_prop_list( 28201195e687SMark J Musante zpool_prop_to_name(ZPOOL_PROP_ALTROOT), optarg, 28211195e687SMark J Musante &props, B_TRUE) != 0) { 28221195e687SMark J Musante if (props) 28231195e687SMark J Musante nvlist_free(props); 28241195e687SMark J Musante usage(B_FALSE); 28251195e687SMark J Musante } 28261195e687SMark J Musante break; 28271195e687SMark J Musante case 'n': 28281195e687SMark J Musante flags.dryrun = B_TRUE; 28291195e687SMark J Musante break; 28301195e687SMark J Musante case 'o': 28311195e687SMark J Musante if ((propval = strchr(optarg, '=')) != NULL) { 28321195e687SMark J Musante *propval = '\0'; 28331195e687SMark J Musante propval++; 28341195e687SMark J Musante if (add_prop_list(optarg, propval, 28351195e687SMark J Musante &props, B_TRUE) != 0) { 28361195e687SMark J Musante if (props) 28371195e687SMark J Musante nvlist_free(props); 28381195e687SMark J Musante usage(B_FALSE); 28391195e687SMark J Musante } 28401195e687SMark J Musante } else { 28411195e687SMark J Musante mntopts = optarg; 28421195e687SMark J Musante } 28431195e687SMark J Musante break; 28441195e687SMark J Musante case ':': 28451195e687SMark J Musante (void) fprintf(stderr, gettext("missing argument for " 28461195e687SMark J Musante "'%c' option\n"), optopt); 28471195e687SMark J Musante usage(B_FALSE); 28481195e687SMark J Musante break; 28491195e687SMark J Musante case '?': 28501195e687SMark J Musante (void) fprintf(stderr, gettext("invalid option '%c'\n"), 28511195e687SMark J Musante optopt); 28521195e687SMark J Musante usage(B_FALSE); 28531195e687SMark J Musante break; 28541195e687SMark J Musante } 28551195e687SMark J Musante } 28561195e687SMark J Musante 28571195e687SMark J Musante if (!flags.import && mntopts != NULL) { 28581195e687SMark J Musante (void) fprintf(stderr, gettext("setting mntopts is only " 28591195e687SMark J Musante "valid when importing the pool\n")); 28601195e687SMark J Musante usage(B_FALSE); 28611195e687SMark J Musante } 28621195e687SMark J Musante 28631195e687SMark J Musante argc -= optind; 28641195e687SMark J Musante argv += optind; 28651195e687SMark J Musante 28661195e687SMark J Musante if (argc < 1) { 28671195e687SMark J Musante (void) fprintf(stderr, gettext("Missing pool name\n")); 28681195e687SMark J Musante usage(B_FALSE); 28691195e687SMark J Musante } 28701195e687SMark J Musante if (argc < 2) { 28711195e687SMark J Musante (void) fprintf(stderr, gettext("Missing new pool name\n")); 28721195e687SMark J Musante usage(B_FALSE); 28731195e687SMark J Musante } 28741195e687SMark J Musante 28751195e687SMark J Musante srcpool = argv[0]; 28761195e687SMark J Musante newpool = argv[1]; 28771195e687SMark J Musante 28781195e687SMark J Musante argc -= 2; 28791195e687SMark J Musante argv += 2; 28801195e687SMark J Musante 28811195e687SMark J Musante if ((zhp = zpool_open(g_zfs, srcpool)) == NULL) 28821195e687SMark J Musante return (1); 28831195e687SMark J Musante 28841195e687SMark J Musante config = split_mirror_vdev(zhp, newpool, props, flags, argc, argv); 28851195e687SMark J Musante if (config == NULL) { 28861195e687SMark J Musante ret = 1; 28871195e687SMark J Musante } else { 28881195e687SMark J Musante if (flags.dryrun) { 28891195e687SMark J Musante (void) printf(gettext("would create '%s' with the " 28901195e687SMark J Musante "following layout:\n\n"), newpool); 28911195e687SMark J Musante print_vdev_tree(NULL, newpool, config, 0, B_FALSE); 28921195e687SMark J Musante } 28931195e687SMark J Musante nvlist_free(config); 28941195e687SMark J Musante } 28951195e687SMark J Musante 28961195e687SMark J Musante zpool_close(zhp); 28971195e687SMark J Musante 28981195e687SMark J Musante if (ret != 0 || flags.dryrun || !flags.import) 28991195e687SMark J Musante return (ret); 29001195e687SMark J Musante 29011195e687SMark J Musante /* 29021195e687SMark J Musante * The split was successful. Now we need to open the new 29031195e687SMark J Musante * pool and import it. 29041195e687SMark J Musante */ 29051195e687SMark J Musante if ((zhp = zpool_open_canfail(g_zfs, newpool)) == NULL) 29061195e687SMark J Musante return (1); 29071195e687SMark J Musante if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 29081195e687SMark J Musante zpool_enable_datasets(zhp, mntopts, 0) != 0) { 29091195e687SMark J Musante ret = 1; 29101195e687SMark J Musante (void) fprintf(stderr, gettext("Split was succssful, but " 29111195e687SMark J Musante "the datasets could not all be mounted\n")); 29121195e687SMark J Musante (void) fprintf(stderr, gettext("Try doing '%s' with a " 29131195e687SMark J Musante "different altroot\n"), "zpool import"); 29141195e687SMark J Musante } 29151195e687SMark J Musante zpool_close(zhp); 29161195e687SMark J Musante 29171195e687SMark J Musante return (ret); 29181195e687SMark J Musante } 29191195e687SMark J Musante 29201195e687SMark J Musante 29211195e687SMark J Musante 2922fa9e4066Sahrens /* 2923441d80aaSlling * zpool online <pool> <device> ... 2924fa9e4066Sahrens */ 2925fa9e4066Sahrens int 2926fa9e4066Sahrens zpool_do_online(int argc, char **argv) 2927fa9e4066Sahrens { 2928fa9e4066Sahrens int c, i; 2929fa9e4066Sahrens char *poolname; 2930fa9e4066Sahrens zpool_handle_t *zhp; 2931fa9e4066Sahrens int ret = 0; 29323d7072f8Seschrock vdev_state_t newstate; 2933573ca77eSGeorge Wilson int flags = 0; 2934fa9e4066Sahrens 2935fa9e4066Sahrens /* check options */ 2936573ca77eSGeorge Wilson while ((c = getopt(argc, argv, "et")) != -1) { 2937fa9e4066Sahrens switch (c) { 2938573ca77eSGeorge Wilson case 'e': 2939573ca77eSGeorge Wilson flags |= ZFS_ONLINE_EXPAND; 2940573ca77eSGeorge Wilson break; 2941fa9e4066Sahrens case 't': 2942fa9e4066Sahrens case '?': 2943fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 2944fa9e4066Sahrens optopt); 294599653d4eSeschrock usage(B_FALSE); 2946fa9e4066Sahrens } 2947fa9e4066Sahrens } 2948fa9e4066Sahrens 2949fa9e4066Sahrens argc -= optind; 2950fa9e4066Sahrens argv += optind; 2951fa9e4066Sahrens 2952fa9e4066Sahrens /* get pool name and check number of arguments */ 2953fa9e4066Sahrens if (argc < 1) { 2954fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 295599653d4eSeschrock usage(B_FALSE); 2956fa9e4066Sahrens } 2957fa9e4066Sahrens if (argc < 2) { 2958fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 295999653d4eSeschrock usage(B_FALSE); 2960fa9e4066Sahrens } 2961fa9e4066Sahrens 2962fa9e4066Sahrens poolname = argv[0]; 2963fa9e4066Sahrens 296499653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 2965fa9e4066Sahrens return (1); 2966fa9e4066Sahrens 29673d7072f8Seschrock for (i = 1; i < argc; i++) { 2968573ca77eSGeorge Wilson if (zpool_vdev_online(zhp, argv[i], flags, &newstate) == 0) { 29693d7072f8Seschrock if (newstate != VDEV_STATE_HEALTHY) { 29703d7072f8Seschrock (void) printf(gettext("warning: device '%s' " 29713d7072f8Seschrock "onlined, but remains in faulted state\n"), 29723d7072f8Seschrock argv[i]); 29733d7072f8Seschrock if (newstate == VDEV_STATE_FAULTED) 29743d7072f8Seschrock (void) printf(gettext("use 'zpool " 29753d7072f8Seschrock "clear' to restore a faulted " 29763d7072f8Seschrock "device\n")); 29773d7072f8Seschrock else 29783d7072f8Seschrock (void) printf(gettext("use 'zpool " 29793d7072f8Seschrock "replace' to replace devices " 29803d7072f8Seschrock "that are no longer present\n")); 29813d7072f8Seschrock } 29823d7072f8Seschrock } else { 2983fa9e4066Sahrens ret = 1; 29843d7072f8Seschrock } 29853d7072f8Seschrock } 2986fa9e4066Sahrens 298799653d4eSeschrock zpool_close(zhp); 298899653d4eSeschrock 2989fa9e4066Sahrens return (ret); 2990fa9e4066Sahrens } 2991fa9e4066Sahrens 2992fa9e4066Sahrens /* 2993441d80aaSlling * zpool offline [-ft] <pool> <device> ... 2994fa9e4066Sahrens * 2995fa9e4066Sahrens * -f Force the device into the offline state, even if doing 2996fa9e4066Sahrens * so would appear to compromise pool availability. 2997fa9e4066Sahrens * (not supported yet) 2998fa9e4066Sahrens * 2999fa9e4066Sahrens * -t Only take the device off-line temporarily. The offline 3000fa9e4066Sahrens * state will not be persistent across reboots. 3001fa9e4066Sahrens */ 3002fa9e4066Sahrens /* ARGSUSED */ 3003fa9e4066Sahrens int 3004fa9e4066Sahrens zpool_do_offline(int argc, char **argv) 3005fa9e4066Sahrens { 3006fa9e4066Sahrens int c, i; 3007fa9e4066Sahrens char *poolname; 3008fa9e4066Sahrens zpool_handle_t *zhp; 300999653d4eSeschrock int ret = 0; 301099653d4eSeschrock boolean_t istmp = B_FALSE; 3011fa9e4066Sahrens 3012fa9e4066Sahrens /* check options */ 3013fa9e4066Sahrens while ((c = getopt(argc, argv, "ft")) != -1) { 3014fa9e4066Sahrens switch (c) { 3015fa9e4066Sahrens case 't': 301699653d4eSeschrock istmp = B_TRUE; 3017441d80aaSlling break; 3018441d80aaSlling case 'f': 3019fa9e4066Sahrens case '?': 3020fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3021fa9e4066Sahrens optopt); 302299653d4eSeschrock usage(B_FALSE); 3023fa9e4066Sahrens } 3024fa9e4066Sahrens } 3025fa9e4066Sahrens 3026fa9e4066Sahrens argc -= optind; 3027fa9e4066Sahrens argv += optind; 3028fa9e4066Sahrens 3029fa9e4066Sahrens /* get pool name and check number of arguments */ 3030fa9e4066Sahrens if (argc < 1) { 3031fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name\n")); 303299653d4eSeschrock usage(B_FALSE); 3033fa9e4066Sahrens } 3034fa9e4066Sahrens if (argc < 2) { 3035fa9e4066Sahrens (void) fprintf(stderr, gettext("missing device name\n")); 303699653d4eSeschrock usage(B_FALSE); 3037fa9e4066Sahrens } 3038fa9e4066Sahrens 3039fa9e4066Sahrens poolname = argv[0]; 3040fa9e4066Sahrens 304199653d4eSeschrock if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 3042fa9e4066Sahrens return (1); 3043fa9e4066Sahrens 30443d7072f8Seschrock for (i = 1; i < argc; i++) { 30453d7072f8Seschrock if (zpool_vdev_offline(zhp, argv[i], istmp) != 0) 3046fa9e4066Sahrens ret = 1; 30473d7072f8Seschrock } 3048fa9e4066Sahrens 304999653d4eSeschrock zpool_close(zhp); 305099653d4eSeschrock 3051fa9e4066Sahrens return (ret); 3052fa9e4066Sahrens } 3053fa9e4066Sahrens 3054ea8dc4b6Seschrock /* 3055ea8dc4b6Seschrock * zpool clear <pool> [device] 3056ea8dc4b6Seschrock * 3057ea8dc4b6Seschrock * Clear all errors associated with a pool or a particular device. 3058ea8dc4b6Seschrock */ 3059ea8dc4b6Seschrock int 3060ea8dc4b6Seschrock zpool_do_clear(int argc, char **argv) 3061ea8dc4b6Seschrock { 3062468c413aSTim Haley int c; 3063ea8dc4b6Seschrock int ret = 0; 3064468c413aSTim Haley boolean_t dryrun = B_FALSE; 3065468c413aSTim Haley boolean_t do_rewind = B_FALSE; 3066468c413aSTim Haley boolean_t xtreme_rewind = B_FALSE; 3067468c413aSTim Haley uint32_t rewind_policy = ZPOOL_NO_REWIND; 3068468c413aSTim Haley nvlist_t *policy = NULL; 3069ea8dc4b6Seschrock zpool_handle_t *zhp; 3070ea8dc4b6Seschrock char *pool, *device; 3071ea8dc4b6Seschrock 3072468c413aSTim Haley /* check options */ 3073468c413aSTim Haley while ((c = getopt(argc, argv, "FnX")) != -1) { 3074468c413aSTim Haley switch (c) { 3075468c413aSTim Haley case 'F': 3076468c413aSTim Haley do_rewind = B_TRUE; 3077468c413aSTim Haley break; 3078468c413aSTim Haley case 'n': 3079468c413aSTim Haley dryrun = B_TRUE; 3080468c413aSTim Haley break; 3081468c413aSTim Haley case 'X': 3082468c413aSTim Haley xtreme_rewind = B_TRUE; 3083468c413aSTim Haley break; 3084468c413aSTim Haley case '?': 3085468c413aSTim Haley (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3086468c413aSTim Haley optopt); 3087468c413aSTim Haley usage(B_FALSE); 3088468c413aSTim Haley } 3089468c413aSTim Haley } 3090468c413aSTim Haley 3091468c413aSTim Haley argc -= optind; 3092468c413aSTim Haley argv += optind; 3093468c413aSTim Haley 3094468c413aSTim Haley if (argc < 1) { 3095ea8dc4b6Seschrock (void) fprintf(stderr, gettext("missing pool name\n")); 309699653d4eSeschrock usage(B_FALSE); 3097ea8dc4b6Seschrock } 3098ea8dc4b6Seschrock 3099468c413aSTim Haley if (argc > 2) { 3100ea8dc4b6Seschrock (void) fprintf(stderr, gettext("too many arguments\n")); 310199653d4eSeschrock usage(B_FALSE); 3102ea8dc4b6Seschrock } 3103ea8dc4b6Seschrock 3104468c413aSTim Haley if ((dryrun || xtreme_rewind) && !do_rewind) { 3105468c413aSTim Haley (void) fprintf(stderr, 3106468c413aSTim Haley gettext("-n or -X only meaningful with -F\n")); 3107468c413aSTim Haley usage(B_FALSE); 3108468c413aSTim Haley } 3109468c413aSTim Haley if (dryrun) 3110468c413aSTim Haley rewind_policy = ZPOOL_TRY_REWIND; 3111468c413aSTim Haley else if (do_rewind) 3112468c413aSTim Haley rewind_policy = ZPOOL_DO_REWIND; 3113468c413aSTim Haley if (xtreme_rewind) 3114468c413aSTim Haley rewind_policy |= ZPOOL_EXTREME_REWIND; 3115468c413aSTim Haley 3116468c413aSTim Haley /* In future, further rewind policy choices can be passed along here */ 3117468c413aSTim Haley if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 3118468c413aSTim Haley nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0) 3119468c413aSTim Haley return (1); 3120468c413aSTim Haley 3121468c413aSTim Haley pool = argv[0]; 3122468c413aSTim Haley device = argc == 2 ? argv[1] : NULL; 3123ea8dc4b6Seschrock 3124468c413aSTim Haley if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 3125468c413aSTim Haley nvlist_free(policy); 3126ea8dc4b6Seschrock return (1); 3127468c413aSTim Haley } 3128ea8dc4b6Seschrock 3129468c413aSTim Haley if (zpool_clear(zhp, device, policy) != 0) 3130ea8dc4b6Seschrock ret = 1; 3131ea8dc4b6Seschrock 3132ea8dc4b6Seschrock zpool_close(zhp); 3133ea8dc4b6Seschrock 3134468c413aSTim Haley nvlist_free(policy); 3135468c413aSTim Haley 3136ea8dc4b6Seschrock return (ret); 3137ea8dc4b6Seschrock } 3138ea8dc4b6Seschrock 3139fa9e4066Sahrens typedef struct scrub_cbdata { 3140fa9e4066Sahrens int cb_type; 314106eeb2adSek int cb_argc; 314206eeb2adSek char **cb_argv; 3143fa9e4066Sahrens } scrub_cbdata_t; 3144fa9e4066Sahrens 3145fa9e4066Sahrens int 3146fa9e4066Sahrens scrub_callback(zpool_handle_t *zhp, void *data) 3147fa9e4066Sahrens { 3148fa9e4066Sahrens scrub_cbdata_t *cb = data; 314906eeb2adSek int err; 3150fa9e4066Sahrens 3151ea8dc4b6Seschrock /* 3152ea8dc4b6Seschrock * Ignore faulted pools. 3153ea8dc4b6Seschrock */ 3154ea8dc4b6Seschrock if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 3155ea8dc4b6Seschrock (void) fprintf(stderr, gettext("cannot scrub '%s': pool is " 3156ea8dc4b6Seschrock "currently unavailable\n"), zpool_get_name(zhp)); 3157ea8dc4b6Seschrock return (1); 3158ea8dc4b6Seschrock } 3159ea8dc4b6Seschrock 3160*3f9d6ad7SLin Ling err = zpool_scan(zhp, cb->cb_type); 316106eeb2adSek 316206eeb2adSek return (err != 0); 3163fa9e4066Sahrens } 3164fa9e4066Sahrens 3165fa9e4066Sahrens /* 3166fa9e4066Sahrens * zpool scrub [-s] <pool> ... 3167fa9e4066Sahrens * 3168fa9e4066Sahrens * -s Stop. Stops any in-progress scrub. 3169fa9e4066Sahrens */ 3170fa9e4066Sahrens int 3171fa9e4066Sahrens zpool_do_scrub(int argc, char **argv) 3172fa9e4066Sahrens { 3173fa9e4066Sahrens int c; 3174fa9e4066Sahrens scrub_cbdata_t cb; 3175fa9e4066Sahrens 3176*3f9d6ad7SLin Ling cb.cb_type = POOL_SCAN_SCRUB; 3177fa9e4066Sahrens 3178fa9e4066Sahrens /* check options */ 3179fa9e4066Sahrens while ((c = getopt(argc, argv, "s")) != -1) { 3180fa9e4066Sahrens switch (c) { 3181fa9e4066Sahrens case 's': 3182*3f9d6ad7SLin Ling cb.cb_type = POOL_SCAN_NONE; 3183fa9e4066Sahrens break; 3184fa9e4066Sahrens case '?': 3185fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3186fa9e4066Sahrens optopt); 318799653d4eSeschrock usage(B_FALSE); 3188fa9e4066Sahrens } 3189fa9e4066Sahrens } 3190fa9e4066Sahrens 319106eeb2adSek cb.cb_argc = argc; 319206eeb2adSek cb.cb_argv = argv; 3193fa9e4066Sahrens argc -= optind; 3194fa9e4066Sahrens argv += optind; 3195fa9e4066Sahrens 3196fa9e4066Sahrens if (argc < 1) { 3197fa9e4066Sahrens (void) fprintf(stderr, gettext("missing pool name argument\n")); 319899653d4eSeschrock usage(B_FALSE); 3199fa9e4066Sahrens } 3200fa9e4066Sahrens 3201b1b8ab34Slling return (for_each_pool(argc, argv, B_TRUE, NULL, scrub_callback, &cb)); 3202fa9e4066Sahrens } 3203fa9e4066Sahrens 3204fa9e4066Sahrens typedef struct status_cbdata { 320599653d4eSeschrock int cb_count; 3206e9dbad6fSeschrock boolean_t cb_allpools; 320799653d4eSeschrock boolean_t cb_verbose; 320899653d4eSeschrock boolean_t cb_explain; 320999653d4eSeschrock boolean_t cb_first; 32109eb19f4dSGeorge Wilson boolean_t cb_dedup_stats; 3211fa9e4066Sahrens } status_cbdata_t; 3212fa9e4066Sahrens 3213fa9e4066Sahrens /* 3214fa9e4066Sahrens * Print out detailed scrub status. 3215fa9e4066Sahrens */ 3216fa9e4066Sahrens void 3217*3f9d6ad7SLin Ling print_scan_status(pool_scan_stat_t *ps) 3218fa9e4066Sahrens { 3219*3f9d6ad7SLin Ling time_t start, end; 3220*3f9d6ad7SLin Ling uint64_t elapsed, mins_left; 3221*3f9d6ad7SLin Ling uint64_t pass_exam, examined, total; 3222*3f9d6ad7SLin Ling uint_t rate; 3223fa9e4066Sahrens double fraction_done; 3224*3f9d6ad7SLin Ling char processed_buf[7], examined_buf[7], total_buf[7], rate_buf[7]; 3225fa9e4066Sahrens 3226*3f9d6ad7SLin Ling (void) printf(gettext(" scan: ")); 3227fa9e4066Sahrens 3228*3f9d6ad7SLin Ling /* If there's never been a scan, there's not much to say. */ 3229*3f9d6ad7SLin Ling if (ps == NULL || ps->pss_func == POOL_SCAN_NONE || 3230*3f9d6ad7SLin Ling ps->pss_func >= POOL_SCAN_FUNCS) { 3231fa9e4066Sahrens (void) printf(gettext("none requested\n")); 3232fa9e4066Sahrens return; 3233fa9e4066Sahrens } 3234fa9e4066Sahrens 3235*3f9d6ad7SLin Ling start = ps->pss_start_time; 3236*3f9d6ad7SLin Ling end = ps->pss_end_time; 3237*3f9d6ad7SLin Ling zfs_nicenum(ps->pss_processed, processed_buf, sizeof (processed_buf)); 3238fa9e4066Sahrens 3239*3f9d6ad7SLin Ling assert(ps->pss_func == POOL_SCAN_SCRUB || 3240*3f9d6ad7SLin Ling ps->pss_func == POOL_SCAN_RESILVER); 3241*3f9d6ad7SLin Ling /* 3242*3f9d6ad7SLin Ling * Scan is finished or canceled. 3243*3f9d6ad7SLin Ling */ 3244*3f9d6ad7SLin Ling if (ps->pss_state == DSS_FINISHED) { 3245*3f9d6ad7SLin Ling uint64_t minutes_taken = (end - start) / 60; 3246*3f9d6ad7SLin Ling char *fmt; 3247*3f9d6ad7SLin Ling 3248*3f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_SCRUB) { 3249*3f9d6ad7SLin Ling fmt = gettext("scrub repaired %s in %lluh%um with " 3250*3f9d6ad7SLin Ling "%llu errors on %s"); 3251*3f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_RESILVER) { 3252*3f9d6ad7SLin Ling fmt = gettext("resilvered %s in %lluh%um with " 3253*3f9d6ad7SLin Ling "%llu errors on %s"); 3254*3f9d6ad7SLin Ling } 3255*3f9d6ad7SLin Ling /* LINTED */ 3256*3f9d6ad7SLin Ling (void) printf(fmt, processed_buf, 325718ce54dfSek (u_longlong_t)(minutes_taken / 60), 325818ce54dfSek (uint_t)(minutes_taken % 60), 3259*3f9d6ad7SLin Ling (u_longlong_t)ps->pss_errors, 3260*3f9d6ad7SLin Ling ctime((time_t *)&end)); 3261*3f9d6ad7SLin Ling return; 3262*3f9d6ad7SLin Ling } else if (ps->pss_state == DSS_CANCELED) { 3263*3f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_SCRUB) { 3264*3f9d6ad7SLin Ling (void) printf(gettext("scrub canceled on %s"), 3265*3f9d6ad7SLin Ling ctime(&end)); 3266*3f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_RESILVER) { 3267*3f9d6ad7SLin Ling (void) printf(gettext("resilver canceled on %s"), 3268*3f9d6ad7SLin Ling ctime(&end)); 3269*3f9d6ad7SLin Ling } 3270fa9e4066Sahrens return; 3271fa9e4066Sahrens } 3272fa9e4066Sahrens 3273*3f9d6ad7SLin Ling assert(ps->pss_state == DSS_SCANNING); 3274*3f9d6ad7SLin Ling 3275*3f9d6ad7SLin Ling /* 3276*3f9d6ad7SLin Ling * Scan is in progress. 3277*3f9d6ad7SLin Ling */ 3278*3f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_SCRUB) { 3279*3f9d6ad7SLin Ling (void) printf(gettext("scrub in progress since %s"), 3280*3f9d6ad7SLin Ling ctime(&start)); 3281*3f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_RESILVER) { 3282*3f9d6ad7SLin Ling (void) printf(gettext("resilver in progress since %s"), 3283*3f9d6ad7SLin Ling ctime(&start)); 3284*3f9d6ad7SLin Ling } 3285fa9e4066Sahrens 3286*3f9d6ad7SLin Ling examined = ps->pss_examined ? ps->pss_examined : 1; 3287*3f9d6ad7SLin Ling total = ps->pss_to_examine; 3288fa9e4066Sahrens fraction_done = (double)examined / total; 3289*3f9d6ad7SLin Ling 3290*3f9d6ad7SLin Ling /* elapsed time for this pass */ 3291*3f9d6ad7SLin Ling elapsed = time(NULL) - ps->pss_pass_start; 3292*3f9d6ad7SLin Ling elapsed = elapsed ? elapsed : 1; 3293*3f9d6ad7SLin Ling pass_exam = ps->pss_pass_exam ? ps->pss_pass_exam : 1; 3294*3f9d6ad7SLin Ling rate = pass_exam / elapsed; 3295*3f9d6ad7SLin Ling rate = rate ? rate : 1; 3296*3f9d6ad7SLin Ling mins_left = ((total - examined) / rate) / 60; 3297*3f9d6ad7SLin Ling 3298*3f9d6ad7SLin Ling zfs_nicenum(examined, examined_buf, sizeof (examined_buf)); 3299*3f9d6ad7SLin Ling zfs_nicenum(total, total_buf, sizeof (total_buf)); 3300*3f9d6ad7SLin Ling zfs_nicenum(rate, rate_buf, sizeof (rate_buf)); 3301*3f9d6ad7SLin Ling 3302*3f9d6ad7SLin Ling (void) printf(gettext(" %s scanned out of %s at " 3303*3f9d6ad7SLin Ling "%s/s, %lluh%um to go\n"), examined_buf, total_buf, rate_buf, 3304*3f9d6ad7SLin Ling (u_longlong_t)(mins_left / 60), 3305*3f9d6ad7SLin Ling (uint_t)(mins_left % 60)); 3306*3f9d6ad7SLin Ling 3307*3f9d6ad7SLin Ling if (ps->pss_func == POOL_SCAN_RESILVER) { 3308*3f9d6ad7SLin Ling (void) printf(gettext(" %s resilvered, %.2f%% done\n"), 3309*3f9d6ad7SLin Ling processed_buf, 100 * fraction_done); 3310*3f9d6ad7SLin Ling } else if (ps->pss_func == POOL_SCAN_SCRUB) { 3311*3f9d6ad7SLin Ling (void) printf(gettext(" %s repaired, %.2f%% done\n"), 3312*3f9d6ad7SLin Ling processed_buf, 100 * fraction_done); 3313*3f9d6ad7SLin Ling } 3314fa9e4066Sahrens } 3315fa9e4066Sahrens 3316ea8dc4b6Seschrock static void 3317ea8dc4b6Seschrock print_error_log(zpool_handle_t *zhp) 3318ea8dc4b6Seschrock { 331975519f38Sek nvlist_t *nverrlist = NULL; 332055434c77Sek nvpair_t *elem; 332155434c77Sek char *pathname; 332255434c77Sek size_t len = MAXPATHLEN * 2; 3323ea8dc4b6Seschrock 332455434c77Sek if (zpool_get_errlog(zhp, &nverrlist) != 0) { 3325ea8dc4b6Seschrock (void) printf("errors: List of errors unavailable " 3326ea8dc4b6Seschrock "(insufficient privileges)\n"); 3327ea8dc4b6Seschrock return; 3328ea8dc4b6Seschrock } 3329ea8dc4b6Seschrock 333055434c77Sek (void) printf("errors: Permanent errors have been " 333155434c77Sek "detected in the following files:\n\n"); 3332ea8dc4b6Seschrock 333355434c77Sek pathname = safe_malloc(len); 333455434c77Sek elem = NULL; 333555434c77Sek while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) { 333655434c77Sek nvlist_t *nv; 333755434c77Sek uint64_t dsobj, obj; 333855434c77Sek 333955434c77Sek verify(nvpair_value_nvlist(elem, &nv) == 0); 334055434c77Sek verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET, 334155434c77Sek &dsobj) == 0); 334255434c77Sek verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT, 334355434c77Sek &obj) == 0); 334455434c77Sek zpool_obj_to_path(zhp, dsobj, obj, pathname, len); 334555434c77Sek (void) printf("%7s %s\n", "", pathname); 334655434c77Sek } 334755434c77Sek free(pathname); 334855434c77Sek nvlist_free(nverrlist); 3349ea8dc4b6Seschrock } 3350ea8dc4b6Seschrock 335199653d4eSeschrock static void 335299653d4eSeschrock print_spares(zpool_handle_t *zhp, nvlist_t **spares, uint_t nspares, 335399653d4eSeschrock int namewidth) 335499653d4eSeschrock { 335599653d4eSeschrock uint_t i; 335699653d4eSeschrock char *name; 335799653d4eSeschrock 335899653d4eSeschrock if (nspares == 0) 335999653d4eSeschrock return; 336099653d4eSeschrock 336199653d4eSeschrock (void) printf(gettext("\tspares\n")); 336299653d4eSeschrock 336399653d4eSeschrock for (i = 0; i < nspares; i++) { 336488ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, spares[i], B_FALSE); 336599653d4eSeschrock print_status_config(zhp, name, spares[i], 3366aa8cf21aSNeil Perrin namewidth, 2, B_TRUE); 336799653d4eSeschrock free(name); 336899653d4eSeschrock } 336999653d4eSeschrock } 337099653d4eSeschrock 3371fa94a07fSbrendan static void 3372fa94a07fSbrendan print_l2cache(zpool_handle_t *zhp, nvlist_t **l2cache, uint_t nl2cache, 3373fa94a07fSbrendan int namewidth) 3374fa94a07fSbrendan { 3375fa94a07fSbrendan uint_t i; 3376fa94a07fSbrendan char *name; 3377fa94a07fSbrendan 3378fa94a07fSbrendan if (nl2cache == 0) 3379fa94a07fSbrendan return; 3380fa94a07fSbrendan 3381fa94a07fSbrendan (void) printf(gettext("\tcache\n")); 3382fa94a07fSbrendan 3383fa94a07fSbrendan for (i = 0; i < nl2cache; i++) { 338488ecc943SGeorge Wilson name = zpool_vdev_name(g_zfs, zhp, l2cache[i], B_FALSE); 3385fa94a07fSbrendan print_status_config(zhp, name, l2cache[i], 3386aa8cf21aSNeil Perrin namewidth, 2, B_FALSE); 3387aa8cf21aSNeil Perrin free(name); 3388aa8cf21aSNeil Perrin } 3389aa8cf21aSNeil Perrin } 3390aa8cf21aSNeil Perrin 33919eb19f4dSGeorge Wilson static void 33929eb19f4dSGeorge Wilson print_dedup_stats(nvlist_t *config) 33939eb19f4dSGeorge Wilson { 33949eb19f4dSGeorge Wilson ddt_histogram_t *ddh; 33959eb19f4dSGeorge Wilson ddt_stat_t *dds; 33969eb19f4dSGeorge Wilson ddt_object_t *ddo; 33979eb19f4dSGeorge Wilson uint_t c; 33989eb19f4dSGeorge Wilson 33999eb19f4dSGeorge Wilson /* 34009eb19f4dSGeorge Wilson * If the pool was faulted then we may not have been able to 34019eb19f4dSGeorge Wilson * obtain the config. Otherwise, if have anything in the dedup 34029eb19f4dSGeorge Wilson * table continue processing the stats. 34039eb19f4dSGeorge Wilson */ 34049eb19f4dSGeorge Wilson if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_OBJ_STATS, 34059eb19f4dSGeorge Wilson (uint64_t **)&ddo, &c) != 0 || ddo->ddo_count == 0) 34069eb19f4dSGeorge Wilson return; 34079eb19f4dSGeorge Wilson 34089eb19f4dSGeorge Wilson (void) printf("\n"); 34099eb19f4dSGeorge Wilson (void) printf("DDT entries %llu, size %llu on disk, %llu in core\n", 34109eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_count, 34119eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_dspace, 34129eb19f4dSGeorge Wilson (u_longlong_t)ddo->ddo_mspace); 34139eb19f4dSGeorge Wilson 34149eb19f4dSGeorge Wilson verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS, 34159eb19f4dSGeorge Wilson (uint64_t **)&dds, &c) == 0); 34169eb19f4dSGeorge Wilson verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_HISTOGRAM, 34179eb19f4dSGeorge Wilson (uint64_t **)&ddh, &c) == 0); 34189eb19f4dSGeorge Wilson zpool_dump_ddt(dds, ddh); 34199eb19f4dSGeorge Wilson } 34209eb19f4dSGeorge Wilson 3421fa9e4066Sahrens /* 3422fa9e4066Sahrens * Display a summary of pool status. Displays a summary such as: 3423fa9e4066Sahrens * 3424fa9e4066Sahrens * pool: tank 3425fa9e4066Sahrens * status: DEGRADED 3426fa9e4066Sahrens * reason: One or more devices ... 3427fa9e4066Sahrens * see: http://www.sun.com/msg/ZFS-xxxx-01 3428fa9e4066Sahrens * config: 3429fa9e4066Sahrens * mirror DEGRADED 3430fa9e4066Sahrens * c1t0d0 OK 3431ea8dc4b6Seschrock * c2t0d0 UNAVAIL 3432fa9e4066Sahrens * 3433fa9e4066Sahrens * When given the '-v' option, we print out the complete config. If the '-e' 3434fa9e4066Sahrens * option is specified, then we print out error rate information as well. 3435fa9e4066Sahrens */ 3436fa9e4066Sahrens int 3437fa9e4066Sahrens status_callback(zpool_handle_t *zhp, void *data) 3438fa9e4066Sahrens { 3439fa9e4066Sahrens status_cbdata_t *cbp = data; 3440fa9e4066Sahrens nvlist_t *config, *nvroot; 3441fa9e4066Sahrens char *msgid; 3442fa9e4066Sahrens int reason; 344346657f8dSmmusante const char *health; 344446657f8dSmmusante uint_t c; 344546657f8dSmmusante vdev_stat_t *vs; 3446fa9e4066Sahrens 3447088e9d47Seschrock config = zpool_get_config(zhp, NULL); 3448fa9e4066Sahrens reason = zpool_get_status(zhp, &msgid); 3449fa9e4066Sahrens 3450fa9e4066Sahrens cbp->cb_count++; 3451fa9e4066Sahrens 3452fa9e4066Sahrens /* 3453fa9e4066Sahrens * If we were given 'zpool status -x', only report those pools with 3454fa9e4066Sahrens * problems. 3455fa9e4066Sahrens */ 3456e9dbad6fSeschrock if (reason == ZPOOL_STATUS_OK && cbp->cb_explain) { 3457e9dbad6fSeschrock if (!cbp->cb_allpools) { 3458e9dbad6fSeschrock (void) printf(gettext("pool '%s' is healthy\n"), 3459e9dbad6fSeschrock zpool_get_name(zhp)); 3460e9dbad6fSeschrock if (cbp->cb_first) 3461e9dbad6fSeschrock cbp->cb_first = B_FALSE; 3462e9dbad6fSeschrock } 3463fa9e4066Sahrens return (0); 3464e9dbad6fSeschrock } 3465fa9e4066Sahrens 3466fa9e4066Sahrens if (cbp->cb_first) 346799653d4eSeschrock cbp->cb_first = B_FALSE; 3468fa9e4066Sahrens else 3469fa9e4066Sahrens (void) printf("\n"); 3470fa9e4066Sahrens 347146657f8dSmmusante verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 347246657f8dSmmusante &nvroot) == 0); 3473*3f9d6ad7SLin Ling verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 347446657f8dSmmusante (uint64_t **)&vs, &c) == 0); 3475990b4856Slling health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 3476fa9e4066Sahrens 3477fa9e4066Sahrens (void) printf(gettext(" pool: %s\n"), zpool_get_name(zhp)); 3478fa9e4066Sahrens (void) printf(gettext(" state: %s\n"), health); 3479fa9e4066Sahrens 3480fa9e4066Sahrens switch (reason) { 3481fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_R: 3482fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3483fa9e4066Sahrens "be opened. Sufficient replicas exist for\n\tthe pool to " 3484fa9e4066Sahrens "continue functioning in a degraded state.\n")); 3485fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 3486fa9e4066Sahrens "online it using 'zpool online'.\n")); 3487fa9e4066Sahrens break; 3488fa9e4066Sahrens 3489fa9e4066Sahrens case ZPOOL_STATUS_MISSING_DEV_NR: 3490fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3491fa9e4066Sahrens "be opened. There are insufficient\n\treplicas for the " 3492fa9e4066Sahrens "pool to continue functioning.\n")); 3493fa9e4066Sahrens (void) printf(gettext("action: Attach the missing device and " 3494fa9e4066Sahrens "online it using 'zpool online'.\n")); 3495fa9e4066Sahrens break; 3496fa9e4066Sahrens 3497fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_R: 3498fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3499fa9e4066Sahrens "be used because the label is missing or\n\tinvalid. " 3500fa9e4066Sahrens "Sufficient replicas exist for the pool to continue\n\t" 3501fa9e4066Sahrens "functioning in a degraded state.\n")); 3502fa9e4066Sahrens (void) printf(gettext("action: Replace the device using " 3503fa9e4066Sahrens "'zpool replace'.\n")); 3504fa9e4066Sahrens break; 3505fa9e4066Sahrens 3506fa9e4066Sahrens case ZPOOL_STATUS_CORRUPT_LABEL_NR: 3507fa9e4066Sahrens (void) printf(gettext("status: One or more devices could not " 3508b1b8ab34Slling "be used because the label is missing \n\tor invalid. " 3509fa9e4066Sahrens "There are insufficient replicas for the pool to " 3510fa9e4066Sahrens "continue\n\tfunctioning.\n")); 3511468c413aSTim Haley zpool_explain_recover(zpool_get_handle(zhp), 3512468c413aSTim Haley zpool_get_name(zhp), reason, config); 3513fa9e4066Sahrens break; 3514fa9e4066Sahrens 3515fa9e4066Sahrens case ZPOOL_STATUS_FAILING_DEV: 3516fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 3517fa9e4066Sahrens "experienced an unrecoverable error. An\n\tattempt was " 3518fa9e4066Sahrens "made to correct the error. Applications are " 3519fa9e4066Sahrens "unaffected.\n")); 3520fa9e4066Sahrens (void) printf(gettext("action: Determine if the device needs " 3521fa9e4066Sahrens "to be replaced, and clear the errors\n\tusing " 3522ea8dc4b6Seschrock "'zpool clear' or replace the device with 'zpool " 3523fa9e4066Sahrens "replace'.\n")); 3524fa9e4066Sahrens break; 3525fa9e4066Sahrens 3526fa9e4066Sahrens case ZPOOL_STATUS_OFFLINE_DEV: 3527fa9e4066Sahrens (void) printf(gettext("status: One or more devices has " 3528d7d4af51Smmusante "been taken offline by the administrator.\n\tSufficient " 3529fa9e4066Sahrens "replicas exist for the pool to continue functioning in " 3530fa9e4066Sahrens "a\n\tdegraded state.\n")); 3531fa9e4066Sahrens (void) printf(gettext("action: Online the device using " 3532fa9e4066Sahrens "'zpool online' or replace the device with\n\t'zpool " 3533fa9e4066Sahrens "replace'.\n")); 3534fa9e4066Sahrens break; 3535fa9e4066Sahrens 3536c25309d4SGeorge Wilson case ZPOOL_STATUS_REMOVED_DEV: 3537c25309d4SGeorge Wilson (void) printf(gettext("status: One or more devices has " 3538c25309d4SGeorge Wilson "been removed by the administrator.\n\tSufficient " 3539c25309d4SGeorge Wilson "replicas exist for the pool to continue functioning in " 3540c25309d4SGeorge Wilson "a\n\tdegraded state.\n")); 3541c25309d4SGeorge Wilson (void) printf(gettext("action: Online the device using " 3542c25309d4SGeorge Wilson "'zpool online' or replace the device with\n\t'zpool " 3543c25309d4SGeorge Wilson "replace'.\n")); 3544c25309d4SGeorge Wilson break; 3545c25309d4SGeorge Wilson 3546fa9e4066Sahrens case ZPOOL_STATUS_RESILVERING: 3547fa9e4066Sahrens (void) printf(gettext("status: One or more devices is " 3548fa9e4066Sahrens "currently being resilvered. The pool will\n\tcontinue " 3549fa9e4066Sahrens "to function, possibly in a degraded state.\n")); 3550fa9e4066Sahrens (void) printf(gettext("action: Wait for the resilver to " 3551fa9e4066Sahrens "complete.\n")); 3552fa9e4066Sahrens break; 3553fa9e4066Sahrens 3554ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_DATA: 3555ea8dc4b6Seschrock (void) printf(gettext("status: One or more devices has " 3556ea8dc4b6Seschrock "experienced an error resulting in data\n\tcorruption. " 3557ea8dc4b6Seschrock "Applications may be affected.\n")); 3558ea8dc4b6Seschrock (void) printf(gettext("action: Restore the file in question " 3559ea8dc4b6Seschrock "if possible. Otherwise restore the\n\tentire pool from " 3560ea8dc4b6Seschrock "backup.\n")); 3561ea8dc4b6Seschrock break; 3562ea8dc4b6Seschrock 3563ea8dc4b6Seschrock case ZPOOL_STATUS_CORRUPT_POOL: 3564ea8dc4b6Seschrock (void) printf(gettext("status: The pool metadata is corrupted " 3565ea8dc4b6Seschrock "and the pool cannot be opened.\n")); 3566468c413aSTim Haley zpool_explain_recover(zpool_get_handle(zhp), 3567468c413aSTim Haley zpool_get_name(zhp), reason, config); 3568ea8dc4b6Seschrock break; 3569ea8dc4b6Seschrock 3570eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_OLDER: 3571eaca9bbdSeschrock (void) printf(gettext("status: The pool is formatted using an " 3572eaca9bbdSeschrock "older on-disk format. The pool can\n\tstill be used, but " 3573eaca9bbdSeschrock "some features are unavailable.\n")); 3574eaca9bbdSeschrock (void) printf(gettext("action: Upgrade the pool using 'zpool " 3575eaca9bbdSeschrock "upgrade'. Once this is done, the\n\tpool will no longer " 3576eaca9bbdSeschrock "be accessible on older software versions.\n")); 3577eaca9bbdSeschrock break; 3578eaca9bbdSeschrock 3579eaca9bbdSeschrock case ZPOOL_STATUS_VERSION_NEWER: 3580eaca9bbdSeschrock (void) printf(gettext("status: The pool has been upgraded to a " 3581eaca9bbdSeschrock "newer, incompatible on-disk version.\n\tThe pool cannot " 3582eaca9bbdSeschrock "be accessed on this system.\n")); 3583eaca9bbdSeschrock (void) printf(gettext("action: Access the pool from a system " 3584eaca9bbdSeschrock "running more recent software, or\n\trestore the pool from " 3585eaca9bbdSeschrock "backup.\n")); 3586eaca9bbdSeschrock break; 3587eaca9bbdSeschrock 35883d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_R: 35893d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 35903d7072f8Seschrock "faulted in response to persistent errors.\n\tSufficient " 35913d7072f8Seschrock "replicas exist for the pool to continue functioning " 35923d7072f8Seschrock "in a\n\tdegraded state.\n")); 35933d7072f8Seschrock (void) printf(gettext("action: Replace the faulted device, " 35943d7072f8Seschrock "or use 'zpool clear' to mark the device\n\trepaired.\n")); 35953d7072f8Seschrock break; 35963d7072f8Seschrock 35973d7072f8Seschrock case ZPOOL_STATUS_FAULTED_DEV_NR: 35983d7072f8Seschrock (void) printf(gettext("status: One or more devices are " 35993d7072f8Seschrock "faulted in response to persistent errors. There are " 36003d7072f8Seschrock "insufficient replicas for the pool to\n\tcontinue " 36013d7072f8Seschrock "functioning.\n")); 36023d7072f8Seschrock (void) printf(gettext("action: Destroy and re-create the pool " 36033d7072f8Seschrock "from a backup source. Manually marking the device\n" 36043d7072f8Seschrock "\trepaired using 'zpool clear' may allow some data " 36053d7072f8Seschrock "to be recovered.\n")); 36063d7072f8Seschrock break; 36073d7072f8Seschrock 360832b87932Sek case ZPOOL_STATUS_IO_FAILURE_WAIT: 360932b87932Sek case ZPOOL_STATUS_IO_FAILURE_CONTINUE: 361032b87932Sek (void) printf(gettext("status: One or more devices are " 36118a79c1b5Sek "faulted in response to IO failures.\n")); 361232b87932Sek (void) printf(gettext("action: Make sure the affected devices " 361332b87932Sek "are connected, then run 'zpool clear'.\n")); 361432b87932Sek break; 361532b87932Sek 3616b87f3af3Sperrin case ZPOOL_STATUS_BAD_LOG: 3617b87f3af3Sperrin (void) printf(gettext("status: An intent log record " 3618b87f3af3Sperrin "could not be read.\n" 3619b87f3af3Sperrin "\tWaiting for adminstrator intervention to fix the " 3620b87f3af3Sperrin "faulted pool.\n")); 3621b87f3af3Sperrin (void) printf(gettext("action: Either restore the affected " 3622b87f3af3Sperrin "device(s) and run 'zpool online',\n" 3623b87f3af3Sperrin "\tor ignore the intent log records by running " 3624b87f3af3Sperrin "'zpool clear'.\n")); 3625b87f3af3Sperrin break; 3626b87f3af3Sperrin 3627fa9e4066Sahrens default: 3628fa9e4066Sahrens /* 3629fa9e4066Sahrens * The remaining errors can't actually be generated, yet. 3630fa9e4066Sahrens */ 3631fa9e4066Sahrens assert(reason == ZPOOL_STATUS_OK); 3632fa9e4066Sahrens } 3633fa9e4066Sahrens 3634fa9e4066Sahrens if (msgid != NULL) 3635fa9e4066Sahrens (void) printf(gettext(" see: http://www.sun.com/msg/%s\n"), 3636fa9e4066Sahrens msgid); 3637fa9e4066Sahrens 3638fa9e4066Sahrens if (config != NULL) { 3639fa9e4066Sahrens int namewidth; 3640ea8dc4b6Seschrock uint64_t nerr; 3641fa94a07fSbrendan nvlist_t **spares, **l2cache; 3642fa94a07fSbrendan uint_t nspares, nl2cache; 3643*3f9d6ad7SLin Ling pool_scan_stat_t *ps = NULL; 3644fa9e4066Sahrens 3645*3f9d6ad7SLin Ling (void) nvlist_lookup_uint64_array(nvroot, 3646*3f9d6ad7SLin Ling ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &c); 3647*3f9d6ad7SLin Ling print_scan_status(ps); 3648fa9e4066Sahrens 3649c67d9675Seschrock namewidth = max_width(zhp, nvroot, 0, 0); 3650fa9e4066Sahrens if (namewidth < 10) 3651fa9e4066Sahrens namewidth = 10; 3652fa9e4066Sahrens 3653fa9e4066Sahrens (void) printf(gettext("config:\n\n")); 3654fa9e4066Sahrens (void) printf(gettext("\t%-*s %-8s %5s %5s %5s\n"), namewidth, 3655fa9e4066Sahrens "NAME", "STATE", "READ", "WRITE", "CKSUM"); 3656c67d9675Seschrock print_status_config(zhp, zpool_get_name(zhp), nvroot, 3657aa8cf21aSNeil Perrin namewidth, 0, B_FALSE); 365899653d4eSeschrock 36594dea40f0SNeil Perrin if (num_logs(nvroot) > 0) 3660e6ca193dSGeorge Wilson print_logs(zhp, nvroot, namewidth, B_TRUE); 3661fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 3662fa94a07fSbrendan &l2cache, &nl2cache) == 0) 3663fa94a07fSbrendan print_l2cache(zhp, l2cache, nl2cache, namewidth); 3664fa94a07fSbrendan 366599653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 366699653d4eSeschrock &spares, &nspares) == 0) 366799653d4eSeschrock print_spares(zhp, spares, nspares, namewidth); 3668ea8dc4b6Seschrock 3669ea8dc4b6Seschrock if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT, 3670ea8dc4b6Seschrock &nerr) == 0) { 367155434c77Sek nvlist_t *nverrlist = NULL; 367255434c77Sek 3673ea8dc4b6Seschrock /* 3674ea8dc4b6Seschrock * If the approximate error count is small, get a 3675ea8dc4b6Seschrock * precise count by fetching the entire log and 3676ea8dc4b6Seschrock * uniquifying the results. 3677ea8dc4b6Seschrock */ 367875519f38Sek if (nerr > 0 && nerr < 100 && !cbp->cb_verbose && 367955434c77Sek zpool_get_errlog(zhp, &nverrlist) == 0) { 368055434c77Sek nvpair_t *elem; 368155434c77Sek 368255434c77Sek elem = NULL; 368355434c77Sek nerr = 0; 368455434c77Sek while ((elem = nvlist_next_nvpair(nverrlist, 368555434c77Sek elem)) != NULL) { 368655434c77Sek nerr++; 368755434c77Sek } 368855434c77Sek } 368955434c77Sek nvlist_free(nverrlist); 3690ea8dc4b6Seschrock 3691ea8dc4b6Seschrock (void) printf("\n"); 369299653d4eSeschrock 3693ea8dc4b6Seschrock if (nerr == 0) 3694ea8dc4b6Seschrock (void) printf(gettext("errors: No known data " 3695ea8dc4b6Seschrock "errors\n")); 3696ea8dc4b6Seschrock else if (!cbp->cb_verbose) 3697e9dbad6fSeschrock (void) printf(gettext("errors: %llu data " 36985ad82045Snd "errors, use '-v' for a list\n"), 36995ad82045Snd (u_longlong_t)nerr); 3700ea8dc4b6Seschrock else 3701ea8dc4b6Seschrock print_error_log(zhp); 3702ea8dc4b6Seschrock } 37039eb19f4dSGeorge Wilson 37049eb19f4dSGeorge Wilson if (cbp->cb_dedup_stats) 37059eb19f4dSGeorge Wilson print_dedup_stats(config); 3706fa9e4066Sahrens } else { 3707fa9e4066Sahrens (void) printf(gettext("config: The configuration cannot be " 3708fa9e4066Sahrens "determined.\n")); 3709fa9e4066Sahrens } 3710fa9e4066Sahrens 3711fa9e4066Sahrens return (0); 3712fa9e4066Sahrens } 3713fa9e4066Sahrens 3714fa9e4066Sahrens /* 3715*3f9d6ad7SLin Ling * zpool status [-vx] [-T d|u] [pool] ... [interval [count]] 3716fa9e4066Sahrens * 3717fa9e4066Sahrens * -v Display complete error logs 3718fa9e4066Sahrens * -x Display only pools with potential problems 37199eb19f4dSGeorge Wilson * -D Display dedup status (undocumented) 3720*3f9d6ad7SLin Ling * -T Display a timestamp in date(1) or Unix format 3721fa9e4066Sahrens * 3722fa9e4066Sahrens * Describes the health status of all pools or some subset. 3723fa9e4066Sahrens */ 3724fa9e4066Sahrens int 3725fa9e4066Sahrens zpool_do_status(int argc, char **argv) 3726fa9e4066Sahrens { 3727fa9e4066Sahrens int c; 3728fa9e4066Sahrens int ret; 3729*3f9d6ad7SLin Ling unsigned long interval = 0, count = 0; 3730fa9e4066Sahrens status_cbdata_t cb = { 0 }; 3731fa9e4066Sahrens 3732fa9e4066Sahrens /* check options */ 3733*3f9d6ad7SLin Ling while ((c = getopt(argc, argv, "vxDT:")) != -1) { 3734fa9e4066Sahrens switch (c) { 3735fa9e4066Sahrens case 'v': 373699653d4eSeschrock cb.cb_verbose = B_TRUE; 3737fa9e4066Sahrens break; 3738fa9e4066Sahrens case 'x': 373999653d4eSeschrock cb.cb_explain = B_TRUE; 3740fa9e4066Sahrens break; 37419eb19f4dSGeorge Wilson case 'D': 37429eb19f4dSGeorge Wilson cb.cb_dedup_stats = B_TRUE; 37439eb19f4dSGeorge Wilson break; 3744*3f9d6ad7SLin Ling case 'T': 3745*3f9d6ad7SLin Ling get_timestamp_arg(*optarg); 3746*3f9d6ad7SLin Ling break; 3747fa9e4066Sahrens case '?': 3748fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3749fa9e4066Sahrens optopt); 375099653d4eSeschrock usage(B_FALSE); 3751fa9e4066Sahrens } 3752fa9e4066Sahrens } 3753fa9e4066Sahrens 3754fa9e4066Sahrens argc -= optind; 3755fa9e4066Sahrens argv += optind; 3756fa9e4066Sahrens 3757*3f9d6ad7SLin Ling get_interval_count(&argc, argv, &interval, &count); 3758fa9e4066Sahrens 3759e9dbad6fSeschrock if (argc == 0) 3760e9dbad6fSeschrock cb.cb_allpools = B_TRUE; 3761e9dbad6fSeschrock 3762*3f9d6ad7SLin Ling cb.cb_first = B_TRUE; 3763fa9e4066Sahrens 3764*3f9d6ad7SLin Ling for (;;) { 3765*3f9d6ad7SLin Ling if (timestamp_fmt != NODATE) 3766*3f9d6ad7SLin Ling print_timestamp(timestamp_fmt); 3767fa9e4066Sahrens 3768*3f9d6ad7SLin Ling ret = for_each_pool(argc, argv, B_TRUE, NULL, 3769*3f9d6ad7SLin Ling status_callback, &cb); 3770*3f9d6ad7SLin Ling 3771*3f9d6ad7SLin Ling if (argc == 0 && cb.cb_count == 0) 3772*3f9d6ad7SLin Ling (void) printf(gettext("no pools available\n")); 3773*3f9d6ad7SLin Ling else if (cb.cb_explain && cb.cb_first && cb.cb_allpools) 3774*3f9d6ad7SLin Ling (void) printf(gettext("all pools are healthy\n")); 3775*3f9d6ad7SLin Ling 3776*3f9d6ad7SLin Ling if (ret != 0) 3777*3f9d6ad7SLin Ling return (ret); 3778*3f9d6ad7SLin Ling 3779*3f9d6ad7SLin Ling if (interval == 0) 3780*3f9d6ad7SLin Ling break; 3781*3f9d6ad7SLin Ling 3782*3f9d6ad7SLin Ling if (count != 0 && --count == 0) 3783*3f9d6ad7SLin Ling break; 3784*3f9d6ad7SLin Ling 3785*3f9d6ad7SLin Ling (void) sleep(interval); 3786*3f9d6ad7SLin Ling } 3787*3f9d6ad7SLin Ling 3788*3f9d6ad7SLin Ling return (0); 3789fa9e4066Sahrens } 3790fa9e4066Sahrens 3791eaca9bbdSeschrock typedef struct upgrade_cbdata { 3792eaca9bbdSeschrock int cb_all; 3793eaca9bbdSeschrock int cb_first; 3794eaca9bbdSeschrock int cb_newer; 379506eeb2adSek int cb_argc; 3796990b4856Slling uint64_t cb_version; 379706eeb2adSek char **cb_argv; 3798eaca9bbdSeschrock } upgrade_cbdata_t; 3799eaca9bbdSeschrock 3800eaca9bbdSeschrock static int 3801eaca9bbdSeschrock upgrade_cb(zpool_handle_t *zhp, void *arg) 3802eaca9bbdSeschrock { 3803eaca9bbdSeschrock upgrade_cbdata_t *cbp = arg; 3804eaca9bbdSeschrock nvlist_t *config; 3805eaca9bbdSeschrock uint64_t version; 3806eaca9bbdSeschrock int ret = 0; 3807eaca9bbdSeschrock 3808eaca9bbdSeschrock config = zpool_get_config(zhp, NULL); 3809eaca9bbdSeschrock verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 3810eaca9bbdSeschrock &version) == 0); 3811eaca9bbdSeschrock 3812e7437265Sahrens if (!cbp->cb_newer && version < SPA_VERSION) { 3813eaca9bbdSeschrock if (!cbp->cb_all) { 3814eaca9bbdSeschrock if (cbp->cb_first) { 3815eaca9bbdSeschrock (void) printf(gettext("The following pools are " 3816eaca9bbdSeschrock "out of date, and can be upgraded. After " 3817eaca9bbdSeschrock "being\nupgraded, these pools will no " 3818eaca9bbdSeschrock "longer be accessible by older software " 3819eaca9bbdSeschrock "versions.\n\n")); 3820eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 3821eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 382299653d4eSeschrock cbp->cb_first = B_FALSE; 3823eaca9bbdSeschrock } 3824eaca9bbdSeschrock 38255ad82045Snd (void) printf("%2llu %s\n", (u_longlong_t)version, 3826eaca9bbdSeschrock zpool_get_name(zhp)); 3827eaca9bbdSeschrock } else { 382899653d4eSeschrock cbp->cb_first = B_FALSE; 3829990b4856Slling ret = zpool_upgrade(zhp, cbp->cb_version); 383006eeb2adSek if (!ret) { 3831eaca9bbdSeschrock (void) printf(gettext("Successfully upgraded " 3832990b4856Slling "'%s'\n\n"), zpool_get_name(zhp)); 383306eeb2adSek } 3834eaca9bbdSeschrock } 3835e7437265Sahrens } else if (cbp->cb_newer && version > SPA_VERSION) { 3836eaca9bbdSeschrock assert(!cbp->cb_all); 3837eaca9bbdSeschrock 3838eaca9bbdSeschrock if (cbp->cb_first) { 3839eaca9bbdSeschrock (void) printf(gettext("The following pools are " 3840eaca9bbdSeschrock "formatted using a newer software version and\n" 3841eaca9bbdSeschrock "cannot be accessed on the current system.\n\n")); 3842eaca9bbdSeschrock (void) printf(gettext("VER POOL\n")); 3843eaca9bbdSeschrock (void) printf(gettext("--- ------------\n")); 384499653d4eSeschrock cbp->cb_first = B_FALSE; 3845eaca9bbdSeschrock } 3846eaca9bbdSeschrock 38475ad82045Snd (void) printf("%2llu %s\n", (u_longlong_t)version, 3848eaca9bbdSeschrock zpool_get_name(zhp)); 3849eaca9bbdSeschrock } 3850eaca9bbdSeschrock 3851eaca9bbdSeschrock zpool_close(zhp); 3852eaca9bbdSeschrock return (ret); 3853eaca9bbdSeschrock } 3854eaca9bbdSeschrock 3855eaca9bbdSeschrock /* ARGSUSED */ 3856eaca9bbdSeschrock static int 385706eeb2adSek upgrade_one(zpool_handle_t *zhp, void *data) 3858eaca9bbdSeschrock { 3859990b4856Slling upgrade_cbdata_t *cbp = data; 3860990b4856Slling uint64_t cur_version; 3861eaca9bbdSeschrock int ret; 3862eaca9bbdSeschrock 38638654d025Sperrin if (strcmp("log", zpool_get_name(zhp)) == 0) { 38648654d025Sperrin (void) printf(gettext("'log' is now a reserved word\n" 38658654d025Sperrin "Pool 'log' must be renamed using export and import" 38668654d025Sperrin " to upgrade.\n")); 38678654d025Sperrin return (1); 38688654d025Sperrin } 3869990b4856Slling 3870990b4856Slling cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 3871e6c728e1Sbrendan if (cur_version > cbp->cb_version) { 3872eaca9bbdSeschrock (void) printf(gettext("Pool '%s' is already formatted " 3873e6c728e1Sbrendan "using more current version '%llu'.\n"), 3874e6c728e1Sbrendan zpool_get_name(zhp), cur_version); 3875e6c728e1Sbrendan return (0); 3876e6c728e1Sbrendan } 3877e6c728e1Sbrendan if (cur_version == cbp->cb_version) { 3878e6c728e1Sbrendan (void) printf(gettext("Pool '%s' is already formatted " 3879e6c728e1Sbrendan "using the current version.\n"), zpool_get_name(zhp)); 3880eaca9bbdSeschrock return (0); 3881eaca9bbdSeschrock } 3882eaca9bbdSeschrock 3883990b4856Slling ret = zpool_upgrade(zhp, cbp->cb_version); 388406eeb2adSek 388506eeb2adSek if (!ret) { 388644cd46caSbillm (void) printf(gettext("Successfully upgraded '%s' " 3887990b4856Slling "from version %llu to version %llu\n\n"), 3888990b4856Slling zpool_get_name(zhp), (u_longlong_t)cur_version, 3889990b4856Slling (u_longlong_t)cbp->cb_version); 389006eeb2adSek } 3891eaca9bbdSeschrock 3892eaca9bbdSeschrock return (ret != 0); 3893eaca9bbdSeschrock } 3894eaca9bbdSeschrock 3895eaca9bbdSeschrock /* 3896eaca9bbdSeschrock * zpool upgrade 3897eaca9bbdSeschrock * zpool upgrade -v 3898990b4856Slling * zpool upgrade [-V version] <-a | pool ...> 3899eaca9bbdSeschrock * 3900eaca9bbdSeschrock * With no arguments, display downrev'd ZFS pool available for upgrade. 3901eaca9bbdSeschrock * Individual pools can be upgraded by specifying the pool, and '-a' will 3902eaca9bbdSeschrock * upgrade all pools. 3903eaca9bbdSeschrock */ 3904eaca9bbdSeschrock int 3905eaca9bbdSeschrock zpool_do_upgrade(int argc, char **argv) 3906eaca9bbdSeschrock { 3907eaca9bbdSeschrock int c; 3908eaca9bbdSeschrock upgrade_cbdata_t cb = { 0 }; 3909eaca9bbdSeschrock int ret = 0; 3910eaca9bbdSeschrock boolean_t showversions = B_FALSE; 3911990b4856Slling char *end; 3912990b4856Slling 3913eaca9bbdSeschrock 3914eaca9bbdSeschrock /* check options */ 3915478ed9adSEric Taylor while ((c = getopt(argc, argv, ":avV:")) != -1) { 3916eaca9bbdSeschrock switch (c) { 3917eaca9bbdSeschrock case 'a': 391899653d4eSeschrock cb.cb_all = B_TRUE; 3919eaca9bbdSeschrock break; 3920eaca9bbdSeschrock case 'v': 3921eaca9bbdSeschrock showversions = B_TRUE; 3922eaca9bbdSeschrock break; 3923990b4856Slling case 'V': 3924990b4856Slling cb.cb_version = strtoll(optarg, &end, 10); 3925351420b3Slling if (*end != '\0' || cb.cb_version > SPA_VERSION || 3926351420b3Slling cb.cb_version < SPA_VERSION_1) { 3927990b4856Slling (void) fprintf(stderr, 3928990b4856Slling gettext("invalid version '%s'\n"), optarg); 3929990b4856Slling usage(B_FALSE); 3930990b4856Slling } 3931990b4856Slling break; 3932478ed9adSEric Taylor case ':': 3933478ed9adSEric Taylor (void) fprintf(stderr, gettext("missing argument for " 3934478ed9adSEric Taylor "'%c' option\n"), optopt); 3935478ed9adSEric Taylor usage(B_FALSE); 3936478ed9adSEric Taylor break; 3937eaca9bbdSeschrock case '?': 3938eaca9bbdSeschrock (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3939eaca9bbdSeschrock optopt); 394099653d4eSeschrock usage(B_FALSE); 3941eaca9bbdSeschrock } 3942eaca9bbdSeschrock } 3943eaca9bbdSeschrock 394406eeb2adSek cb.cb_argc = argc; 394506eeb2adSek cb.cb_argv = argv; 3946eaca9bbdSeschrock argc -= optind; 3947eaca9bbdSeschrock argv += optind; 3948eaca9bbdSeschrock 3949351420b3Slling if (cb.cb_version == 0) { 3950351420b3Slling cb.cb_version = SPA_VERSION; 3951351420b3Slling } else if (!cb.cb_all && argc == 0) { 3952351420b3Slling (void) fprintf(stderr, gettext("-V option is " 3953351420b3Slling "incompatible with other arguments\n")); 3954351420b3Slling usage(B_FALSE); 3955351420b3Slling } 3956351420b3Slling 3957eaca9bbdSeschrock if (showversions) { 3958eaca9bbdSeschrock if (cb.cb_all || argc != 0) { 3959eaca9bbdSeschrock (void) fprintf(stderr, gettext("-v option is " 3960eaca9bbdSeschrock "incompatible with other arguments\n")); 396199653d4eSeschrock usage(B_FALSE); 3962eaca9bbdSeschrock } 3963eaca9bbdSeschrock } else if (cb.cb_all) { 3964eaca9bbdSeschrock if (argc != 0) { 3965351420b3Slling (void) fprintf(stderr, gettext("-a option should not " 3966351420b3Slling "be used along with a pool name\n")); 396799653d4eSeschrock usage(B_FALSE); 3968eaca9bbdSeschrock } 3969eaca9bbdSeschrock } 3970eaca9bbdSeschrock 3971e7437265Sahrens (void) printf(gettext("This system is currently running " 3972e7437265Sahrens "ZFS pool version %llu.\n\n"), SPA_VERSION); 397399653d4eSeschrock cb.cb_first = B_TRUE; 3974eaca9bbdSeschrock if (showversions) { 3975eaca9bbdSeschrock (void) printf(gettext("The following versions are " 3976d7d4af51Smmusante "supported:\n\n")); 3977eaca9bbdSeschrock (void) printf(gettext("VER DESCRIPTION\n")); 3978eaca9bbdSeschrock (void) printf("--- -----------------------------------------" 3979eaca9bbdSeschrock "---------------\n"); 398099653d4eSeschrock (void) printf(gettext(" 1 Initial ZFS version\n")); 398144cd46caSbillm (void) printf(gettext(" 2 Ditto blocks " 398244cd46caSbillm "(replicated metadata)\n")); 398399653d4eSeschrock (void) printf(gettext(" 3 Hot spares and double parity " 398499653d4eSeschrock "RAID-Z\n")); 3985d7306b64Sek (void) printf(gettext(" 4 zpool history\n")); 3986c9431fa1Sahl (void) printf(gettext(" 5 Compression using the gzip " 3987c9431fa1Sahl "algorithm\n")); 3988990b4856Slling (void) printf(gettext(" 6 bootfs pool property\n")); 39898654d025Sperrin (void) printf(gettext(" 7 Separate intent log devices\n")); 3990ecd6cf80Smarks (void) printf(gettext(" 8 Delegated administration\n")); 39918eed72d4Sck (void) printf(gettext(" 9 refquota and refreservation " 3992a9799022Sck "properties\n")); 3993fa94a07fSbrendan (void) printf(gettext(" 10 Cache devices\n")); 3994088f3894Sahrens (void) printf(gettext(" 11 Improved scrub performance\n")); 3995bb0ade09Sahrens (void) printf(gettext(" 12 Snapshot properties\n")); 399674e7dc98SMatthew Ahrens (void) printf(gettext(" 13 snapused property\n")); 399714843421SMatthew Ahrens (void) printf(gettext(" 14 passthrough-x aclinherit\n")); 399814843421SMatthew Ahrens (void) printf(gettext(" 15 user/group space accounting\n")); 3999478ed9adSEric Taylor (void) printf(gettext(" 16 stmf property support\n")); 40007aeab329SAdam Leventhal (void) printf(gettext(" 17 Triple-parity RAID-Z\n")); 4001b24ab676SJeff Bonwick (void) printf(gettext(" 18 Snapshot user holds\n")); 400288ecc943SGeorge Wilson (void) printf(gettext(" 19 Log device removal\n")); 4003b24ab676SJeff Bonwick (void) printf(gettext(" 20 Compression using zle " 4004b24ab676SJeff Bonwick "(zero-length encoding)\n")); 4005b24ab676SJeff Bonwick (void) printf(gettext(" 21 Deduplication\n")); 400692241e0bSTom Erickson (void) printf(gettext(" 22 Received properties\n")); 40076e1f5caaSNeil Perrin (void) printf(gettext(" 23 Slim ZIL\n")); 40080a586ceaSMark Shellenbaum (void) printf(gettext(" 24 System attributes\n")); 4009*3f9d6ad7SLin Ling (void) printf(gettext(" 25 Improved scrub stats\n")); 4010b24ab676SJeff Bonwick (void) printf(gettext("\nFor more information on a particular " 4011eaca9bbdSeschrock "version, including supported releases, see:\n\n")); 4012eaca9bbdSeschrock (void) printf("http://www.opensolaris.org/os/community/zfs/" 4013eaca9bbdSeschrock "version/N\n\n"); 4014eaca9bbdSeschrock (void) printf(gettext("Where 'N' is the version number.\n")); 4015eaca9bbdSeschrock } else if (argc == 0) { 4016eaca9bbdSeschrock int notfound; 4017eaca9bbdSeschrock 401899653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 4019eaca9bbdSeschrock notfound = cb.cb_first; 4020eaca9bbdSeschrock 4021eaca9bbdSeschrock if (!cb.cb_all && ret == 0) { 4022eaca9bbdSeschrock if (!cb.cb_first) 4023eaca9bbdSeschrock (void) printf("\n"); 4024eaca9bbdSeschrock cb.cb_first = B_TRUE; 4025eaca9bbdSeschrock cb.cb_newer = B_TRUE; 402699653d4eSeschrock ret = zpool_iter(g_zfs, upgrade_cb, &cb); 4027eaca9bbdSeschrock if (!cb.cb_first) { 4028eaca9bbdSeschrock notfound = B_FALSE; 4029eaca9bbdSeschrock (void) printf("\n"); 4030eaca9bbdSeschrock } 4031eaca9bbdSeschrock } 4032eaca9bbdSeschrock 4033eaca9bbdSeschrock if (ret == 0) { 4034eaca9bbdSeschrock if (notfound) 4035eaca9bbdSeschrock (void) printf(gettext("All pools are formatted " 4036eaca9bbdSeschrock "using this version.\n")); 4037eaca9bbdSeschrock else if (!cb.cb_all) 4038eaca9bbdSeschrock (void) printf(gettext("Use 'zpool upgrade -v' " 4039eaca9bbdSeschrock "for a list of available versions and " 4040eaca9bbdSeschrock "their associated\nfeatures.\n")); 4041eaca9bbdSeschrock } 4042eaca9bbdSeschrock } else { 4043b1b8ab34Slling ret = for_each_pool(argc, argv, B_FALSE, NULL, 4044b1b8ab34Slling upgrade_one, &cb); 404506eeb2adSek } 404606eeb2adSek 404706eeb2adSek return (ret); 404806eeb2adSek } 404906eeb2adSek 4050ecd6cf80Smarks typedef struct hist_cbdata { 4051ecd6cf80Smarks boolean_t first; 4052ecd6cf80Smarks int longfmt; 4053ecd6cf80Smarks int internal; 4054ecd6cf80Smarks } hist_cbdata_t; 4055ecd6cf80Smarks 405606eeb2adSek /* 405706eeb2adSek * Print out the command history for a specific pool. 405806eeb2adSek */ 405906eeb2adSek static int 406006eeb2adSek get_history_one(zpool_handle_t *zhp, void *data) 406106eeb2adSek { 406206eeb2adSek nvlist_t *nvhis; 406306eeb2adSek nvlist_t **records; 406406eeb2adSek uint_t numrecords; 406506eeb2adSek char *cmdstr; 4066ecd6cf80Smarks char *pathstr; 406706eeb2adSek uint64_t dst_time; 406806eeb2adSek time_t tsec; 406906eeb2adSek struct tm t; 407006eeb2adSek char tbuf[30]; 407106eeb2adSek int ret, i; 4072ecd6cf80Smarks uint64_t who; 4073ecd6cf80Smarks struct passwd *pwd; 4074ecd6cf80Smarks char *hostname; 4075ecd6cf80Smarks char *zonename; 4076ecd6cf80Smarks char internalstr[MAXPATHLEN]; 4077ecd6cf80Smarks hist_cbdata_t *cb = (hist_cbdata_t *)data; 4078ecd6cf80Smarks uint64_t txg; 4079ecd6cf80Smarks uint64_t ievent; 408006eeb2adSek 4081ecd6cf80Smarks cb->first = B_FALSE; 408206eeb2adSek 408306eeb2adSek (void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp)); 408406eeb2adSek 408506eeb2adSek if ((ret = zpool_get_history(zhp, &nvhis)) != 0) 408606eeb2adSek return (ret); 408706eeb2adSek 408806eeb2adSek verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD, 408906eeb2adSek &records, &numrecords) == 0); 409006eeb2adSek for (i = 0; i < numrecords; i++) { 409106eeb2adSek if (nvlist_lookup_uint64(records[i], ZPOOL_HIST_TIME, 4092ecd6cf80Smarks &dst_time) != 0) 4093ecd6cf80Smarks continue; 4094ecd6cf80Smarks 4095ecd6cf80Smarks /* is it an internal event or a standard event? */ 4096ecd6cf80Smarks if (nvlist_lookup_string(records[i], ZPOOL_HIST_CMD, 4097ecd6cf80Smarks &cmdstr) != 0) { 4098ecd6cf80Smarks if (cb->internal == 0) 4099ecd6cf80Smarks continue; 4100ecd6cf80Smarks 4101ecd6cf80Smarks if (nvlist_lookup_uint64(records[i], 4102ecd6cf80Smarks ZPOOL_HIST_INT_EVENT, &ievent) != 0) 4103ecd6cf80Smarks continue; 4104ecd6cf80Smarks verify(nvlist_lookup_uint64(records[i], 4105ecd6cf80Smarks ZPOOL_HIST_TXG, &txg) == 0); 4106ecd6cf80Smarks verify(nvlist_lookup_string(records[i], 4107ecd6cf80Smarks ZPOOL_HIST_INT_STR, &pathstr) == 0); 4108088f3894Sahrens if (ievent >= LOG_END) 4109ecd6cf80Smarks continue; 4110ecd6cf80Smarks (void) snprintf(internalstr, 4111ecd6cf80Smarks sizeof (internalstr), 4112ecd6cf80Smarks "[internal %s txg:%lld] %s", 4113*3f9d6ad7SLin Ling zfs_history_event_names[ievent], txg, 4114ecd6cf80Smarks pathstr); 4115ecd6cf80Smarks cmdstr = internalstr; 411606eeb2adSek } 4117ecd6cf80Smarks tsec = dst_time; 4118ecd6cf80Smarks (void) localtime_r(&tsec, &t); 4119ecd6cf80Smarks (void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t); 4120ecd6cf80Smarks (void) printf("%s %s", tbuf, cmdstr); 4121ecd6cf80Smarks 4122ecd6cf80Smarks if (!cb->longfmt) { 4123ecd6cf80Smarks (void) printf("\n"); 4124ecd6cf80Smarks continue; 4125ecd6cf80Smarks } 4126ecd6cf80Smarks (void) printf(" ["); 4127ecd6cf80Smarks if (nvlist_lookup_uint64(records[i], 4128ecd6cf80Smarks ZPOOL_HIST_WHO, &who) == 0) { 4129ecd6cf80Smarks pwd = getpwuid((uid_t)who); 4130ecd6cf80Smarks if (pwd) 4131ecd6cf80Smarks (void) printf("user %s on", 4132ecd6cf80Smarks pwd->pw_name); 4133ecd6cf80Smarks else 4134ecd6cf80Smarks (void) printf("user %d on", 4135ecd6cf80Smarks (int)who); 4136ecd6cf80Smarks } else { 4137ecd6cf80Smarks (void) printf(gettext("no info]\n")); 4138ecd6cf80Smarks continue; 4139ecd6cf80Smarks } 4140ecd6cf80Smarks if (nvlist_lookup_string(records[i], 4141ecd6cf80Smarks ZPOOL_HIST_HOST, &hostname) == 0) { 4142ecd6cf80Smarks (void) printf(" %s", hostname); 4143ecd6cf80Smarks } 4144ecd6cf80Smarks if (nvlist_lookup_string(records[i], 4145ecd6cf80Smarks ZPOOL_HIST_ZONE, &zonename) == 0) { 4146ecd6cf80Smarks (void) printf(":%s", zonename); 4147ecd6cf80Smarks } 4148ecd6cf80Smarks 4149ecd6cf80Smarks (void) printf("]"); 4150ecd6cf80Smarks (void) printf("\n"); 415106eeb2adSek } 415206eeb2adSek (void) printf("\n"); 415306eeb2adSek nvlist_free(nvhis); 415406eeb2adSek 415506eeb2adSek return (ret); 415606eeb2adSek } 415706eeb2adSek 415806eeb2adSek /* 415906eeb2adSek * zpool history <pool> 416006eeb2adSek * 416106eeb2adSek * Displays the history of commands that modified pools. 416206eeb2adSek */ 4163ecd6cf80Smarks 4164ecd6cf80Smarks 416506eeb2adSek int 416606eeb2adSek zpool_do_history(int argc, char **argv) 416706eeb2adSek { 4168ecd6cf80Smarks hist_cbdata_t cbdata = { 0 }; 416906eeb2adSek int ret; 4170ecd6cf80Smarks int c; 417106eeb2adSek 4172ecd6cf80Smarks cbdata.first = B_TRUE; 4173ecd6cf80Smarks /* check options */ 4174ecd6cf80Smarks while ((c = getopt(argc, argv, "li")) != -1) { 4175ecd6cf80Smarks switch (c) { 4176ecd6cf80Smarks case 'l': 4177ecd6cf80Smarks cbdata.longfmt = 1; 4178ecd6cf80Smarks break; 4179ecd6cf80Smarks case 'i': 4180ecd6cf80Smarks cbdata.internal = 1; 4181ecd6cf80Smarks break; 4182ecd6cf80Smarks case '?': 4183ecd6cf80Smarks (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4184ecd6cf80Smarks optopt); 4185ecd6cf80Smarks usage(B_FALSE); 4186ecd6cf80Smarks } 4187ecd6cf80Smarks } 418806eeb2adSek argc -= optind; 418906eeb2adSek argv += optind; 419006eeb2adSek 4191b1b8ab34Slling ret = for_each_pool(argc, argv, B_FALSE, NULL, get_history_one, 4192ecd6cf80Smarks &cbdata); 419306eeb2adSek 4194ecd6cf80Smarks if (argc == 0 && cbdata.first == B_TRUE) { 419506eeb2adSek (void) printf(gettext("no pools available\n")); 419606eeb2adSek return (0); 4197eaca9bbdSeschrock } 4198eaca9bbdSeschrock 4199eaca9bbdSeschrock return (ret); 4200eaca9bbdSeschrock } 4201eaca9bbdSeschrock 4202b1b8ab34Slling static int 4203b1b8ab34Slling get_callback(zpool_handle_t *zhp, void *data) 4204b1b8ab34Slling { 4205990b4856Slling zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 4206b1b8ab34Slling char value[MAXNAMELEN]; 4207990b4856Slling zprop_source_t srctype; 4208990b4856Slling zprop_list_t *pl; 4209b1b8ab34Slling 4210b1b8ab34Slling for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) { 4211b1b8ab34Slling 4212b1b8ab34Slling /* 4213990b4856Slling * Skip the special fake placeholder. This will also skip 4214990b4856Slling * over the name property when 'all' is specified. 4215b1b8ab34Slling */ 4216990b4856Slling if (pl->pl_prop == ZPOOL_PROP_NAME && 4217b1b8ab34Slling pl == cbp->cb_proplist) 4218b1b8ab34Slling continue; 4219b1b8ab34Slling 4220b1b8ab34Slling if (zpool_get_prop(zhp, pl->pl_prop, 4221b1b8ab34Slling value, sizeof (value), &srctype) != 0) 4222b1b8ab34Slling continue; 4223b1b8ab34Slling 4224990b4856Slling zprop_print_one_property(zpool_get_name(zhp), cbp, 422592241e0bSTom Erickson zpool_prop_to_name(pl->pl_prop), value, srctype, NULL, 422692241e0bSTom Erickson NULL); 4227b1b8ab34Slling } 4228b1b8ab34Slling return (0); 4229b1b8ab34Slling } 4230b1b8ab34Slling 4231b1b8ab34Slling int 4232b1b8ab34Slling zpool_do_get(int argc, char **argv) 4233b1b8ab34Slling { 4234990b4856Slling zprop_get_cbdata_t cb = { 0 }; 4235990b4856Slling zprop_list_t fake_name = { 0 }; 4236b1b8ab34Slling int ret; 4237b1b8ab34Slling 4238b1b8ab34Slling if (argc < 3) 4239b1b8ab34Slling usage(B_FALSE); 4240b1b8ab34Slling 4241b1b8ab34Slling cb.cb_first = B_TRUE; 4242990b4856Slling cb.cb_sources = ZPROP_SRC_ALL; 4243b1b8ab34Slling cb.cb_columns[0] = GET_COL_NAME; 4244b1b8ab34Slling cb.cb_columns[1] = GET_COL_PROPERTY; 4245b1b8ab34Slling cb.cb_columns[2] = GET_COL_VALUE; 4246b1b8ab34Slling cb.cb_columns[3] = GET_COL_SOURCE; 4247990b4856Slling cb.cb_type = ZFS_TYPE_POOL; 4248b1b8ab34Slling 4249990b4856Slling if (zprop_get_list(g_zfs, argv[1], &cb.cb_proplist, 4250990b4856Slling ZFS_TYPE_POOL) != 0) 4251b1b8ab34Slling usage(B_FALSE); 4252b1b8ab34Slling 4253b1b8ab34Slling if (cb.cb_proplist != NULL) { 4254990b4856Slling fake_name.pl_prop = ZPOOL_PROP_NAME; 4255b1b8ab34Slling fake_name.pl_width = strlen(gettext("NAME")); 4256b1b8ab34Slling fake_name.pl_next = cb.cb_proplist; 4257b1b8ab34Slling cb.cb_proplist = &fake_name; 4258b1b8ab34Slling } 4259b1b8ab34Slling 4260b1b8ab34Slling ret = for_each_pool(argc - 2, argv + 2, B_TRUE, &cb.cb_proplist, 4261b1b8ab34Slling get_callback, &cb); 4262b1b8ab34Slling 4263b1b8ab34Slling if (cb.cb_proplist == &fake_name) 4264990b4856Slling zprop_free_list(fake_name.pl_next); 4265b1b8ab34Slling else 4266990b4856Slling zprop_free_list(cb.cb_proplist); 4267b1b8ab34Slling 4268b1b8ab34Slling return (ret); 4269b1b8ab34Slling } 4270b1b8ab34Slling 4271b1b8ab34Slling typedef struct set_cbdata { 4272b1b8ab34Slling char *cb_propname; 4273b1b8ab34Slling char *cb_value; 4274b1b8ab34Slling boolean_t cb_any_successful; 4275b1b8ab34Slling } set_cbdata_t; 4276b1b8ab34Slling 4277b1b8ab34Slling int 4278b1b8ab34Slling set_callback(zpool_handle_t *zhp, void *data) 4279b1b8ab34Slling { 4280b1b8ab34Slling int error; 4281b1b8ab34Slling set_cbdata_t *cb = (set_cbdata_t *)data; 4282b1b8ab34Slling 4283b1b8ab34Slling error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value); 4284b1b8ab34Slling 4285b1b8ab34Slling if (!error) 4286b1b8ab34Slling cb->cb_any_successful = B_TRUE; 4287b1b8ab34Slling 4288b1b8ab34Slling return (error); 4289b1b8ab34Slling } 4290b1b8ab34Slling 4291b1b8ab34Slling int 4292b1b8ab34Slling zpool_do_set(int argc, char **argv) 4293b1b8ab34Slling { 4294b1b8ab34Slling set_cbdata_t cb = { 0 }; 4295b1b8ab34Slling int error; 4296b1b8ab34Slling 4297b1b8ab34Slling if (argc > 1 && argv[1][0] == '-') { 4298b1b8ab34Slling (void) fprintf(stderr, gettext("invalid option '%c'\n"), 4299b1b8ab34Slling argv[1][1]); 4300b1b8ab34Slling usage(B_FALSE); 4301b1b8ab34Slling } 4302b1b8ab34Slling 4303b1b8ab34Slling if (argc < 2) { 4304b1b8ab34Slling (void) fprintf(stderr, gettext("missing property=value " 4305b1b8ab34Slling "argument\n")); 4306b1b8ab34Slling usage(B_FALSE); 4307b1b8ab34Slling } 4308b1b8ab34Slling 4309b1b8ab34Slling if (argc < 3) { 4310b1b8ab34Slling (void) fprintf(stderr, gettext("missing pool name\n")); 4311b1b8ab34Slling usage(B_FALSE); 4312b1b8ab34Slling } 4313b1b8ab34Slling 4314b1b8ab34Slling if (argc > 3) { 4315b1b8ab34Slling (void) fprintf(stderr, gettext("too many pool names\n")); 4316b1b8ab34Slling usage(B_FALSE); 4317b1b8ab34Slling } 4318b1b8ab34Slling 4319b1b8ab34Slling cb.cb_propname = argv[1]; 4320b1b8ab34Slling cb.cb_value = strchr(cb.cb_propname, '='); 4321b1b8ab34Slling if (cb.cb_value == NULL) { 4322b1b8ab34Slling (void) fprintf(stderr, gettext("missing value in " 4323b1b8ab34Slling "property=value argument\n")); 4324b1b8ab34Slling usage(B_FALSE); 4325b1b8ab34Slling } 4326b1b8ab34Slling 4327b1b8ab34Slling *(cb.cb_value) = '\0'; 4328b1b8ab34Slling cb.cb_value++; 4329b1b8ab34Slling 4330b1b8ab34Slling error = for_each_pool(argc - 2, argv + 2, B_TRUE, NULL, 4331b1b8ab34Slling set_callback, &cb); 4332b1b8ab34Slling 4333b1b8ab34Slling return (error); 4334b1b8ab34Slling } 4335b1b8ab34Slling 4336b1b8ab34Slling static int 4337b1b8ab34Slling find_command_idx(char *command, int *idx) 4338b1b8ab34Slling { 4339b1b8ab34Slling int i; 4340b1b8ab34Slling 4341b1b8ab34Slling for (i = 0; i < NCOMMAND; i++) { 4342b1b8ab34Slling if (command_table[i].name == NULL) 4343b1b8ab34Slling continue; 4344b1b8ab34Slling 4345b1b8ab34Slling if (strcmp(command, command_table[i].name) == 0) { 4346b1b8ab34Slling *idx = i; 4347b1b8ab34Slling return (0); 4348b1b8ab34Slling } 4349b1b8ab34Slling } 4350b1b8ab34Slling return (1); 4351b1b8ab34Slling } 4352b1b8ab34Slling 4353fa9e4066Sahrens int 4354fa9e4066Sahrens main(int argc, char **argv) 4355fa9e4066Sahrens { 4356fa9e4066Sahrens int ret; 4357fa9e4066Sahrens int i; 4358fa9e4066Sahrens char *cmdname; 4359fa9e4066Sahrens 4360fa9e4066Sahrens (void) setlocale(LC_ALL, ""); 4361fa9e4066Sahrens (void) textdomain(TEXT_DOMAIN); 4362fa9e4066Sahrens 436399653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 436499653d4eSeschrock (void) fprintf(stderr, gettext("internal error: failed to " 4365203a47d8Snd "initialize ZFS library\n")); 436699653d4eSeschrock return (1); 436799653d4eSeschrock } 436899653d4eSeschrock 436999653d4eSeschrock libzfs_print_on_error(g_zfs, B_TRUE); 437099653d4eSeschrock 4371fa9e4066Sahrens opterr = 0; 4372fa9e4066Sahrens 4373fa9e4066Sahrens /* 4374fa9e4066Sahrens * Make sure the user has specified some command. 4375fa9e4066Sahrens */ 4376fa9e4066Sahrens if (argc < 2) { 4377fa9e4066Sahrens (void) fprintf(stderr, gettext("missing command\n")); 437899653d4eSeschrock usage(B_FALSE); 4379fa9e4066Sahrens } 4380fa9e4066Sahrens 4381fa9e4066Sahrens cmdname = argv[1]; 4382fa9e4066Sahrens 4383fa9e4066Sahrens /* 4384fa9e4066Sahrens * Special case '-?' 4385fa9e4066Sahrens */ 4386fa9e4066Sahrens if (strcmp(cmdname, "-?") == 0) 438799653d4eSeschrock usage(B_TRUE); 4388fa9e4066Sahrens 43892a6b87f0Sek zpool_set_history_str("zpool", argc, argv, history_str); 43902a6b87f0Sek verify(zpool_stage_history(g_zfs, history_str) == 0); 43912a6b87f0Sek 4392fa9e4066Sahrens /* 4393fa9e4066Sahrens * Run the appropriate command. 4394fa9e4066Sahrens */ 4395b1b8ab34Slling if (find_command_idx(cmdname, &i) == 0) { 4396b1b8ab34Slling current_command = &command_table[i]; 4397b1b8ab34Slling ret = command_table[i].func(argc - 1, argv + 1); 439891ebeef5Sahrens } else if (strchr(cmdname, '=')) { 439991ebeef5Sahrens verify(find_command_idx("set", &i) == 0); 440091ebeef5Sahrens current_command = &command_table[i]; 440191ebeef5Sahrens ret = command_table[i].func(argc, argv); 440291ebeef5Sahrens } else if (strcmp(cmdname, "freeze") == 0 && argc == 3) { 440391ebeef5Sahrens /* 440491ebeef5Sahrens * 'freeze' is a vile debugging abomination, so we treat 440591ebeef5Sahrens * it as such. 440691ebeef5Sahrens */ 4407ea8dc4b6Seschrock char buf[16384]; 4408ea8dc4b6Seschrock int fd = open(ZFS_DEV, O_RDWR); 4409fa9e4066Sahrens (void) strcpy((void *)buf, argv[2]); 4410fa9e4066Sahrens return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf)); 441191ebeef5Sahrens } else { 4412fa9e4066Sahrens (void) fprintf(stderr, gettext("unrecognized " 4413fa9e4066Sahrens "command '%s'\n"), cmdname); 441499653d4eSeschrock usage(B_FALSE); 4415fa9e4066Sahrens } 4416fa9e4066Sahrens 441799653d4eSeschrock libzfs_fini(g_zfs); 441899653d4eSeschrock 4419fa9e4066Sahrens /* 4420fa9e4066Sahrens * The 'ZFS_ABORT' environment variable causes us to dump core on exit 4421fa9e4066Sahrens * for the purposes of running ::findleaks. 4422fa9e4066Sahrens */ 4423fa9e4066Sahrens if (getenv("ZFS_ABORT") != NULL) { 4424fa9e4066Sahrens (void) printf("dumping core by request\n"); 4425fa9e4066Sahrens abort(); 4426fa9e4066Sahrens } 4427fa9e4066Sahrens 4428fa9e4066Sahrens return (ret); 4429fa9e4066Sahrens } 4430