1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 25 * Copyright (c) 2011, 2020 by Delphix. All rights reserved. 26 * Copyright (c) 2012 by Frederik Wessels. All rights reserved. 27 * Copyright (c) 2012 by Cyril Plisko. All rights reserved. 28 * Copyright (c) 2013 by Prasad Joshi (sTec). All rights reserved. 29 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>. 30 * Copyright (c) 2017 Datto Inc. 31 * Copyright (c) 2017 Open-E, Inc. All Rights Reserved. 32 * Copyright (c) 2017, Intel Corporation. 33 * Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com> 34 * Copyright (c) 2021, Colm Buckley <colm@tuatha.org> 35 * Copyright (c) 2021, Klara Inc. 36 * Copyright [2021] Hewlett Packard Enterprise Development LP 37 */ 38 39 #include <assert.h> 40 #include <ctype.h> 41 #include <dirent.h> 42 #include <errno.h> 43 #include <fcntl.h> 44 #include <getopt.h> 45 #include <libgen.h> 46 #include <libintl.h> 47 #include <libuutil.h> 48 #include <locale.h> 49 #include <pthread.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 #include <strings.h> 54 #include <time.h> 55 #include <unistd.h> 56 #include <pwd.h> 57 #include <zone.h> 58 #include <sys/wait.h> 59 #include <zfs_prop.h> 60 #include <sys/fs/zfs.h> 61 #include <sys/stat.h> 62 #include <sys/systeminfo.h> 63 #include <sys/fm/fs/zfs.h> 64 #include <sys/fm/util.h> 65 #include <sys/fm/protocol.h> 66 #include <sys/zfs_ioctl.h> 67 #include <sys/mount.h> 68 #include <sys/sysmacros.h> 69 70 #include <math.h> 71 72 #include <libzfs.h> 73 #include <libzutil.h> 74 75 #include "zpool_util.h" 76 #include "zfs_comutil.h" 77 #include "zfeature_common.h" 78 79 #include "statcommon.h" 80 81 libzfs_handle_t *g_zfs; 82 83 static int zpool_do_create(int, char **); 84 static int zpool_do_destroy(int, char **); 85 86 static int zpool_do_add(int, char **); 87 static int zpool_do_remove(int, char **); 88 static int zpool_do_labelclear(int, char **); 89 90 static int zpool_do_checkpoint(int, char **); 91 92 static int zpool_do_list(int, char **); 93 static int zpool_do_iostat(int, char **); 94 static int zpool_do_status(int, char **); 95 96 static int zpool_do_online(int, char **); 97 static int zpool_do_offline(int, char **); 98 static int zpool_do_clear(int, char **); 99 static int zpool_do_reopen(int, char **); 100 101 static int zpool_do_reguid(int, char **); 102 103 static int zpool_do_attach(int, char **); 104 static int zpool_do_detach(int, char **); 105 static int zpool_do_replace(int, char **); 106 static int zpool_do_split(int, char **); 107 108 static int zpool_do_initialize(int, char **); 109 static int zpool_do_scrub(int, char **); 110 static int zpool_do_resilver(int, char **); 111 static int zpool_do_trim(int, char **); 112 113 static int zpool_do_import(int, char **); 114 static int zpool_do_export(int, char **); 115 116 static int zpool_do_upgrade(int, char **); 117 118 static int zpool_do_history(int, char **); 119 static int zpool_do_events(int, char **); 120 121 static int zpool_do_get(int, char **); 122 static int zpool_do_set(int, char **); 123 124 static int zpool_do_sync(int, char **); 125 126 static int zpool_do_version(int, char **); 127 128 static int zpool_do_wait(int, char **); 129 130 static zpool_compat_status_t zpool_do_load_compat( 131 const char *, boolean_t *); 132 133 /* 134 * These libumem hooks provide a reasonable set of defaults for the allocator's 135 * debugging facilities. 136 */ 137 138 #ifdef DEBUG 139 const char * 140 _umem_debug_init(void) 141 { 142 return ("default,verbose"); /* $UMEM_DEBUG setting */ 143 } 144 145 const char * 146 _umem_logging_init(void) 147 { 148 return ("fail,contents"); /* $UMEM_LOGGING setting */ 149 } 150 #endif 151 152 typedef enum { 153 HELP_ADD, 154 HELP_ATTACH, 155 HELP_CLEAR, 156 HELP_CREATE, 157 HELP_CHECKPOINT, 158 HELP_DESTROY, 159 HELP_DETACH, 160 HELP_EXPORT, 161 HELP_HISTORY, 162 HELP_IMPORT, 163 HELP_IOSTAT, 164 HELP_LABELCLEAR, 165 HELP_LIST, 166 HELP_OFFLINE, 167 HELP_ONLINE, 168 HELP_REPLACE, 169 HELP_REMOVE, 170 HELP_INITIALIZE, 171 HELP_SCRUB, 172 HELP_RESILVER, 173 HELP_TRIM, 174 HELP_STATUS, 175 HELP_UPGRADE, 176 HELP_EVENTS, 177 HELP_GET, 178 HELP_SET, 179 HELP_SPLIT, 180 HELP_SYNC, 181 HELP_REGUID, 182 HELP_REOPEN, 183 HELP_VERSION, 184 HELP_WAIT 185 } zpool_help_t; 186 187 188 /* 189 * Flags for stats to display with "zpool iostats" 190 */ 191 enum iostat_type { 192 IOS_DEFAULT = 0, 193 IOS_LATENCY = 1, 194 IOS_QUEUES = 2, 195 IOS_L_HISTO = 3, 196 IOS_RQ_HISTO = 4, 197 IOS_COUNT, /* always last element */ 198 }; 199 200 /* iostat_type entries as bitmasks */ 201 #define IOS_DEFAULT_M (1ULL << IOS_DEFAULT) 202 #define IOS_LATENCY_M (1ULL << IOS_LATENCY) 203 #define IOS_QUEUES_M (1ULL << IOS_QUEUES) 204 #define IOS_L_HISTO_M (1ULL << IOS_L_HISTO) 205 #define IOS_RQ_HISTO_M (1ULL << IOS_RQ_HISTO) 206 207 /* Mask of all the histo bits */ 208 #define IOS_ANYHISTO_M (IOS_L_HISTO_M | IOS_RQ_HISTO_M) 209 210 /* 211 * Lookup table for iostat flags to nvlist names. Basically a list 212 * of all the nvlists a flag requires. Also specifies the order in 213 * which data gets printed in zpool iostat. 214 */ 215 static const char *vsx_type_to_nvlist[IOS_COUNT][15] = { 216 [IOS_L_HISTO] = { 217 ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO, 218 ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO, 219 ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO, 220 ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO, 221 ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO, 222 ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO, 223 ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO, 224 ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO, 225 ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO, 226 ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO, 227 ZPOOL_CONFIG_VDEV_REBUILD_LAT_HISTO, 228 NULL}, 229 [IOS_LATENCY] = { 230 ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO, 231 ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO, 232 ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO, 233 ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO, 234 ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO, 235 ZPOOL_CONFIG_VDEV_REBUILD_LAT_HISTO, 236 NULL}, 237 [IOS_QUEUES] = { 238 ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE, 239 ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE, 240 ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE, 241 ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE, 242 ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE, 243 ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE, 244 ZPOOL_CONFIG_VDEV_REBUILD_ACTIVE_QUEUE, 245 NULL}, 246 [IOS_RQ_HISTO] = { 247 ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO, 248 ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO, 249 ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO, 250 ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO, 251 ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO, 252 ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO, 253 ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO, 254 ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO, 255 ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO, 256 ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO, 257 ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO, 258 ZPOOL_CONFIG_VDEV_AGG_TRIM_HISTO, 259 ZPOOL_CONFIG_VDEV_IND_REBUILD_HISTO, 260 ZPOOL_CONFIG_VDEV_AGG_REBUILD_HISTO, 261 NULL}, 262 }; 263 264 265 /* 266 * Given a cb->cb_flags with a histogram bit set, return the iostat_type. 267 * Right now, only one histo bit is ever set at one time, so we can 268 * just do a highbit64(a) 269 */ 270 #define IOS_HISTO_IDX(a) (highbit64(a & IOS_ANYHISTO_M) - 1) 271 272 typedef struct zpool_command { 273 const char *name; 274 int (*func)(int, char **); 275 zpool_help_t usage; 276 } zpool_command_t; 277 278 /* 279 * Master command table. Each ZFS command has a name, associated function, and 280 * usage message. The usage messages need to be internationalized, so we have 281 * to have a function to return the usage message based on a command index. 282 * 283 * These commands are organized according to how they are displayed in the usage 284 * message. An empty command (one with a NULL name) indicates an empty line in 285 * the generic usage message. 286 */ 287 static zpool_command_t command_table[] = { 288 { "version", zpool_do_version, HELP_VERSION }, 289 { NULL }, 290 { "create", zpool_do_create, HELP_CREATE }, 291 { "destroy", zpool_do_destroy, HELP_DESTROY }, 292 { NULL }, 293 { "add", zpool_do_add, HELP_ADD }, 294 { "remove", zpool_do_remove, HELP_REMOVE }, 295 { NULL }, 296 { "labelclear", zpool_do_labelclear, HELP_LABELCLEAR }, 297 { NULL }, 298 { "checkpoint", zpool_do_checkpoint, HELP_CHECKPOINT }, 299 { NULL }, 300 { "list", zpool_do_list, HELP_LIST }, 301 { "iostat", zpool_do_iostat, HELP_IOSTAT }, 302 { "status", zpool_do_status, HELP_STATUS }, 303 { NULL }, 304 { "online", zpool_do_online, HELP_ONLINE }, 305 { "offline", zpool_do_offline, HELP_OFFLINE }, 306 { "clear", zpool_do_clear, HELP_CLEAR }, 307 { "reopen", zpool_do_reopen, HELP_REOPEN }, 308 { NULL }, 309 { "attach", zpool_do_attach, HELP_ATTACH }, 310 { "detach", zpool_do_detach, HELP_DETACH }, 311 { "replace", zpool_do_replace, HELP_REPLACE }, 312 { "split", zpool_do_split, HELP_SPLIT }, 313 { NULL }, 314 { "initialize", zpool_do_initialize, HELP_INITIALIZE }, 315 { "resilver", zpool_do_resilver, HELP_RESILVER }, 316 { "scrub", zpool_do_scrub, HELP_SCRUB }, 317 { "trim", zpool_do_trim, HELP_TRIM }, 318 { NULL }, 319 { "import", zpool_do_import, HELP_IMPORT }, 320 { "export", zpool_do_export, HELP_EXPORT }, 321 { "upgrade", zpool_do_upgrade, HELP_UPGRADE }, 322 { "reguid", zpool_do_reguid, HELP_REGUID }, 323 { NULL }, 324 { "history", zpool_do_history, HELP_HISTORY }, 325 { "events", zpool_do_events, HELP_EVENTS }, 326 { NULL }, 327 { "get", zpool_do_get, HELP_GET }, 328 { "set", zpool_do_set, HELP_SET }, 329 { "sync", zpool_do_sync, HELP_SYNC }, 330 { NULL }, 331 { "wait", zpool_do_wait, HELP_WAIT }, 332 }; 333 334 #define NCOMMAND (ARRAY_SIZE(command_table)) 335 336 #define VDEV_ALLOC_CLASS_LOGS "logs" 337 338 static zpool_command_t *current_command; 339 static zfs_type_t current_prop_type = (ZFS_TYPE_POOL | ZFS_TYPE_VDEV); 340 static char history_str[HIS_MAX_RECORD_LEN]; 341 static boolean_t log_history = B_TRUE; 342 static uint_t timestamp_fmt = NODATE; 343 344 static const char * 345 get_usage(zpool_help_t idx) 346 { 347 switch (idx) { 348 case HELP_ADD: 349 return (gettext("\tadd [-fgLnP] [-o property=value] " 350 "<pool> <vdev> ...\n")); 351 case HELP_ATTACH: 352 return (gettext("\tattach [-fsw] [-o property=value] " 353 "<pool> <device> <new-device>\n")); 354 case HELP_CLEAR: 355 return (gettext("\tclear [-nF] <pool> [device]\n")); 356 case HELP_CREATE: 357 return (gettext("\tcreate [-fnd] [-o property=value] ... \n" 358 "\t [-O file-system-property=value] ... \n" 359 "\t [-m mountpoint] [-R root] <pool> <vdev> ...\n")); 360 case HELP_CHECKPOINT: 361 return (gettext("\tcheckpoint [-d [-w]] <pool> ...\n")); 362 case HELP_DESTROY: 363 return (gettext("\tdestroy [-f] <pool>\n")); 364 case HELP_DETACH: 365 return (gettext("\tdetach <pool> <device>\n")); 366 case HELP_EXPORT: 367 return (gettext("\texport [-af] <pool> ...\n")); 368 case HELP_HISTORY: 369 return (gettext("\thistory [-il] [<pool>] ...\n")); 370 case HELP_IMPORT: 371 return (gettext("\timport [-d dir] [-D]\n" 372 "\timport [-o mntopts] [-o property=value] ... \n" 373 "\t [-d dir | -c cachefile] [-D] [-l] [-f] [-m] [-N] " 374 "[-R root] [-F [-n]] -a\n" 375 "\timport [-o mntopts] [-o property=value] ... \n" 376 "\t [-d dir | -c cachefile] [-D] [-l] [-f] [-m] [-N] " 377 "[-R root] [-F [-n]]\n" 378 "\t [--rewind-to-checkpoint] <pool | id> [newpool]\n")); 379 case HELP_IOSTAT: 380 return (gettext("\tiostat [[[-c [script1,script2,...]" 381 "[-lq]]|[-rw]] [-T d | u] [-ghHLpPvy]\n" 382 "\t [[pool ...]|[pool vdev ...]|[vdev ...]]" 383 " [[-n] interval [count]]\n")); 384 case HELP_LABELCLEAR: 385 return (gettext("\tlabelclear [-f] <vdev>\n")); 386 case HELP_LIST: 387 return (gettext("\tlist [-gHLpPv] [-o property[,...]] " 388 "[-T d|u] [pool] ... \n" 389 "\t [interval [count]]\n")); 390 case HELP_OFFLINE: 391 return (gettext("\toffline [-f] [-t] <pool> <device> ...\n")); 392 case HELP_ONLINE: 393 return (gettext("\tonline [-e] <pool> <device> ...\n")); 394 case HELP_REPLACE: 395 return (gettext("\treplace [-fsw] [-o property=value] " 396 "<pool> <device> [new-device]\n")); 397 case HELP_REMOVE: 398 return (gettext("\tremove [-npsw] <pool> <device> ...\n")); 399 case HELP_REOPEN: 400 return (gettext("\treopen [-n] <pool>\n")); 401 case HELP_INITIALIZE: 402 return (gettext("\tinitialize [-c | -s] [-w] <pool> " 403 "[<device> ...]\n")); 404 case HELP_SCRUB: 405 return (gettext("\tscrub [-s | -p] [-w] <pool> ...\n")); 406 case HELP_RESILVER: 407 return (gettext("\tresilver <pool> ...\n")); 408 case HELP_TRIM: 409 return (gettext("\ttrim [-dw] [-r <rate>] [-c | -s] <pool> " 410 "[<device> ...]\n")); 411 case HELP_STATUS: 412 return (gettext("\tstatus [-c [script1,script2,...]] " 413 "[-igLpPstvxD] [-T d|u] [pool] ... \n" 414 "\t [interval [count]]\n")); 415 case HELP_UPGRADE: 416 return (gettext("\tupgrade\n" 417 "\tupgrade -v\n" 418 "\tupgrade [-V version] <-a | pool ...>\n")); 419 case HELP_EVENTS: 420 return (gettext("\tevents [-vHf [pool] | -c]\n")); 421 case HELP_GET: 422 return (gettext("\tget [-Hp] [-o \"all\" | field[,...]] " 423 "<\"all\" | property[,...]> <pool> ...\n")); 424 case HELP_SET: 425 return (gettext("\tset <property=value> <pool> \n")); 426 case HELP_SPLIT: 427 return (gettext("\tsplit [-gLnPl] [-R altroot] [-o mntopts]\n" 428 "\t [-o property=value] <pool> <newpool> " 429 "[<device> ...]\n")); 430 case HELP_REGUID: 431 return (gettext("\treguid <pool>\n")); 432 case HELP_SYNC: 433 return (gettext("\tsync [pool] ...\n")); 434 case HELP_VERSION: 435 return (gettext("\tversion\n")); 436 case HELP_WAIT: 437 return (gettext("\twait [-Hp] [-T d|u] [-t <activity>[,...]] " 438 "<pool> [interval]\n")); 439 default: 440 __builtin_unreachable(); 441 } 442 } 443 444 static void 445 zpool_collect_leaves(zpool_handle_t *zhp, nvlist_t *nvroot, nvlist_t *res) 446 { 447 uint_t children = 0; 448 nvlist_t **child; 449 uint_t i; 450 451 (void) nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 452 &child, &children); 453 454 if (children == 0) { 455 char *path = zpool_vdev_name(g_zfs, zhp, nvroot, 456 VDEV_NAME_PATH); 457 458 if (strcmp(path, VDEV_TYPE_INDIRECT) != 0 && 459 strcmp(path, VDEV_TYPE_HOLE) != 0) 460 fnvlist_add_boolean(res, path); 461 462 free(path); 463 return; 464 } 465 466 for (i = 0; i < children; i++) { 467 zpool_collect_leaves(zhp, child[i], res); 468 } 469 } 470 471 /* 472 * Callback routine that will print out a pool property value. 473 */ 474 static int 475 print_pool_prop_cb(int prop, void *cb) 476 { 477 FILE *fp = cb; 478 479 (void) fprintf(fp, "\t%-19s ", zpool_prop_to_name(prop)); 480 481 if (zpool_prop_readonly(prop)) 482 (void) fprintf(fp, " NO "); 483 else 484 (void) fprintf(fp, " YES "); 485 486 if (zpool_prop_values(prop) == NULL) 487 (void) fprintf(fp, "-\n"); 488 else 489 (void) fprintf(fp, "%s\n", zpool_prop_values(prop)); 490 491 return (ZPROP_CONT); 492 } 493 494 /* 495 * Callback routine that will print out a vdev property value. 496 */ 497 static int 498 print_vdev_prop_cb(int prop, void *cb) 499 { 500 FILE *fp = cb; 501 502 (void) fprintf(fp, "\t%-19s ", vdev_prop_to_name(prop)); 503 504 if (vdev_prop_readonly(prop)) 505 (void) fprintf(fp, " NO "); 506 else 507 (void) fprintf(fp, " YES "); 508 509 if (vdev_prop_values(prop) == NULL) 510 (void) fprintf(fp, "-\n"); 511 else 512 (void) fprintf(fp, "%s\n", vdev_prop_values(prop)); 513 514 return (ZPROP_CONT); 515 } 516 517 /* 518 * Display usage message. If we're inside a command, display only the usage for 519 * that command. Otherwise, iterate over the entire command table and display 520 * a complete usage message. 521 */ 522 static void 523 usage(boolean_t requested) 524 { 525 FILE *fp = requested ? stdout : stderr; 526 527 if (current_command == NULL) { 528 int i; 529 530 (void) fprintf(fp, gettext("usage: zpool command args ...\n")); 531 (void) fprintf(fp, 532 gettext("where 'command' is one of the following:\n\n")); 533 534 for (i = 0; i < NCOMMAND; i++) { 535 if (command_table[i].name == NULL) 536 (void) fprintf(fp, "\n"); 537 else 538 (void) fprintf(fp, "%s", 539 get_usage(command_table[i].usage)); 540 } 541 } else { 542 (void) fprintf(fp, gettext("usage:\n")); 543 (void) fprintf(fp, "%s", get_usage(current_command->usage)); 544 } 545 546 if (current_command != NULL && 547 current_prop_type != (ZFS_TYPE_POOL | ZFS_TYPE_VDEV) && 548 ((strcmp(current_command->name, "set") == 0) || 549 (strcmp(current_command->name, "get") == 0) || 550 (strcmp(current_command->name, "list") == 0))) { 551 552 (void) fprintf(fp, 553 gettext("\nthe following properties are supported:\n")); 554 555 (void) fprintf(fp, "\n\t%-19s %s %s\n\n", 556 "PROPERTY", "EDIT", "VALUES"); 557 558 /* Iterate over all properties */ 559 if (current_prop_type == ZFS_TYPE_POOL) { 560 (void) zprop_iter(print_pool_prop_cb, fp, B_FALSE, 561 B_TRUE, current_prop_type); 562 563 (void) fprintf(fp, "\t%-19s ", "feature@..."); 564 (void) fprintf(fp, "YES " 565 "disabled | enabled | active\n"); 566 567 (void) fprintf(fp, gettext("\nThe feature@ properties " 568 "must be appended with a feature name.\n" 569 "See zpool-features(7).\n")); 570 } else if (current_prop_type == ZFS_TYPE_VDEV) { 571 (void) zprop_iter(print_vdev_prop_cb, fp, B_FALSE, 572 B_TRUE, current_prop_type); 573 } 574 } 575 576 /* 577 * See comments at end of main(). 578 */ 579 if (getenv("ZFS_ABORT") != NULL) { 580 (void) printf("dumping core by request\n"); 581 abort(); 582 } 583 584 exit(requested ? 0 : 2); 585 } 586 587 /* 588 * zpool initialize [-c | -s] [-w] <pool> [<vdev> ...] 589 * Initialize all unused blocks in the specified vdevs, or all vdevs in the pool 590 * if none specified. 591 * 592 * -c Cancel. Ends active initializing. 593 * -s Suspend. Initializing can then be restarted with no flags. 594 * -w Wait. Blocks until initializing has completed. 595 */ 596 int 597 zpool_do_initialize(int argc, char **argv) 598 { 599 int c; 600 char *poolname; 601 zpool_handle_t *zhp; 602 nvlist_t *vdevs; 603 int err = 0; 604 boolean_t wait = B_FALSE; 605 606 struct option long_options[] = { 607 {"cancel", no_argument, NULL, 'c'}, 608 {"suspend", no_argument, NULL, 's'}, 609 {"wait", no_argument, NULL, 'w'}, 610 {0, 0, 0, 0} 611 }; 612 613 pool_initialize_func_t cmd_type = POOL_INITIALIZE_START; 614 while ((c = getopt_long(argc, argv, "csw", long_options, NULL)) != -1) { 615 switch (c) { 616 case 'c': 617 if (cmd_type != POOL_INITIALIZE_START && 618 cmd_type != POOL_INITIALIZE_CANCEL) { 619 (void) fprintf(stderr, gettext("-c cannot be " 620 "combined with other options\n")); 621 usage(B_FALSE); 622 } 623 cmd_type = POOL_INITIALIZE_CANCEL; 624 break; 625 case 's': 626 if (cmd_type != POOL_INITIALIZE_START && 627 cmd_type != POOL_INITIALIZE_SUSPEND) { 628 (void) fprintf(stderr, gettext("-s cannot be " 629 "combined with other options\n")); 630 usage(B_FALSE); 631 } 632 cmd_type = POOL_INITIALIZE_SUSPEND; 633 break; 634 case 'w': 635 wait = B_TRUE; 636 break; 637 case '?': 638 if (optopt != 0) { 639 (void) fprintf(stderr, 640 gettext("invalid option '%c'\n"), optopt); 641 } else { 642 (void) fprintf(stderr, 643 gettext("invalid option '%s'\n"), 644 argv[optind - 1]); 645 } 646 usage(B_FALSE); 647 } 648 } 649 650 argc -= optind; 651 argv += optind; 652 653 if (argc < 1) { 654 (void) fprintf(stderr, gettext("missing pool name argument\n")); 655 usage(B_FALSE); 656 return (-1); 657 } 658 659 if (wait && (cmd_type != POOL_INITIALIZE_START)) { 660 (void) fprintf(stderr, gettext("-w cannot be used with -c or " 661 "-s\n")); 662 usage(B_FALSE); 663 } 664 665 poolname = argv[0]; 666 zhp = zpool_open(g_zfs, poolname); 667 if (zhp == NULL) 668 return (-1); 669 670 vdevs = fnvlist_alloc(); 671 if (argc == 1) { 672 /* no individual leaf vdevs specified, so add them all */ 673 nvlist_t *config = zpool_get_config(zhp, NULL); 674 nvlist_t *nvroot = fnvlist_lookup_nvlist(config, 675 ZPOOL_CONFIG_VDEV_TREE); 676 zpool_collect_leaves(zhp, nvroot, vdevs); 677 } else { 678 for (int i = 1; i < argc; i++) { 679 fnvlist_add_boolean(vdevs, argv[i]); 680 } 681 } 682 683 if (wait) 684 err = zpool_initialize_wait(zhp, cmd_type, vdevs); 685 else 686 err = zpool_initialize(zhp, cmd_type, vdevs); 687 688 fnvlist_free(vdevs); 689 zpool_close(zhp); 690 691 return (err); 692 } 693 694 /* 695 * print a pool vdev config for dry runs 696 */ 697 static void 698 print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent, 699 const char *match, int name_flags) 700 { 701 nvlist_t **child; 702 uint_t c, children; 703 char *vname; 704 boolean_t printed = B_FALSE; 705 706 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 707 &child, &children) != 0) { 708 if (name != NULL) 709 (void) printf("\t%*s%s\n", indent, "", name); 710 return; 711 } 712 713 for (c = 0; c < children; c++) { 714 uint64_t is_log = B_FALSE, is_hole = B_FALSE; 715 char *class = ""; 716 717 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 718 &is_hole); 719 720 if (is_hole == B_TRUE) { 721 continue; 722 } 723 724 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 725 &is_log); 726 if (is_log) 727 class = VDEV_ALLOC_BIAS_LOG; 728 (void) nvlist_lookup_string(child[c], 729 ZPOOL_CONFIG_ALLOCATION_BIAS, &class); 730 if (strcmp(match, class) != 0) 731 continue; 732 733 if (!printed && name != NULL) { 734 (void) printf("\t%*s%s\n", indent, "", name); 735 printed = B_TRUE; 736 } 737 vname = zpool_vdev_name(g_zfs, zhp, child[c], name_flags); 738 print_vdev_tree(zhp, vname, child[c], indent + 2, "", 739 name_flags); 740 free(vname); 741 } 742 } 743 744 /* 745 * Print the list of l2cache devices for dry runs. 746 */ 747 static void 748 print_cache_list(nvlist_t *nv, int indent) 749 { 750 nvlist_t **child; 751 uint_t c, children; 752 753 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 754 &child, &children) == 0 && children > 0) { 755 (void) printf("\t%*s%s\n", indent, "", "cache"); 756 } else { 757 return; 758 } 759 for (c = 0; c < children; c++) { 760 char *vname; 761 762 vname = zpool_vdev_name(g_zfs, NULL, child[c], 0); 763 (void) printf("\t%*s%s\n", indent + 2, "", vname); 764 free(vname); 765 } 766 } 767 768 /* 769 * Print the list of spares for dry runs. 770 */ 771 static void 772 print_spare_list(nvlist_t *nv, int indent) 773 { 774 nvlist_t **child; 775 uint_t c, children; 776 777 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 778 &child, &children) == 0 && children > 0) { 779 (void) printf("\t%*s%s\n", indent, "", "spares"); 780 } else { 781 return; 782 } 783 for (c = 0; c < children; c++) { 784 char *vname; 785 786 vname = zpool_vdev_name(g_zfs, NULL, child[c], 0); 787 (void) printf("\t%*s%s\n", indent + 2, "", vname); 788 free(vname); 789 } 790 } 791 792 static boolean_t 793 prop_list_contains_feature(nvlist_t *proplist) 794 { 795 nvpair_t *nvp; 796 for (nvp = nvlist_next_nvpair(proplist, NULL); NULL != nvp; 797 nvp = nvlist_next_nvpair(proplist, nvp)) { 798 if (zpool_prop_feature(nvpair_name(nvp))) 799 return (B_TRUE); 800 } 801 return (B_FALSE); 802 } 803 804 /* 805 * Add a property pair (name, string-value) into a property nvlist. 806 */ 807 static int 808 add_prop_list(const char *propname, char *propval, nvlist_t **props, 809 boolean_t poolprop) 810 { 811 zpool_prop_t prop = ZPOOL_PROP_INVAL; 812 nvlist_t *proplist; 813 const char *normnm; 814 char *strval; 815 816 if (*props == NULL && 817 nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) { 818 (void) fprintf(stderr, 819 gettext("internal error: out of memory\n")); 820 return (1); 821 } 822 823 proplist = *props; 824 825 if (poolprop) { 826 const char *vname = zpool_prop_to_name(ZPOOL_PROP_VERSION); 827 const char *cname = 828 zpool_prop_to_name(ZPOOL_PROP_COMPATIBILITY); 829 830 if ((prop = zpool_name_to_prop(propname)) == ZPOOL_PROP_INVAL && 831 (!zpool_prop_feature(propname) && 832 !zpool_prop_vdev(propname))) { 833 (void) fprintf(stderr, gettext("property '%s' is " 834 "not a valid pool or vdev property\n"), propname); 835 return (2); 836 } 837 838 /* 839 * feature@ properties and version should not be specified 840 * at the same time. 841 */ 842 if ((prop == ZPOOL_PROP_INVAL && zpool_prop_feature(propname) && 843 nvlist_exists(proplist, vname)) || 844 (prop == ZPOOL_PROP_VERSION && 845 prop_list_contains_feature(proplist))) { 846 (void) fprintf(stderr, gettext("'feature@' and " 847 "'version' properties cannot be specified " 848 "together\n")); 849 return (2); 850 } 851 852 /* 853 * if version is specified, only "legacy" compatibility 854 * may be requested 855 */ 856 if ((prop == ZPOOL_PROP_COMPATIBILITY && 857 strcmp(propval, ZPOOL_COMPAT_LEGACY) != 0 && 858 nvlist_exists(proplist, vname)) || 859 (prop == ZPOOL_PROP_VERSION && 860 nvlist_exists(proplist, cname) && 861 strcmp(fnvlist_lookup_string(proplist, cname), 862 ZPOOL_COMPAT_LEGACY) != 0)) { 863 (void) fprintf(stderr, gettext("when 'version' is " 864 "specified, the 'compatibility' feature may only " 865 "be set to '" ZPOOL_COMPAT_LEGACY "'\n")); 866 return (2); 867 } 868 869 if (zpool_prop_feature(propname) || zpool_prop_vdev(propname)) 870 normnm = propname; 871 else 872 normnm = zpool_prop_to_name(prop); 873 } else { 874 zfs_prop_t fsprop = zfs_name_to_prop(propname); 875 876 if (zfs_prop_valid_for_type(fsprop, ZFS_TYPE_FILESYSTEM, 877 B_FALSE)) { 878 normnm = zfs_prop_to_name(fsprop); 879 } else if (zfs_prop_user(propname) || 880 zfs_prop_userquota(propname)) { 881 normnm = propname; 882 } else { 883 (void) fprintf(stderr, gettext("property '%s' is " 884 "not a valid filesystem property\n"), propname); 885 return (2); 886 } 887 } 888 889 if (nvlist_lookup_string(proplist, normnm, &strval) == 0 && 890 prop != ZPOOL_PROP_CACHEFILE) { 891 (void) fprintf(stderr, gettext("property '%s' " 892 "specified multiple times\n"), propname); 893 return (2); 894 } 895 896 if (nvlist_add_string(proplist, normnm, propval) != 0) { 897 (void) fprintf(stderr, gettext("internal " 898 "error: out of memory\n")); 899 return (1); 900 } 901 902 return (0); 903 } 904 905 /* 906 * Set a default property pair (name, string-value) in a property nvlist 907 */ 908 static int 909 add_prop_list_default(const char *propname, char *propval, nvlist_t **props) 910 { 911 char *pval; 912 913 if (nvlist_lookup_string(*props, propname, &pval) == 0) 914 return (0); 915 916 return (add_prop_list(propname, propval, props, B_TRUE)); 917 } 918 919 /* 920 * zpool add [-fgLnP] [-o property=value] <pool> <vdev> ... 921 * 922 * -f Force addition of devices, even if they appear in use 923 * -g Display guid for individual vdev name. 924 * -L Follow links when resolving vdev path name. 925 * -n Do not add the devices, but display the resulting layout if 926 * they were to be added. 927 * -o Set property=value. 928 * -P Display full path for vdev name. 929 * 930 * Adds the given vdevs to 'pool'. As with create, the bulk of this work is 931 * handled by make_root_vdev(), which constructs the nvlist needed to pass to 932 * libzfs. 933 */ 934 int 935 zpool_do_add(int argc, char **argv) 936 { 937 boolean_t force = B_FALSE; 938 boolean_t dryrun = B_FALSE; 939 int name_flags = 0; 940 int c; 941 nvlist_t *nvroot; 942 char *poolname; 943 int ret; 944 zpool_handle_t *zhp; 945 nvlist_t *config; 946 nvlist_t *props = NULL; 947 char *propval; 948 949 /* check options */ 950 while ((c = getopt(argc, argv, "fgLno:P")) != -1) { 951 switch (c) { 952 case 'f': 953 force = B_TRUE; 954 break; 955 case 'g': 956 name_flags |= VDEV_NAME_GUID; 957 break; 958 case 'L': 959 name_flags |= VDEV_NAME_FOLLOW_LINKS; 960 break; 961 case 'n': 962 dryrun = B_TRUE; 963 break; 964 case 'o': 965 if ((propval = strchr(optarg, '=')) == NULL) { 966 (void) fprintf(stderr, gettext("missing " 967 "'=' for -o option\n")); 968 usage(B_FALSE); 969 } 970 *propval = '\0'; 971 propval++; 972 973 if ((strcmp(optarg, ZPOOL_CONFIG_ASHIFT) != 0) || 974 (add_prop_list(optarg, propval, &props, B_TRUE))) 975 usage(B_FALSE); 976 break; 977 case 'P': 978 name_flags |= VDEV_NAME_PATH; 979 break; 980 case '?': 981 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 982 optopt); 983 usage(B_FALSE); 984 } 985 } 986 987 argc -= optind; 988 argv += optind; 989 990 /* get pool name and check number of arguments */ 991 if (argc < 1) { 992 (void) fprintf(stderr, gettext("missing pool name argument\n")); 993 usage(B_FALSE); 994 } 995 if (argc < 2) { 996 (void) fprintf(stderr, gettext("missing vdev specification\n")); 997 usage(B_FALSE); 998 } 999 1000 poolname = argv[0]; 1001 1002 argc--; 1003 argv++; 1004 1005 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 1006 return (1); 1007 1008 if ((config = zpool_get_config(zhp, NULL)) == NULL) { 1009 (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 1010 poolname); 1011 zpool_close(zhp); 1012 return (1); 1013 } 1014 1015 /* unless manually specified use "ashift" pool property (if set) */ 1016 if (!nvlist_exists(props, ZPOOL_CONFIG_ASHIFT)) { 1017 int intval; 1018 zprop_source_t src; 1019 char strval[ZPOOL_MAXPROPLEN]; 1020 1021 intval = zpool_get_prop_int(zhp, ZPOOL_PROP_ASHIFT, &src); 1022 if (src != ZPROP_SRC_DEFAULT) { 1023 (void) sprintf(strval, "%" PRId32, intval); 1024 verify(add_prop_list(ZPOOL_CONFIG_ASHIFT, strval, 1025 &props, B_TRUE) == 0); 1026 } 1027 } 1028 1029 /* pass off to make_root_vdev for processing */ 1030 nvroot = make_root_vdev(zhp, props, force, !force, B_FALSE, dryrun, 1031 argc, argv); 1032 if (nvroot == NULL) { 1033 zpool_close(zhp); 1034 return (1); 1035 } 1036 1037 if (dryrun) { 1038 nvlist_t *poolnvroot; 1039 nvlist_t **l2child, **sparechild; 1040 uint_t l2children, sparechildren, c; 1041 char *vname; 1042 boolean_t hadcache = B_FALSE, hadspare = B_FALSE; 1043 1044 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1045 &poolnvroot) == 0); 1046 1047 (void) printf(gettext("would update '%s' to the following " 1048 "configuration:\n\n"), zpool_get_name(zhp)); 1049 1050 /* print original main pool and new tree */ 1051 print_vdev_tree(zhp, poolname, poolnvroot, 0, "", 1052 name_flags | VDEV_NAME_TYPE_ID); 1053 print_vdev_tree(zhp, NULL, nvroot, 0, "", name_flags); 1054 1055 /* print other classes: 'dedup', 'special', and 'log' */ 1056 if (zfs_special_devs(poolnvroot, VDEV_ALLOC_BIAS_DEDUP)) { 1057 print_vdev_tree(zhp, "dedup", poolnvroot, 0, 1058 VDEV_ALLOC_BIAS_DEDUP, name_flags); 1059 print_vdev_tree(zhp, NULL, nvroot, 0, 1060 VDEV_ALLOC_BIAS_DEDUP, name_flags); 1061 } else if (zfs_special_devs(nvroot, VDEV_ALLOC_BIAS_DEDUP)) { 1062 print_vdev_tree(zhp, "dedup", nvroot, 0, 1063 VDEV_ALLOC_BIAS_DEDUP, name_flags); 1064 } 1065 1066 if (zfs_special_devs(poolnvroot, VDEV_ALLOC_BIAS_SPECIAL)) { 1067 print_vdev_tree(zhp, "special", poolnvroot, 0, 1068 VDEV_ALLOC_BIAS_SPECIAL, name_flags); 1069 print_vdev_tree(zhp, NULL, nvroot, 0, 1070 VDEV_ALLOC_BIAS_SPECIAL, name_flags); 1071 } else if (zfs_special_devs(nvroot, VDEV_ALLOC_BIAS_SPECIAL)) { 1072 print_vdev_tree(zhp, "special", nvroot, 0, 1073 VDEV_ALLOC_BIAS_SPECIAL, name_flags); 1074 } 1075 1076 if (num_logs(poolnvroot) > 0) { 1077 print_vdev_tree(zhp, "logs", poolnvroot, 0, 1078 VDEV_ALLOC_BIAS_LOG, name_flags); 1079 print_vdev_tree(zhp, NULL, nvroot, 0, 1080 VDEV_ALLOC_BIAS_LOG, name_flags); 1081 } else if (num_logs(nvroot) > 0) { 1082 print_vdev_tree(zhp, "logs", nvroot, 0, 1083 VDEV_ALLOC_BIAS_LOG, name_flags); 1084 } 1085 1086 /* Do the same for the caches */ 1087 if (nvlist_lookup_nvlist_array(poolnvroot, ZPOOL_CONFIG_L2CACHE, 1088 &l2child, &l2children) == 0 && l2children) { 1089 hadcache = B_TRUE; 1090 (void) printf(gettext("\tcache\n")); 1091 for (c = 0; c < l2children; c++) { 1092 vname = zpool_vdev_name(g_zfs, NULL, 1093 l2child[c], name_flags); 1094 (void) printf("\t %s\n", vname); 1095 free(vname); 1096 } 1097 } 1098 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 1099 &l2child, &l2children) == 0 && l2children) { 1100 if (!hadcache) 1101 (void) printf(gettext("\tcache\n")); 1102 for (c = 0; c < l2children; c++) { 1103 vname = zpool_vdev_name(g_zfs, NULL, 1104 l2child[c], name_flags); 1105 (void) printf("\t %s\n", vname); 1106 free(vname); 1107 } 1108 } 1109 /* And finally the spares */ 1110 if (nvlist_lookup_nvlist_array(poolnvroot, ZPOOL_CONFIG_SPARES, 1111 &sparechild, &sparechildren) == 0 && sparechildren > 0) { 1112 hadspare = B_TRUE; 1113 (void) printf(gettext("\tspares\n")); 1114 for (c = 0; c < sparechildren; c++) { 1115 vname = zpool_vdev_name(g_zfs, NULL, 1116 sparechild[c], name_flags); 1117 (void) printf("\t %s\n", vname); 1118 free(vname); 1119 } 1120 } 1121 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 1122 &sparechild, &sparechildren) == 0 && sparechildren > 0) { 1123 if (!hadspare) 1124 (void) printf(gettext("\tspares\n")); 1125 for (c = 0; c < sparechildren; c++) { 1126 vname = zpool_vdev_name(g_zfs, NULL, 1127 sparechild[c], name_flags); 1128 (void) printf("\t %s\n", vname); 1129 free(vname); 1130 } 1131 } 1132 1133 ret = 0; 1134 } else { 1135 ret = (zpool_add(zhp, nvroot) != 0); 1136 } 1137 1138 nvlist_free(props); 1139 nvlist_free(nvroot); 1140 zpool_close(zhp); 1141 1142 return (ret); 1143 } 1144 1145 /* 1146 * zpool remove [-npsw] <pool> <vdev> ... 1147 * 1148 * Removes the given vdev from the pool. 1149 */ 1150 int 1151 zpool_do_remove(int argc, char **argv) 1152 { 1153 char *poolname; 1154 int i, ret = 0; 1155 zpool_handle_t *zhp = NULL; 1156 boolean_t stop = B_FALSE; 1157 int c; 1158 boolean_t noop = B_FALSE; 1159 boolean_t parsable = B_FALSE; 1160 boolean_t wait = B_FALSE; 1161 1162 /* check options */ 1163 while ((c = getopt(argc, argv, "npsw")) != -1) { 1164 switch (c) { 1165 case 'n': 1166 noop = B_TRUE; 1167 break; 1168 case 'p': 1169 parsable = B_TRUE; 1170 break; 1171 case 's': 1172 stop = B_TRUE; 1173 break; 1174 case 'w': 1175 wait = B_TRUE; 1176 break; 1177 case '?': 1178 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1179 optopt); 1180 usage(B_FALSE); 1181 } 1182 } 1183 1184 argc -= optind; 1185 argv += optind; 1186 1187 /* get pool name and check number of arguments */ 1188 if (argc < 1) { 1189 (void) fprintf(stderr, gettext("missing pool name argument\n")); 1190 usage(B_FALSE); 1191 } 1192 1193 poolname = argv[0]; 1194 1195 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 1196 return (1); 1197 1198 if (stop && noop) { 1199 (void) fprintf(stderr, gettext("stop request ignored\n")); 1200 return (0); 1201 } 1202 1203 if (stop) { 1204 if (argc > 1) { 1205 (void) fprintf(stderr, gettext("too many arguments\n")); 1206 usage(B_FALSE); 1207 } 1208 if (zpool_vdev_remove_cancel(zhp) != 0) 1209 ret = 1; 1210 if (wait) { 1211 (void) fprintf(stderr, gettext("invalid option " 1212 "combination: -w cannot be used with -s\n")); 1213 usage(B_FALSE); 1214 } 1215 } else { 1216 if (argc < 2) { 1217 (void) fprintf(stderr, gettext("missing device\n")); 1218 usage(B_FALSE); 1219 } 1220 1221 for (i = 1; i < argc; i++) { 1222 if (noop) { 1223 uint64_t size; 1224 1225 if (zpool_vdev_indirect_size(zhp, argv[i], 1226 &size) != 0) { 1227 ret = 1; 1228 break; 1229 } 1230 if (parsable) { 1231 (void) printf("%s %llu\n", 1232 argv[i], (unsigned long long)size); 1233 } else { 1234 char valstr[32]; 1235 zfs_nicenum(size, valstr, 1236 sizeof (valstr)); 1237 (void) printf("Memory that will be " 1238 "used after removing %s: %s\n", 1239 argv[i], valstr); 1240 } 1241 } else { 1242 if (zpool_vdev_remove(zhp, argv[i]) != 0) 1243 ret = 1; 1244 } 1245 } 1246 1247 if (ret == 0 && wait) 1248 ret = zpool_wait(zhp, ZPOOL_WAIT_REMOVE); 1249 } 1250 zpool_close(zhp); 1251 1252 return (ret); 1253 } 1254 1255 /* 1256 * Return 1 if a vdev is active (being used in a pool) 1257 * Return 0 if a vdev is inactive (offlined or faulted, or not in active pool) 1258 * 1259 * This is useful for checking if a disk in an active pool is offlined or 1260 * faulted. 1261 */ 1262 static int 1263 vdev_is_active(char *vdev_path) 1264 { 1265 int fd; 1266 fd = open(vdev_path, O_EXCL); 1267 if (fd < 0) { 1268 return (1); /* cant open O_EXCL - disk is active */ 1269 } 1270 1271 close(fd); 1272 return (0); /* disk is inactive in the pool */ 1273 } 1274 1275 /* 1276 * zpool labelclear [-f] <vdev> 1277 * 1278 * -f Force clearing the label for the vdevs which are members of 1279 * the exported or foreign pools. 1280 * 1281 * Verifies that the vdev is not active and zeros out the label information 1282 * on the device. 1283 */ 1284 int 1285 zpool_do_labelclear(int argc, char **argv) 1286 { 1287 char vdev[MAXPATHLEN]; 1288 char *name = NULL; 1289 struct stat st; 1290 int c, fd = -1, ret = 0; 1291 nvlist_t *config; 1292 pool_state_t state; 1293 boolean_t inuse = B_FALSE; 1294 boolean_t force = B_FALSE; 1295 1296 /* check options */ 1297 while ((c = getopt(argc, argv, "f")) != -1) { 1298 switch (c) { 1299 case 'f': 1300 force = B_TRUE; 1301 break; 1302 default: 1303 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1304 optopt); 1305 usage(B_FALSE); 1306 } 1307 } 1308 1309 argc -= optind; 1310 argv += optind; 1311 1312 /* get vdev name */ 1313 if (argc < 1) { 1314 (void) fprintf(stderr, gettext("missing vdev name\n")); 1315 usage(B_FALSE); 1316 } 1317 if (argc > 1) { 1318 (void) fprintf(stderr, gettext("too many arguments\n")); 1319 usage(B_FALSE); 1320 } 1321 1322 /* 1323 * Check if we were given absolute path and use it as is. 1324 * Otherwise if the provided vdev name doesn't point to a file, 1325 * try prepending expected disk paths and partition numbers. 1326 */ 1327 (void) strlcpy(vdev, argv[0], sizeof (vdev)); 1328 if (vdev[0] != '/' && stat(vdev, &st) != 0) { 1329 int error; 1330 1331 error = zfs_resolve_shortname(argv[0], vdev, MAXPATHLEN); 1332 if (error == 0 && zfs_dev_is_whole_disk(vdev)) { 1333 if (zfs_append_partition(vdev, MAXPATHLEN) == -1) 1334 error = ENOENT; 1335 } 1336 1337 if (error || (stat(vdev, &st) != 0)) { 1338 (void) fprintf(stderr, gettext( 1339 "failed to find device %s, try specifying absolute " 1340 "path instead\n"), argv[0]); 1341 return (1); 1342 } 1343 } 1344 1345 if ((fd = open(vdev, O_RDWR)) < 0) { 1346 (void) fprintf(stderr, gettext("failed to open %s: %s\n"), 1347 vdev, strerror(errno)); 1348 return (1); 1349 } 1350 1351 /* 1352 * Flush all dirty pages for the block device. This should not be 1353 * fatal when the device does not support BLKFLSBUF as would be the 1354 * case for a file vdev. 1355 */ 1356 if ((zfs_dev_flush(fd) != 0) && (errno != ENOTTY)) 1357 (void) fprintf(stderr, gettext("failed to invalidate " 1358 "cache for %s: %s\n"), vdev, strerror(errno)); 1359 1360 if (zpool_read_label(fd, &config, NULL) != 0) { 1361 (void) fprintf(stderr, 1362 gettext("failed to read label from %s\n"), vdev); 1363 ret = 1; 1364 goto errout; 1365 } 1366 nvlist_free(config); 1367 1368 ret = zpool_in_use(g_zfs, fd, &state, &name, &inuse); 1369 if (ret != 0) { 1370 (void) fprintf(stderr, 1371 gettext("failed to check state for %s\n"), vdev); 1372 ret = 1; 1373 goto errout; 1374 } 1375 1376 if (!inuse) 1377 goto wipe_label; 1378 1379 switch (state) { 1380 default: 1381 case POOL_STATE_ACTIVE: 1382 case POOL_STATE_SPARE: 1383 case POOL_STATE_L2CACHE: 1384 /* 1385 * We allow the user to call 'zpool offline -f' 1386 * on an offlined disk in an active pool. We can check if 1387 * the disk is online by calling vdev_is_active(). 1388 */ 1389 if (force && !vdev_is_active(vdev)) 1390 break; 1391 1392 (void) fprintf(stderr, gettext( 1393 "%s is a member (%s) of pool \"%s\""), 1394 vdev, zpool_pool_state_to_name(state), name); 1395 1396 if (force) { 1397 (void) fprintf(stderr, gettext( 1398 ". Offline the disk first to clear its label.")); 1399 } 1400 printf("\n"); 1401 ret = 1; 1402 goto errout; 1403 1404 case POOL_STATE_EXPORTED: 1405 if (force) 1406 break; 1407 (void) fprintf(stderr, gettext( 1408 "use '-f' to override the following error:\n" 1409 "%s is a member of exported pool \"%s\"\n"), 1410 vdev, name); 1411 ret = 1; 1412 goto errout; 1413 1414 case POOL_STATE_POTENTIALLY_ACTIVE: 1415 if (force) 1416 break; 1417 (void) fprintf(stderr, gettext( 1418 "use '-f' to override the following error:\n" 1419 "%s is a member of potentially active pool \"%s\"\n"), 1420 vdev, name); 1421 ret = 1; 1422 goto errout; 1423 1424 case POOL_STATE_DESTROYED: 1425 /* inuse should never be set for a destroyed pool */ 1426 assert(0); 1427 break; 1428 } 1429 1430 wipe_label: 1431 ret = zpool_clear_label(fd); 1432 if (ret != 0) { 1433 (void) fprintf(stderr, 1434 gettext("failed to clear label for %s\n"), vdev); 1435 } 1436 1437 errout: 1438 free(name); 1439 (void) close(fd); 1440 1441 return (ret); 1442 } 1443 1444 /* 1445 * zpool create [-fnd] [-o property=value] ... 1446 * [-O file-system-property=value] ... 1447 * [-R root] [-m mountpoint] <pool> <dev> ... 1448 * 1449 * -f Force creation, even if devices appear in use 1450 * -n Do not create the pool, but display the resulting layout if it 1451 * were to be created. 1452 * -R Create a pool under an alternate root 1453 * -m Set default mountpoint for the root dataset. By default it's 1454 * '/<pool>' 1455 * -o Set property=value. 1456 * -o Set feature@feature=enabled|disabled. 1457 * -d Don't automatically enable all supported pool features 1458 * (individual features can be enabled with -o). 1459 * -O Set fsproperty=value in the pool's root file system 1460 * 1461 * Creates the named pool according to the given vdev specification. The 1462 * bulk of the vdev processing is done in make_root_vdev() in zpool_vdev.c. 1463 * Once we get the nvlist back from make_root_vdev(), we either print out the 1464 * contents (if '-n' was specified), or pass it to libzfs to do the creation. 1465 */ 1466 int 1467 zpool_do_create(int argc, char **argv) 1468 { 1469 boolean_t force = B_FALSE; 1470 boolean_t dryrun = B_FALSE; 1471 boolean_t enable_pool_features = B_TRUE; 1472 1473 int c; 1474 nvlist_t *nvroot = NULL; 1475 char *poolname; 1476 char *tname = NULL; 1477 int ret = 1; 1478 char *altroot = NULL; 1479 char *compat = NULL; 1480 char *mountpoint = NULL; 1481 nvlist_t *fsprops = NULL; 1482 nvlist_t *props = NULL; 1483 char *propval; 1484 1485 /* check options */ 1486 while ((c = getopt(argc, argv, ":fndR:m:o:O:t:")) != -1) { 1487 switch (c) { 1488 case 'f': 1489 force = B_TRUE; 1490 break; 1491 case 'n': 1492 dryrun = B_TRUE; 1493 break; 1494 case 'd': 1495 enable_pool_features = B_FALSE; 1496 break; 1497 case 'R': 1498 altroot = optarg; 1499 if (add_prop_list(zpool_prop_to_name( 1500 ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 1501 goto errout; 1502 if (add_prop_list_default(zpool_prop_to_name( 1503 ZPOOL_PROP_CACHEFILE), "none", &props)) 1504 goto errout; 1505 break; 1506 case 'm': 1507 /* Equivalent to -O mountpoint=optarg */ 1508 mountpoint = optarg; 1509 break; 1510 case 'o': 1511 if ((propval = strchr(optarg, '=')) == NULL) { 1512 (void) fprintf(stderr, gettext("missing " 1513 "'=' for -o option\n")); 1514 goto errout; 1515 } 1516 *propval = '\0'; 1517 propval++; 1518 1519 if (add_prop_list(optarg, propval, &props, B_TRUE)) 1520 goto errout; 1521 1522 /* 1523 * If the user is creating a pool that doesn't support 1524 * feature flags, don't enable any features. 1525 */ 1526 if (zpool_name_to_prop(optarg) == ZPOOL_PROP_VERSION) { 1527 char *end; 1528 u_longlong_t ver; 1529 1530 ver = strtoull(propval, &end, 10); 1531 if (*end == '\0' && 1532 ver < SPA_VERSION_FEATURES) { 1533 enable_pool_features = B_FALSE; 1534 } 1535 } 1536 if (zpool_name_to_prop(optarg) == ZPOOL_PROP_ALTROOT) 1537 altroot = propval; 1538 if (zpool_name_to_prop(optarg) == 1539 ZPOOL_PROP_COMPATIBILITY) 1540 compat = propval; 1541 break; 1542 case 'O': 1543 if ((propval = strchr(optarg, '=')) == NULL) { 1544 (void) fprintf(stderr, gettext("missing " 1545 "'=' for -O option\n")); 1546 goto errout; 1547 } 1548 *propval = '\0'; 1549 propval++; 1550 1551 /* 1552 * Mountpoints are checked and then added later. 1553 * Uniquely among properties, they can be specified 1554 * more than once, to avoid conflict with -m. 1555 */ 1556 if (0 == strcmp(optarg, 1557 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT))) { 1558 mountpoint = propval; 1559 } else if (add_prop_list(optarg, propval, &fsprops, 1560 B_FALSE)) { 1561 goto errout; 1562 } 1563 break; 1564 case 't': 1565 /* 1566 * Sanity check temporary pool name. 1567 */ 1568 if (strchr(optarg, '/') != NULL) { 1569 (void) fprintf(stderr, gettext("cannot create " 1570 "'%s': invalid character '/' in temporary " 1571 "name\n"), optarg); 1572 (void) fprintf(stderr, gettext("use 'zfs " 1573 "create' to create a dataset\n")); 1574 goto errout; 1575 } 1576 1577 if (add_prop_list(zpool_prop_to_name( 1578 ZPOOL_PROP_TNAME), optarg, &props, B_TRUE)) 1579 goto errout; 1580 if (add_prop_list_default(zpool_prop_to_name( 1581 ZPOOL_PROP_CACHEFILE), "none", &props)) 1582 goto errout; 1583 tname = optarg; 1584 break; 1585 case ':': 1586 (void) fprintf(stderr, gettext("missing argument for " 1587 "'%c' option\n"), optopt); 1588 goto badusage; 1589 case '?': 1590 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1591 optopt); 1592 goto badusage; 1593 } 1594 } 1595 1596 argc -= optind; 1597 argv += optind; 1598 1599 /* get pool name and check number of arguments */ 1600 if (argc < 1) { 1601 (void) fprintf(stderr, gettext("missing pool name argument\n")); 1602 goto badusage; 1603 } 1604 if (argc < 2) { 1605 (void) fprintf(stderr, gettext("missing vdev specification\n")); 1606 goto badusage; 1607 } 1608 1609 poolname = argv[0]; 1610 1611 /* 1612 * As a special case, check for use of '/' in the name, and direct the 1613 * user to use 'zfs create' instead. 1614 */ 1615 if (strchr(poolname, '/') != NULL) { 1616 (void) fprintf(stderr, gettext("cannot create '%s': invalid " 1617 "character '/' in pool name\n"), poolname); 1618 (void) fprintf(stderr, gettext("use 'zfs create' to " 1619 "create a dataset\n")); 1620 goto errout; 1621 } 1622 1623 /* pass off to make_root_vdev for bulk processing */ 1624 nvroot = make_root_vdev(NULL, props, force, !force, B_FALSE, dryrun, 1625 argc - 1, argv + 1); 1626 if (nvroot == NULL) 1627 goto errout; 1628 1629 /* make_root_vdev() allows 0 toplevel children if there are spares */ 1630 if (!zfs_allocatable_devs(nvroot)) { 1631 (void) fprintf(stderr, gettext("invalid vdev " 1632 "specification: at least one toplevel vdev must be " 1633 "specified\n")); 1634 goto errout; 1635 } 1636 1637 if (altroot != NULL && altroot[0] != '/') { 1638 (void) fprintf(stderr, gettext("invalid alternate root '%s': " 1639 "must be an absolute path\n"), altroot); 1640 goto errout; 1641 } 1642 1643 /* 1644 * Check the validity of the mountpoint and direct the user to use the 1645 * '-m' mountpoint option if it looks like its in use. 1646 */ 1647 if (mountpoint == NULL || 1648 (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 && 1649 strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) { 1650 char buf[MAXPATHLEN]; 1651 DIR *dirp; 1652 1653 if (mountpoint && mountpoint[0] != '/') { 1654 (void) fprintf(stderr, gettext("invalid mountpoint " 1655 "'%s': must be an absolute path, 'legacy', or " 1656 "'none'\n"), mountpoint); 1657 goto errout; 1658 } 1659 1660 if (mountpoint == NULL) { 1661 if (altroot != NULL) 1662 (void) snprintf(buf, sizeof (buf), "%s/%s", 1663 altroot, poolname); 1664 else 1665 (void) snprintf(buf, sizeof (buf), "/%s", 1666 poolname); 1667 } else { 1668 if (altroot != NULL) 1669 (void) snprintf(buf, sizeof (buf), "%s%s", 1670 altroot, mountpoint); 1671 else 1672 (void) snprintf(buf, sizeof (buf), "%s", 1673 mountpoint); 1674 } 1675 1676 if ((dirp = opendir(buf)) == NULL && errno != ENOENT) { 1677 (void) fprintf(stderr, gettext("mountpoint '%s' : " 1678 "%s\n"), buf, strerror(errno)); 1679 (void) fprintf(stderr, gettext("use '-m' " 1680 "option to provide a different default\n")); 1681 goto errout; 1682 } else if (dirp) { 1683 int count = 0; 1684 1685 while (count < 3 && readdir(dirp) != NULL) 1686 count++; 1687 (void) closedir(dirp); 1688 1689 if (count > 2) { 1690 (void) fprintf(stderr, gettext("mountpoint " 1691 "'%s' exists and is not empty\n"), buf); 1692 (void) fprintf(stderr, gettext("use '-m' " 1693 "option to provide a " 1694 "different default\n")); 1695 goto errout; 1696 } 1697 } 1698 } 1699 1700 /* 1701 * Now that the mountpoint's validity has been checked, ensure that 1702 * the property is set appropriately prior to creating the pool. 1703 */ 1704 if (mountpoint != NULL) { 1705 ret = add_prop_list(zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1706 mountpoint, &fsprops, B_FALSE); 1707 if (ret != 0) 1708 goto errout; 1709 } 1710 1711 ret = 1; 1712 if (dryrun) { 1713 /* 1714 * For a dry run invocation, print out a basic message and run 1715 * through all the vdevs in the list and print out in an 1716 * appropriate hierarchy. 1717 */ 1718 (void) printf(gettext("would create '%s' with the " 1719 "following layout:\n\n"), poolname); 1720 1721 print_vdev_tree(NULL, poolname, nvroot, 0, "", 0); 1722 print_vdev_tree(NULL, "dedup", nvroot, 0, 1723 VDEV_ALLOC_BIAS_DEDUP, 0); 1724 print_vdev_tree(NULL, "special", nvroot, 0, 1725 VDEV_ALLOC_BIAS_SPECIAL, 0); 1726 print_vdev_tree(NULL, "logs", nvroot, 0, 1727 VDEV_ALLOC_BIAS_LOG, 0); 1728 print_cache_list(nvroot, 0); 1729 print_spare_list(nvroot, 0); 1730 1731 ret = 0; 1732 } else { 1733 /* 1734 * Load in feature set. 1735 * Note: if compatibility property not given, we'll have 1736 * NULL, which means 'all features'. 1737 */ 1738 boolean_t requested_features[SPA_FEATURES]; 1739 if (zpool_do_load_compat(compat, requested_features) != 1740 ZPOOL_COMPATIBILITY_OK) 1741 goto errout; 1742 1743 /* 1744 * props contains list of features to enable. 1745 * For each feature: 1746 * - remove it if feature@name=disabled 1747 * - leave it there if feature@name=enabled 1748 * - add it if: 1749 * - enable_pool_features (ie: no '-d' or '-o version') 1750 * - it's supported by the kernel module 1751 * - it's in the requested feature set 1752 * - warn if it's enabled but not in compat 1753 */ 1754 for (spa_feature_t i = 0; i < SPA_FEATURES; i++) { 1755 char propname[MAXPATHLEN]; 1756 char *propval; 1757 zfeature_info_t *feat = &spa_feature_table[i]; 1758 1759 (void) snprintf(propname, sizeof (propname), 1760 "feature@%s", feat->fi_uname); 1761 1762 if (!nvlist_lookup_string(props, propname, &propval)) { 1763 if (strcmp(propval, ZFS_FEATURE_DISABLED) == 0) 1764 (void) nvlist_remove_all(props, 1765 propname); 1766 if (strcmp(propval, 1767 ZFS_FEATURE_ENABLED) == 0 && 1768 !requested_features[i]) 1769 (void) fprintf(stderr, gettext( 1770 "Warning: feature \"%s\" enabled " 1771 "but is not in specified " 1772 "'compatibility' feature set.\n"), 1773 feat->fi_uname); 1774 } else if ( 1775 enable_pool_features && 1776 feat->fi_zfs_mod_supported && 1777 requested_features[i]) { 1778 ret = add_prop_list(propname, 1779 ZFS_FEATURE_ENABLED, &props, B_TRUE); 1780 if (ret != 0) 1781 goto errout; 1782 } 1783 } 1784 1785 ret = 1; 1786 if (zpool_create(g_zfs, poolname, 1787 nvroot, props, fsprops) == 0) { 1788 zfs_handle_t *pool = zfs_open(g_zfs, 1789 tname ? tname : poolname, ZFS_TYPE_FILESYSTEM); 1790 if (pool != NULL) { 1791 if (zfs_mount(pool, NULL, 0) == 0) { 1792 ret = zfs_shareall(pool); 1793 zfs_commit_all_shares(); 1794 } 1795 zfs_close(pool); 1796 } 1797 } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) { 1798 (void) fprintf(stderr, gettext("pool name may have " 1799 "been omitted\n")); 1800 } 1801 } 1802 1803 errout: 1804 nvlist_free(nvroot); 1805 nvlist_free(fsprops); 1806 nvlist_free(props); 1807 return (ret); 1808 badusage: 1809 nvlist_free(fsprops); 1810 nvlist_free(props); 1811 usage(B_FALSE); 1812 return (2); 1813 } 1814 1815 /* 1816 * zpool destroy <pool> 1817 * 1818 * -f Forcefully unmount any datasets 1819 * 1820 * Destroy the given pool. Automatically unmounts any datasets in the pool. 1821 */ 1822 int 1823 zpool_do_destroy(int argc, char **argv) 1824 { 1825 boolean_t force = B_FALSE; 1826 int c; 1827 char *pool; 1828 zpool_handle_t *zhp; 1829 int ret; 1830 1831 /* check options */ 1832 while ((c = getopt(argc, argv, "f")) != -1) { 1833 switch (c) { 1834 case 'f': 1835 force = B_TRUE; 1836 break; 1837 case '?': 1838 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1839 optopt); 1840 usage(B_FALSE); 1841 } 1842 } 1843 1844 argc -= optind; 1845 argv += optind; 1846 1847 /* check arguments */ 1848 if (argc < 1) { 1849 (void) fprintf(stderr, gettext("missing pool argument\n")); 1850 usage(B_FALSE); 1851 } 1852 if (argc > 1) { 1853 (void) fprintf(stderr, gettext("too many arguments\n")); 1854 usage(B_FALSE); 1855 } 1856 1857 pool = argv[0]; 1858 1859 if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 1860 /* 1861 * As a special case, check for use of '/' in the name, and 1862 * direct the user to use 'zfs destroy' instead. 1863 */ 1864 if (strchr(pool, '/') != NULL) 1865 (void) fprintf(stderr, gettext("use 'zfs destroy' to " 1866 "destroy a dataset\n")); 1867 return (1); 1868 } 1869 1870 if (zpool_disable_datasets(zhp, force) != 0) { 1871 (void) fprintf(stderr, gettext("could not destroy '%s': " 1872 "could not unmount datasets\n"), zpool_get_name(zhp)); 1873 zpool_close(zhp); 1874 return (1); 1875 } 1876 1877 /* The history must be logged as part of the export */ 1878 log_history = B_FALSE; 1879 1880 ret = (zpool_destroy(zhp, history_str) != 0); 1881 1882 zpool_close(zhp); 1883 1884 return (ret); 1885 } 1886 1887 typedef struct export_cbdata { 1888 boolean_t force; 1889 boolean_t hardforce; 1890 } export_cbdata_t; 1891 1892 /* 1893 * Export one pool 1894 */ 1895 static int 1896 zpool_export_one(zpool_handle_t *zhp, void *data) 1897 { 1898 export_cbdata_t *cb = data; 1899 1900 if (zpool_disable_datasets(zhp, cb->force) != 0) 1901 return (1); 1902 1903 /* The history must be logged as part of the export */ 1904 log_history = B_FALSE; 1905 1906 if (cb->hardforce) { 1907 if (zpool_export_force(zhp, history_str) != 0) 1908 return (1); 1909 } else if (zpool_export(zhp, cb->force, history_str) != 0) { 1910 return (1); 1911 } 1912 1913 return (0); 1914 } 1915 1916 /* 1917 * zpool export [-f] <pool> ... 1918 * 1919 * -a Export all pools 1920 * -f Forcefully unmount datasets 1921 * 1922 * Export the given pools. By default, the command will attempt to cleanly 1923 * unmount any active datasets within the pool. If the '-f' flag is specified, 1924 * then the datasets will be forcefully unmounted. 1925 */ 1926 int 1927 zpool_do_export(int argc, char **argv) 1928 { 1929 export_cbdata_t cb; 1930 boolean_t do_all = B_FALSE; 1931 boolean_t force = B_FALSE; 1932 boolean_t hardforce = B_FALSE; 1933 int c, ret; 1934 1935 /* check options */ 1936 while ((c = getopt(argc, argv, "afF")) != -1) { 1937 switch (c) { 1938 case 'a': 1939 do_all = B_TRUE; 1940 break; 1941 case 'f': 1942 force = B_TRUE; 1943 break; 1944 case 'F': 1945 hardforce = B_TRUE; 1946 break; 1947 case '?': 1948 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 1949 optopt); 1950 usage(B_FALSE); 1951 } 1952 } 1953 1954 cb.force = force; 1955 cb.hardforce = hardforce; 1956 argc -= optind; 1957 argv += optind; 1958 1959 if (do_all) { 1960 if (argc != 0) { 1961 (void) fprintf(stderr, gettext("too many arguments\n")); 1962 usage(B_FALSE); 1963 } 1964 1965 return (for_each_pool(argc, argv, B_TRUE, NULL, 1966 ZFS_TYPE_POOL, B_FALSE, zpool_export_one, &cb)); 1967 } 1968 1969 /* check arguments */ 1970 if (argc < 1) { 1971 (void) fprintf(stderr, gettext("missing pool argument\n")); 1972 usage(B_FALSE); 1973 } 1974 1975 ret = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 1976 B_FALSE, zpool_export_one, &cb); 1977 1978 return (ret); 1979 } 1980 1981 /* 1982 * Given a vdev configuration, determine the maximum width needed for the device 1983 * name column. 1984 */ 1985 static int 1986 max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max, 1987 int name_flags) 1988 { 1989 char *name; 1990 nvlist_t **child; 1991 uint_t c, children; 1992 int ret; 1993 1994 name = zpool_vdev_name(g_zfs, zhp, nv, name_flags); 1995 if (strlen(name) + depth > max) 1996 max = strlen(name) + depth; 1997 1998 free(name); 1999 2000 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 2001 &child, &children) == 0) { 2002 for (c = 0; c < children; c++) 2003 if ((ret = max_width(zhp, child[c], depth + 2, 2004 max, name_flags)) > max) 2005 max = ret; 2006 } 2007 2008 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 2009 &child, &children) == 0) { 2010 for (c = 0; c < children; c++) 2011 if ((ret = max_width(zhp, child[c], depth + 2, 2012 max, name_flags)) > max) 2013 max = ret; 2014 } 2015 2016 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2017 &child, &children) == 0) { 2018 for (c = 0; c < children; c++) 2019 if ((ret = max_width(zhp, child[c], depth + 2, 2020 max, name_flags)) > max) 2021 max = ret; 2022 } 2023 2024 return (max); 2025 } 2026 2027 typedef struct spare_cbdata { 2028 uint64_t cb_guid; 2029 zpool_handle_t *cb_zhp; 2030 } spare_cbdata_t; 2031 2032 static boolean_t 2033 find_vdev(nvlist_t *nv, uint64_t search) 2034 { 2035 uint64_t guid; 2036 nvlist_t **child; 2037 uint_t c, children; 2038 2039 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 && 2040 search == guid) 2041 return (B_TRUE); 2042 2043 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2044 &child, &children) == 0) { 2045 for (c = 0; c < children; c++) 2046 if (find_vdev(child[c], search)) 2047 return (B_TRUE); 2048 } 2049 2050 return (B_FALSE); 2051 } 2052 2053 static int 2054 find_spare(zpool_handle_t *zhp, void *data) 2055 { 2056 spare_cbdata_t *cbp = data; 2057 nvlist_t *config, *nvroot; 2058 2059 config = zpool_get_config(zhp, NULL); 2060 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2061 &nvroot) == 0); 2062 2063 if (find_vdev(nvroot, cbp->cb_guid)) { 2064 cbp->cb_zhp = zhp; 2065 return (1); 2066 } 2067 2068 zpool_close(zhp); 2069 return (0); 2070 } 2071 2072 typedef struct status_cbdata { 2073 int cb_count; 2074 int cb_name_flags; 2075 int cb_namewidth; 2076 boolean_t cb_allpools; 2077 boolean_t cb_verbose; 2078 boolean_t cb_literal; 2079 boolean_t cb_explain; 2080 boolean_t cb_first; 2081 boolean_t cb_dedup_stats; 2082 boolean_t cb_print_status; 2083 boolean_t cb_print_slow_ios; 2084 boolean_t cb_print_vdev_init; 2085 boolean_t cb_print_vdev_trim; 2086 vdev_cmd_data_list_t *vcdl; 2087 } status_cbdata_t; 2088 2089 /* Return 1 if string is NULL, empty, or whitespace; return 0 otherwise. */ 2090 static int 2091 is_blank_str(char *str) 2092 { 2093 while (str != NULL && *str != '\0') { 2094 if (!isblank(*str)) 2095 return (0); 2096 str++; 2097 } 2098 return (1); 2099 } 2100 2101 /* Print command output lines for specific vdev in a specific pool */ 2102 static void 2103 zpool_print_cmd(vdev_cmd_data_list_t *vcdl, const char *pool, char *path) 2104 { 2105 vdev_cmd_data_t *data; 2106 int i, j; 2107 char *val; 2108 2109 for (i = 0; i < vcdl->count; i++) { 2110 if ((strcmp(vcdl->data[i].path, path) != 0) || 2111 (strcmp(vcdl->data[i].pool, pool) != 0)) { 2112 /* Not the vdev we're looking for */ 2113 continue; 2114 } 2115 2116 data = &vcdl->data[i]; 2117 /* Print out all the output values for this vdev */ 2118 for (j = 0; j < vcdl->uniq_cols_cnt; j++) { 2119 val = NULL; 2120 /* Does this vdev have values for this column? */ 2121 for (int k = 0; k < data->cols_cnt; k++) { 2122 if (strcmp(data->cols[k], 2123 vcdl->uniq_cols[j]) == 0) { 2124 /* yes it does, record the value */ 2125 val = data->lines[k]; 2126 break; 2127 } 2128 } 2129 /* 2130 * Mark empty values with dashes to make output 2131 * awk-able. 2132 */ 2133 if (val == NULL || is_blank_str(val)) 2134 val = "-"; 2135 2136 printf("%*s", vcdl->uniq_cols_width[j], val); 2137 if (j < vcdl->uniq_cols_cnt - 1) 2138 printf(" "); 2139 } 2140 2141 /* Print out any values that aren't in a column at the end */ 2142 for (j = data->cols_cnt; j < data->lines_cnt; j++) { 2143 /* Did we have any columns? If so print a spacer. */ 2144 if (vcdl->uniq_cols_cnt > 0) 2145 printf(" "); 2146 2147 val = data->lines[j]; 2148 printf("%s", val ? val : ""); 2149 } 2150 break; 2151 } 2152 } 2153 2154 /* 2155 * Print vdev initialization status for leaves 2156 */ 2157 static void 2158 print_status_initialize(vdev_stat_t *vs, boolean_t verbose) 2159 { 2160 if (verbose) { 2161 if ((vs->vs_initialize_state == VDEV_INITIALIZE_ACTIVE || 2162 vs->vs_initialize_state == VDEV_INITIALIZE_SUSPENDED || 2163 vs->vs_initialize_state == VDEV_INITIALIZE_COMPLETE) && 2164 !vs->vs_scan_removing) { 2165 char zbuf[1024]; 2166 char tbuf[256]; 2167 struct tm zaction_ts; 2168 2169 time_t t = vs->vs_initialize_action_time; 2170 int initialize_pct = 100; 2171 if (vs->vs_initialize_state != 2172 VDEV_INITIALIZE_COMPLETE) { 2173 initialize_pct = (vs->vs_initialize_bytes_done * 2174 100 / (vs->vs_initialize_bytes_est + 1)); 2175 } 2176 2177 (void) localtime_r(&t, &zaction_ts); 2178 (void) strftime(tbuf, sizeof (tbuf), "%c", &zaction_ts); 2179 2180 switch (vs->vs_initialize_state) { 2181 case VDEV_INITIALIZE_SUSPENDED: 2182 (void) snprintf(zbuf, sizeof (zbuf), ", %s %s", 2183 gettext("suspended, started at"), tbuf); 2184 break; 2185 case VDEV_INITIALIZE_ACTIVE: 2186 (void) snprintf(zbuf, sizeof (zbuf), ", %s %s", 2187 gettext("started at"), tbuf); 2188 break; 2189 case VDEV_INITIALIZE_COMPLETE: 2190 (void) snprintf(zbuf, sizeof (zbuf), ", %s %s", 2191 gettext("completed at"), tbuf); 2192 break; 2193 } 2194 2195 (void) printf(gettext(" (%d%% initialized%s)"), 2196 initialize_pct, zbuf); 2197 } else { 2198 (void) printf(gettext(" (uninitialized)")); 2199 } 2200 } else if (vs->vs_initialize_state == VDEV_INITIALIZE_ACTIVE) { 2201 (void) printf(gettext(" (initializing)")); 2202 } 2203 } 2204 2205 /* 2206 * Print vdev TRIM status for leaves 2207 */ 2208 static void 2209 print_status_trim(vdev_stat_t *vs, boolean_t verbose) 2210 { 2211 if (verbose) { 2212 if ((vs->vs_trim_state == VDEV_TRIM_ACTIVE || 2213 vs->vs_trim_state == VDEV_TRIM_SUSPENDED || 2214 vs->vs_trim_state == VDEV_TRIM_COMPLETE) && 2215 !vs->vs_scan_removing) { 2216 char zbuf[1024]; 2217 char tbuf[256]; 2218 struct tm zaction_ts; 2219 2220 time_t t = vs->vs_trim_action_time; 2221 int trim_pct = 100; 2222 if (vs->vs_trim_state != VDEV_TRIM_COMPLETE) { 2223 trim_pct = (vs->vs_trim_bytes_done * 2224 100 / (vs->vs_trim_bytes_est + 1)); 2225 } 2226 2227 (void) localtime_r(&t, &zaction_ts); 2228 (void) strftime(tbuf, sizeof (tbuf), "%c", &zaction_ts); 2229 2230 switch (vs->vs_trim_state) { 2231 case VDEV_TRIM_SUSPENDED: 2232 (void) snprintf(zbuf, sizeof (zbuf), ", %s %s", 2233 gettext("suspended, started at"), tbuf); 2234 break; 2235 case VDEV_TRIM_ACTIVE: 2236 (void) snprintf(zbuf, sizeof (zbuf), ", %s %s", 2237 gettext("started at"), tbuf); 2238 break; 2239 case VDEV_TRIM_COMPLETE: 2240 (void) snprintf(zbuf, sizeof (zbuf), ", %s %s", 2241 gettext("completed at"), tbuf); 2242 break; 2243 } 2244 2245 (void) printf(gettext(" (%d%% trimmed%s)"), 2246 trim_pct, zbuf); 2247 } else if (vs->vs_trim_notsup) { 2248 (void) printf(gettext(" (trim unsupported)")); 2249 } else { 2250 (void) printf(gettext(" (untrimmed)")); 2251 } 2252 } else if (vs->vs_trim_state == VDEV_TRIM_ACTIVE) { 2253 (void) printf(gettext(" (trimming)")); 2254 } 2255 } 2256 2257 /* 2258 * Return the color associated with a health string. This includes returning 2259 * NULL for no color change. 2260 */ 2261 static char * 2262 health_str_to_color(const char *health) 2263 { 2264 if (strcmp(health, gettext("FAULTED")) == 0 || 2265 strcmp(health, gettext("SUSPENDED")) == 0 || 2266 strcmp(health, gettext("UNAVAIL")) == 0) { 2267 return (ANSI_RED); 2268 } 2269 2270 if (strcmp(health, gettext("OFFLINE")) == 0 || 2271 strcmp(health, gettext("DEGRADED")) == 0 || 2272 strcmp(health, gettext("REMOVED")) == 0) { 2273 return (ANSI_YELLOW); 2274 } 2275 2276 return (NULL); 2277 } 2278 2279 /* 2280 * Print out configuration state as requested by status_callback. 2281 */ 2282 static void 2283 print_status_config(zpool_handle_t *zhp, status_cbdata_t *cb, const char *name, 2284 nvlist_t *nv, int depth, boolean_t isspare, vdev_rebuild_stat_t *vrs) 2285 { 2286 nvlist_t **child, *root; 2287 uint_t c, i, vsc, children; 2288 pool_scan_stat_t *ps = NULL; 2289 vdev_stat_t *vs; 2290 char rbuf[6], wbuf[6], cbuf[6]; 2291 char *vname; 2292 uint64_t notpresent; 2293 spare_cbdata_t spare_cb; 2294 const char *state; 2295 char *type; 2296 char *path = NULL; 2297 char *rcolor = NULL, *wcolor = NULL, *ccolor = NULL; 2298 2299 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2300 &child, &children) != 0) 2301 children = 0; 2302 2303 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 2304 (uint64_t **)&vs, &vsc) == 0); 2305 2306 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 2307 2308 if (strcmp(type, VDEV_TYPE_INDIRECT) == 0) 2309 return; 2310 2311 state = zpool_state_to_name(vs->vs_state, vs->vs_aux); 2312 2313 if (isspare) { 2314 /* 2315 * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for 2316 * online drives. 2317 */ 2318 if (vs->vs_aux == VDEV_AUX_SPARED) 2319 state = gettext("INUSE"); 2320 else if (vs->vs_state == VDEV_STATE_HEALTHY) 2321 state = gettext("AVAIL"); 2322 } 2323 2324 printf_color(health_str_to_color(state), 2325 "\t%*s%-*s %-8s", depth, "", cb->cb_namewidth - depth, 2326 name, state); 2327 2328 if (!isspare) { 2329 if (vs->vs_read_errors) 2330 rcolor = ANSI_RED; 2331 2332 if (vs->vs_write_errors) 2333 wcolor = ANSI_RED; 2334 2335 if (vs->vs_checksum_errors) 2336 ccolor = ANSI_RED; 2337 2338 if (cb->cb_literal) { 2339 printf(" "); 2340 printf_color(rcolor, "%5llu", 2341 (u_longlong_t)vs->vs_read_errors); 2342 printf(" "); 2343 printf_color(wcolor, "%5llu", 2344 (u_longlong_t)vs->vs_write_errors); 2345 printf(" "); 2346 printf_color(ccolor, "%5llu", 2347 (u_longlong_t)vs->vs_checksum_errors); 2348 } else { 2349 zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf)); 2350 zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf)); 2351 zfs_nicenum(vs->vs_checksum_errors, cbuf, 2352 sizeof (cbuf)); 2353 printf(" "); 2354 printf_color(rcolor, "%5s", rbuf); 2355 printf(" "); 2356 printf_color(wcolor, "%5s", wbuf); 2357 printf(" "); 2358 printf_color(ccolor, "%5s", cbuf); 2359 } 2360 if (cb->cb_print_slow_ios) { 2361 if (children == 0) { 2362 /* Only leafs vdevs have slow IOs */ 2363 zfs_nicenum(vs->vs_slow_ios, rbuf, 2364 sizeof (rbuf)); 2365 } else { 2366 snprintf(rbuf, sizeof (rbuf), "-"); 2367 } 2368 2369 if (cb->cb_literal) 2370 printf(" %5llu", (u_longlong_t)vs->vs_slow_ios); 2371 else 2372 printf(" %5s", rbuf); 2373 } 2374 } 2375 2376 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 2377 ¬present) == 0) { 2378 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 2379 (void) printf(" %s %s", gettext("was"), path); 2380 } else if (vs->vs_aux != 0) { 2381 (void) printf(" "); 2382 color_start(ANSI_RED); 2383 switch (vs->vs_aux) { 2384 case VDEV_AUX_OPEN_FAILED: 2385 (void) printf(gettext("cannot open")); 2386 break; 2387 2388 case VDEV_AUX_BAD_GUID_SUM: 2389 (void) printf(gettext("missing device")); 2390 break; 2391 2392 case VDEV_AUX_NO_REPLICAS: 2393 (void) printf(gettext("insufficient replicas")); 2394 break; 2395 2396 case VDEV_AUX_VERSION_NEWER: 2397 (void) printf(gettext("newer version")); 2398 break; 2399 2400 case VDEV_AUX_UNSUP_FEAT: 2401 (void) printf(gettext("unsupported feature(s)")); 2402 break; 2403 2404 case VDEV_AUX_ASHIFT_TOO_BIG: 2405 (void) printf(gettext("unsupported minimum blocksize")); 2406 break; 2407 2408 case VDEV_AUX_SPARED: 2409 verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, 2410 &spare_cb.cb_guid) == 0); 2411 if (zpool_iter(g_zfs, find_spare, &spare_cb) == 1) { 2412 if (strcmp(zpool_get_name(spare_cb.cb_zhp), 2413 zpool_get_name(zhp)) == 0) 2414 (void) printf(gettext("currently in " 2415 "use")); 2416 else 2417 (void) printf(gettext("in use by " 2418 "pool '%s'"), 2419 zpool_get_name(spare_cb.cb_zhp)); 2420 zpool_close(spare_cb.cb_zhp); 2421 } else { 2422 (void) printf(gettext("currently in use")); 2423 } 2424 break; 2425 2426 case VDEV_AUX_ERR_EXCEEDED: 2427 (void) printf(gettext("too many errors")); 2428 break; 2429 2430 case VDEV_AUX_IO_FAILURE: 2431 (void) printf(gettext("experienced I/O failures")); 2432 break; 2433 2434 case VDEV_AUX_BAD_LOG: 2435 (void) printf(gettext("bad intent log")); 2436 break; 2437 2438 case VDEV_AUX_EXTERNAL: 2439 (void) printf(gettext("external device fault")); 2440 break; 2441 2442 case VDEV_AUX_SPLIT_POOL: 2443 (void) printf(gettext("split into new pool")); 2444 break; 2445 2446 case VDEV_AUX_ACTIVE: 2447 (void) printf(gettext("currently in use")); 2448 break; 2449 2450 case VDEV_AUX_CHILDREN_OFFLINE: 2451 (void) printf(gettext("all children offline")); 2452 break; 2453 2454 case VDEV_AUX_BAD_LABEL: 2455 (void) printf(gettext("invalid label")); 2456 break; 2457 2458 default: 2459 (void) printf(gettext("corrupted data")); 2460 break; 2461 } 2462 color_end(); 2463 } else if (children == 0 && !isspare && 2464 getenv("ZPOOL_STATUS_NON_NATIVE_ASHIFT_IGNORE") == NULL && 2465 VDEV_STAT_VALID(vs_physical_ashift, vsc) && 2466 vs->vs_configured_ashift < vs->vs_physical_ashift) { 2467 (void) printf( 2468 gettext(" block size: %dB configured, %dB native"), 2469 1 << vs->vs_configured_ashift, 1 << vs->vs_physical_ashift); 2470 } 2471 2472 if (vs->vs_scan_removing != 0) { 2473 (void) printf(gettext(" (removing)")); 2474 } else if (vs->vs_noalloc != 0) { 2475 (void) printf(gettext(" (non-allocating)")); 2476 } 2477 2478 /* The root vdev has the scrub/resilver stats */ 2479 root = fnvlist_lookup_nvlist(zpool_get_config(zhp, NULL), 2480 ZPOOL_CONFIG_VDEV_TREE); 2481 (void) nvlist_lookup_uint64_array(root, ZPOOL_CONFIG_SCAN_STATS, 2482 (uint64_t **)&ps, &c); 2483 2484 if (ps != NULL && ps->pss_state == DSS_SCANNING && children == 0) { 2485 if (vs->vs_scan_processed != 0) { 2486 (void) printf(gettext(" (%s)"), 2487 (ps->pss_func == POOL_SCAN_RESILVER) ? 2488 "resilvering" : "repairing"); 2489 } else if (vs->vs_resilver_deferred) { 2490 (void) printf(gettext(" (awaiting resilver)")); 2491 } 2492 } 2493 2494 /* The top-level vdevs have the rebuild stats */ 2495 if (vrs != NULL && vrs->vrs_state == VDEV_REBUILD_ACTIVE && 2496 children == 0) { 2497 if (vs->vs_rebuild_processed != 0) { 2498 (void) printf(gettext(" (resilvering)")); 2499 } 2500 } 2501 2502 if (cb->vcdl != NULL) { 2503 if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) { 2504 printf(" "); 2505 zpool_print_cmd(cb->vcdl, zpool_get_name(zhp), path); 2506 } 2507 } 2508 2509 /* Display vdev initialization and trim status for leaves. */ 2510 if (children == 0) { 2511 print_status_initialize(vs, cb->cb_print_vdev_init); 2512 print_status_trim(vs, cb->cb_print_vdev_trim); 2513 } 2514 2515 (void) printf("\n"); 2516 2517 for (c = 0; c < children; c++) { 2518 uint64_t islog = B_FALSE, ishole = B_FALSE; 2519 2520 /* Don't print logs or holes here */ 2521 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 2522 &islog); 2523 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 2524 &ishole); 2525 if (islog || ishole) 2526 continue; 2527 /* Only print normal classes here */ 2528 if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS)) 2529 continue; 2530 2531 /* Provide vdev_rebuild_stats to children if available */ 2532 if (vrs == NULL) { 2533 (void) nvlist_lookup_uint64_array(nv, 2534 ZPOOL_CONFIG_REBUILD_STATS, 2535 (uint64_t **)&vrs, &i); 2536 } 2537 2538 vname = zpool_vdev_name(g_zfs, zhp, child[c], 2539 cb->cb_name_flags | VDEV_NAME_TYPE_ID); 2540 print_status_config(zhp, cb, vname, child[c], depth + 2, 2541 isspare, vrs); 2542 free(vname); 2543 } 2544 } 2545 2546 /* 2547 * Print the configuration of an exported pool. Iterate over all vdevs in the 2548 * pool, printing out the name and status for each one. 2549 */ 2550 static void 2551 print_import_config(status_cbdata_t *cb, const char *name, nvlist_t *nv, 2552 int depth) 2553 { 2554 nvlist_t **child; 2555 uint_t c, children; 2556 vdev_stat_t *vs; 2557 char *type, *vname; 2558 2559 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 2560 if (strcmp(type, VDEV_TYPE_MISSING) == 0 || 2561 strcmp(type, VDEV_TYPE_HOLE) == 0) 2562 return; 2563 2564 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 2565 (uint64_t **)&vs, &c) == 0); 2566 2567 (void) printf("\t%*s%-*s", depth, "", cb->cb_namewidth - depth, name); 2568 (void) printf(" %s", zpool_state_to_name(vs->vs_state, vs->vs_aux)); 2569 2570 if (vs->vs_aux != 0) { 2571 (void) printf(" "); 2572 2573 switch (vs->vs_aux) { 2574 case VDEV_AUX_OPEN_FAILED: 2575 (void) printf(gettext("cannot open")); 2576 break; 2577 2578 case VDEV_AUX_BAD_GUID_SUM: 2579 (void) printf(gettext("missing device")); 2580 break; 2581 2582 case VDEV_AUX_NO_REPLICAS: 2583 (void) printf(gettext("insufficient replicas")); 2584 break; 2585 2586 case VDEV_AUX_VERSION_NEWER: 2587 (void) printf(gettext("newer version")); 2588 break; 2589 2590 case VDEV_AUX_UNSUP_FEAT: 2591 (void) printf(gettext("unsupported feature(s)")); 2592 break; 2593 2594 case VDEV_AUX_ERR_EXCEEDED: 2595 (void) printf(gettext("too many errors")); 2596 break; 2597 2598 case VDEV_AUX_ACTIVE: 2599 (void) printf(gettext("currently in use")); 2600 break; 2601 2602 case VDEV_AUX_CHILDREN_OFFLINE: 2603 (void) printf(gettext("all children offline")); 2604 break; 2605 2606 case VDEV_AUX_BAD_LABEL: 2607 (void) printf(gettext("invalid label")); 2608 break; 2609 2610 default: 2611 (void) printf(gettext("corrupted data")); 2612 break; 2613 } 2614 } 2615 (void) printf("\n"); 2616 2617 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2618 &child, &children) != 0) 2619 return; 2620 2621 for (c = 0; c < children; c++) { 2622 uint64_t is_log = B_FALSE; 2623 2624 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 2625 &is_log); 2626 if (is_log) 2627 continue; 2628 if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS)) 2629 continue; 2630 2631 vname = zpool_vdev_name(g_zfs, NULL, child[c], 2632 cb->cb_name_flags | VDEV_NAME_TYPE_ID); 2633 print_import_config(cb, vname, child[c], depth + 2); 2634 free(vname); 2635 } 2636 2637 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 2638 &child, &children) == 0) { 2639 (void) printf(gettext("\tcache\n")); 2640 for (c = 0; c < children; c++) { 2641 vname = zpool_vdev_name(g_zfs, NULL, child[c], 2642 cb->cb_name_flags); 2643 (void) printf("\t %s\n", vname); 2644 free(vname); 2645 } 2646 } 2647 2648 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 2649 &child, &children) == 0) { 2650 (void) printf(gettext("\tspares\n")); 2651 for (c = 0; c < children; c++) { 2652 vname = zpool_vdev_name(g_zfs, NULL, child[c], 2653 cb->cb_name_flags); 2654 (void) printf("\t %s\n", vname); 2655 free(vname); 2656 } 2657 } 2658 } 2659 2660 /* 2661 * Print specialized class vdevs. 2662 * 2663 * These are recorded as top level vdevs in the main pool child array 2664 * but with "is_log" set to 1 or an "alloc_bias" string. We use either 2665 * print_status_config() or print_import_config() to print the top level 2666 * class vdevs then any of their children (eg mirrored slogs) are printed 2667 * recursively - which works because only the top level vdev is marked. 2668 */ 2669 static void 2670 print_class_vdevs(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t *nv, 2671 const char *class) 2672 { 2673 uint_t c, children; 2674 nvlist_t **child; 2675 boolean_t printed = B_FALSE; 2676 2677 assert(zhp != NULL || !cb->cb_verbose); 2678 2679 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child, 2680 &children) != 0) 2681 return; 2682 2683 for (c = 0; c < children; c++) { 2684 uint64_t is_log = B_FALSE; 2685 char *bias = NULL; 2686 char *type = NULL; 2687 2688 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 2689 &is_log); 2690 2691 if (is_log) { 2692 bias = VDEV_ALLOC_CLASS_LOGS; 2693 } else { 2694 (void) nvlist_lookup_string(child[c], 2695 ZPOOL_CONFIG_ALLOCATION_BIAS, &bias); 2696 (void) nvlist_lookup_string(child[c], 2697 ZPOOL_CONFIG_TYPE, &type); 2698 } 2699 2700 if (bias == NULL || strcmp(bias, class) != 0) 2701 continue; 2702 if (!is_log && strcmp(type, VDEV_TYPE_INDIRECT) == 0) 2703 continue; 2704 2705 if (!printed) { 2706 (void) printf("\t%s\t\n", gettext(class)); 2707 printed = B_TRUE; 2708 } 2709 2710 char *name = zpool_vdev_name(g_zfs, zhp, child[c], 2711 cb->cb_name_flags | VDEV_NAME_TYPE_ID); 2712 if (cb->cb_print_status) 2713 print_status_config(zhp, cb, name, child[c], 2, 2714 B_FALSE, NULL); 2715 else 2716 print_import_config(cb, name, child[c], 2); 2717 free(name); 2718 } 2719 } 2720 2721 /* 2722 * Display the status for the given pool. 2723 */ 2724 static int 2725 show_import(nvlist_t *config, boolean_t report_error) 2726 { 2727 uint64_t pool_state; 2728 vdev_stat_t *vs; 2729 char *name; 2730 uint64_t guid; 2731 uint64_t hostid = 0; 2732 char *msgid; 2733 char *hostname = "unknown"; 2734 nvlist_t *nvroot, *nvinfo; 2735 zpool_status_t reason; 2736 zpool_errata_t errata; 2737 const char *health; 2738 uint_t vsc; 2739 char *comment; 2740 status_cbdata_t cb = { 0 }; 2741 2742 verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 2743 &name) == 0); 2744 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 2745 &guid) == 0); 2746 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 2747 &pool_state) == 0); 2748 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 2749 &nvroot) == 0); 2750 2751 verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 2752 (uint64_t **)&vs, &vsc) == 0); 2753 health = zpool_state_to_name(vs->vs_state, vs->vs_aux); 2754 2755 reason = zpool_import_status(config, &msgid, &errata); 2756 2757 /* 2758 * If we're importing using a cachefile, then we won't report any 2759 * errors unless we are in the scan phase of the import. 2760 */ 2761 if (reason != ZPOOL_STATUS_OK && !report_error) 2762 return (reason); 2763 2764 (void) printf(gettext(" pool: %s\n"), name); 2765 (void) printf(gettext(" id: %llu\n"), (u_longlong_t)guid); 2766 (void) printf(gettext(" state: %s"), health); 2767 if (pool_state == POOL_STATE_DESTROYED) 2768 (void) printf(gettext(" (DESTROYED)")); 2769 (void) printf("\n"); 2770 2771 switch (reason) { 2772 case ZPOOL_STATUS_MISSING_DEV_R: 2773 case ZPOOL_STATUS_MISSING_DEV_NR: 2774 case ZPOOL_STATUS_BAD_GUID_SUM: 2775 printf_color(ANSI_BOLD, gettext("status: ")); 2776 printf_color(ANSI_YELLOW, gettext("One or more devices are " 2777 "missing from the system.\n")); 2778 break; 2779 2780 case ZPOOL_STATUS_CORRUPT_LABEL_R: 2781 case ZPOOL_STATUS_CORRUPT_LABEL_NR: 2782 printf_color(ANSI_BOLD, gettext("status: ")); 2783 printf_color(ANSI_YELLOW, gettext("One or more devices contains" 2784 " corrupted data.\n")); 2785 break; 2786 2787 case ZPOOL_STATUS_CORRUPT_DATA: 2788 (void) printf( 2789 gettext(" status: The pool data is corrupted.\n")); 2790 break; 2791 2792 case ZPOOL_STATUS_OFFLINE_DEV: 2793 printf_color(ANSI_BOLD, gettext("status: ")); 2794 printf_color(ANSI_YELLOW, gettext("One or more devices " 2795 "are offlined.\n")); 2796 break; 2797 2798 case ZPOOL_STATUS_CORRUPT_POOL: 2799 printf_color(ANSI_BOLD, gettext("status: ")); 2800 printf_color(ANSI_YELLOW, gettext("The pool metadata is " 2801 "corrupted.\n")); 2802 break; 2803 2804 case ZPOOL_STATUS_VERSION_OLDER: 2805 printf_color(ANSI_BOLD, gettext("status: ")); 2806 printf_color(ANSI_YELLOW, gettext("The pool is formatted using " 2807 "a legacy on-disk version.\n")); 2808 break; 2809 2810 case ZPOOL_STATUS_VERSION_NEWER: 2811 printf_color(ANSI_BOLD, gettext("status: ")); 2812 printf_color(ANSI_YELLOW, gettext("The pool is formatted using " 2813 "an incompatible version.\n")); 2814 break; 2815 2816 case ZPOOL_STATUS_FEAT_DISABLED: 2817 printf_color(ANSI_BOLD, gettext("status: ")); 2818 printf_color(ANSI_YELLOW, gettext("Some supported " 2819 "features are not enabled on the pool.\n\t" 2820 "(Note that they may be intentionally disabled " 2821 "if the\n\t'compatibility' property is set.)\n")); 2822 break; 2823 2824 case ZPOOL_STATUS_COMPATIBILITY_ERR: 2825 printf_color(ANSI_BOLD, gettext("status: ")); 2826 printf_color(ANSI_YELLOW, gettext("Error reading or parsing " 2827 "the file(s) indicated by the 'compatibility'\n" 2828 "property.\n")); 2829 break; 2830 2831 case ZPOOL_STATUS_INCOMPATIBLE_FEAT: 2832 printf_color(ANSI_BOLD, gettext("status: ")); 2833 printf_color(ANSI_YELLOW, gettext("One or more features " 2834 "are enabled on the pool despite not being\n" 2835 "requested by the 'compatibility' property.\n")); 2836 break; 2837 2838 case ZPOOL_STATUS_UNSUP_FEAT_READ: 2839 printf_color(ANSI_BOLD, gettext("status: ")); 2840 printf_color(ANSI_YELLOW, gettext("The pool uses the following " 2841 "feature(s) not supported on this system:\n")); 2842 color_start(ANSI_YELLOW); 2843 zpool_print_unsup_feat(config); 2844 color_end(); 2845 break; 2846 2847 case ZPOOL_STATUS_UNSUP_FEAT_WRITE: 2848 printf_color(ANSI_BOLD, gettext("status: ")); 2849 printf_color(ANSI_YELLOW, gettext("The pool can only be " 2850 "accessed in read-only mode on this system. It\n\tcannot be" 2851 " accessed in read-write mode because it uses the " 2852 "following\n\tfeature(s) not supported on this system:\n")); 2853 color_start(ANSI_YELLOW); 2854 zpool_print_unsup_feat(config); 2855 color_end(); 2856 break; 2857 2858 case ZPOOL_STATUS_HOSTID_ACTIVE: 2859 printf_color(ANSI_BOLD, gettext("status: ")); 2860 printf_color(ANSI_YELLOW, gettext("The pool is currently " 2861 "imported by another system.\n")); 2862 break; 2863 2864 case ZPOOL_STATUS_HOSTID_REQUIRED: 2865 printf_color(ANSI_BOLD, gettext("status: ")); 2866 printf_color(ANSI_YELLOW, gettext("The pool has the " 2867 "multihost property on. It cannot\n\tbe safely imported " 2868 "when the system hostid is not set.\n")); 2869 break; 2870 2871 case ZPOOL_STATUS_HOSTID_MISMATCH: 2872 printf_color(ANSI_BOLD, gettext("status: ")); 2873 printf_color(ANSI_YELLOW, gettext("The pool was last accessed " 2874 "by another system.\n")); 2875 break; 2876 2877 case ZPOOL_STATUS_FAULTED_DEV_R: 2878 case ZPOOL_STATUS_FAULTED_DEV_NR: 2879 printf_color(ANSI_BOLD, gettext("status: ")); 2880 printf_color(ANSI_YELLOW, gettext("One or more devices are " 2881 "faulted.\n")); 2882 break; 2883 2884 case ZPOOL_STATUS_BAD_LOG: 2885 printf_color(ANSI_BOLD, gettext("status: ")); 2886 printf_color(ANSI_YELLOW, gettext("An intent log record cannot " 2887 "be read.\n")); 2888 break; 2889 2890 case ZPOOL_STATUS_RESILVERING: 2891 case ZPOOL_STATUS_REBUILDING: 2892 printf_color(ANSI_BOLD, gettext("status: ")); 2893 printf_color(ANSI_YELLOW, gettext("One or more devices were " 2894 "being resilvered.\n")); 2895 break; 2896 2897 case ZPOOL_STATUS_ERRATA: 2898 printf_color(ANSI_BOLD, gettext("status: ")); 2899 printf_color(ANSI_YELLOW, gettext("Errata #%d detected.\n"), 2900 errata); 2901 break; 2902 2903 case ZPOOL_STATUS_NON_NATIVE_ASHIFT: 2904 printf_color(ANSI_BOLD, gettext("status: ")); 2905 printf_color(ANSI_YELLOW, gettext("One or more devices are " 2906 "configured to use a non-native block size.\n" 2907 "\tExpect reduced performance.\n")); 2908 break; 2909 2910 default: 2911 /* 2912 * No other status can be seen when importing pools. 2913 */ 2914 assert(reason == ZPOOL_STATUS_OK); 2915 } 2916 2917 /* 2918 * Print out an action according to the overall state of the pool. 2919 */ 2920 if (vs->vs_state == VDEV_STATE_HEALTHY) { 2921 if (reason == ZPOOL_STATUS_VERSION_OLDER || 2922 reason == ZPOOL_STATUS_FEAT_DISABLED) { 2923 (void) printf(gettext(" action: The pool can be " 2924 "imported using its name or numeric identifier, " 2925 "though\n\tsome features will not be available " 2926 "without an explicit 'zpool upgrade'.\n")); 2927 } else if (reason == ZPOOL_STATUS_COMPATIBILITY_ERR) { 2928 (void) printf(gettext(" action: The pool can be " 2929 "imported using its name or numeric\n\tidentifier, " 2930 "though the file(s) indicated by its " 2931 "'compatibility'\n\tproperty cannot be parsed at " 2932 "this time.\n")); 2933 } else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) { 2934 (void) printf(gettext(" action: The pool can be " 2935 "imported using its name or numeric " 2936 "identifier and\n\tthe '-f' flag.\n")); 2937 } else if (reason == ZPOOL_STATUS_ERRATA) { 2938 switch (errata) { 2939 case ZPOOL_ERRATA_NONE: 2940 break; 2941 2942 case ZPOOL_ERRATA_ZOL_2094_SCRUB: 2943 (void) printf(gettext(" action: The pool can " 2944 "be imported using its name or numeric " 2945 "identifier,\n\thowever there is a compat" 2946 "ibility issue which should be corrected" 2947 "\n\tby running 'zpool scrub'\n")); 2948 break; 2949 2950 case ZPOOL_ERRATA_ZOL_2094_ASYNC_DESTROY: 2951 (void) printf(gettext(" action: The pool can" 2952 "not be imported with this version of ZFS " 2953 "due to\n\tan active asynchronous destroy. " 2954 "Revert to an earlier version\n\tand " 2955 "allow the destroy to complete before " 2956 "updating.\n")); 2957 break; 2958 2959 case ZPOOL_ERRATA_ZOL_6845_ENCRYPTION: 2960 (void) printf(gettext(" action: Existing " 2961 "encrypted datasets contain an on-disk " 2962 "incompatibility, which\n\tneeds to be " 2963 "corrected. Backup these datasets to new " 2964 "encrypted datasets\n\tand destroy the " 2965 "old ones.\n")); 2966 break; 2967 2968 case ZPOOL_ERRATA_ZOL_8308_ENCRYPTION: 2969 (void) printf(gettext(" action: Existing " 2970 "encrypted snapshots and bookmarks contain " 2971 "an on-disk\n\tincompatibility. This may " 2972 "cause on-disk corruption if they are used" 2973 "\n\twith 'zfs recv'. To correct the " 2974 "issue, enable the bookmark_v2 feature.\n\t" 2975 "No additional action is needed if there " 2976 "are no encrypted snapshots or\n\t" 2977 "bookmarks. If preserving the encrypted " 2978 "snapshots and bookmarks is\n\trequired, " 2979 "use a non-raw send to backup and restore " 2980 "them. Alternately,\n\tthey may be removed" 2981 " to resolve the incompatibility.\n")); 2982 break; 2983 default: 2984 /* 2985 * All errata must contain an action message. 2986 */ 2987 assert(0); 2988 } 2989 } else { 2990 (void) printf(gettext(" action: The pool can be " 2991 "imported using its name or numeric " 2992 "identifier.\n")); 2993 } 2994 } else if (vs->vs_state == VDEV_STATE_DEGRADED) { 2995 (void) printf(gettext(" action: The pool can be imported " 2996 "despite missing or damaged devices. The\n\tfault " 2997 "tolerance of the pool may be compromised if imported.\n")); 2998 } else { 2999 switch (reason) { 3000 case ZPOOL_STATUS_VERSION_NEWER: 3001 (void) printf(gettext(" action: The pool cannot be " 3002 "imported. Access the pool on a system running " 3003 "newer\n\tsoftware, or recreate the pool from " 3004 "backup.\n")); 3005 break; 3006 case ZPOOL_STATUS_UNSUP_FEAT_READ: 3007 printf_color(ANSI_BOLD, gettext("action: ")); 3008 printf_color(ANSI_YELLOW, gettext("The pool cannot be " 3009 "imported. Access the pool on a system that " 3010 "supports\n\tthe required feature(s), or recreate " 3011 "the pool from backup.\n")); 3012 break; 3013 case ZPOOL_STATUS_UNSUP_FEAT_WRITE: 3014 printf_color(ANSI_BOLD, gettext("action: ")); 3015 printf_color(ANSI_YELLOW, gettext("The pool cannot be " 3016 "imported in read-write mode. Import the pool " 3017 "with\n" 3018 "\t\"-o readonly=on\", access the pool on a system " 3019 "that supports the\n\trequired feature(s), or " 3020 "recreate the pool from backup.\n")); 3021 break; 3022 case ZPOOL_STATUS_MISSING_DEV_R: 3023 case ZPOOL_STATUS_MISSING_DEV_NR: 3024 case ZPOOL_STATUS_BAD_GUID_SUM: 3025 (void) printf(gettext(" action: The pool cannot be " 3026 "imported. Attach the missing\n\tdevices and try " 3027 "again.\n")); 3028 break; 3029 case ZPOOL_STATUS_HOSTID_ACTIVE: 3030 VERIFY0(nvlist_lookup_nvlist(config, 3031 ZPOOL_CONFIG_LOAD_INFO, &nvinfo)); 3032 3033 if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTNAME)) 3034 hostname = fnvlist_lookup_string(nvinfo, 3035 ZPOOL_CONFIG_MMP_HOSTNAME); 3036 3037 if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTID)) 3038 hostid = fnvlist_lookup_uint64(nvinfo, 3039 ZPOOL_CONFIG_MMP_HOSTID); 3040 3041 (void) printf(gettext(" action: The pool must be " 3042 "exported from %s (hostid=%lx)\n\tbefore it " 3043 "can be safely imported.\n"), hostname, 3044 (unsigned long) hostid); 3045 break; 3046 case ZPOOL_STATUS_HOSTID_REQUIRED: 3047 (void) printf(gettext(" action: Set a unique system " 3048 "hostid with the zgenhostid(8) command.\n")); 3049 break; 3050 default: 3051 (void) printf(gettext(" action: The pool cannot be " 3052 "imported due to damaged devices or data.\n")); 3053 } 3054 } 3055 3056 /* Print the comment attached to the pool. */ 3057 if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0) 3058 (void) printf(gettext("comment: %s\n"), comment); 3059 3060 /* 3061 * If the state is "closed" or "can't open", and the aux state 3062 * is "corrupt data": 3063 */ 3064 if (((vs->vs_state == VDEV_STATE_CLOSED) || 3065 (vs->vs_state == VDEV_STATE_CANT_OPEN)) && 3066 (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) { 3067 if (pool_state == POOL_STATE_DESTROYED) 3068 (void) printf(gettext("\tThe pool was destroyed, " 3069 "but can be imported using the '-Df' flags.\n")); 3070 else if (pool_state != POOL_STATE_EXPORTED) 3071 (void) printf(gettext("\tThe pool may be active on " 3072 "another system, but can be imported using\n\t" 3073 "the '-f' flag.\n")); 3074 } 3075 3076 if (msgid != NULL) { 3077 (void) printf(gettext( 3078 " see: https://openzfs.github.io/openzfs-docs/msg/%s\n"), 3079 msgid); 3080 } 3081 3082 (void) printf(gettext(" config:\n\n")); 3083 3084 cb.cb_namewidth = max_width(NULL, nvroot, 0, strlen(name), 3085 VDEV_NAME_TYPE_ID); 3086 if (cb.cb_namewidth < 10) 3087 cb.cb_namewidth = 10; 3088 3089 print_import_config(&cb, name, nvroot, 0); 3090 3091 print_class_vdevs(NULL, &cb, nvroot, VDEV_ALLOC_BIAS_DEDUP); 3092 print_class_vdevs(NULL, &cb, nvroot, VDEV_ALLOC_BIAS_SPECIAL); 3093 print_class_vdevs(NULL, &cb, nvroot, VDEV_ALLOC_CLASS_LOGS); 3094 3095 if (reason == ZPOOL_STATUS_BAD_GUID_SUM) { 3096 (void) printf(gettext("\n\tAdditional devices are known to " 3097 "be part of this pool, though their\n\texact " 3098 "configuration cannot be determined.\n")); 3099 } 3100 return (0); 3101 } 3102 3103 static boolean_t 3104 zfs_force_import_required(nvlist_t *config) 3105 { 3106 uint64_t state; 3107 uint64_t hostid = 0; 3108 nvlist_t *nvinfo; 3109 3110 state = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE); 3111 (void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, &hostid); 3112 3113 if (state != POOL_STATE_EXPORTED && hostid != get_system_hostid()) 3114 return (B_TRUE); 3115 3116 nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO); 3117 if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_STATE)) { 3118 mmp_state_t mmp_state = fnvlist_lookup_uint64(nvinfo, 3119 ZPOOL_CONFIG_MMP_STATE); 3120 3121 if (mmp_state != MMP_STATE_INACTIVE) 3122 return (B_TRUE); 3123 } 3124 3125 return (B_FALSE); 3126 } 3127 3128 /* 3129 * Perform the import for the given configuration. This passes the heavy 3130 * lifting off to zpool_import_props(), and then mounts the datasets contained 3131 * within the pool. 3132 */ 3133 static int 3134 do_import(nvlist_t *config, const char *newname, const char *mntopts, 3135 nvlist_t *props, int flags) 3136 { 3137 int ret = 0; 3138 zpool_handle_t *zhp; 3139 char *name; 3140 uint64_t version; 3141 3142 name = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME); 3143 version = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION); 3144 3145 if (!SPA_VERSION_IS_SUPPORTED(version)) { 3146 (void) fprintf(stderr, gettext("cannot import '%s': pool " 3147 "is formatted using an unsupported ZFS version\n"), name); 3148 return (1); 3149 } else if (zfs_force_import_required(config) && 3150 !(flags & ZFS_IMPORT_ANY_HOST)) { 3151 mmp_state_t mmp_state = MMP_STATE_INACTIVE; 3152 nvlist_t *nvinfo; 3153 3154 nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO); 3155 if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_STATE)) 3156 mmp_state = fnvlist_lookup_uint64(nvinfo, 3157 ZPOOL_CONFIG_MMP_STATE); 3158 3159 if (mmp_state == MMP_STATE_ACTIVE) { 3160 char *hostname = "<unknown>"; 3161 uint64_t hostid = 0; 3162 3163 if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTNAME)) 3164 hostname = fnvlist_lookup_string(nvinfo, 3165 ZPOOL_CONFIG_MMP_HOSTNAME); 3166 3167 if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTID)) 3168 hostid = fnvlist_lookup_uint64(nvinfo, 3169 ZPOOL_CONFIG_MMP_HOSTID); 3170 3171 (void) fprintf(stderr, gettext("cannot import '%s': " 3172 "pool is imported on %s (hostid: " 3173 "0x%lx)\nExport the pool on the other system, " 3174 "then run 'zpool import'.\n"), 3175 name, hostname, (unsigned long) hostid); 3176 } else if (mmp_state == MMP_STATE_NO_HOSTID) { 3177 (void) fprintf(stderr, gettext("Cannot import '%s': " 3178 "pool has the multihost property on and the\n" 3179 "system's hostid is not set. Set a unique hostid " 3180 "with the zgenhostid(8) command.\n"), name); 3181 } else { 3182 char *hostname = "<unknown>"; 3183 uint64_t timestamp = 0; 3184 uint64_t hostid = 0; 3185 3186 if (nvlist_exists(config, ZPOOL_CONFIG_HOSTNAME)) 3187 hostname = fnvlist_lookup_string(config, 3188 ZPOOL_CONFIG_HOSTNAME); 3189 3190 if (nvlist_exists(config, ZPOOL_CONFIG_TIMESTAMP)) 3191 timestamp = fnvlist_lookup_uint64(config, 3192 ZPOOL_CONFIG_TIMESTAMP); 3193 3194 if (nvlist_exists(config, ZPOOL_CONFIG_HOSTID)) 3195 hostid = fnvlist_lookup_uint64(config, 3196 ZPOOL_CONFIG_HOSTID); 3197 3198 (void) fprintf(stderr, gettext("cannot import '%s': " 3199 "pool was previously in use from another system.\n" 3200 "Last accessed by %s (hostid=%lx) at %s" 3201 "The pool can be imported, use 'zpool import -f' " 3202 "to import the pool.\n"), name, hostname, 3203 (unsigned long)hostid, ctime((time_t *)×tamp)); 3204 } 3205 3206 return (1); 3207 } 3208 3209 if (zpool_import_props(g_zfs, config, newname, props, flags) != 0) 3210 return (1); 3211 3212 if (newname != NULL) 3213 name = (char *)newname; 3214 3215 if ((zhp = zpool_open_canfail(g_zfs, name)) == NULL) 3216 return (1); 3217 3218 /* 3219 * Loading keys is best effort. We don't want to return immediately 3220 * if it fails but we do want to give the error to the caller. 3221 */ 3222 if (flags & ZFS_IMPORT_LOAD_KEYS) { 3223 ret = zfs_crypto_attempt_load_keys(g_zfs, name); 3224 if (ret != 0) 3225 ret = 1; 3226 } 3227 3228 if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 3229 !(flags & ZFS_IMPORT_ONLY) && 3230 zpool_enable_datasets(zhp, mntopts, 0) != 0) { 3231 zpool_close(zhp); 3232 return (1); 3233 } 3234 3235 zpool_close(zhp); 3236 return (ret); 3237 } 3238 3239 static int 3240 import_pools(nvlist_t *pools, nvlist_t *props, char *mntopts, int flags, 3241 char *orig_name, char *new_name, 3242 boolean_t do_destroyed, boolean_t pool_specified, boolean_t do_all, 3243 importargs_t *import) 3244 { 3245 nvlist_t *config = NULL; 3246 nvlist_t *found_config = NULL; 3247 uint64_t pool_state; 3248 3249 /* 3250 * At this point we have a list of import candidate configs. Even if 3251 * we were searching by pool name or guid, we still need to 3252 * post-process the list to deal with pool state and possible 3253 * duplicate names. 3254 */ 3255 int err = 0; 3256 nvpair_t *elem = NULL; 3257 boolean_t first = B_TRUE; 3258 while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) { 3259 3260 verify(nvpair_value_nvlist(elem, &config) == 0); 3261 3262 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, 3263 &pool_state) == 0); 3264 if (!do_destroyed && pool_state == POOL_STATE_DESTROYED) 3265 continue; 3266 if (do_destroyed && pool_state != POOL_STATE_DESTROYED) 3267 continue; 3268 3269 verify(nvlist_add_nvlist(config, ZPOOL_LOAD_POLICY, 3270 import->policy) == 0); 3271 3272 if (!pool_specified) { 3273 if (first) 3274 first = B_FALSE; 3275 else if (!do_all) 3276 (void) printf("\n"); 3277 3278 if (do_all) { 3279 err |= do_import(config, NULL, mntopts, 3280 props, flags); 3281 } else { 3282 /* 3283 * If we're importing from cachefile, then 3284 * we don't want to report errors until we 3285 * are in the scan phase of the import. If 3286 * we get an error, then we return that error 3287 * to invoke the scan phase. 3288 */ 3289 if (import->cachefile && !import->scan) 3290 err = show_import(config, B_FALSE); 3291 else 3292 (void) show_import(config, B_TRUE); 3293 } 3294 } else if (import->poolname != NULL) { 3295 char *name; 3296 3297 /* 3298 * We are searching for a pool based on name. 3299 */ 3300 verify(nvlist_lookup_string(config, 3301 ZPOOL_CONFIG_POOL_NAME, &name) == 0); 3302 3303 if (strcmp(name, import->poolname) == 0) { 3304 if (found_config != NULL) { 3305 (void) fprintf(stderr, gettext( 3306 "cannot import '%s': more than " 3307 "one matching pool\n"), 3308 import->poolname); 3309 (void) fprintf(stderr, gettext( 3310 "import by numeric ID instead\n")); 3311 err = B_TRUE; 3312 } 3313 found_config = config; 3314 } 3315 } else { 3316 uint64_t guid; 3317 3318 /* 3319 * Search for a pool by guid. 3320 */ 3321 verify(nvlist_lookup_uint64(config, 3322 ZPOOL_CONFIG_POOL_GUID, &guid) == 0); 3323 3324 if (guid == import->guid) 3325 found_config = config; 3326 } 3327 } 3328 3329 /* 3330 * If we were searching for a specific pool, verify that we found a 3331 * pool, and then do the import. 3332 */ 3333 if (pool_specified && err == 0) { 3334 if (found_config == NULL) { 3335 (void) fprintf(stderr, gettext("cannot import '%s': " 3336 "no such pool available\n"), orig_name); 3337 err = B_TRUE; 3338 } else { 3339 err |= do_import(found_config, new_name, 3340 mntopts, props, flags); 3341 } 3342 } 3343 3344 /* 3345 * If we were just looking for pools, report an error if none were 3346 * found. 3347 */ 3348 if (!pool_specified && first) 3349 (void) fprintf(stderr, 3350 gettext("no pools available to import\n")); 3351 return (err); 3352 } 3353 3354 typedef struct target_exists_args { 3355 const char *poolname; 3356 uint64_t poolguid; 3357 } target_exists_args_t; 3358 3359 static int 3360 name_or_guid_exists(zpool_handle_t *zhp, void *data) 3361 { 3362 target_exists_args_t *args = data; 3363 nvlist_t *config = zpool_get_config(zhp, NULL); 3364 int found = 0; 3365 3366 if (config == NULL) 3367 return (0); 3368 3369 if (args->poolname != NULL) { 3370 char *pool_name; 3371 3372 verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME, 3373 &pool_name) == 0); 3374 if (strcmp(pool_name, args->poolname) == 0) 3375 found = 1; 3376 } else { 3377 uint64_t pool_guid; 3378 3379 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 3380 &pool_guid) == 0); 3381 if (pool_guid == args->poolguid) 3382 found = 1; 3383 } 3384 zpool_close(zhp); 3385 3386 return (found); 3387 } 3388 /* 3389 * zpool checkpoint <pool> 3390 * checkpoint --discard <pool> 3391 * 3392 * -d Discard the checkpoint from a checkpointed 3393 * --discard pool. 3394 * 3395 * -w Wait for discarding a checkpoint to complete. 3396 * --wait 3397 * 3398 * Checkpoints the specified pool, by taking a "snapshot" of its 3399 * current state. A pool can only have one checkpoint at a time. 3400 */ 3401 int 3402 zpool_do_checkpoint(int argc, char **argv) 3403 { 3404 boolean_t discard, wait; 3405 char *pool; 3406 zpool_handle_t *zhp; 3407 int c, err; 3408 3409 struct option long_options[] = { 3410 {"discard", no_argument, NULL, 'd'}, 3411 {"wait", no_argument, NULL, 'w'}, 3412 {0, 0, 0, 0} 3413 }; 3414 3415 discard = B_FALSE; 3416 wait = B_FALSE; 3417 while ((c = getopt_long(argc, argv, ":dw", long_options, NULL)) != -1) { 3418 switch (c) { 3419 case 'd': 3420 discard = B_TRUE; 3421 break; 3422 case 'w': 3423 wait = B_TRUE; 3424 break; 3425 case '?': 3426 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3427 optopt); 3428 usage(B_FALSE); 3429 } 3430 } 3431 3432 if (wait && !discard) { 3433 (void) fprintf(stderr, gettext("--wait only valid when " 3434 "--discard also specified\n")); 3435 usage(B_FALSE); 3436 } 3437 3438 argc -= optind; 3439 argv += optind; 3440 3441 if (argc < 1) { 3442 (void) fprintf(stderr, gettext("missing pool argument\n")); 3443 usage(B_FALSE); 3444 } 3445 3446 if (argc > 1) { 3447 (void) fprintf(stderr, gettext("too many arguments\n")); 3448 usage(B_FALSE); 3449 } 3450 3451 pool = argv[0]; 3452 3453 if ((zhp = zpool_open(g_zfs, pool)) == NULL) { 3454 /* As a special case, check for use of '/' in the name */ 3455 if (strchr(pool, '/') != NULL) 3456 (void) fprintf(stderr, gettext("'zpool checkpoint' " 3457 "doesn't work on datasets. To save the state " 3458 "of a dataset from a specific point in time " 3459 "please use 'zfs snapshot'\n")); 3460 return (1); 3461 } 3462 3463 if (discard) { 3464 err = (zpool_discard_checkpoint(zhp) != 0); 3465 if (err == 0 && wait) 3466 err = zpool_wait(zhp, ZPOOL_WAIT_CKPT_DISCARD); 3467 } else { 3468 err = (zpool_checkpoint(zhp) != 0); 3469 } 3470 3471 zpool_close(zhp); 3472 3473 return (err); 3474 } 3475 3476 #define CHECKPOINT_OPT 1024 3477 3478 /* 3479 * zpool import [-d dir] [-D] 3480 * import [-o mntopts] [-o prop=value] ... [-R root] [-D] [-l] 3481 * [-d dir | -c cachefile | -s] [-f] -a 3482 * import [-o mntopts] [-o prop=value] ... [-R root] [-D] [-l] 3483 * [-d dir | -c cachefile | -s] [-f] [-n] [-F] <pool | id> 3484 * [newpool] 3485 * 3486 * -c Read pool information from a cachefile instead of searching 3487 * devices. If importing from a cachefile config fails, then 3488 * fallback to searching for devices only in the directories that 3489 * exist in the cachefile. 3490 * 3491 * -d Scan in a specific directory, other than /dev/. More than 3492 * one directory can be specified using multiple '-d' options. 3493 * 3494 * -D Scan for previously destroyed pools or import all or only 3495 * specified destroyed pools. 3496 * 3497 * -R Temporarily import the pool, with all mountpoints relative to 3498 * the given root. The pool will remain exported when the machine 3499 * is rebooted. 3500 * 3501 * -V Import even in the presence of faulted vdevs. This is an 3502 * intentionally undocumented option for testing purposes, and 3503 * treats the pool configuration as complete, leaving any bad 3504 * vdevs in the FAULTED state. In other words, it does verbatim 3505 * import. 3506 * 3507 * -f Force import, even if it appears that the pool is active. 3508 * 3509 * -F Attempt rewind if necessary. 3510 * 3511 * -n See if rewind would work, but don't actually rewind. 3512 * 3513 * -N Import the pool but don't mount datasets. 3514 * 3515 * -T Specify a starting txg to use for import. This option is 3516 * intentionally undocumented option for testing purposes. 3517 * 3518 * -a Import all pools found. 3519 * 3520 * -l Load encryption keys while importing. 3521 * 3522 * -o Set property=value and/or temporary mount options (without '='). 3523 * 3524 * -s Scan using the default search path, the libblkid cache will 3525 * not be consulted. 3526 * 3527 * --rewind-to-checkpoint 3528 * Import the pool and revert back to the checkpoint. 3529 * 3530 * The import command scans for pools to import, and import pools based on pool 3531 * name and GUID. The pool can also be renamed as part of the import process. 3532 */ 3533 int 3534 zpool_do_import(int argc, char **argv) 3535 { 3536 char **searchdirs = NULL; 3537 char *env, *envdup = NULL; 3538 int nsearch = 0; 3539 int c; 3540 int err = 0; 3541 nvlist_t *pools = NULL; 3542 boolean_t do_all = B_FALSE; 3543 boolean_t do_destroyed = B_FALSE; 3544 char *mntopts = NULL; 3545 uint64_t searchguid = 0; 3546 char *searchname = NULL; 3547 char *propval; 3548 nvlist_t *policy = NULL; 3549 nvlist_t *props = NULL; 3550 int flags = ZFS_IMPORT_NORMAL; 3551 uint32_t rewind_policy = ZPOOL_NO_REWIND; 3552 boolean_t dryrun = B_FALSE; 3553 boolean_t do_rewind = B_FALSE; 3554 boolean_t xtreme_rewind = B_FALSE; 3555 boolean_t do_scan = B_FALSE; 3556 boolean_t pool_exists = B_FALSE; 3557 boolean_t pool_specified = B_FALSE; 3558 uint64_t txg = -1ULL; 3559 char *cachefile = NULL; 3560 importargs_t idata = { 0 }; 3561 char *endptr; 3562 3563 struct option long_options[] = { 3564 {"rewind-to-checkpoint", no_argument, NULL, CHECKPOINT_OPT}, 3565 {0, 0, 0, 0} 3566 }; 3567 3568 /* check options */ 3569 while ((c = getopt_long(argc, argv, ":aCc:d:DEfFlmnNo:R:stT:VX", 3570 long_options, NULL)) != -1) { 3571 switch (c) { 3572 case 'a': 3573 do_all = B_TRUE; 3574 break; 3575 case 'c': 3576 cachefile = optarg; 3577 break; 3578 case 'd': 3579 searchdirs = safe_realloc(searchdirs, 3580 (nsearch + 1) * sizeof (char *)); 3581 searchdirs[nsearch++] = optarg; 3582 break; 3583 case 'D': 3584 do_destroyed = B_TRUE; 3585 break; 3586 case 'f': 3587 flags |= ZFS_IMPORT_ANY_HOST; 3588 break; 3589 case 'F': 3590 do_rewind = B_TRUE; 3591 break; 3592 case 'l': 3593 flags |= ZFS_IMPORT_LOAD_KEYS; 3594 break; 3595 case 'm': 3596 flags |= ZFS_IMPORT_MISSING_LOG; 3597 break; 3598 case 'n': 3599 dryrun = B_TRUE; 3600 break; 3601 case 'N': 3602 flags |= ZFS_IMPORT_ONLY; 3603 break; 3604 case 'o': 3605 if ((propval = strchr(optarg, '=')) != NULL) { 3606 *propval = '\0'; 3607 propval++; 3608 if (add_prop_list(optarg, propval, 3609 &props, B_TRUE)) 3610 goto error; 3611 } else { 3612 mntopts = optarg; 3613 } 3614 break; 3615 case 'R': 3616 if (add_prop_list(zpool_prop_to_name( 3617 ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE)) 3618 goto error; 3619 if (add_prop_list_default(zpool_prop_to_name( 3620 ZPOOL_PROP_CACHEFILE), "none", &props)) 3621 goto error; 3622 break; 3623 case 's': 3624 do_scan = B_TRUE; 3625 break; 3626 case 't': 3627 flags |= ZFS_IMPORT_TEMP_NAME; 3628 if (add_prop_list_default(zpool_prop_to_name( 3629 ZPOOL_PROP_CACHEFILE), "none", &props)) 3630 goto error; 3631 break; 3632 3633 case 'T': 3634 errno = 0; 3635 txg = strtoull(optarg, &endptr, 0); 3636 if (errno != 0 || *endptr != '\0') { 3637 (void) fprintf(stderr, 3638 gettext("invalid txg value\n")); 3639 usage(B_FALSE); 3640 } 3641 rewind_policy = ZPOOL_DO_REWIND | ZPOOL_EXTREME_REWIND; 3642 break; 3643 case 'V': 3644 flags |= ZFS_IMPORT_VERBATIM; 3645 break; 3646 case 'X': 3647 xtreme_rewind = B_TRUE; 3648 break; 3649 case CHECKPOINT_OPT: 3650 flags |= ZFS_IMPORT_CHECKPOINT; 3651 break; 3652 case ':': 3653 (void) fprintf(stderr, gettext("missing argument for " 3654 "'%c' option\n"), optopt); 3655 usage(B_FALSE); 3656 break; 3657 case '?': 3658 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3659 optopt); 3660 usage(B_FALSE); 3661 } 3662 } 3663 3664 argc -= optind; 3665 argv += optind; 3666 3667 if (cachefile && nsearch != 0) { 3668 (void) fprintf(stderr, gettext("-c is incompatible with -d\n")); 3669 usage(B_FALSE); 3670 } 3671 3672 if (cachefile && do_scan) { 3673 (void) fprintf(stderr, gettext("-c is incompatible with -s\n")); 3674 usage(B_FALSE); 3675 } 3676 3677 if ((flags & ZFS_IMPORT_LOAD_KEYS) && (flags & ZFS_IMPORT_ONLY)) { 3678 (void) fprintf(stderr, gettext("-l is incompatible with -N\n")); 3679 usage(B_FALSE); 3680 } 3681 3682 if ((flags & ZFS_IMPORT_LOAD_KEYS) && !do_all && argc == 0) { 3683 (void) fprintf(stderr, gettext("-l is only meaningful during " 3684 "an import\n")); 3685 usage(B_FALSE); 3686 } 3687 3688 if ((dryrun || xtreme_rewind) && !do_rewind) { 3689 (void) fprintf(stderr, 3690 gettext("-n or -X only meaningful with -F\n")); 3691 usage(B_FALSE); 3692 } 3693 if (dryrun) 3694 rewind_policy = ZPOOL_TRY_REWIND; 3695 else if (do_rewind) 3696 rewind_policy = ZPOOL_DO_REWIND; 3697 if (xtreme_rewind) 3698 rewind_policy |= ZPOOL_EXTREME_REWIND; 3699 3700 /* In the future, we can capture further policy and include it here */ 3701 if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 3702 nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, txg) != 0 || 3703 nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, 3704 rewind_policy) != 0) 3705 goto error; 3706 3707 /* check argument count */ 3708 if (do_all) { 3709 if (argc != 0) { 3710 (void) fprintf(stderr, gettext("too many arguments\n")); 3711 usage(B_FALSE); 3712 } 3713 } else { 3714 if (argc > 2) { 3715 (void) fprintf(stderr, gettext("too many arguments\n")); 3716 usage(B_FALSE); 3717 } 3718 } 3719 3720 /* 3721 * Check for the effective uid. We do this explicitly here because 3722 * otherwise any attempt to discover pools will silently fail. 3723 */ 3724 if (argc == 0 && geteuid() != 0) { 3725 (void) fprintf(stderr, gettext("cannot " 3726 "discover pools: permission denied\n")); 3727 if (searchdirs != NULL) 3728 free(searchdirs); 3729 3730 nvlist_free(props); 3731 nvlist_free(policy); 3732 return (1); 3733 } 3734 3735 /* 3736 * Depending on the arguments given, we do one of the following: 3737 * 3738 * <none> Iterate through all pools and display information about 3739 * each one. 3740 * 3741 * -a Iterate through all pools and try to import each one. 3742 * 3743 * <id> Find the pool that corresponds to the given GUID/pool 3744 * name and import that one. 3745 * 3746 * -D Above options applies only to destroyed pools. 3747 */ 3748 if (argc != 0) { 3749 char *endptr; 3750 3751 errno = 0; 3752 searchguid = strtoull(argv[0], &endptr, 10); 3753 if (errno != 0 || *endptr != '\0') { 3754 searchname = argv[0]; 3755 searchguid = 0; 3756 } 3757 pool_specified = B_TRUE; 3758 3759 /* 3760 * User specified a name or guid. Ensure it's unique. 3761 */ 3762 target_exists_args_t search = {searchname, searchguid}; 3763 pool_exists = zpool_iter(g_zfs, name_or_guid_exists, &search); 3764 } 3765 3766 /* 3767 * Check the environment for the preferred search path. 3768 */ 3769 if ((searchdirs == NULL) && (env = getenv("ZPOOL_IMPORT_PATH"))) { 3770 char *dir, *tmp = NULL; 3771 3772 envdup = strdup(env); 3773 3774 for (dir = strtok_r(envdup, ":", &tmp); 3775 dir != NULL; 3776 dir = strtok_r(NULL, ":", &tmp)) { 3777 searchdirs = safe_realloc(searchdirs, 3778 (nsearch + 1) * sizeof (char *)); 3779 searchdirs[nsearch++] = dir; 3780 } 3781 } 3782 3783 idata.path = searchdirs; 3784 idata.paths = nsearch; 3785 idata.poolname = searchname; 3786 idata.guid = searchguid; 3787 idata.cachefile = cachefile; 3788 idata.scan = do_scan; 3789 idata.policy = policy; 3790 3791 pools = zpool_search_import(g_zfs, &idata, &libzfs_config_ops); 3792 3793 if (pools != NULL && pool_exists && 3794 (argc == 1 || strcmp(argv[0], argv[1]) == 0)) { 3795 (void) fprintf(stderr, gettext("cannot import '%s': " 3796 "a pool with that name already exists\n"), 3797 argv[0]); 3798 (void) fprintf(stderr, gettext("use the form '%s " 3799 "<pool | id> <newpool>' to give it a new name\n"), 3800 "zpool import"); 3801 err = 1; 3802 } else if (pools == NULL && pool_exists) { 3803 (void) fprintf(stderr, gettext("cannot import '%s': " 3804 "a pool with that name is already created/imported,\n"), 3805 argv[0]); 3806 (void) fprintf(stderr, gettext("and no additional pools " 3807 "with that name were found\n")); 3808 err = 1; 3809 } else if (pools == NULL) { 3810 if (argc != 0) { 3811 (void) fprintf(stderr, gettext("cannot import '%s': " 3812 "no such pool available\n"), argv[0]); 3813 } 3814 err = 1; 3815 } 3816 3817 if (err == 1) { 3818 free(searchdirs); 3819 free(envdup); 3820 nvlist_free(policy); 3821 nvlist_free(pools); 3822 nvlist_free(props); 3823 return (1); 3824 } 3825 3826 err = import_pools(pools, props, mntopts, flags, 3827 argc >= 1 ? argv[0] : NULL, 3828 argc >= 2 ? argv[1] : NULL, 3829 do_destroyed, pool_specified, do_all, &idata); 3830 3831 /* 3832 * If we're using the cachefile and we failed to import, then 3833 * fallback to scanning the directory for pools that match 3834 * those in the cachefile. 3835 */ 3836 if (err != 0 && cachefile != NULL) { 3837 (void) printf(gettext("cachefile import failed, retrying\n")); 3838 3839 /* 3840 * We use the scan flag to gather the directories that exist 3841 * in the cachefile. If we need to fallback to searching for 3842 * the pool config, we will only search devices in these 3843 * directories. 3844 */ 3845 idata.scan = B_TRUE; 3846 nvlist_free(pools); 3847 pools = zpool_search_import(g_zfs, &idata, &libzfs_config_ops); 3848 3849 err = import_pools(pools, props, mntopts, flags, 3850 argc >= 1 ? argv[0] : NULL, 3851 argc >= 2 ? argv[1] : NULL, 3852 do_destroyed, pool_specified, do_all, &idata); 3853 } 3854 3855 error: 3856 nvlist_free(props); 3857 nvlist_free(pools); 3858 nvlist_free(policy); 3859 free(searchdirs); 3860 free(envdup); 3861 3862 return (err ? 1 : 0); 3863 } 3864 3865 /* 3866 * zpool sync [-f] [pool] ... 3867 * 3868 * -f (undocumented) force uberblock (and config including zpool cache file) 3869 * update. 3870 * 3871 * Sync the specified pool(s). 3872 * Without arguments "zpool sync" will sync all pools. 3873 * This command initiates TXG sync(s) and will return after the TXG(s) commit. 3874 * 3875 */ 3876 static int 3877 zpool_do_sync(int argc, char **argv) 3878 { 3879 int ret; 3880 boolean_t force = B_FALSE; 3881 3882 /* check options */ 3883 while ((ret = getopt(argc, argv, "f")) != -1) { 3884 switch (ret) { 3885 case 'f': 3886 force = B_TRUE; 3887 break; 3888 case '?': 3889 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 3890 optopt); 3891 usage(B_FALSE); 3892 } 3893 } 3894 3895 argc -= optind; 3896 argv += optind; 3897 3898 /* if argc == 0 we will execute zpool_sync_one on all pools */ 3899 ret = for_each_pool(argc, argv, B_FALSE, NULL, ZFS_TYPE_POOL, 3900 B_FALSE, zpool_sync_one, &force); 3901 3902 return (ret); 3903 } 3904 3905 typedef struct iostat_cbdata { 3906 uint64_t cb_flags; 3907 int cb_namewidth; 3908 int cb_iteration; 3909 boolean_t cb_verbose; 3910 boolean_t cb_literal; 3911 boolean_t cb_scripted; 3912 zpool_list_t *cb_list; 3913 vdev_cmd_data_list_t *vcdl; 3914 vdev_cbdata_t cb_vdevs; 3915 } iostat_cbdata_t; 3916 3917 /* iostat labels */ 3918 typedef struct name_and_columns { 3919 const char *name; /* Column name */ 3920 unsigned int columns; /* Center name to this number of columns */ 3921 } name_and_columns_t; 3922 3923 #define IOSTAT_MAX_LABELS 15 /* Max number of labels on one line */ 3924 3925 static const name_and_columns_t iostat_top_labels[][IOSTAT_MAX_LABELS] = 3926 { 3927 [IOS_DEFAULT] = {{"capacity", 2}, {"operations", 2}, {"bandwidth", 2}, 3928 {NULL}}, 3929 [IOS_LATENCY] = {{"total_wait", 2}, {"disk_wait", 2}, {"syncq_wait", 2}, 3930 {"asyncq_wait", 2}, {"scrub", 1}, {"trim", 1}, {"rebuild", 1}, 3931 {NULL}}, 3932 [IOS_QUEUES] = {{"syncq_read", 2}, {"syncq_write", 2}, 3933 {"asyncq_read", 2}, {"asyncq_write", 2}, {"scrubq_read", 2}, 3934 {"trimq_write", 2}, {"rebuildq_write", 2}, {NULL}}, 3935 [IOS_L_HISTO] = {{"total_wait", 2}, {"disk_wait", 2}, {"syncq_wait", 2}, 3936 {"asyncq_wait", 2}, {NULL}}, 3937 [IOS_RQ_HISTO] = {{"sync_read", 2}, {"sync_write", 2}, 3938 {"async_read", 2}, {"async_write", 2}, {"scrub", 2}, 3939 {"trim", 2}, {"rebuild", 2}, {NULL}}, 3940 }; 3941 3942 /* Shorthand - if "columns" field not set, default to 1 column */ 3943 static const name_and_columns_t iostat_bottom_labels[][IOSTAT_MAX_LABELS] = 3944 { 3945 [IOS_DEFAULT] = {{"alloc"}, {"free"}, {"read"}, {"write"}, {"read"}, 3946 {"write"}, {NULL}}, 3947 [IOS_LATENCY] = {{"read"}, {"write"}, {"read"}, {"write"}, {"read"}, 3948 {"write"}, {"read"}, {"write"}, {"wait"}, {"wait"}, {"wait"}, 3949 {NULL}}, 3950 [IOS_QUEUES] = {{"pend"}, {"activ"}, {"pend"}, {"activ"}, {"pend"}, 3951 {"activ"}, {"pend"}, {"activ"}, {"pend"}, {"activ"}, 3952 {"pend"}, {"activ"}, {"pend"}, {"activ"}, {NULL}}, 3953 [IOS_L_HISTO] = {{"read"}, {"write"}, {"read"}, {"write"}, {"read"}, 3954 {"write"}, {"read"}, {"write"}, {"scrub"}, {"trim"}, {"rebuild"}, 3955 {NULL}}, 3956 [IOS_RQ_HISTO] = {{"ind"}, {"agg"}, {"ind"}, {"agg"}, {"ind"}, {"agg"}, 3957 {"ind"}, {"agg"}, {"ind"}, {"agg"}, {"ind"}, {"agg"}, 3958 {"ind"}, {"agg"}, {NULL}}, 3959 }; 3960 3961 static const char *histo_to_title[] = { 3962 [IOS_L_HISTO] = "latency", 3963 [IOS_RQ_HISTO] = "req_size", 3964 }; 3965 3966 /* 3967 * Return the number of labels in a null-terminated name_and_columns_t 3968 * array. 3969 * 3970 */ 3971 static unsigned int 3972 label_array_len(const name_and_columns_t *labels) 3973 { 3974 int i = 0; 3975 3976 while (labels[i].name) 3977 i++; 3978 3979 return (i); 3980 } 3981 3982 /* 3983 * Return the number of strings in a null-terminated string array. 3984 * For example: 3985 * 3986 * const char foo[] = {"bar", "baz", NULL} 3987 * 3988 * returns 2 3989 */ 3990 static uint64_t 3991 str_array_len(const char *array[]) 3992 { 3993 uint64_t i = 0; 3994 while (array[i]) 3995 i++; 3996 3997 return (i); 3998 } 3999 4000 4001 /* 4002 * Return a default column width for default/latency/queue columns. This does 4003 * not include histograms, which have their columns autosized. 4004 */ 4005 static unsigned int 4006 default_column_width(iostat_cbdata_t *cb, enum iostat_type type) 4007 { 4008 unsigned long column_width = 5; /* Normal niceprint */ 4009 static unsigned long widths[] = { 4010 /* 4011 * Choose some sane default column sizes for printing the 4012 * raw numbers. 4013 */ 4014 [IOS_DEFAULT] = 15, /* 1PB capacity */ 4015 [IOS_LATENCY] = 10, /* 1B ns = 10sec */ 4016 [IOS_QUEUES] = 6, /* 1M queue entries */ 4017 [IOS_L_HISTO] = 10, /* 1B ns = 10sec */ 4018 [IOS_RQ_HISTO] = 6, /* 1M queue entries */ 4019 }; 4020 4021 if (cb->cb_literal) 4022 column_width = widths[type]; 4023 4024 return (column_width); 4025 } 4026 4027 /* 4028 * Print the column labels, i.e: 4029 * 4030 * capacity operations bandwidth 4031 * alloc free read write read write ... 4032 * 4033 * If force_column_width is set, use it for the column width. If not set, use 4034 * the default column width. 4035 */ 4036 static void 4037 print_iostat_labels(iostat_cbdata_t *cb, unsigned int force_column_width, 4038 const name_and_columns_t labels[][IOSTAT_MAX_LABELS]) 4039 { 4040 int i, idx, s; 4041 int text_start, rw_column_width, spaces_to_end; 4042 uint64_t flags = cb->cb_flags; 4043 uint64_t f; 4044 unsigned int column_width = force_column_width; 4045 4046 /* For each bit set in flags */ 4047 for (f = flags; f; f &= ~(1ULL << idx)) { 4048 idx = lowbit64(f) - 1; 4049 if (!force_column_width) 4050 column_width = default_column_width(cb, idx); 4051 /* Print our top labels centered over "read write" label. */ 4052 for (i = 0; i < label_array_len(labels[idx]); i++) { 4053 const char *name = labels[idx][i].name; 4054 /* 4055 * We treat labels[][].columns == 0 as shorthand 4056 * for one column. It makes writing out the label 4057 * tables more concise. 4058 */ 4059 unsigned int columns = MAX(1, labels[idx][i].columns); 4060 unsigned int slen = strlen(name); 4061 4062 rw_column_width = (column_width * columns) + 4063 (2 * (columns - 1)); 4064 4065 text_start = (int)((rw_column_width) / columns - 4066 slen / columns); 4067 if (text_start < 0) 4068 text_start = 0; 4069 4070 printf(" "); /* Two spaces between columns */ 4071 4072 /* Space from beginning of column to label */ 4073 for (s = 0; s < text_start; s++) 4074 printf(" "); 4075 4076 printf("%s", name); 4077 4078 /* Print space after label to end of column */ 4079 spaces_to_end = rw_column_width - text_start - slen; 4080 if (spaces_to_end < 0) 4081 spaces_to_end = 0; 4082 4083 for (s = 0; s < spaces_to_end; s++) 4084 printf(" "); 4085 } 4086 } 4087 } 4088 4089 4090 /* 4091 * print_cmd_columns - Print custom column titles from -c 4092 * 4093 * If the user specified the "zpool status|iostat -c" then print their custom 4094 * column titles in the header. For example, print_cmd_columns() would print 4095 * the " col1 col2" part of this: 4096 * 4097 * $ zpool iostat -vc 'echo col1=val1; echo col2=val2' 4098 * ... 4099 * capacity operations bandwidth 4100 * pool alloc free read write read write col1 col2 4101 * ---------- ----- ----- ----- ----- ----- ----- ---- ---- 4102 * mypool 269K 1008M 0 0 107 946 4103 * mirror 269K 1008M 0 0 107 946 4104 * sdb - - 0 0 102 473 val1 val2 4105 * sdc - - 0 0 5 473 val1 val2 4106 * ---------- ----- ----- ----- ----- ----- ----- ---- ---- 4107 */ 4108 static void 4109 print_cmd_columns(vdev_cmd_data_list_t *vcdl, int use_dashes) 4110 { 4111 int i, j; 4112 vdev_cmd_data_t *data = &vcdl->data[0]; 4113 4114 if (vcdl->count == 0 || data == NULL) 4115 return; 4116 4117 /* 4118 * Each vdev cmd should have the same column names unless the user did 4119 * something weird with their cmd. Just take the column names from the 4120 * first vdev and assume it works for all of them. 4121 */ 4122 for (i = 0; i < vcdl->uniq_cols_cnt; i++) { 4123 printf(" "); 4124 if (use_dashes) { 4125 for (j = 0; j < vcdl->uniq_cols_width[i]; j++) 4126 printf("-"); 4127 } else { 4128 printf_color(ANSI_BOLD, "%*s", vcdl->uniq_cols_width[i], 4129 vcdl->uniq_cols[i]); 4130 } 4131 } 4132 } 4133 4134 4135 /* 4136 * Utility function to print out a line of dashes like: 4137 * 4138 * -------------------------------- ----- ----- ----- ----- ----- 4139 * 4140 * ...or a dashed named-row line like: 4141 * 4142 * logs - - - - - 4143 * 4144 * @cb: iostat data 4145 * 4146 * @force_column_width If non-zero, use the value as the column width. 4147 * Otherwise use the default column widths. 4148 * 4149 * @name: Print a dashed named-row line starting 4150 * with @name. Otherwise, print a regular 4151 * dashed line. 4152 */ 4153 static void 4154 print_iostat_dashes(iostat_cbdata_t *cb, unsigned int force_column_width, 4155 const char *name) 4156 { 4157 int i; 4158 unsigned int namewidth; 4159 uint64_t flags = cb->cb_flags; 4160 uint64_t f; 4161 int idx; 4162 const name_and_columns_t *labels; 4163 const char *title; 4164 4165 4166 if (cb->cb_flags & IOS_ANYHISTO_M) { 4167 title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)]; 4168 } else if (cb->cb_vdevs.cb_names_count) { 4169 title = "vdev"; 4170 } else { 4171 title = "pool"; 4172 } 4173 4174 namewidth = MAX(MAX(strlen(title), cb->cb_namewidth), 4175 name ? strlen(name) : 0); 4176 4177 4178 if (name) { 4179 printf("%-*s", namewidth, name); 4180 } else { 4181 for (i = 0; i < namewidth; i++) 4182 (void) printf("-"); 4183 } 4184 4185 /* For each bit in flags */ 4186 for (f = flags; f; f &= ~(1ULL << idx)) { 4187 unsigned int column_width; 4188 idx = lowbit64(f) - 1; 4189 if (force_column_width) 4190 column_width = force_column_width; 4191 else 4192 column_width = default_column_width(cb, idx); 4193 4194 labels = iostat_bottom_labels[idx]; 4195 for (i = 0; i < label_array_len(labels); i++) { 4196 if (name) 4197 printf(" %*s-", column_width - 1, " "); 4198 else 4199 printf(" %.*s", column_width, 4200 "--------------------"); 4201 } 4202 } 4203 } 4204 4205 4206 static void 4207 print_iostat_separator_impl(iostat_cbdata_t *cb, 4208 unsigned int force_column_width) 4209 { 4210 print_iostat_dashes(cb, force_column_width, NULL); 4211 } 4212 4213 static void 4214 print_iostat_separator(iostat_cbdata_t *cb) 4215 { 4216 print_iostat_separator_impl(cb, 0); 4217 } 4218 4219 static void 4220 print_iostat_header_impl(iostat_cbdata_t *cb, unsigned int force_column_width, 4221 const char *histo_vdev_name) 4222 { 4223 unsigned int namewidth; 4224 const char *title; 4225 4226 if (cb->cb_flags & IOS_ANYHISTO_M) { 4227 title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)]; 4228 } else if (cb->cb_vdevs.cb_names_count) { 4229 title = "vdev"; 4230 } else { 4231 title = "pool"; 4232 } 4233 4234 namewidth = MAX(MAX(strlen(title), cb->cb_namewidth), 4235 histo_vdev_name ? strlen(histo_vdev_name) : 0); 4236 4237 if (histo_vdev_name) 4238 printf("%-*s", namewidth, histo_vdev_name); 4239 else 4240 printf("%*s", namewidth, ""); 4241 4242 4243 print_iostat_labels(cb, force_column_width, iostat_top_labels); 4244 printf("\n"); 4245 4246 printf("%-*s", namewidth, title); 4247 4248 print_iostat_labels(cb, force_column_width, iostat_bottom_labels); 4249 if (cb->vcdl != NULL) 4250 print_cmd_columns(cb->vcdl, 0); 4251 4252 printf("\n"); 4253 4254 print_iostat_separator_impl(cb, force_column_width); 4255 4256 if (cb->vcdl != NULL) 4257 print_cmd_columns(cb->vcdl, 1); 4258 4259 printf("\n"); 4260 } 4261 4262 static void 4263 print_iostat_header(iostat_cbdata_t *cb) 4264 { 4265 print_iostat_header_impl(cb, 0, NULL); 4266 } 4267 4268 4269 /* 4270 * Display a single statistic. 4271 */ 4272 static void 4273 print_one_stat(uint64_t value, enum zfs_nicenum_format format, 4274 unsigned int column_size, boolean_t scripted) 4275 { 4276 char buf[64]; 4277 4278 zfs_nicenum_format(value, buf, sizeof (buf), format); 4279 4280 if (scripted) 4281 printf("\t%s", buf); 4282 else 4283 printf(" %*s", column_size, buf); 4284 } 4285 4286 /* 4287 * Calculate the default vdev stats 4288 * 4289 * Subtract oldvs from newvs, apply a scaling factor, and save the resulting 4290 * stats into calcvs. 4291 */ 4292 static void 4293 calc_default_iostats(vdev_stat_t *oldvs, vdev_stat_t *newvs, 4294 vdev_stat_t *calcvs) 4295 { 4296 int i; 4297 4298 memcpy(calcvs, newvs, sizeof (*calcvs)); 4299 for (i = 0; i < ARRAY_SIZE(calcvs->vs_ops); i++) 4300 calcvs->vs_ops[i] = (newvs->vs_ops[i] - oldvs->vs_ops[i]); 4301 4302 for (i = 0; i < ARRAY_SIZE(calcvs->vs_bytes); i++) 4303 calcvs->vs_bytes[i] = (newvs->vs_bytes[i] - oldvs->vs_bytes[i]); 4304 } 4305 4306 /* 4307 * Internal representation of the extended iostats data. 4308 * 4309 * The extended iostat stats are exported in nvlists as either uint64_t arrays 4310 * or single uint64_t's. We make both look like arrays to make them easier 4311 * to process. In order to make single uint64_t's look like arrays, we set 4312 * __data to the stat data, and then set *data = &__data with count = 1. Then, 4313 * we can just use *data and count. 4314 */ 4315 struct stat_array { 4316 uint64_t *data; 4317 uint_t count; /* Number of entries in data[] */ 4318 uint64_t __data; /* Only used when data is a single uint64_t */ 4319 }; 4320 4321 static uint64_t 4322 stat_histo_max(struct stat_array *nva, unsigned int len) 4323 { 4324 uint64_t max = 0; 4325 int i; 4326 for (i = 0; i < len; i++) 4327 max = MAX(max, array64_max(nva[i].data, nva[i].count)); 4328 4329 return (max); 4330 } 4331 4332 /* 4333 * Helper function to lookup a uint64_t array or uint64_t value and store its 4334 * data as a stat_array. If the nvpair is a single uint64_t value, then we make 4335 * it look like a one element array to make it easier to process. 4336 */ 4337 static int 4338 nvpair64_to_stat_array(nvlist_t *nvl, const char *name, 4339 struct stat_array *nva) 4340 { 4341 nvpair_t *tmp; 4342 int ret; 4343 4344 verify(nvlist_lookup_nvpair(nvl, name, &tmp) == 0); 4345 switch (nvpair_type(tmp)) { 4346 case DATA_TYPE_UINT64_ARRAY: 4347 ret = nvpair_value_uint64_array(tmp, &nva->data, &nva->count); 4348 break; 4349 case DATA_TYPE_UINT64: 4350 ret = nvpair_value_uint64(tmp, &nva->__data); 4351 nva->data = &nva->__data; 4352 nva->count = 1; 4353 break; 4354 default: 4355 /* Not a uint64_t */ 4356 ret = EINVAL; 4357 break; 4358 } 4359 4360 return (ret); 4361 } 4362 4363 /* 4364 * Given a list of nvlist names, look up the extended stats in newnv and oldnv, 4365 * subtract them, and return the results in a newly allocated stat_array. 4366 * You must free the returned array after you are done with it with 4367 * free_calc_stats(). 4368 * 4369 * Additionally, you can set "oldnv" to NULL if you simply want the newnv 4370 * values. 4371 */ 4372 static struct stat_array * 4373 calc_and_alloc_stats_ex(const char **names, unsigned int len, nvlist_t *oldnv, 4374 nvlist_t *newnv) 4375 { 4376 nvlist_t *oldnvx = NULL, *newnvx; 4377 struct stat_array *oldnva, *newnva, *calcnva; 4378 int i, j; 4379 unsigned int alloc_size = (sizeof (struct stat_array)) * len; 4380 4381 /* Extract our extended stats nvlist from the main list */ 4382 verify(nvlist_lookup_nvlist(newnv, ZPOOL_CONFIG_VDEV_STATS_EX, 4383 &newnvx) == 0); 4384 if (oldnv) { 4385 verify(nvlist_lookup_nvlist(oldnv, ZPOOL_CONFIG_VDEV_STATS_EX, 4386 &oldnvx) == 0); 4387 } 4388 4389 newnva = safe_malloc(alloc_size); 4390 oldnva = safe_malloc(alloc_size); 4391 calcnva = safe_malloc(alloc_size); 4392 4393 for (j = 0; j < len; j++) { 4394 verify(nvpair64_to_stat_array(newnvx, names[j], 4395 &newnva[j]) == 0); 4396 calcnva[j].count = newnva[j].count; 4397 alloc_size = calcnva[j].count * sizeof (calcnva[j].data[0]); 4398 calcnva[j].data = safe_malloc(alloc_size); 4399 memcpy(calcnva[j].data, newnva[j].data, alloc_size); 4400 4401 if (oldnvx) { 4402 verify(nvpair64_to_stat_array(oldnvx, names[j], 4403 &oldnva[j]) == 0); 4404 for (i = 0; i < oldnva[j].count; i++) 4405 calcnva[j].data[i] -= oldnva[j].data[i]; 4406 } 4407 } 4408 free(newnva); 4409 free(oldnva); 4410 return (calcnva); 4411 } 4412 4413 static void 4414 free_calc_stats(struct stat_array *nva, unsigned int len) 4415 { 4416 int i; 4417 for (i = 0; i < len; i++) 4418 free(nva[i].data); 4419 4420 free(nva); 4421 } 4422 4423 static void 4424 print_iostat_histo(struct stat_array *nva, unsigned int len, 4425 iostat_cbdata_t *cb, unsigned int column_width, unsigned int namewidth, 4426 double scale) 4427 { 4428 int i, j; 4429 char buf[6]; 4430 uint64_t val; 4431 enum zfs_nicenum_format format; 4432 unsigned int buckets; 4433 unsigned int start_bucket; 4434 4435 if (cb->cb_literal) 4436 format = ZFS_NICENUM_RAW; 4437 else 4438 format = ZFS_NICENUM_1024; 4439 4440 /* All these histos are the same size, so just use nva[0].count */ 4441 buckets = nva[0].count; 4442 4443 if (cb->cb_flags & IOS_RQ_HISTO_M) { 4444 /* Start at 512 - req size should never be lower than this */ 4445 start_bucket = 9; 4446 } else { 4447 start_bucket = 0; 4448 } 4449 4450 for (j = start_bucket; j < buckets; j++) { 4451 /* Print histogram bucket label */ 4452 if (cb->cb_flags & IOS_L_HISTO_M) { 4453 /* Ending range of this bucket */ 4454 val = (1UL << (j + 1)) - 1; 4455 zfs_nicetime(val, buf, sizeof (buf)); 4456 } else { 4457 /* Request size (starting range of bucket) */ 4458 val = (1UL << j); 4459 zfs_nicenum(val, buf, sizeof (buf)); 4460 } 4461 4462 if (cb->cb_scripted) 4463 printf("%llu", (u_longlong_t)val); 4464 else 4465 printf("%-*s", namewidth, buf); 4466 4467 /* Print the values on the line */ 4468 for (i = 0; i < len; i++) { 4469 print_one_stat(nva[i].data[j] * scale, format, 4470 column_width, cb->cb_scripted); 4471 } 4472 printf("\n"); 4473 } 4474 } 4475 4476 static void 4477 print_solid_separator(unsigned int length) 4478 { 4479 while (length--) 4480 printf("-"); 4481 printf("\n"); 4482 } 4483 4484 static void 4485 print_iostat_histos(iostat_cbdata_t *cb, nvlist_t *oldnv, 4486 nvlist_t *newnv, double scale, const char *name) 4487 { 4488 unsigned int column_width; 4489 unsigned int namewidth; 4490 unsigned int entire_width; 4491 enum iostat_type type; 4492 struct stat_array *nva; 4493 const char **names; 4494 unsigned int names_len; 4495 4496 /* What type of histo are we? */ 4497 type = IOS_HISTO_IDX(cb->cb_flags); 4498 4499 /* Get NULL-terminated array of nvlist names for our histo */ 4500 names = vsx_type_to_nvlist[type]; 4501 names_len = str_array_len(names); /* num of names */ 4502 4503 nva = calc_and_alloc_stats_ex(names, names_len, oldnv, newnv); 4504 4505 if (cb->cb_literal) { 4506 column_width = MAX(5, 4507 (unsigned int) log10(stat_histo_max(nva, names_len)) + 1); 4508 } else { 4509 column_width = 5; 4510 } 4511 4512 namewidth = MAX(cb->cb_namewidth, 4513 strlen(histo_to_title[IOS_HISTO_IDX(cb->cb_flags)])); 4514 4515 /* 4516 * Calculate the entire line width of what we're printing. The 4517 * +2 is for the two spaces between columns: 4518 */ 4519 /* read write */ 4520 /* ----- ----- */ 4521 /* |___| <---------- column_width */ 4522 /* */ 4523 /* |__________| <--- entire_width */ 4524 /* */ 4525 entire_width = namewidth + (column_width + 2) * 4526 label_array_len(iostat_bottom_labels[type]); 4527 4528 if (cb->cb_scripted) 4529 printf("%s\n", name); 4530 else 4531 print_iostat_header_impl(cb, column_width, name); 4532 4533 print_iostat_histo(nva, names_len, cb, column_width, 4534 namewidth, scale); 4535 4536 free_calc_stats(nva, names_len); 4537 if (!cb->cb_scripted) 4538 print_solid_separator(entire_width); 4539 } 4540 4541 /* 4542 * Calculate the average latency of a power-of-two latency histogram 4543 */ 4544 static uint64_t 4545 single_histo_average(uint64_t *histo, unsigned int buckets) 4546 { 4547 int i; 4548 uint64_t count = 0, total = 0; 4549 4550 for (i = 0; i < buckets; i++) { 4551 /* 4552 * Our buckets are power-of-two latency ranges. Use the 4553 * midpoint latency of each bucket to calculate the average. 4554 * For example: 4555 * 4556 * Bucket Midpoint 4557 * 8ns-15ns: 12ns 4558 * 16ns-31ns: 24ns 4559 * ... 4560 */ 4561 if (histo[i] != 0) { 4562 total += histo[i] * (((1UL << i) + ((1UL << i)/2))); 4563 count += histo[i]; 4564 } 4565 } 4566 4567 /* Prevent divide by zero */ 4568 return (count == 0 ? 0 : total / count); 4569 } 4570 4571 static void 4572 print_iostat_queues(iostat_cbdata_t *cb, nvlist_t *newnv) 4573 { 4574 const char *names[] = { 4575 ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE, 4576 ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE, 4577 ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE, 4578 ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE, 4579 ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE, 4580 ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE, 4581 ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE, 4582 ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE, 4583 ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE, 4584 ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE, 4585 ZPOOL_CONFIG_VDEV_TRIM_PEND_QUEUE, 4586 ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE, 4587 ZPOOL_CONFIG_VDEV_REBUILD_PEND_QUEUE, 4588 ZPOOL_CONFIG_VDEV_REBUILD_ACTIVE_QUEUE, 4589 }; 4590 4591 struct stat_array *nva; 4592 4593 unsigned int column_width = default_column_width(cb, IOS_QUEUES); 4594 enum zfs_nicenum_format format; 4595 4596 nva = calc_and_alloc_stats_ex(names, ARRAY_SIZE(names), NULL, newnv); 4597 4598 if (cb->cb_literal) 4599 format = ZFS_NICENUM_RAW; 4600 else 4601 format = ZFS_NICENUM_1024; 4602 4603 for (int i = 0; i < ARRAY_SIZE(names); i++) { 4604 uint64_t val = nva[i].data[0]; 4605 print_one_stat(val, format, column_width, cb->cb_scripted); 4606 } 4607 4608 free_calc_stats(nva, ARRAY_SIZE(names)); 4609 } 4610 4611 static void 4612 print_iostat_latency(iostat_cbdata_t *cb, nvlist_t *oldnv, 4613 nvlist_t *newnv) 4614 { 4615 int i; 4616 uint64_t val; 4617 const char *names[] = { 4618 ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO, 4619 ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO, 4620 ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO, 4621 ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO, 4622 ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO, 4623 ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO, 4624 ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO, 4625 ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO, 4626 ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO, 4627 ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO, 4628 ZPOOL_CONFIG_VDEV_REBUILD_LAT_HISTO, 4629 }; 4630 struct stat_array *nva; 4631 4632 unsigned int column_width = default_column_width(cb, IOS_LATENCY); 4633 enum zfs_nicenum_format format; 4634 4635 nva = calc_and_alloc_stats_ex(names, ARRAY_SIZE(names), oldnv, newnv); 4636 4637 if (cb->cb_literal) 4638 format = ZFS_NICENUM_RAWTIME; 4639 else 4640 format = ZFS_NICENUM_TIME; 4641 4642 /* Print our avg latencies on the line */ 4643 for (i = 0; i < ARRAY_SIZE(names); i++) { 4644 /* Compute average latency for a latency histo */ 4645 val = single_histo_average(nva[i].data, nva[i].count); 4646 print_one_stat(val, format, column_width, cb->cb_scripted); 4647 } 4648 free_calc_stats(nva, ARRAY_SIZE(names)); 4649 } 4650 4651 /* 4652 * Print default statistics (capacity/operations/bandwidth) 4653 */ 4654 static void 4655 print_iostat_default(vdev_stat_t *vs, iostat_cbdata_t *cb, double scale) 4656 { 4657 unsigned int column_width = default_column_width(cb, IOS_DEFAULT); 4658 enum zfs_nicenum_format format; 4659 char na; /* char to print for "not applicable" values */ 4660 4661 if (cb->cb_literal) { 4662 format = ZFS_NICENUM_RAW; 4663 na = '0'; 4664 } else { 4665 format = ZFS_NICENUM_1024; 4666 na = '-'; 4667 } 4668 4669 /* only toplevel vdevs have capacity stats */ 4670 if (vs->vs_space == 0) { 4671 if (cb->cb_scripted) 4672 printf("\t%c\t%c", na, na); 4673 else 4674 printf(" %*c %*c", column_width, na, column_width, 4675 na); 4676 } else { 4677 print_one_stat(vs->vs_alloc, format, column_width, 4678 cb->cb_scripted); 4679 print_one_stat(vs->vs_space - vs->vs_alloc, format, 4680 column_width, cb->cb_scripted); 4681 } 4682 4683 print_one_stat((uint64_t)(vs->vs_ops[ZIO_TYPE_READ] * scale), 4684 format, column_width, cb->cb_scripted); 4685 print_one_stat((uint64_t)(vs->vs_ops[ZIO_TYPE_WRITE] * scale), 4686 format, column_width, cb->cb_scripted); 4687 print_one_stat((uint64_t)(vs->vs_bytes[ZIO_TYPE_READ] * scale), 4688 format, column_width, cb->cb_scripted); 4689 print_one_stat((uint64_t)(vs->vs_bytes[ZIO_TYPE_WRITE] * scale), 4690 format, column_width, cb->cb_scripted); 4691 } 4692 4693 static const char *class_name[] = { 4694 VDEV_ALLOC_BIAS_DEDUP, 4695 VDEV_ALLOC_BIAS_SPECIAL, 4696 VDEV_ALLOC_CLASS_LOGS 4697 }; 4698 4699 /* 4700 * Print out all the statistics for the given vdev. This can either be the 4701 * toplevel configuration, or called recursively. If 'name' is NULL, then this 4702 * is a verbose output, and we don't want to display the toplevel pool stats. 4703 * 4704 * Returns the number of stat lines printed. 4705 */ 4706 static unsigned int 4707 print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv, 4708 nvlist_t *newnv, iostat_cbdata_t *cb, int depth) 4709 { 4710 nvlist_t **oldchild, **newchild; 4711 uint_t c, children, oldchildren; 4712 vdev_stat_t *oldvs, *newvs, *calcvs; 4713 vdev_stat_t zerovs = { 0 }; 4714 char *vname; 4715 int i; 4716 int ret = 0; 4717 uint64_t tdelta; 4718 double scale; 4719 4720 if (strcmp(name, VDEV_TYPE_INDIRECT) == 0) 4721 return (ret); 4722 4723 calcvs = safe_malloc(sizeof (*calcvs)); 4724 4725 if (oldnv != NULL) { 4726 verify(nvlist_lookup_uint64_array(oldnv, 4727 ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&oldvs, &c) == 0); 4728 } else { 4729 oldvs = &zerovs; 4730 } 4731 4732 /* Do we only want to see a specific vdev? */ 4733 for (i = 0; i < cb->cb_vdevs.cb_names_count; i++) { 4734 /* Yes we do. Is this the vdev? */ 4735 if (strcmp(name, cb->cb_vdevs.cb_names[i]) == 0) { 4736 /* 4737 * This is our vdev. Since it is the only vdev we 4738 * will be displaying, make depth = 0 so that it 4739 * doesn't get indented. 4740 */ 4741 depth = 0; 4742 break; 4743 } 4744 } 4745 4746 if (cb->cb_vdevs.cb_names_count && (i == cb->cb_vdevs.cb_names_count)) { 4747 /* Couldn't match the name */ 4748 goto children; 4749 } 4750 4751 4752 verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_VDEV_STATS, 4753 (uint64_t **)&newvs, &c) == 0); 4754 4755 /* 4756 * Print the vdev name unless it's is a histogram. Histograms 4757 * display the vdev name in the header itself. 4758 */ 4759 if (!(cb->cb_flags & IOS_ANYHISTO_M)) { 4760 if (cb->cb_scripted) { 4761 printf("%s", name); 4762 } else { 4763 if (strlen(name) + depth > cb->cb_namewidth) 4764 (void) printf("%*s%s", depth, "", name); 4765 else 4766 (void) printf("%*s%s%*s", depth, "", name, 4767 (int)(cb->cb_namewidth - strlen(name) - 4768 depth), ""); 4769 } 4770 } 4771 4772 /* Calculate our scaling factor */ 4773 tdelta = newvs->vs_timestamp - oldvs->vs_timestamp; 4774 if ((oldvs->vs_timestamp == 0) && (cb->cb_flags & IOS_ANYHISTO_M)) { 4775 /* 4776 * If we specify printing histograms with no time interval, then 4777 * print the histogram numbers over the entire lifetime of the 4778 * vdev. 4779 */ 4780 scale = 1; 4781 } else { 4782 if (tdelta == 0) 4783 scale = 1.0; 4784 else 4785 scale = (double)NANOSEC / tdelta; 4786 } 4787 4788 if (cb->cb_flags & IOS_DEFAULT_M) { 4789 calc_default_iostats(oldvs, newvs, calcvs); 4790 print_iostat_default(calcvs, cb, scale); 4791 } 4792 if (cb->cb_flags & IOS_LATENCY_M) 4793 print_iostat_latency(cb, oldnv, newnv); 4794 if (cb->cb_flags & IOS_QUEUES_M) 4795 print_iostat_queues(cb, newnv); 4796 if (cb->cb_flags & IOS_ANYHISTO_M) { 4797 printf("\n"); 4798 print_iostat_histos(cb, oldnv, newnv, scale, name); 4799 } 4800 4801 if (cb->vcdl != NULL) { 4802 char *path; 4803 if (nvlist_lookup_string(newnv, ZPOOL_CONFIG_PATH, 4804 &path) == 0) { 4805 printf(" "); 4806 zpool_print_cmd(cb->vcdl, zpool_get_name(zhp), path); 4807 } 4808 } 4809 4810 if (!(cb->cb_flags & IOS_ANYHISTO_M)) 4811 printf("\n"); 4812 4813 ret++; 4814 4815 children: 4816 4817 free(calcvs); 4818 4819 if (!cb->cb_verbose) 4820 return (ret); 4821 4822 if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN, 4823 &newchild, &children) != 0) 4824 return (ret); 4825 4826 if (oldnv) { 4827 if (nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN, 4828 &oldchild, &oldchildren) != 0) 4829 return (ret); 4830 4831 children = MIN(oldchildren, children); 4832 } 4833 4834 /* 4835 * print normal top-level devices 4836 */ 4837 for (c = 0; c < children; c++) { 4838 uint64_t ishole = B_FALSE, islog = B_FALSE; 4839 4840 (void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_HOLE, 4841 &ishole); 4842 4843 (void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_LOG, 4844 &islog); 4845 4846 if (ishole || islog) 4847 continue; 4848 4849 if (nvlist_exists(newchild[c], ZPOOL_CONFIG_ALLOCATION_BIAS)) 4850 continue; 4851 4852 vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 4853 cb->cb_vdevs.cb_name_flags); 4854 ret += print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL, 4855 newchild[c], cb, depth + 2); 4856 free(vname); 4857 } 4858 4859 /* 4860 * print all other top-level devices 4861 */ 4862 for (uint_t n = 0; n < 3; n++) { 4863 boolean_t printed = B_FALSE; 4864 4865 for (c = 0; c < children; c++) { 4866 uint64_t islog = B_FALSE; 4867 char *bias = NULL; 4868 char *type = NULL; 4869 4870 (void) nvlist_lookup_uint64(newchild[c], 4871 ZPOOL_CONFIG_IS_LOG, &islog); 4872 if (islog) { 4873 bias = VDEV_ALLOC_CLASS_LOGS; 4874 } else { 4875 (void) nvlist_lookup_string(newchild[c], 4876 ZPOOL_CONFIG_ALLOCATION_BIAS, &bias); 4877 (void) nvlist_lookup_string(newchild[c], 4878 ZPOOL_CONFIG_TYPE, &type); 4879 } 4880 if (bias == NULL || strcmp(bias, class_name[n]) != 0) 4881 continue; 4882 if (!islog && strcmp(type, VDEV_TYPE_INDIRECT) == 0) 4883 continue; 4884 4885 if (!printed) { 4886 if ((!(cb->cb_flags & IOS_ANYHISTO_M)) && 4887 !cb->cb_scripted && 4888 !cb->cb_vdevs.cb_names) { 4889 print_iostat_dashes(cb, 0, 4890 class_name[n]); 4891 } 4892 printf("\n"); 4893 printed = B_TRUE; 4894 } 4895 4896 vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 4897 cb->cb_vdevs.cb_name_flags); 4898 ret += print_vdev_stats(zhp, vname, oldnv ? 4899 oldchild[c] : NULL, newchild[c], cb, depth + 2); 4900 free(vname); 4901 } 4902 } 4903 4904 /* 4905 * Include level 2 ARC devices in iostat output 4906 */ 4907 if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE, 4908 &newchild, &children) != 0) 4909 return (ret); 4910 4911 if (oldnv) { 4912 if (nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE, 4913 &oldchild, &oldchildren) != 0) 4914 return (ret); 4915 4916 children = MIN(oldchildren, children); 4917 } 4918 4919 if (children > 0) { 4920 if ((!(cb->cb_flags & IOS_ANYHISTO_M)) && !cb->cb_scripted && 4921 !cb->cb_vdevs.cb_names) { 4922 print_iostat_dashes(cb, 0, "cache"); 4923 } 4924 printf("\n"); 4925 4926 for (c = 0; c < children; c++) { 4927 vname = zpool_vdev_name(g_zfs, zhp, newchild[c], 4928 cb->cb_vdevs.cb_name_flags); 4929 ret += print_vdev_stats(zhp, vname, oldnv ? oldchild[c] 4930 : NULL, newchild[c], cb, depth + 2); 4931 free(vname); 4932 } 4933 } 4934 4935 return (ret); 4936 } 4937 4938 static int 4939 refresh_iostat(zpool_handle_t *zhp, void *data) 4940 { 4941 iostat_cbdata_t *cb = data; 4942 boolean_t missing; 4943 4944 /* 4945 * If the pool has disappeared, remove it from the list and continue. 4946 */ 4947 if (zpool_refresh_stats(zhp, &missing) != 0) 4948 return (-1); 4949 4950 if (missing) 4951 pool_list_remove(cb->cb_list, zhp); 4952 4953 return (0); 4954 } 4955 4956 /* 4957 * Callback to print out the iostats for the given pool. 4958 */ 4959 static int 4960 print_iostat(zpool_handle_t *zhp, void *data) 4961 { 4962 iostat_cbdata_t *cb = data; 4963 nvlist_t *oldconfig, *newconfig; 4964 nvlist_t *oldnvroot, *newnvroot; 4965 int ret; 4966 4967 newconfig = zpool_get_config(zhp, &oldconfig); 4968 4969 if (cb->cb_iteration == 1) 4970 oldconfig = NULL; 4971 4972 verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE, 4973 &newnvroot) == 0); 4974 4975 if (oldconfig == NULL) 4976 oldnvroot = NULL; 4977 else 4978 verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE, 4979 &oldnvroot) == 0); 4980 4981 ret = print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, 4982 cb, 0); 4983 if ((ret != 0) && !(cb->cb_flags & IOS_ANYHISTO_M) && 4984 !cb->cb_scripted && cb->cb_verbose && 4985 !cb->cb_vdevs.cb_names_count) { 4986 print_iostat_separator(cb); 4987 if (cb->vcdl != NULL) { 4988 print_cmd_columns(cb->vcdl, 1); 4989 } 4990 printf("\n"); 4991 } 4992 4993 return (ret); 4994 } 4995 4996 static int 4997 get_columns(void) 4998 { 4999 struct winsize ws; 5000 int columns = 80; 5001 int error; 5002 5003 if (isatty(STDOUT_FILENO)) { 5004 error = ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws); 5005 if (error == 0) 5006 columns = ws.ws_col; 5007 } else { 5008 columns = 999; 5009 } 5010 5011 return (columns); 5012 } 5013 5014 /* 5015 * Return the required length of the pool/vdev name column. The minimum 5016 * allowed width and output formatting flags must be provided. 5017 */ 5018 static int 5019 get_namewidth(zpool_handle_t *zhp, int min_width, int flags, boolean_t verbose) 5020 { 5021 nvlist_t *config, *nvroot; 5022 int width = min_width; 5023 5024 if ((config = zpool_get_config(zhp, NULL)) != NULL) { 5025 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 5026 &nvroot) == 0); 5027 unsigned int poolname_len = strlen(zpool_get_name(zhp)); 5028 if (verbose == B_FALSE) { 5029 width = MAX(poolname_len, min_width); 5030 } else { 5031 width = MAX(poolname_len, 5032 max_width(zhp, nvroot, 0, min_width, flags)); 5033 } 5034 } 5035 5036 return (width); 5037 } 5038 5039 /* 5040 * Parse the input string, get the 'interval' and 'count' value if there is one. 5041 */ 5042 static void 5043 get_interval_count(int *argcp, char **argv, float *iv, 5044 unsigned long *cnt) 5045 { 5046 float interval = 0; 5047 unsigned long count = 0; 5048 int argc = *argcp; 5049 5050 /* 5051 * Determine if the last argument is an integer or a pool name 5052 */ 5053 if (argc > 0 && zfs_isnumber(argv[argc - 1])) { 5054 char *end; 5055 5056 errno = 0; 5057 interval = strtof(argv[argc - 1], &end); 5058 5059 if (*end == '\0' && errno == 0) { 5060 if (interval == 0) { 5061 (void) fprintf(stderr, gettext( 5062 "interval cannot be zero\n")); 5063 usage(B_FALSE); 5064 } 5065 /* 5066 * Ignore the last parameter 5067 */ 5068 argc--; 5069 } else { 5070 /* 5071 * If this is not a valid number, just plow on. The 5072 * user will get a more informative error message later 5073 * on. 5074 */ 5075 interval = 0; 5076 } 5077 } 5078 5079 /* 5080 * If the last argument is also an integer, then we have both a count 5081 * and an interval. 5082 */ 5083 if (argc > 0 && zfs_isnumber(argv[argc - 1])) { 5084 char *end; 5085 5086 errno = 0; 5087 count = interval; 5088 interval = strtof(argv[argc - 1], &end); 5089 5090 if (*end == '\0' && errno == 0) { 5091 if (interval == 0) { 5092 (void) fprintf(stderr, gettext( 5093 "interval cannot be zero\n")); 5094 usage(B_FALSE); 5095 } 5096 5097 /* 5098 * Ignore the last parameter 5099 */ 5100 argc--; 5101 } else { 5102 interval = 0; 5103 } 5104 } 5105 5106 *iv = interval; 5107 *cnt = count; 5108 *argcp = argc; 5109 } 5110 5111 static void 5112 get_timestamp_arg(char c) 5113 { 5114 if (c == 'u') 5115 timestamp_fmt = UDATE; 5116 else if (c == 'd') 5117 timestamp_fmt = DDATE; 5118 else 5119 usage(B_FALSE); 5120 } 5121 5122 /* 5123 * Return stat flags that are supported by all pools by both the module and 5124 * zpool iostat. "*data" should be initialized to all 0xFFs before running. 5125 * It will get ANDed down until only the flags that are supported on all pools 5126 * remain. 5127 */ 5128 static int 5129 get_stat_flags_cb(zpool_handle_t *zhp, void *data) 5130 { 5131 uint64_t *mask = data; 5132 nvlist_t *config, *nvroot, *nvx; 5133 uint64_t flags = 0; 5134 int i, j; 5135 5136 config = zpool_get_config(zhp, NULL); 5137 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 5138 &nvroot) == 0); 5139 5140 /* Default stats are always supported, but for completeness.. */ 5141 if (nvlist_exists(nvroot, ZPOOL_CONFIG_VDEV_STATS)) 5142 flags |= IOS_DEFAULT_M; 5143 5144 /* Get our extended stats nvlist from the main list */ 5145 if (nvlist_lookup_nvlist(nvroot, ZPOOL_CONFIG_VDEV_STATS_EX, 5146 &nvx) != 0) { 5147 /* 5148 * No extended stats; they're probably running an older 5149 * module. No big deal, we support that too. 5150 */ 5151 goto end; 5152 } 5153 5154 /* For each extended stat, make sure all its nvpairs are supported */ 5155 for (j = 0; j < ARRAY_SIZE(vsx_type_to_nvlist); j++) { 5156 if (!vsx_type_to_nvlist[j][0]) 5157 continue; 5158 5159 /* Start off by assuming the flag is supported, then check */ 5160 flags |= (1ULL << j); 5161 for (i = 0; vsx_type_to_nvlist[j][i]; i++) { 5162 if (!nvlist_exists(nvx, vsx_type_to_nvlist[j][i])) { 5163 /* flag isn't supported */ 5164 flags = flags & ~(1ULL << j); 5165 break; 5166 } 5167 } 5168 } 5169 end: 5170 *mask = *mask & flags; 5171 return (0); 5172 } 5173 5174 /* 5175 * Return a bitmask of stats that are supported on all pools by both the module 5176 * and zpool iostat. 5177 */ 5178 static uint64_t 5179 get_stat_flags(zpool_list_t *list) 5180 { 5181 uint64_t mask = -1; 5182 5183 /* 5184 * get_stat_flags_cb() will lop off bits from "mask" until only the 5185 * flags that are supported on all pools remain. 5186 */ 5187 pool_list_iter(list, B_FALSE, get_stat_flags_cb, &mask); 5188 return (mask); 5189 } 5190 5191 /* 5192 * Return 1 if cb_data->cb_names[0] is this vdev's name, 0 otherwise. 5193 */ 5194 static int 5195 is_vdev_cb(void *zhp_data, nvlist_t *nv, void *cb_data) 5196 { 5197 vdev_cbdata_t *cb = cb_data; 5198 char *name = NULL; 5199 int ret = 1; /* assume match */ 5200 zpool_handle_t *zhp = zhp_data; 5201 5202 name = zpool_vdev_name(g_zfs, zhp, nv, cb->cb_name_flags); 5203 5204 if (strcmp(name, cb->cb_names[0])) { 5205 free(name); 5206 name = zpool_vdev_name(g_zfs, zhp, nv, VDEV_NAME_GUID); 5207 ret = (strcmp(name, cb->cb_names[0]) == 0); 5208 } 5209 free(name); 5210 5211 return (ret); 5212 } 5213 5214 /* 5215 * Returns 1 if cb_data->cb_names[0] is a vdev name, 0 otherwise. 5216 */ 5217 static int 5218 is_vdev(zpool_handle_t *zhp, void *cb_data) 5219 { 5220 return (for_each_vdev(zhp, is_vdev_cb, cb_data)); 5221 } 5222 5223 /* 5224 * Check if vdevs are in a pool 5225 * 5226 * Return 1 if all argv[] strings are vdev names in pool "pool_name". Otherwise 5227 * return 0. If pool_name is NULL, then search all pools. 5228 */ 5229 static int 5230 are_vdevs_in_pool(int argc, char **argv, char *pool_name, 5231 vdev_cbdata_t *cb) 5232 { 5233 char **tmp_name; 5234 int ret = 0; 5235 int i; 5236 int pool_count = 0; 5237 5238 if ((argc == 0) || !*argv) 5239 return (0); 5240 5241 if (pool_name) 5242 pool_count = 1; 5243 5244 /* Temporarily hijack cb_names for a second... */ 5245 tmp_name = cb->cb_names; 5246 5247 /* Go though our list of prospective vdev names */ 5248 for (i = 0; i < argc; i++) { 5249 cb->cb_names = argv + i; 5250 5251 /* Is this name a vdev in our pools? */ 5252 ret = for_each_pool(pool_count, &pool_name, B_TRUE, NULL, 5253 ZFS_TYPE_POOL, B_FALSE, is_vdev, cb); 5254 if (!ret) { 5255 /* No match */ 5256 break; 5257 } 5258 } 5259 5260 cb->cb_names = tmp_name; 5261 5262 return (ret); 5263 } 5264 5265 static int 5266 is_pool_cb(zpool_handle_t *zhp, void *data) 5267 { 5268 char *name = data; 5269 if (strcmp(name, zpool_get_name(zhp)) == 0) 5270 return (1); 5271 5272 return (0); 5273 } 5274 5275 /* 5276 * Do we have a pool named *name? If so, return 1, otherwise 0. 5277 */ 5278 static int 5279 is_pool(char *name) 5280 { 5281 return (for_each_pool(0, NULL, B_TRUE, NULL, ZFS_TYPE_POOL, B_FALSE, 5282 is_pool_cb, name)); 5283 } 5284 5285 /* Are all our argv[] strings pool names? If so return 1, 0 otherwise. */ 5286 static int 5287 are_all_pools(int argc, char **argv) 5288 { 5289 if ((argc == 0) || !*argv) 5290 return (0); 5291 5292 while (--argc >= 0) 5293 if (!is_pool(argv[argc])) 5294 return (0); 5295 5296 return (1); 5297 } 5298 5299 /* 5300 * Helper function to print out vdev/pool names we can't resolve. Used for an 5301 * error message. 5302 */ 5303 static void 5304 error_list_unresolved_vdevs(int argc, char **argv, char *pool_name, 5305 vdev_cbdata_t *cb) 5306 { 5307 int i; 5308 char *name; 5309 char *str; 5310 for (i = 0; i < argc; i++) { 5311 name = argv[i]; 5312 5313 if (is_pool(name)) 5314 str = gettext("pool"); 5315 else if (are_vdevs_in_pool(1, &name, pool_name, cb)) 5316 str = gettext("vdev in this pool"); 5317 else if (are_vdevs_in_pool(1, &name, NULL, cb)) 5318 str = gettext("vdev in another pool"); 5319 else 5320 str = gettext("unknown"); 5321 5322 fprintf(stderr, "\t%s (%s)\n", name, str); 5323 } 5324 } 5325 5326 /* 5327 * Same as get_interval_count(), but with additional checks to not misinterpret 5328 * guids as interval/count values. Assumes VDEV_NAME_GUID is set in 5329 * cb.cb_vdevs.cb_name_flags. 5330 */ 5331 static void 5332 get_interval_count_filter_guids(int *argc, char **argv, float *interval, 5333 unsigned long *count, iostat_cbdata_t *cb) 5334 { 5335 char **tmpargv = argv; 5336 int argc_for_interval = 0; 5337 5338 /* Is the last arg an interval value? Or a guid? */ 5339 if (*argc >= 1 && !are_vdevs_in_pool(1, &argv[*argc - 1], NULL, 5340 &cb->cb_vdevs)) { 5341 /* 5342 * The last arg is not a guid, so it's probably an 5343 * interval value. 5344 */ 5345 argc_for_interval++; 5346 5347 if (*argc >= 2 && 5348 !are_vdevs_in_pool(1, &argv[*argc - 2], NULL, 5349 &cb->cb_vdevs)) { 5350 /* 5351 * The 2nd to last arg is not a guid, so it's probably 5352 * an interval value. 5353 */ 5354 argc_for_interval++; 5355 } 5356 } 5357 5358 /* Point to our list of possible intervals */ 5359 tmpargv = &argv[*argc - argc_for_interval]; 5360 5361 *argc = *argc - argc_for_interval; 5362 get_interval_count(&argc_for_interval, tmpargv, 5363 interval, count); 5364 } 5365 5366 /* 5367 * Floating point sleep(). Allows you to pass in a floating point value for 5368 * seconds. 5369 */ 5370 static void 5371 fsleep(float sec) 5372 { 5373 struct timespec req; 5374 req.tv_sec = floor(sec); 5375 req.tv_nsec = (sec - (float)req.tv_sec) * NANOSEC; 5376 nanosleep(&req, NULL); 5377 } 5378 5379 /* 5380 * Terminal height, in rows. Returns -1 if stdout is not connected to a TTY or 5381 * if we were unable to determine its size. 5382 */ 5383 static int 5384 terminal_height(void) 5385 { 5386 struct winsize win; 5387 5388 if (isatty(STDOUT_FILENO) == 0) 5389 return (-1); 5390 5391 if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) != -1 && win.ws_row > 0) 5392 return (win.ws_row); 5393 5394 return (-1); 5395 } 5396 5397 /* 5398 * Run one of the zpool status/iostat -c scripts with the help (-h) option and 5399 * print the result. 5400 * 5401 * name: Short name of the script ('iostat'). 5402 * path: Full path to the script ('/usr/local/etc/zfs/zpool.d/iostat'); 5403 */ 5404 static void 5405 print_zpool_script_help(char *name, char *path) 5406 { 5407 char *argv[] = {path, "-h", NULL}; 5408 char **lines = NULL; 5409 int lines_cnt = 0; 5410 int rc; 5411 5412 rc = libzfs_run_process_get_stdout_nopath(path, argv, NULL, &lines, 5413 &lines_cnt); 5414 if (rc != 0 || lines == NULL || lines_cnt <= 0) { 5415 if (lines != NULL) 5416 libzfs_free_str_array(lines, lines_cnt); 5417 return; 5418 } 5419 5420 for (int i = 0; i < lines_cnt; i++) 5421 if (!is_blank_str(lines[i])) 5422 printf(" %-14s %s\n", name, lines[i]); 5423 5424 libzfs_free_str_array(lines, lines_cnt); 5425 } 5426 5427 /* 5428 * Go though the zpool status/iostat -c scripts in the user's path, run their 5429 * help option (-h), and print out the results. 5430 */ 5431 static void 5432 print_zpool_dir_scripts(char *dirpath) 5433 { 5434 DIR *dir; 5435 struct dirent *ent; 5436 char fullpath[MAXPATHLEN]; 5437 struct stat dir_stat; 5438 5439 if ((dir = opendir(dirpath)) != NULL) { 5440 /* print all the files and directories within directory */ 5441 while ((ent = readdir(dir)) != NULL) { 5442 sprintf(fullpath, "%s/%s", dirpath, ent->d_name); 5443 5444 /* Print the scripts */ 5445 if (stat(fullpath, &dir_stat) == 0) 5446 if (dir_stat.st_mode & S_IXUSR && 5447 S_ISREG(dir_stat.st_mode)) 5448 print_zpool_script_help(ent->d_name, 5449 fullpath); 5450 } 5451 closedir(dir); 5452 } 5453 } 5454 5455 /* 5456 * Print out help text for all zpool status/iostat -c scripts. 5457 */ 5458 static void 5459 print_zpool_script_list(char *subcommand) 5460 { 5461 char *dir, *sp, *tmp; 5462 5463 printf(gettext("Available 'zpool %s -c' commands:\n"), subcommand); 5464 5465 sp = zpool_get_cmd_search_path(); 5466 if (sp == NULL) 5467 return; 5468 5469 for (dir = strtok_r(sp, ":", &tmp); 5470 dir != NULL; 5471 dir = strtok_r(NULL, ":", &tmp)) 5472 print_zpool_dir_scripts(dir); 5473 5474 free(sp); 5475 } 5476 5477 /* 5478 * Set the minimum pool/vdev name column width. The width must be at least 10, 5479 * but may be as large as the column width - 42 so it still fits on one line. 5480 * NOTE: 42 is the width of the default capacity/operations/bandwidth output 5481 */ 5482 static int 5483 get_namewidth_iostat(zpool_handle_t *zhp, void *data) 5484 { 5485 iostat_cbdata_t *cb = data; 5486 int width, available_width; 5487 5488 /* 5489 * get_namewidth() returns the maximum width of any name in that column 5490 * for any pool/vdev/device line that will be output. 5491 */ 5492 width = get_namewidth(zhp, cb->cb_namewidth, cb->cb_vdevs.cb_name_flags, 5493 cb->cb_verbose); 5494 5495 /* 5496 * The width we are calculating is the width of the header and also the 5497 * padding width for names that are less than maximum width. The stats 5498 * take up 42 characters, so the width available for names is: 5499 */ 5500 available_width = get_columns() - 42; 5501 5502 /* 5503 * If the maximum width fits on a screen, then great! Make everything 5504 * line up by justifying all lines to the same width. If that max 5505 * width is larger than what's available, the name plus stats won't fit 5506 * on one line, and justifying to that width would cause every line to 5507 * wrap on the screen. We only want lines with long names to wrap. 5508 * Limit the padding to what won't wrap. 5509 */ 5510 if (width > available_width) 5511 width = available_width; 5512 5513 /* 5514 * And regardless of whatever the screen width is (get_columns can 5515 * return 0 if the width is not known or less than 42 for a narrow 5516 * terminal) have the width be a minimum of 10. 5517 */ 5518 if (width < 10) 5519 width = 10; 5520 5521 /* Save the calculated width */ 5522 cb->cb_namewidth = width; 5523 5524 return (0); 5525 } 5526 5527 /* 5528 * zpool iostat [[-c [script1,script2,...]] [-lq]|[-rw]] [-ghHLpPvy] [-n name] 5529 * [-T d|u] [[ pool ...]|[pool vdev ...]|[vdev ...]] 5530 * [interval [count]] 5531 * 5532 * -c CMD For each vdev, run command CMD 5533 * -g Display guid for individual vdev name. 5534 * -L Follow links when resolving vdev path name. 5535 * -P Display full path for vdev name. 5536 * -v Display statistics for individual vdevs 5537 * -h Display help 5538 * -p Display values in parsable (exact) format. 5539 * -H Scripted mode. Don't display headers, and separate properties 5540 * by a single tab. 5541 * -l Display average latency 5542 * -q Display queue depths 5543 * -w Display latency histograms 5544 * -r Display request size histogram 5545 * -T Display a timestamp in date(1) or Unix format 5546 * -n Only print headers once 5547 * 5548 * This command can be tricky because we want to be able to deal with pool 5549 * creation/destruction as well as vdev configuration changes. The bulk of this 5550 * processing is handled by the pool_list_* routines in zpool_iter.c. We rely 5551 * on pool_list_update() to detect the addition of new pools. Configuration 5552 * changes are all handled within libzfs. 5553 */ 5554 int 5555 zpool_do_iostat(int argc, char **argv) 5556 { 5557 int c; 5558 int ret; 5559 int npools; 5560 float interval = 0; 5561 unsigned long count = 0; 5562 int winheight = 24; 5563 zpool_list_t *list; 5564 boolean_t verbose = B_FALSE; 5565 boolean_t latency = B_FALSE, l_histo = B_FALSE, rq_histo = B_FALSE; 5566 boolean_t queues = B_FALSE, parsable = B_FALSE, scripted = B_FALSE; 5567 boolean_t omit_since_boot = B_FALSE; 5568 boolean_t guid = B_FALSE; 5569 boolean_t follow_links = B_FALSE; 5570 boolean_t full_name = B_FALSE; 5571 boolean_t headers_once = B_FALSE; 5572 iostat_cbdata_t cb = { 0 }; 5573 char *cmd = NULL; 5574 5575 /* Used for printing error message */ 5576 const char flag_to_arg[] = {[IOS_LATENCY] = 'l', [IOS_QUEUES] = 'q', 5577 [IOS_L_HISTO] = 'w', [IOS_RQ_HISTO] = 'r'}; 5578 5579 uint64_t unsupported_flags; 5580 5581 /* check options */ 5582 while ((c = getopt(argc, argv, "c:gLPT:vyhplqrwnH")) != -1) { 5583 switch (c) { 5584 case 'c': 5585 if (cmd != NULL) { 5586 fprintf(stderr, 5587 gettext("Can't set -c flag twice\n")); 5588 exit(1); 5589 } 5590 5591 if (getenv("ZPOOL_SCRIPTS_ENABLED") != NULL && 5592 !libzfs_envvar_is_set("ZPOOL_SCRIPTS_ENABLED")) { 5593 fprintf(stderr, gettext( 5594 "Can't run -c, disabled by " 5595 "ZPOOL_SCRIPTS_ENABLED.\n")); 5596 exit(1); 5597 } 5598 5599 if ((getuid() <= 0 || geteuid() <= 0) && 5600 !libzfs_envvar_is_set("ZPOOL_SCRIPTS_AS_ROOT")) { 5601 fprintf(stderr, gettext( 5602 "Can't run -c with root privileges " 5603 "unless ZPOOL_SCRIPTS_AS_ROOT is set.\n")); 5604 exit(1); 5605 } 5606 cmd = optarg; 5607 verbose = B_TRUE; 5608 break; 5609 case 'g': 5610 guid = B_TRUE; 5611 break; 5612 case 'L': 5613 follow_links = B_TRUE; 5614 break; 5615 case 'P': 5616 full_name = B_TRUE; 5617 break; 5618 case 'T': 5619 get_timestamp_arg(*optarg); 5620 break; 5621 case 'v': 5622 verbose = B_TRUE; 5623 break; 5624 case 'p': 5625 parsable = B_TRUE; 5626 break; 5627 case 'l': 5628 latency = B_TRUE; 5629 break; 5630 case 'q': 5631 queues = B_TRUE; 5632 break; 5633 case 'H': 5634 scripted = B_TRUE; 5635 break; 5636 case 'w': 5637 l_histo = B_TRUE; 5638 break; 5639 case 'r': 5640 rq_histo = B_TRUE; 5641 break; 5642 case 'y': 5643 omit_since_boot = B_TRUE; 5644 break; 5645 case 'n': 5646 headers_once = B_TRUE; 5647 break; 5648 case 'h': 5649 usage(B_FALSE); 5650 break; 5651 case '?': 5652 if (optopt == 'c') { 5653 print_zpool_script_list("iostat"); 5654 exit(0); 5655 } else { 5656 fprintf(stderr, 5657 gettext("invalid option '%c'\n"), optopt); 5658 } 5659 usage(B_FALSE); 5660 } 5661 } 5662 5663 argc -= optind; 5664 argv += optind; 5665 5666 cb.cb_literal = parsable; 5667 cb.cb_scripted = scripted; 5668 5669 if (guid) 5670 cb.cb_vdevs.cb_name_flags |= VDEV_NAME_GUID; 5671 if (follow_links) 5672 cb.cb_vdevs.cb_name_flags |= VDEV_NAME_FOLLOW_LINKS; 5673 if (full_name) 5674 cb.cb_vdevs.cb_name_flags |= VDEV_NAME_PATH; 5675 cb.cb_iteration = 0; 5676 cb.cb_namewidth = 0; 5677 cb.cb_verbose = verbose; 5678 5679 /* Get our interval and count values (if any) */ 5680 if (guid) { 5681 get_interval_count_filter_guids(&argc, argv, &interval, 5682 &count, &cb); 5683 } else { 5684 get_interval_count(&argc, argv, &interval, &count); 5685 } 5686 5687 if (argc == 0) { 5688 /* No args, so just print the defaults. */ 5689 } else if (are_all_pools(argc, argv)) { 5690 /* All the args are pool names */ 5691 } else if (are_vdevs_in_pool(argc, argv, NULL, &cb.cb_vdevs)) { 5692 /* All the args are vdevs */ 5693 cb.cb_vdevs.cb_names = argv; 5694 cb.cb_vdevs.cb_names_count = argc; 5695 argc = 0; /* No pools to process */ 5696 } else if (are_all_pools(1, argv)) { 5697 /* The first arg is a pool name */ 5698 if (are_vdevs_in_pool(argc - 1, argv + 1, argv[0], 5699 &cb.cb_vdevs)) { 5700 /* ...and the rest are vdev names */ 5701 cb.cb_vdevs.cb_names = argv + 1; 5702 cb.cb_vdevs.cb_names_count = argc - 1; 5703 argc = 1; /* One pool to process */ 5704 } else { 5705 fprintf(stderr, gettext("Expected either a list of ")); 5706 fprintf(stderr, gettext("pools, or list of vdevs in")); 5707 fprintf(stderr, " \"%s\", ", argv[0]); 5708 fprintf(stderr, gettext("but got:\n")); 5709 error_list_unresolved_vdevs(argc - 1, argv + 1, 5710 argv[0], &cb.cb_vdevs); 5711 fprintf(stderr, "\n"); 5712 usage(B_FALSE); 5713 return (1); 5714 } 5715 } else { 5716 /* 5717 * The args don't make sense. The first arg isn't a pool name, 5718 * nor are all the args vdevs. 5719 */ 5720 fprintf(stderr, gettext("Unable to parse pools/vdevs list.\n")); 5721 fprintf(stderr, "\n"); 5722 return (1); 5723 } 5724 5725 if (cb.cb_vdevs.cb_names_count != 0) { 5726 /* 5727 * If user specified vdevs, it implies verbose. 5728 */ 5729 cb.cb_verbose = B_TRUE; 5730 } 5731 5732 /* 5733 * Construct the list of all interesting pools. 5734 */ 5735 ret = 0; 5736 if ((list = pool_list_get(argc, argv, NULL, ZFS_TYPE_POOL, parsable, 5737 &ret)) == NULL) 5738 return (1); 5739 5740 if (pool_list_count(list) == 0 && argc != 0) { 5741 pool_list_free(list); 5742 return (1); 5743 } 5744 5745 if (pool_list_count(list) == 0 && interval == 0) { 5746 pool_list_free(list); 5747 (void) fprintf(stderr, gettext("no pools available\n")); 5748 return (1); 5749 } 5750 5751 if ((l_histo || rq_histo) && (cmd != NULL || latency || queues)) { 5752 pool_list_free(list); 5753 (void) fprintf(stderr, 5754 gettext("[-r|-w] isn't allowed with [-c|-l|-q]\n")); 5755 usage(B_FALSE); 5756 return (1); 5757 } 5758 5759 if (l_histo && rq_histo) { 5760 pool_list_free(list); 5761 (void) fprintf(stderr, 5762 gettext("Only one of [-r|-w] can be passed at a time\n")); 5763 usage(B_FALSE); 5764 return (1); 5765 } 5766 5767 /* 5768 * Enter the main iostat loop. 5769 */ 5770 cb.cb_list = list; 5771 5772 if (l_histo) { 5773 /* 5774 * Histograms tables look out of place when you try to display 5775 * them with the other stats, so make a rule that you can only 5776 * print histograms by themselves. 5777 */ 5778 cb.cb_flags = IOS_L_HISTO_M; 5779 } else if (rq_histo) { 5780 cb.cb_flags = IOS_RQ_HISTO_M; 5781 } else { 5782 cb.cb_flags = IOS_DEFAULT_M; 5783 if (latency) 5784 cb.cb_flags |= IOS_LATENCY_M; 5785 if (queues) 5786 cb.cb_flags |= IOS_QUEUES_M; 5787 } 5788 5789 /* 5790 * See if the module supports all the stats we want to display. 5791 */ 5792 unsupported_flags = cb.cb_flags & ~get_stat_flags(list); 5793 if (unsupported_flags) { 5794 uint64_t f; 5795 int idx; 5796 fprintf(stderr, 5797 gettext("The loaded zfs module doesn't support:")); 5798 5799 /* for each bit set in unsupported_flags */ 5800 for (f = unsupported_flags; f; f &= ~(1ULL << idx)) { 5801 idx = lowbit64(f) - 1; 5802 fprintf(stderr, " -%c", flag_to_arg[idx]); 5803 } 5804 5805 fprintf(stderr, ". Try running a newer module.\n"); 5806 pool_list_free(list); 5807 5808 return (1); 5809 } 5810 5811 for (;;) { 5812 if ((npools = pool_list_count(list)) == 0) 5813 (void) fprintf(stderr, gettext("no pools available\n")); 5814 else { 5815 /* 5816 * If this is the first iteration and -y was supplied 5817 * we skip any printing. 5818 */ 5819 boolean_t skip = (omit_since_boot && 5820 cb.cb_iteration == 0); 5821 5822 /* 5823 * Refresh all statistics. This is done as an 5824 * explicit step before calculating the maximum name 5825 * width, so that any * configuration changes are 5826 * properly accounted for. 5827 */ 5828 (void) pool_list_iter(list, B_FALSE, refresh_iostat, 5829 &cb); 5830 5831 /* 5832 * Iterate over all pools to determine the maximum width 5833 * for the pool / device name column across all pools. 5834 */ 5835 cb.cb_namewidth = 0; 5836 (void) pool_list_iter(list, B_FALSE, 5837 get_namewidth_iostat, &cb); 5838 5839 if (timestamp_fmt != NODATE) 5840 print_timestamp(timestamp_fmt); 5841 5842 if (cmd != NULL && cb.cb_verbose && 5843 !(cb.cb_flags & IOS_ANYHISTO_M)) { 5844 cb.vcdl = all_pools_for_each_vdev_run(argc, 5845 argv, cmd, g_zfs, cb.cb_vdevs.cb_names, 5846 cb.cb_vdevs.cb_names_count, 5847 cb.cb_vdevs.cb_name_flags); 5848 } else { 5849 cb.vcdl = NULL; 5850 } 5851 5852 5853 /* 5854 * Check terminal size so we can print headers 5855 * even when terminal window has its height 5856 * changed. 5857 */ 5858 winheight = terminal_height(); 5859 /* 5860 * Are we connected to TTY? If not, headers_once 5861 * should be true, to avoid breaking scripts. 5862 */ 5863 if (winheight < 0) 5864 headers_once = B_TRUE; 5865 5866 /* 5867 * If it's the first time and we're not skipping it, 5868 * or either skip or verbose mode, print the header. 5869 * 5870 * The histogram code explicitly prints its header on 5871 * every vdev, so skip this for histograms. 5872 */ 5873 if (((++cb.cb_iteration == 1 && !skip) || 5874 (skip != verbose) || 5875 (!headers_once && 5876 (cb.cb_iteration % winheight) == 0)) && 5877 (!(cb.cb_flags & IOS_ANYHISTO_M)) && 5878 !cb.cb_scripted) 5879 print_iostat_header(&cb); 5880 5881 if (skip) { 5882 (void) fsleep(interval); 5883 continue; 5884 } 5885 5886 pool_list_iter(list, B_FALSE, print_iostat, &cb); 5887 5888 /* 5889 * If there's more than one pool, and we're not in 5890 * verbose mode (which prints a separator for us), 5891 * then print a separator. 5892 * 5893 * In addition, if we're printing specific vdevs then 5894 * we also want an ending separator. 5895 */ 5896 if (((npools > 1 && !verbose && 5897 !(cb.cb_flags & IOS_ANYHISTO_M)) || 5898 (!(cb.cb_flags & IOS_ANYHISTO_M) && 5899 cb.cb_vdevs.cb_names_count)) && 5900 !cb.cb_scripted) { 5901 print_iostat_separator(&cb); 5902 if (cb.vcdl != NULL) 5903 print_cmd_columns(cb.vcdl, 1); 5904 printf("\n"); 5905 } 5906 5907 if (cb.vcdl != NULL) 5908 free_vdev_cmd_data_list(cb.vcdl); 5909 5910 } 5911 5912 /* 5913 * Flush the output so that redirection to a file isn't buffered 5914 * indefinitely. 5915 */ 5916 (void) fflush(stdout); 5917 5918 if (interval == 0) 5919 break; 5920 5921 if (count != 0 && --count == 0) 5922 break; 5923 5924 (void) fsleep(interval); 5925 } 5926 5927 pool_list_free(list); 5928 5929 return (ret); 5930 } 5931 5932 typedef struct list_cbdata { 5933 boolean_t cb_verbose; 5934 int cb_name_flags; 5935 int cb_namewidth; 5936 boolean_t cb_scripted; 5937 zprop_list_t *cb_proplist; 5938 boolean_t cb_literal; 5939 } list_cbdata_t; 5940 5941 5942 /* 5943 * Given a list of columns to display, output appropriate headers for each one. 5944 */ 5945 static void 5946 print_header(list_cbdata_t *cb) 5947 { 5948 zprop_list_t *pl = cb->cb_proplist; 5949 char headerbuf[ZPOOL_MAXPROPLEN]; 5950 const char *header; 5951 boolean_t first = B_TRUE; 5952 boolean_t right_justify; 5953 size_t width = 0; 5954 5955 for (; pl != NULL; pl = pl->pl_next) { 5956 width = pl->pl_width; 5957 if (first && cb->cb_verbose) { 5958 /* 5959 * Reset the width to accommodate the verbose listing 5960 * of devices. 5961 */ 5962 width = cb->cb_namewidth; 5963 } 5964 5965 if (!first) 5966 (void) printf(" "); 5967 else 5968 first = B_FALSE; 5969 5970 right_justify = B_FALSE; 5971 if (pl->pl_prop != ZPROP_INVAL) { 5972 header = zpool_prop_column_name(pl->pl_prop); 5973 right_justify = zpool_prop_align_right(pl->pl_prop); 5974 } else { 5975 int i; 5976 5977 for (i = 0; pl->pl_user_prop[i] != '\0'; i++) 5978 headerbuf[i] = toupper(pl->pl_user_prop[i]); 5979 headerbuf[i] = '\0'; 5980 header = headerbuf; 5981 } 5982 5983 if (pl->pl_next == NULL && !right_justify) 5984 (void) printf("%s", header); 5985 else if (right_justify) 5986 (void) printf("%*s", (int)width, header); 5987 else 5988 (void) printf("%-*s", (int)width, header); 5989 } 5990 5991 (void) printf("\n"); 5992 } 5993 5994 /* 5995 * Given a pool and a list of properties, print out all the properties according 5996 * to the described layout. Used by zpool_do_list(). 5997 */ 5998 static void 5999 print_pool(zpool_handle_t *zhp, list_cbdata_t *cb) 6000 { 6001 zprop_list_t *pl = cb->cb_proplist; 6002 boolean_t first = B_TRUE; 6003 char property[ZPOOL_MAXPROPLEN]; 6004 char *propstr; 6005 boolean_t right_justify; 6006 size_t width; 6007 6008 for (; pl != NULL; pl = pl->pl_next) { 6009 6010 width = pl->pl_width; 6011 if (first && cb->cb_verbose) { 6012 /* 6013 * Reset the width to accommodate the verbose listing 6014 * of devices. 6015 */ 6016 width = cb->cb_namewidth; 6017 } 6018 6019 if (!first) { 6020 if (cb->cb_scripted) 6021 (void) printf("\t"); 6022 else 6023 (void) printf(" "); 6024 } else { 6025 first = B_FALSE; 6026 } 6027 6028 right_justify = B_FALSE; 6029 if (pl->pl_prop != ZPROP_INVAL) { 6030 if (zpool_get_prop(zhp, pl->pl_prop, property, 6031 sizeof (property), NULL, cb->cb_literal) != 0) 6032 propstr = "-"; 6033 else 6034 propstr = property; 6035 6036 right_justify = zpool_prop_align_right(pl->pl_prop); 6037 } else if ((zpool_prop_feature(pl->pl_user_prop) || 6038 zpool_prop_unsupported(pl->pl_user_prop)) && 6039 zpool_prop_get_feature(zhp, pl->pl_user_prop, property, 6040 sizeof (property)) == 0) { 6041 propstr = property; 6042 } else { 6043 propstr = "-"; 6044 } 6045 6046 6047 /* 6048 * If this is being called in scripted mode, or if this is the 6049 * last column and it is left-justified, don't include a width 6050 * format specifier. 6051 */ 6052 if (cb->cb_scripted || (pl->pl_next == NULL && !right_justify)) 6053 (void) printf("%s", propstr); 6054 else if (right_justify) 6055 (void) printf("%*s", (int)width, propstr); 6056 else 6057 (void) printf("%-*s", (int)width, propstr); 6058 } 6059 6060 (void) printf("\n"); 6061 } 6062 6063 static void 6064 print_one_column(zpool_prop_t prop, uint64_t value, const char *str, 6065 boolean_t scripted, boolean_t valid, enum zfs_nicenum_format format) 6066 { 6067 char propval[64]; 6068 boolean_t fixed; 6069 size_t width = zprop_width(prop, &fixed, ZFS_TYPE_POOL); 6070 6071 switch (prop) { 6072 case ZPOOL_PROP_EXPANDSZ: 6073 case ZPOOL_PROP_CHECKPOINT: 6074 case ZPOOL_PROP_DEDUPRATIO: 6075 if (value == 0) 6076 (void) strlcpy(propval, "-", sizeof (propval)); 6077 else 6078 zfs_nicenum_format(value, propval, sizeof (propval), 6079 format); 6080 break; 6081 case ZPOOL_PROP_FRAGMENTATION: 6082 if (value == ZFS_FRAG_INVALID) { 6083 (void) strlcpy(propval, "-", sizeof (propval)); 6084 } else if (format == ZFS_NICENUM_RAW) { 6085 (void) snprintf(propval, sizeof (propval), "%llu", 6086 (unsigned long long)value); 6087 } else { 6088 (void) snprintf(propval, sizeof (propval), "%llu%%", 6089 (unsigned long long)value); 6090 } 6091 break; 6092 case ZPOOL_PROP_CAPACITY: 6093 /* capacity value is in parts-per-10,000 (aka permyriad) */ 6094 if (format == ZFS_NICENUM_RAW) 6095 (void) snprintf(propval, sizeof (propval), "%llu", 6096 (unsigned long long)value / 100); 6097 else 6098 (void) snprintf(propval, sizeof (propval), 6099 value < 1000 ? "%1.2f%%" : value < 10000 ? 6100 "%2.1f%%" : "%3.0f%%", value / 100.0); 6101 break; 6102 case ZPOOL_PROP_HEALTH: 6103 width = 8; 6104 (void) strlcpy(propval, str, sizeof (propval)); 6105 break; 6106 default: 6107 zfs_nicenum_format(value, propval, sizeof (propval), format); 6108 } 6109 6110 if (!valid) 6111 (void) strlcpy(propval, "-", sizeof (propval)); 6112 6113 if (scripted) 6114 (void) printf("\t%s", propval); 6115 else 6116 (void) printf(" %*s", (int)width, propval); 6117 } 6118 6119 /* 6120 * print static default line per vdev 6121 * not compatible with '-o' <proplist> option 6122 */ 6123 static void 6124 print_list_stats(zpool_handle_t *zhp, const char *name, nvlist_t *nv, 6125 list_cbdata_t *cb, int depth, boolean_t isspare) 6126 { 6127 nvlist_t **child; 6128 vdev_stat_t *vs; 6129 uint_t c, children; 6130 char *vname; 6131 boolean_t scripted = cb->cb_scripted; 6132 uint64_t islog = B_FALSE; 6133 char *dashes = "%-*s - - - - " 6134 "- - - - -\n"; 6135 6136 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 6137 (uint64_t **)&vs, &c) == 0); 6138 6139 if (name != NULL) { 6140 boolean_t toplevel = (vs->vs_space != 0); 6141 uint64_t cap; 6142 enum zfs_nicenum_format format; 6143 const char *state; 6144 6145 if (cb->cb_literal) 6146 format = ZFS_NICENUM_RAW; 6147 else 6148 format = ZFS_NICENUM_1024; 6149 6150 if (strcmp(name, VDEV_TYPE_INDIRECT) == 0) 6151 return; 6152 6153 if (scripted) 6154 (void) printf("\t%s", name); 6155 else if (strlen(name) + depth > cb->cb_namewidth) 6156 (void) printf("%*s%s", depth, "", name); 6157 else 6158 (void) printf("%*s%s%*s", depth, "", name, 6159 (int)(cb->cb_namewidth - strlen(name) - depth), ""); 6160 6161 /* 6162 * Print the properties for the individual vdevs. Some 6163 * properties are only applicable to toplevel vdevs. The 6164 * 'toplevel' boolean value is passed to the print_one_column() 6165 * to indicate that the value is valid. 6166 */ 6167 print_one_column(ZPOOL_PROP_SIZE, vs->vs_space, NULL, scripted, 6168 toplevel, format); 6169 print_one_column(ZPOOL_PROP_ALLOCATED, vs->vs_alloc, NULL, 6170 scripted, toplevel, format); 6171 print_one_column(ZPOOL_PROP_FREE, vs->vs_space - vs->vs_alloc, 6172 NULL, scripted, toplevel, format); 6173 print_one_column(ZPOOL_PROP_CHECKPOINT, 6174 vs->vs_checkpoint_space, NULL, scripted, toplevel, format); 6175 print_one_column(ZPOOL_PROP_EXPANDSZ, vs->vs_esize, NULL, 6176 scripted, B_TRUE, format); 6177 print_one_column(ZPOOL_PROP_FRAGMENTATION, 6178 vs->vs_fragmentation, NULL, scripted, 6179 (vs->vs_fragmentation != ZFS_FRAG_INVALID && toplevel), 6180 format); 6181 cap = (vs->vs_space == 0) ? 0 : 6182 (vs->vs_alloc * 10000 / vs->vs_space); 6183 print_one_column(ZPOOL_PROP_CAPACITY, cap, NULL, 6184 scripted, toplevel, format); 6185 print_one_column(ZPOOL_PROP_DEDUPRATIO, 0, NULL, 6186 scripted, toplevel, format); 6187 state = zpool_state_to_name(vs->vs_state, vs->vs_aux); 6188 if (isspare) { 6189 if (vs->vs_aux == VDEV_AUX_SPARED) 6190 state = "INUSE"; 6191 else if (vs->vs_state == VDEV_STATE_HEALTHY) 6192 state = "AVAIL"; 6193 } 6194 print_one_column(ZPOOL_PROP_HEALTH, 0, state, scripted, 6195 B_TRUE, format); 6196 (void) printf("\n"); 6197 } 6198 6199 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 6200 &child, &children) != 0) 6201 return; 6202 6203 /* list the normal vdevs first */ 6204 for (c = 0; c < children; c++) { 6205 uint64_t ishole = B_FALSE; 6206 6207 if (nvlist_lookup_uint64(child[c], 6208 ZPOOL_CONFIG_IS_HOLE, &ishole) == 0 && ishole) 6209 continue; 6210 6211 if (nvlist_lookup_uint64(child[c], 6212 ZPOOL_CONFIG_IS_LOG, &islog) == 0 && islog) 6213 continue; 6214 6215 if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS)) 6216 continue; 6217 6218 vname = zpool_vdev_name(g_zfs, zhp, child[c], 6219 cb->cb_name_flags); 6220 print_list_stats(zhp, vname, child[c], cb, depth + 2, B_FALSE); 6221 free(vname); 6222 } 6223 6224 /* list the classes: 'logs', 'dedup', and 'special' */ 6225 for (uint_t n = 0; n < 3; n++) { 6226 boolean_t printed = B_FALSE; 6227 6228 for (c = 0; c < children; c++) { 6229 char *bias = NULL; 6230 char *type = NULL; 6231 6232 if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 6233 &islog) == 0 && islog) { 6234 bias = VDEV_ALLOC_CLASS_LOGS; 6235 } else { 6236 (void) nvlist_lookup_string(child[c], 6237 ZPOOL_CONFIG_ALLOCATION_BIAS, &bias); 6238 (void) nvlist_lookup_string(child[c], 6239 ZPOOL_CONFIG_TYPE, &type); 6240 } 6241 if (bias == NULL || strcmp(bias, class_name[n]) != 0) 6242 continue; 6243 if (!islog && strcmp(type, VDEV_TYPE_INDIRECT) == 0) 6244 continue; 6245 6246 if (!printed) { 6247 /* LINTED E_SEC_PRINTF_VAR_FMT */ 6248 (void) printf(dashes, cb->cb_namewidth, 6249 class_name[n]); 6250 printed = B_TRUE; 6251 } 6252 vname = zpool_vdev_name(g_zfs, zhp, child[c], 6253 cb->cb_name_flags); 6254 print_list_stats(zhp, vname, child[c], cb, depth + 2, 6255 B_FALSE); 6256 free(vname); 6257 } 6258 } 6259 6260 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 6261 &child, &children) == 0 && children > 0) { 6262 /* LINTED E_SEC_PRINTF_VAR_FMT */ 6263 (void) printf(dashes, cb->cb_namewidth, "cache"); 6264 for (c = 0; c < children; c++) { 6265 vname = zpool_vdev_name(g_zfs, zhp, child[c], 6266 cb->cb_name_flags); 6267 print_list_stats(zhp, vname, child[c], cb, depth + 2, 6268 B_FALSE); 6269 free(vname); 6270 } 6271 } 6272 6273 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, &child, 6274 &children) == 0 && children > 0) { 6275 /* LINTED E_SEC_PRINTF_VAR_FMT */ 6276 (void) printf(dashes, cb->cb_namewidth, "spare"); 6277 for (c = 0; c < children; c++) { 6278 vname = zpool_vdev_name(g_zfs, zhp, child[c], 6279 cb->cb_name_flags); 6280 print_list_stats(zhp, vname, child[c], cb, depth + 2, 6281 B_TRUE); 6282 free(vname); 6283 } 6284 } 6285 } 6286 6287 /* 6288 * Generic callback function to list a pool. 6289 */ 6290 static int 6291 list_callback(zpool_handle_t *zhp, void *data) 6292 { 6293 list_cbdata_t *cbp = data; 6294 6295 print_pool(zhp, cbp); 6296 6297 if (cbp->cb_verbose) { 6298 nvlist_t *config, *nvroot; 6299 6300 config = zpool_get_config(zhp, NULL); 6301 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 6302 &nvroot) == 0); 6303 print_list_stats(zhp, NULL, nvroot, cbp, 0, B_FALSE); 6304 } 6305 6306 return (0); 6307 } 6308 6309 /* 6310 * Set the minimum pool/vdev name column width. The width must be at least 9, 6311 * but may be as large as needed. 6312 */ 6313 static int 6314 get_namewidth_list(zpool_handle_t *zhp, void *data) 6315 { 6316 list_cbdata_t *cb = data; 6317 int width; 6318 6319 width = get_namewidth(zhp, cb->cb_namewidth, cb->cb_name_flags, 6320 cb->cb_verbose); 6321 6322 if (width < 9) 6323 width = 9; 6324 6325 cb->cb_namewidth = width; 6326 6327 return (0); 6328 } 6329 6330 /* 6331 * zpool list [-gHLpP] [-o prop[,prop]*] [-T d|u] [pool] ... [interval [count]] 6332 * 6333 * -g Display guid for individual vdev name. 6334 * -H Scripted mode. Don't display headers, and separate properties 6335 * by a single tab. 6336 * -L Follow links when resolving vdev path name. 6337 * -o List of properties to display. Defaults to 6338 * "name,size,allocated,free,expandsize,fragmentation,capacity," 6339 * "dedupratio,health,altroot" 6340 * -p Display values in parsable (exact) format. 6341 * -P Display full path for vdev name. 6342 * -T Display a timestamp in date(1) or Unix format 6343 * 6344 * List all pools in the system, whether or not they're healthy. Output space 6345 * statistics for each one, as well as health status summary. 6346 */ 6347 int 6348 zpool_do_list(int argc, char **argv) 6349 { 6350 int c; 6351 int ret = 0; 6352 list_cbdata_t cb = { 0 }; 6353 static char default_props[] = 6354 "name,size,allocated,free,checkpoint,expandsize,fragmentation," 6355 "capacity,dedupratio,health,altroot"; 6356 char *props = default_props; 6357 float interval = 0; 6358 unsigned long count = 0; 6359 zpool_list_t *list; 6360 boolean_t first = B_TRUE; 6361 current_prop_type = ZFS_TYPE_POOL; 6362 6363 /* check options */ 6364 while ((c = getopt(argc, argv, ":gHLo:pPT:v")) != -1) { 6365 switch (c) { 6366 case 'g': 6367 cb.cb_name_flags |= VDEV_NAME_GUID; 6368 break; 6369 case 'H': 6370 cb.cb_scripted = B_TRUE; 6371 break; 6372 case 'L': 6373 cb.cb_name_flags |= VDEV_NAME_FOLLOW_LINKS; 6374 break; 6375 case 'o': 6376 props = optarg; 6377 break; 6378 case 'P': 6379 cb.cb_name_flags |= VDEV_NAME_PATH; 6380 break; 6381 case 'p': 6382 cb.cb_literal = B_TRUE; 6383 break; 6384 case 'T': 6385 get_timestamp_arg(*optarg); 6386 break; 6387 case 'v': 6388 cb.cb_verbose = B_TRUE; 6389 cb.cb_namewidth = 8; /* 8 until precalc is avail */ 6390 break; 6391 case ':': 6392 (void) fprintf(stderr, gettext("missing argument for " 6393 "'%c' option\n"), optopt); 6394 usage(B_FALSE); 6395 break; 6396 case '?': 6397 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 6398 optopt); 6399 usage(B_FALSE); 6400 } 6401 } 6402 6403 argc -= optind; 6404 argv += optind; 6405 6406 get_interval_count(&argc, argv, &interval, &count); 6407 6408 if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0) 6409 usage(B_FALSE); 6410 6411 for (;;) { 6412 if ((list = pool_list_get(argc, argv, &cb.cb_proplist, 6413 ZFS_TYPE_POOL, cb.cb_literal, &ret)) == NULL) 6414 return (1); 6415 6416 if (pool_list_count(list) == 0) 6417 break; 6418 6419 cb.cb_namewidth = 0; 6420 (void) pool_list_iter(list, B_FALSE, get_namewidth_list, &cb); 6421 6422 if (timestamp_fmt != NODATE) 6423 print_timestamp(timestamp_fmt); 6424 6425 if (!cb.cb_scripted && (first || cb.cb_verbose)) { 6426 print_header(&cb); 6427 first = B_FALSE; 6428 } 6429 ret = pool_list_iter(list, B_TRUE, list_callback, &cb); 6430 6431 if (interval == 0) 6432 break; 6433 6434 if (count != 0 && --count == 0) 6435 break; 6436 6437 pool_list_free(list); 6438 (void) fsleep(interval); 6439 } 6440 6441 if (argc == 0 && !cb.cb_scripted && pool_list_count(list) == 0) { 6442 (void) printf(gettext("no pools available\n")); 6443 ret = 0; 6444 } 6445 6446 pool_list_free(list); 6447 zprop_free_list(cb.cb_proplist); 6448 return (ret); 6449 } 6450 6451 static int 6452 zpool_do_attach_or_replace(int argc, char **argv, int replacing) 6453 { 6454 boolean_t force = B_FALSE; 6455 boolean_t rebuild = B_FALSE; 6456 boolean_t wait = B_FALSE; 6457 int c; 6458 nvlist_t *nvroot; 6459 char *poolname, *old_disk, *new_disk; 6460 zpool_handle_t *zhp; 6461 nvlist_t *props = NULL; 6462 char *propval; 6463 int ret; 6464 6465 /* check options */ 6466 while ((c = getopt(argc, argv, "fo:sw")) != -1) { 6467 switch (c) { 6468 case 'f': 6469 force = B_TRUE; 6470 break; 6471 case 'o': 6472 if ((propval = strchr(optarg, '=')) == NULL) { 6473 (void) fprintf(stderr, gettext("missing " 6474 "'=' for -o option\n")); 6475 usage(B_FALSE); 6476 } 6477 *propval = '\0'; 6478 propval++; 6479 6480 if ((strcmp(optarg, ZPOOL_CONFIG_ASHIFT) != 0) || 6481 (add_prop_list(optarg, propval, &props, B_TRUE))) 6482 usage(B_FALSE); 6483 break; 6484 case 's': 6485 rebuild = B_TRUE; 6486 break; 6487 case 'w': 6488 wait = B_TRUE; 6489 break; 6490 case '?': 6491 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 6492 optopt); 6493 usage(B_FALSE); 6494 } 6495 } 6496 6497 argc -= optind; 6498 argv += optind; 6499 6500 /* get pool name and check number of arguments */ 6501 if (argc < 1) { 6502 (void) fprintf(stderr, gettext("missing pool name argument\n")); 6503 usage(B_FALSE); 6504 } 6505 6506 poolname = argv[0]; 6507 6508 if (argc < 2) { 6509 (void) fprintf(stderr, 6510 gettext("missing <device> specification\n")); 6511 usage(B_FALSE); 6512 } 6513 6514 old_disk = argv[1]; 6515 6516 if (argc < 3) { 6517 if (!replacing) { 6518 (void) fprintf(stderr, 6519 gettext("missing <new_device> specification\n")); 6520 usage(B_FALSE); 6521 } 6522 new_disk = old_disk; 6523 argc -= 1; 6524 argv += 1; 6525 } else { 6526 new_disk = argv[2]; 6527 argc -= 2; 6528 argv += 2; 6529 } 6530 6531 if (argc > 1) { 6532 (void) fprintf(stderr, gettext("too many arguments\n")); 6533 usage(B_FALSE); 6534 } 6535 6536 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) { 6537 nvlist_free(props); 6538 return (1); 6539 } 6540 6541 if (zpool_get_config(zhp, NULL) == NULL) { 6542 (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"), 6543 poolname); 6544 zpool_close(zhp); 6545 nvlist_free(props); 6546 return (1); 6547 } 6548 6549 /* unless manually specified use "ashift" pool property (if set) */ 6550 if (!nvlist_exists(props, ZPOOL_CONFIG_ASHIFT)) { 6551 int intval; 6552 zprop_source_t src; 6553 char strval[ZPOOL_MAXPROPLEN]; 6554 6555 intval = zpool_get_prop_int(zhp, ZPOOL_PROP_ASHIFT, &src); 6556 if (src != ZPROP_SRC_DEFAULT) { 6557 (void) sprintf(strval, "%" PRId32, intval); 6558 verify(add_prop_list(ZPOOL_CONFIG_ASHIFT, strval, 6559 &props, B_TRUE) == 0); 6560 } 6561 } 6562 6563 nvroot = make_root_vdev(zhp, props, force, B_FALSE, replacing, B_FALSE, 6564 argc, argv); 6565 if (nvroot == NULL) { 6566 zpool_close(zhp); 6567 nvlist_free(props); 6568 return (1); 6569 } 6570 6571 ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing, 6572 rebuild); 6573 6574 if (ret == 0 && wait) 6575 ret = zpool_wait(zhp, 6576 replacing ? ZPOOL_WAIT_REPLACE : ZPOOL_WAIT_RESILVER); 6577 6578 nvlist_free(props); 6579 nvlist_free(nvroot); 6580 zpool_close(zhp); 6581 6582 return (ret); 6583 } 6584 6585 /* 6586 * zpool replace [-fsw] [-o property=value] <pool> <device> <new_device> 6587 * 6588 * -f Force attach, even if <new_device> appears to be in use. 6589 * -s Use sequential instead of healing reconstruction for resilver. 6590 * -o Set property=value. 6591 * -w Wait for replacing to complete before returning 6592 * 6593 * Replace <device> with <new_device>. 6594 */ 6595 int 6596 zpool_do_replace(int argc, char **argv) 6597 { 6598 return (zpool_do_attach_or_replace(argc, argv, B_TRUE)); 6599 } 6600 6601 /* 6602 * zpool attach [-fsw] [-o property=value] <pool> <device> <new_device> 6603 * 6604 * -f Force attach, even if <new_device> appears to be in use. 6605 * -s Use sequential instead of healing reconstruction for resilver. 6606 * -o Set property=value. 6607 * -w Wait for resilvering to complete before returning 6608 * 6609 * Attach <new_device> to the mirror containing <device>. If <device> is not 6610 * part of a mirror, then <device> will be transformed into a mirror of 6611 * <device> and <new_device>. In either case, <new_device> will begin life 6612 * with a DTL of [0, now], and will immediately begin to resilver itself. 6613 */ 6614 int 6615 zpool_do_attach(int argc, char **argv) 6616 { 6617 return (zpool_do_attach_or_replace(argc, argv, B_FALSE)); 6618 } 6619 6620 /* 6621 * zpool detach [-f] <pool> <device> 6622 * 6623 * -f Force detach of <device>, even if DTLs argue against it 6624 * (not supported yet) 6625 * 6626 * Detach a device from a mirror. The operation will be refused if <device> 6627 * is the last device in the mirror, or if the DTLs indicate that this device 6628 * has the only valid copy of some data. 6629 */ 6630 int 6631 zpool_do_detach(int argc, char **argv) 6632 { 6633 int c; 6634 char *poolname, *path; 6635 zpool_handle_t *zhp; 6636 int ret; 6637 6638 /* check options */ 6639 while ((c = getopt(argc, argv, "")) != -1) { 6640 switch (c) { 6641 case '?': 6642 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 6643 optopt); 6644 usage(B_FALSE); 6645 } 6646 } 6647 6648 argc -= optind; 6649 argv += optind; 6650 6651 /* get pool name and check number of arguments */ 6652 if (argc < 1) { 6653 (void) fprintf(stderr, gettext("missing pool name argument\n")); 6654 usage(B_FALSE); 6655 } 6656 6657 if (argc < 2) { 6658 (void) fprintf(stderr, 6659 gettext("missing <device> specification\n")); 6660 usage(B_FALSE); 6661 } 6662 6663 poolname = argv[0]; 6664 path = argv[1]; 6665 6666 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 6667 return (1); 6668 6669 ret = zpool_vdev_detach(zhp, path); 6670 6671 zpool_close(zhp); 6672 6673 return (ret); 6674 } 6675 6676 /* 6677 * zpool split [-gLnP] [-o prop=val] ... 6678 * [-o mntopt] ... 6679 * [-R altroot] <pool> <newpool> [<device> ...] 6680 * 6681 * -g Display guid for individual vdev name. 6682 * -L Follow links when resolving vdev path name. 6683 * -n Do not split the pool, but display the resulting layout if 6684 * it were to be split. 6685 * -o Set property=value, or set mount options. 6686 * -P Display full path for vdev name. 6687 * -R Mount the split-off pool under an alternate root. 6688 * -l Load encryption keys while importing. 6689 * 6690 * Splits the named pool and gives it the new pool name. Devices to be split 6691 * off may be listed, provided that no more than one device is specified 6692 * per top-level vdev mirror. The newly split pool is left in an exported 6693 * state unless -R is specified. 6694 * 6695 * Restrictions: the top-level of the pool pool must only be made up of 6696 * mirrors; all devices in the pool must be healthy; no device may be 6697 * undergoing a resilvering operation. 6698 */ 6699 int 6700 zpool_do_split(int argc, char **argv) 6701 { 6702 char *srcpool, *newpool, *propval; 6703 char *mntopts = NULL; 6704 splitflags_t flags; 6705 int c, ret = 0; 6706 boolean_t loadkeys = B_FALSE; 6707 zpool_handle_t *zhp; 6708 nvlist_t *config, *props = NULL; 6709 6710 flags.dryrun = B_FALSE; 6711 flags.import = B_FALSE; 6712 flags.name_flags = 0; 6713 6714 /* check options */ 6715 while ((c = getopt(argc, argv, ":gLR:lno:P")) != -1) { 6716 switch (c) { 6717 case 'g': 6718 flags.name_flags |= VDEV_NAME_GUID; 6719 break; 6720 case 'L': 6721 flags.name_flags |= VDEV_NAME_FOLLOW_LINKS; 6722 break; 6723 case 'R': 6724 flags.import = B_TRUE; 6725 if (add_prop_list( 6726 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), optarg, 6727 &props, B_TRUE) != 0) { 6728 nvlist_free(props); 6729 usage(B_FALSE); 6730 } 6731 break; 6732 case 'l': 6733 loadkeys = B_TRUE; 6734 break; 6735 case 'n': 6736 flags.dryrun = B_TRUE; 6737 break; 6738 case 'o': 6739 if ((propval = strchr(optarg, '=')) != NULL) { 6740 *propval = '\0'; 6741 propval++; 6742 if (add_prop_list(optarg, propval, 6743 &props, B_TRUE) != 0) { 6744 nvlist_free(props); 6745 usage(B_FALSE); 6746 } 6747 } else { 6748 mntopts = optarg; 6749 } 6750 break; 6751 case 'P': 6752 flags.name_flags |= VDEV_NAME_PATH; 6753 break; 6754 case ':': 6755 (void) fprintf(stderr, gettext("missing argument for " 6756 "'%c' option\n"), optopt); 6757 usage(B_FALSE); 6758 break; 6759 case '?': 6760 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 6761 optopt); 6762 usage(B_FALSE); 6763 break; 6764 } 6765 } 6766 6767 if (!flags.import && mntopts != NULL) { 6768 (void) fprintf(stderr, gettext("setting mntopts is only " 6769 "valid when importing the pool\n")); 6770 usage(B_FALSE); 6771 } 6772 6773 if (!flags.import && loadkeys) { 6774 (void) fprintf(stderr, gettext("loading keys is only " 6775 "valid when importing the pool\n")); 6776 usage(B_FALSE); 6777 } 6778 6779 argc -= optind; 6780 argv += optind; 6781 6782 if (argc < 1) { 6783 (void) fprintf(stderr, gettext("Missing pool name\n")); 6784 usage(B_FALSE); 6785 } 6786 if (argc < 2) { 6787 (void) fprintf(stderr, gettext("Missing new pool name\n")); 6788 usage(B_FALSE); 6789 } 6790 6791 srcpool = argv[0]; 6792 newpool = argv[1]; 6793 6794 argc -= 2; 6795 argv += 2; 6796 6797 if ((zhp = zpool_open(g_zfs, srcpool)) == NULL) { 6798 nvlist_free(props); 6799 return (1); 6800 } 6801 6802 config = split_mirror_vdev(zhp, newpool, props, flags, argc, argv); 6803 if (config == NULL) { 6804 ret = 1; 6805 } else { 6806 if (flags.dryrun) { 6807 (void) printf(gettext("would create '%s' with the " 6808 "following layout:\n\n"), newpool); 6809 print_vdev_tree(NULL, newpool, config, 0, "", 6810 flags.name_flags); 6811 print_vdev_tree(NULL, "dedup", config, 0, 6812 VDEV_ALLOC_BIAS_DEDUP, 0); 6813 print_vdev_tree(NULL, "special", config, 0, 6814 VDEV_ALLOC_BIAS_SPECIAL, 0); 6815 } 6816 } 6817 6818 zpool_close(zhp); 6819 6820 if (ret != 0 || flags.dryrun || !flags.import) { 6821 nvlist_free(config); 6822 nvlist_free(props); 6823 return (ret); 6824 } 6825 6826 /* 6827 * The split was successful. Now we need to open the new 6828 * pool and import it. 6829 */ 6830 if ((zhp = zpool_open_canfail(g_zfs, newpool)) == NULL) { 6831 nvlist_free(config); 6832 nvlist_free(props); 6833 return (1); 6834 } 6835 6836 if (loadkeys) { 6837 ret = zfs_crypto_attempt_load_keys(g_zfs, newpool); 6838 if (ret != 0) 6839 ret = 1; 6840 } 6841 6842 if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL && 6843 zpool_enable_datasets(zhp, mntopts, 0) != 0) { 6844 ret = 1; 6845 (void) fprintf(stderr, gettext("Split was successful, but " 6846 "the datasets could not all be mounted\n")); 6847 (void) fprintf(stderr, gettext("Try doing '%s' with a " 6848 "different altroot\n"), "zpool import"); 6849 } 6850 zpool_close(zhp); 6851 nvlist_free(config); 6852 nvlist_free(props); 6853 6854 return (ret); 6855 } 6856 6857 6858 6859 /* 6860 * zpool online <pool> <device> ... 6861 */ 6862 int 6863 zpool_do_online(int argc, char **argv) 6864 { 6865 int c, i; 6866 char *poolname; 6867 zpool_handle_t *zhp; 6868 int ret = 0; 6869 vdev_state_t newstate; 6870 int flags = 0; 6871 6872 /* check options */ 6873 while ((c = getopt(argc, argv, "e")) != -1) { 6874 switch (c) { 6875 case 'e': 6876 flags |= ZFS_ONLINE_EXPAND; 6877 break; 6878 case '?': 6879 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 6880 optopt); 6881 usage(B_FALSE); 6882 } 6883 } 6884 6885 argc -= optind; 6886 argv += optind; 6887 6888 /* get pool name and check number of arguments */ 6889 if (argc < 1) { 6890 (void) fprintf(stderr, gettext("missing pool name\n")); 6891 usage(B_FALSE); 6892 } 6893 if (argc < 2) { 6894 (void) fprintf(stderr, gettext("missing device name\n")); 6895 usage(B_FALSE); 6896 } 6897 6898 poolname = argv[0]; 6899 6900 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 6901 return (1); 6902 6903 for (i = 1; i < argc; i++) { 6904 if (zpool_vdev_online(zhp, argv[i], flags, &newstate) == 0) { 6905 if (newstate != VDEV_STATE_HEALTHY) { 6906 (void) printf(gettext("warning: device '%s' " 6907 "onlined, but remains in faulted state\n"), 6908 argv[i]); 6909 if (newstate == VDEV_STATE_FAULTED) 6910 (void) printf(gettext("use 'zpool " 6911 "clear' to restore a faulted " 6912 "device\n")); 6913 else 6914 (void) printf(gettext("use 'zpool " 6915 "replace' to replace devices " 6916 "that are no longer present\n")); 6917 } 6918 } else { 6919 ret = 1; 6920 } 6921 } 6922 6923 zpool_close(zhp); 6924 6925 return (ret); 6926 } 6927 6928 /* 6929 * zpool offline [-ft] <pool> <device> ... 6930 * 6931 * -f Force the device into a faulted state. 6932 * 6933 * -t Only take the device off-line temporarily. The offline/faulted 6934 * state will not be persistent across reboots. 6935 */ 6936 int 6937 zpool_do_offline(int argc, char **argv) 6938 { 6939 int c, i; 6940 char *poolname; 6941 zpool_handle_t *zhp; 6942 int ret = 0; 6943 boolean_t istmp = B_FALSE; 6944 boolean_t fault = B_FALSE; 6945 6946 /* check options */ 6947 while ((c = getopt(argc, argv, "ft")) != -1) { 6948 switch (c) { 6949 case 'f': 6950 fault = B_TRUE; 6951 break; 6952 case 't': 6953 istmp = B_TRUE; 6954 break; 6955 case '?': 6956 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 6957 optopt); 6958 usage(B_FALSE); 6959 } 6960 } 6961 6962 argc -= optind; 6963 argv += optind; 6964 6965 /* get pool name and check number of arguments */ 6966 if (argc < 1) { 6967 (void) fprintf(stderr, gettext("missing pool name\n")); 6968 usage(B_FALSE); 6969 } 6970 if (argc < 2) { 6971 (void) fprintf(stderr, gettext("missing device name\n")); 6972 usage(B_FALSE); 6973 } 6974 6975 poolname = argv[0]; 6976 6977 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 6978 return (1); 6979 6980 for (i = 1; i < argc; i++) { 6981 if (fault) { 6982 uint64_t guid = zpool_vdev_path_to_guid(zhp, argv[i]); 6983 vdev_aux_t aux; 6984 if (istmp == B_FALSE) { 6985 /* Force the fault to persist across imports */ 6986 aux = VDEV_AUX_EXTERNAL_PERSIST; 6987 } else { 6988 aux = VDEV_AUX_EXTERNAL; 6989 } 6990 6991 if (guid == 0 || zpool_vdev_fault(zhp, guid, aux) != 0) 6992 ret = 1; 6993 } else { 6994 if (zpool_vdev_offline(zhp, argv[i], istmp) != 0) 6995 ret = 1; 6996 } 6997 } 6998 6999 zpool_close(zhp); 7000 7001 return (ret); 7002 } 7003 7004 /* 7005 * zpool clear <pool> [device] 7006 * 7007 * Clear all errors associated with a pool or a particular device. 7008 */ 7009 int 7010 zpool_do_clear(int argc, char **argv) 7011 { 7012 int c; 7013 int ret = 0; 7014 boolean_t dryrun = B_FALSE; 7015 boolean_t do_rewind = B_FALSE; 7016 boolean_t xtreme_rewind = B_FALSE; 7017 uint32_t rewind_policy = ZPOOL_NO_REWIND; 7018 nvlist_t *policy = NULL; 7019 zpool_handle_t *zhp; 7020 char *pool, *device; 7021 7022 /* check options */ 7023 while ((c = getopt(argc, argv, "FnX")) != -1) { 7024 switch (c) { 7025 case 'F': 7026 do_rewind = B_TRUE; 7027 break; 7028 case 'n': 7029 dryrun = B_TRUE; 7030 break; 7031 case 'X': 7032 xtreme_rewind = B_TRUE; 7033 break; 7034 case '?': 7035 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 7036 optopt); 7037 usage(B_FALSE); 7038 } 7039 } 7040 7041 argc -= optind; 7042 argv += optind; 7043 7044 if (argc < 1) { 7045 (void) fprintf(stderr, gettext("missing pool name\n")); 7046 usage(B_FALSE); 7047 } 7048 7049 if (argc > 2) { 7050 (void) fprintf(stderr, gettext("too many arguments\n")); 7051 usage(B_FALSE); 7052 } 7053 7054 if ((dryrun || xtreme_rewind) && !do_rewind) { 7055 (void) fprintf(stderr, 7056 gettext("-n or -X only meaningful with -F\n")); 7057 usage(B_FALSE); 7058 } 7059 if (dryrun) 7060 rewind_policy = ZPOOL_TRY_REWIND; 7061 else if (do_rewind) 7062 rewind_policy = ZPOOL_DO_REWIND; 7063 if (xtreme_rewind) 7064 rewind_policy |= ZPOOL_EXTREME_REWIND; 7065 7066 /* In future, further rewind policy choices can be passed along here */ 7067 if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 || 7068 nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, 7069 rewind_policy) != 0) { 7070 return (1); 7071 } 7072 7073 pool = argv[0]; 7074 device = argc == 2 ? argv[1] : NULL; 7075 7076 if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) { 7077 nvlist_free(policy); 7078 return (1); 7079 } 7080 7081 if (zpool_clear(zhp, device, policy) != 0) 7082 ret = 1; 7083 7084 zpool_close(zhp); 7085 7086 nvlist_free(policy); 7087 7088 return (ret); 7089 } 7090 7091 /* 7092 * zpool reguid <pool> 7093 */ 7094 int 7095 zpool_do_reguid(int argc, char **argv) 7096 { 7097 int c; 7098 char *poolname; 7099 zpool_handle_t *zhp; 7100 int ret = 0; 7101 7102 /* check options */ 7103 while ((c = getopt(argc, argv, "")) != -1) { 7104 switch (c) { 7105 case '?': 7106 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 7107 optopt); 7108 usage(B_FALSE); 7109 } 7110 } 7111 7112 argc -= optind; 7113 argv += optind; 7114 7115 /* get pool name and check number of arguments */ 7116 if (argc < 1) { 7117 (void) fprintf(stderr, gettext("missing pool name\n")); 7118 usage(B_FALSE); 7119 } 7120 7121 if (argc > 1) { 7122 (void) fprintf(stderr, gettext("too many arguments\n")); 7123 usage(B_FALSE); 7124 } 7125 7126 poolname = argv[0]; 7127 if ((zhp = zpool_open(g_zfs, poolname)) == NULL) 7128 return (1); 7129 7130 ret = zpool_reguid(zhp); 7131 7132 zpool_close(zhp); 7133 return (ret); 7134 } 7135 7136 7137 /* 7138 * zpool reopen <pool> 7139 * 7140 * Reopen the pool so that the kernel can update the sizes of all vdevs. 7141 */ 7142 int 7143 zpool_do_reopen(int argc, char **argv) 7144 { 7145 int c; 7146 int ret = 0; 7147 boolean_t scrub_restart = B_TRUE; 7148 7149 /* check options */ 7150 while ((c = getopt(argc, argv, "n")) != -1) { 7151 switch (c) { 7152 case 'n': 7153 scrub_restart = B_FALSE; 7154 break; 7155 case '?': 7156 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 7157 optopt); 7158 usage(B_FALSE); 7159 } 7160 } 7161 7162 argc -= optind; 7163 argv += optind; 7164 7165 /* if argc == 0 we will execute zpool_reopen_one on all pools */ 7166 ret = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 7167 B_FALSE, zpool_reopen_one, &scrub_restart); 7168 7169 return (ret); 7170 } 7171 7172 typedef struct scrub_cbdata { 7173 int cb_type; 7174 pool_scrub_cmd_t cb_scrub_cmd; 7175 } scrub_cbdata_t; 7176 7177 static boolean_t 7178 zpool_has_checkpoint(zpool_handle_t *zhp) 7179 { 7180 nvlist_t *config, *nvroot; 7181 7182 config = zpool_get_config(zhp, NULL); 7183 7184 if (config != NULL) { 7185 pool_checkpoint_stat_t *pcs = NULL; 7186 uint_t c; 7187 7188 nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 7189 (void) nvlist_lookup_uint64_array(nvroot, 7190 ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c); 7191 7192 if (pcs == NULL || pcs->pcs_state == CS_NONE) 7193 return (B_FALSE); 7194 7195 assert(pcs->pcs_state == CS_CHECKPOINT_EXISTS || 7196 pcs->pcs_state == CS_CHECKPOINT_DISCARDING); 7197 return (B_TRUE); 7198 } 7199 7200 return (B_FALSE); 7201 } 7202 7203 static int 7204 scrub_callback(zpool_handle_t *zhp, void *data) 7205 { 7206 scrub_cbdata_t *cb = data; 7207 int err; 7208 7209 /* 7210 * Ignore faulted pools. 7211 */ 7212 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 7213 (void) fprintf(stderr, gettext("cannot scan '%s': pool is " 7214 "currently unavailable\n"), zpool_get_name(zhp)); 7215 return (1); 7216 } 7217 7218 err = zpool_scan(zhp, cb->cb_type, cb->cb_scrub_cmd); 7219 7220 if (err == 0 && zpool_has_checkpoint(zhp) && 7221 cb->cb_type == POOL_SCAN_SCRUB) { 7222 (void) printf(gettext("warning: will not scrub state that " 7223 "belongs to the checkpoint of pool '%s'\n"), 7224 zpool_get_name(zhp)); 7225 } 7226 7227 return (err != 0); 7228 } 7229 7230 static int 7231 wait_callback(zpool_handle_t *zhp, void *data) 7232 { 7233 zpool_wait_activity_t *act = data; 7234 return (zpool_wait(zhp, *act)); 7235 } 7236 7237 /* 7238 * zpool scrub [-s | -p] [-w] <pool> ... 7239 * 7240 * -s Stop. Stops any in-progress scrub. 7241 * -p Pause. Pause in-progress scrub. 7242 * -w Wait. Blocks until scrub has completed. 7243 */ 7244 int 7245 zpool_do_scrub(int argc, char **argv) 7246 { 7247 int c; 7248 scrub_cbdata_t cb; 7249 boolean_t wait = B_FALSE; 7250 int error; 7251 7252 cb.cb_type = POOL_SCAN_SCRUB; 7253 cb.cb_scrub_cmd = POOL_SCRUB_NORMAL; 7254 7255 /* check options */ 7256 while ((c = getopt(argc, argv, "spw")) != -1) { 7257 switch (c) { 7258 case 's': 7259 cb.cb_type = POOL_SCAN_NONE; 7260 break; 7261 case 'p': 7262 cb.cb_scrub_cmd = POOL_SCRUB_PAUSE; 7263 break; 7264 case 'w': 7265 wait = B_TRUE; 7266 break; 7267 case '?': 7268 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 7269 optopt); 7270 usage(B_FALSE); 7271 } 7272 } 7273 7274 if (cb.cb_type == POOL_SCAN_NONE && 7275 cb.cb_scrub_cmd == POOL_SCRUB_PAUSE) { 7276 (void) fprintf(stderr, gettext("invalid option combination: " 7277 "-s and -p are mutually exclusive\n")); 7278 usage(B_FALSE); 7279 } 7280 7281 if (wait && (cb.cb_type == POOL_SCAN_NONE || 7282 cb.cb_scrub_cmd == POOL_SCRUB_PAUSE)) { 7283 (void) fprintf(stderr, gettext("invalid option combination: " 7284 "-w cannot be used with -p or -s\n")); 7285 usage(B_FALSE); 7286 } 7287 7288 argc -= optind; 7289 argv += optind; 7290 7291 if (argc < 1) { 7292 (void) fprintf(stderr, gettext("missing pool name argument\n")); 7293 usage(B_FALSE); 7294 } 7295 7296 error = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 7297 B_FALSE, scrub_callback, &cb); 7298 7299 if (wait && !error) { 7300 zpool_wait_activity_t act = ZPOOL_WAIT_SCRUB; 7301 error = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 7302 B_FALSE, wait_callback, &act); 7303 } 7304 7305 return (error); 7306 } 7307 7308 /* 7309 * zpool resilver <pool> ... 7310 * 7311 * Restarts any in-progress resilver 7312 */ 7313 int 7314 zpool_do_resilver(int argc, char **argv) 7315 { 7316 int c; 7317 scrub_cbdata_t cb; 7318 7319 cb.cb_type = POOL_SCAN_RESILVER; 7320 cb.cb_scrub_cmd = POOL_SCRUB_NORMAL; 7321 7322 /* check options */ 7323 while ((c = getopt(argc, argv, "")) != -1) { 7324 switch (c) { 7325 case '?': 7326 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 7327 optopt); 7328 usage(B_FALSE); 7329 } 7330 } 7331 7332 argc -= optind; 7333 argv += optind; 7334 7335 if (argc < 1) { 7336 (void) fprintf(stderr, gettext("missing pool name argument\n")); 7337 usage(B_FALSE); 7338 } 7339 7340 return (for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 7341 B_FALSE, scrub_callback, &cb)); 7342 } 7343 7344 /* 7345 * zpool trim [-d] [-r <rate>] [-c | -s] <pool> [<device> ...] 7346 * 7347 * -c Cancel. Ends any in-progress trim. 7348 * -d Secure trim. Requires kernel and device support. 7349 * -r <rate> Sets the TRIM rate in bytes (per second). Supports 7350 * adding a multiplier suffix such as 'k' or 'm'. 7351 * -s Suspend. TRIM can then be restarted with no flags. 7352 * -w Wait. Blocks until trimming has completed. 7353 */ 7354 int 7355 zpool_do_trim(int argc, char **argv) 7356 { 7357 struct option long_options[] = { 7358 {"cancel", no_argument, NULL, 'c'}, 7359 {"secure", no_argument, NULL, 'd'}, 7360 {"rate", required_argument, NULL, 'r'}, 7361 {"suspend", no_argument, NULL, 's'}, 7362 {"wait", no_argument, NULL, 'w'}, 7363 {0, 0, 0, 0} 7364 }; 7365 7366 pool_trim_func_t cmd_type = POOL_TRIM_START; 7367 uint64_t rate = 0; 7368 boolean_t secure = B_FALSE; 7369 boolean_t wait = B_FALSE; 7370 7371 int c; 7372 while ((c = getopt_long(argc, argv, "cdr:sw", long_options, NULL)) 7373 != -1) { 7374 switch (c) { 7375 case 'c': 7376 if (cmd_type != POOL_TRIM_START && 7377 cmd_type != POOL_TRIM_CANCEL) { 7378 (void) fprintf(stderr, gettext("-c cannot be " 7379 "combined with other options\n")); 7380 usage(B_FALSE); 7381 } 7382 cmd_type = POOL_TRIM_CANCEL; 7383 break; 7384 case 'd': 7385 if (cmd_type != POOL_TRIM_START) { 7386 (void) fprintf(stderr, gettext("-d cannot be " 7387 "combined with the -c or -s options\n")); 7388 usage(B_FALSE); 7389 } 7390 secure = B_TRUE; 7391 break; 7392 case 'r': 7393 if (cmd_type != POOL_TRIM_START) { 7394 (void) fprintf(stderr, gettext("-r cannot be " 7395 "combined with the -c or -s options\n")); 7396 usage(B_FALSE); 7397 } 7398 if (zfs_nicestrtonum(g_zfs, optarg, &rate) == -1) { 7399 (void) fprintf(stderr, "%s: %s\n", 7400 gettext("invalid value for rate"), 7401 libzfs_error_description(g_zfs)); 7402 usage(B_FALSE); 7403 } 7404 break; 7405 case 's': 7406 if (cmd_type != POOL_TRIM_START && 7407 cmd_type != POOL_TRIM_SUSPEND) { 7408 (void) fprintf(stderr, gettext("-s cannot be " 7409 "combined with other options\n")); 7410 usage(B_FALSE); 7411 } 7412 cmd_type = POOL_TRIM_SUSPEND; 7413 break; 7414 case 'w': 7415 wait = B_TRUE; 7416 break; 7417 case '?': 7418 if (optopt != 0) { 7419 (void) fprintf(stderr, 7420 gettext("invalid option '%c'\n"), optopt); 7421 } else { 7422 (void) fprintf(stderr, 7423 gettext("invalid option '%s'\n"), 7424 argv[optind - 1]); 7425 } 7426 usage(B_FALSE); 7427 } 7428 } 7429 7430 argc -= optind; 7431 argv += optind; 7432 7433 if (argc < 1) { 7434 (void) fprintf(stderr, gettext("missing pool name argument\n")); 7435 usage(B_FALSE); 7436 return (-1); 7437 } 7438 7439 if (wait && (cmd_type != POOL_TRIM_START)) { 7440 (void) fprintf(stderr, gettext("-w cannot be used with -c or " 7441 "-s\n")); 7442 usage(B_FALSE); 7443 } 7444 7445 char *poolname = argv[0]; 7446 zpool_handle_t *zhp = zpool_open(g_zfs, poolname); 7447 if (zhp == NULL) 7448 return (-1); 7449 7450 trimflags_t trim_flags = { 7451 .secure = secure, 7452 .rate = rate, 7453 .wait = wait, 7454 }; 7455 7456 nvlist_t *vdevs = fnvlist_alloc(); 7457 if (argc == 1) { 7458 /* no individual leaf vdevs specified, so add them all */ 7459 nvlist_t *config = zpool_get_config(zhp, NULL); 7460 nvlist_t *nvroot = fnvlist_lookup_nvlist(config, 7461 ZPOOL_CONFIG_VDEV_TREE); 7462 zpool_collect_leaves(zhp, nvroot, vdevs); 7463 trim_flags.fullpool = B_TRUE; 7464 } else { 7465 trim_flags.fullpool = B_FALSE; 7466 for (int i = 1; i < argc; i++) { 7467 fnvlist_add_boolean(vdevs, argv[i]); 7468 } 7469 } 7470 7471 int error = zpool_trim(zhp, cmd_type, vdevs, &trim_flags); 7472 7473 fnvlist_free(vdevs); 7474 zpool_close(zhp); 7475 7476 return (error); 7477 } 7478 7479 /* 7480 * Converts a total number of seconds to a human readable string broken 7481 * down in to days/hours/minutes/seconds. 7482 */ 7483 static void 7484 secs_to_dhms(uint64_t total, char *buf) 7485 { 7486 uint64_t days = total / 60 / 60 / 24; 7487 uint64_t hours = (total / 60 / 60) % 24; 7488 uint64_t mins = (total / 60) % 60; 7489 uint64_t secs = (total % 60); 7490 7491 if (days > 0) { 7492 (void) sprintf(buf, "%llu days %02llu:%02llu:%02llu", 7493 (u_longlong_t)days, (u_longlong_t)hours, 7494 (u_longlong_t)mins, (u_longlong_t)secs); 7495 } else { 7496 (void) sprintf(buf, "%02llu:%02llu:%02llu", 7497 (u_longlong_t)hours, (u_longlong_t)mins, 7498 (u_longlong_t)secs); 7499 } 7500 } 7501 7502 /* 7503 * Print out detailed scrub status. 7504 */ 7505 static void 7506 print_scan_scrub_resilver_status(pool_scan_stat_t *ps) 7507 { 7508 time_t start, end, pause; 7509 uint64_t pass_scanned, scanned, pass_issued, issued, total; 7510 uint64_t elapsed, scan_rate, issue_rate; 7511 double fraction_done; 7512 char processed_buf[7], scanned_buf[7], issued_buf[7], total_buf[7]; 7513 char srate_buf[7], irate_buf[7], time_buf[32]; 7514 7515 printf(" "); 7516 printf_color(ANSI_BOLD, gettext("scan:")); 7517 printf(" "); 7518 7519 /* If there's never been a scan, there's not much to say. */ 7520 if (ps == NULL || ps->pss_func == POOL_SCAN_NONE || 7521 ps->pss_func >= POOL_SCAN_FUNCS) { 7522 (void) printf(gettext("none requested\n")); 7523 return; 7524 } 7525 7526 start = ps->pss_start_time; 7527 end = ps->pss_end_time; 7528 pause = ps->pss_pass_scrub_pause; 7529 7530 zfs_nicebytes(ps->pss_processed, processed_buf, sizeof (processed_buf)); 7531 7532 assert(ps->pss_func == POOL_SCAN_SCRUB || 7533 ps->pss_func == POOL_SCAN_RESILVER); 7534 7535 /* Scan is finished or canceled. */ 7536 if (ps->pss_state == DSS_FINISHED) { 7537 secs_to_dhms(end - start, time_buf); 7538 7539 if (ps->pss_func == POOL_SCAN_SCRUB) { 7540 (void) printf(gettext("scrub repaired %s " 7541 "in %s with %llu errors on %s"), processed_buf, 7542 time_buf, (u_longlong_t)ps->pss_errors, 7543 ctime(&end)); 7544 } else if (ps->pss_func == POOL_SCAN_RESILVER) { 7545 (void) printf(gettext("resilvered %s " 7546 "in %s with %llu errors on %s"), processed_buf, 7547 time_buf, (u_longlong_t)ps->pss_errors, 7548 ctime(&end)); 7549 } 7550 return; 7551 } else if (ps->pss_state == DSS_CANCELED) { 7552 if (ps->pss_func == POOL_SCAN_SCRUB) { 7553 (void) printf(gettext("scrub canceled on %s"), 7554 ctime(&end)); 7555 } else if (ps->pss_func == POOL_SCAN_RESILVER) { 7556 (void) printf(gettext("resilver canceled on %s"), 7557 ctime(&end)); 7558 } 7559 return; 7560 } 7561 7562 assert(ps->pss_state == DSS_SCANNING); 7563 7564 /* Scan is in progress. Resilvers can't be paused. */ 7565 if (ps->pss_func == POOL_SCAN_SCRUB) { 7566 if (pause == 0) { 7567 (void) printf(gettext("scrub in progress since %s"), 7568 ctime(&start)); 7569 } else { 7570 (void) printf(gettext("scrub paused since %s"), 7571 ctime(&pause)); 7572 (void) printf(gettext("\tscrub started on %s"), 7573 ctime(&start)); 7574 } 7575 } else if (ps->pss_func == POOL_SCAN_RESILVER) { 7576 (void) printf(gettext("resilver in progress since %s"), 7577 ctime(&start)); 7578 } 7579 7580 scanned = ps->pss_examined; 7581 pass_scanned = ps->pss_pass_exam; 7582 issued = ps->pss_issued; 7583 pass_issued = ps->pss_pass_issued; 7584 total = ps->pss_to_examine; 7585 7586 /* we are only done with a block once we have issued the IO for it */ 7587 fraction_done = (double)issued / total; 7588 7589 /* elapsed time for this pass, rounding up to 1 if it's 0 */ 7590 elapsed = time(NULL) - ps->pss_pass_start; 7591 elapsed -= ps->pss_pass_scrub_spent_paused; 7592 elapsed = (elapsed != 0) ? elapsed : 1; 7593 7594 scan_rate = pass_scanned / elapsed; 7595 issue_rate = pass_issued / elapsed; 7596 uint64_t total_secs_left = (issue_rate != 0 && total >= issued) ? 7597 ((total - issued) / issue_rate) : UINT64_MAX; 7598 secs_to_dhms(total_secs_left, time_buf); 7599 7600 /* format all of the numbers we will be reporting */ 7601 zfs_nicebytes(scanned, scanned_buf, sizeof (scanned_buf)); 7602 zfs_nicebytes(issued, issued_buf, sizeof (issued_buf)); 7603 zfs_nicebytes(total, total_buf, sizeof (total_buf)); 7604 zfs_nicebytes(scan_rate, srate_buf, sizeof (srate_buf)); 7605 zfs_nicebytes(issue_rate, irate_buf, sizeof (irate_buf)); 7606 7607 /* do not print estimated time if we have a paused scrub */ 7608 if (pause == 0) { 7609 (void) printf(gettext("\t%s scanned at %s/s, " 7610 "%s issued at %s/s, %s total\n"), 7611 scanned_buf, srate_buf, issued_buf, irate_buf, total_buf); 7612 } else { 7613 (void) printf(gettext("\t%s scanned, %s issued, %s total\n"), 7614 scanned_buf, issued_buf, total_buf); 7615 } 7616 7617 if (ps->pss_func == POOL_SCAN_RESILVER) { 7618 (void) printf(gettext("\t%s resilvered, %.2f%% done"), 7619 processed_buf, 100 * fraction_done); 7620 } else if (ps->pss_func == POOL_SCAN_SCRUB) { 7621 (void) printf(gettext("\t%s repaired, %.2f%% done"), 7622 processed_buf, 100 * fraction_done); 7623 } 7624 7625 if (pause == 0) { 7626 if (total_secs_left != UINT64_MAX && 7627 issue_rate >= 10 * 1024 * 1024) { 7628 (void) printf(gettext(", %s to go\n"), time_buf); 7629 } else { 7630 (void) printf(gettext(", no estimated " 7631 "completion time\n")); 7632 } 7633 } else { 7634 (void) printf(gettext("\n")); 7635 } 7636 } 7637 7638 static void 7639 print_rebuild_status_impl(vdev_rebuild_stat_t *vrs, char *vdev_name) 7640 { 7641 if (vrs == NULL || vrs->vrs_state == VDEV_REBUILD_NONE) 7642 return; 7643 7644 printf(" "); 7645 printf_color(ANSI_BOLD, gettext("scan:")); 7646 printf(" "); 7647 7648 uint64_t bytes_scanned = vrs->vrs_bytes_scanned; 7649 uint64_t bytes_issued = vrs->vrs_bytes_issued; 7650 uint64_t bytes_rebuilt = vrs->vrs_bytes_rebuilt; 7651 uint64_t bytes_est = vrs->vrs_bytes_est; 7652 uint64_t scan_rate = (vrs->vrs_pass_bytes_scanned / 7653 (vrs->vrs_pass_time_ms + 1)) * 1000; 7654 uint64_t issue_rate = (vrs->vrs_pass_bytes_issued / 7655 (vrs->vrs_pass_time_ms + 1)) * 1000; 7656 double scan_pct = MIN((double)bytes_scanned * 100 / 7657 (bytes_est + 1), 100); 7658 7659 /* Format all of the numbers we will be reporting */ 7660 char bytes_scanned_buf[7], bytes_issued_buf[7]; 7661 char bytes_rebuilt_buf[7], bytes_est_buf[7]; 7662 char scan_rate_buf[7], issue_rate_buf[7], time_buf[32]; 7663 zfs_nicebytes(bytes_scanned, bytes_scanned_buf, 7664 sizeof (bytes_scanned_buf)); 7665 zfs_nicebytes(bytes_issued, bytes_issued_buf, 7666 sizeof (bytes_issued_buf)); 7667 zfs_nicebytes(bytes_rebuilt, bytes_rebuilt_buf, 7668 sizeof (bytes_rebuilt_buf)); 7669 zfs_nicebytes(bytes_est, bytes_est_buf, sizeof (bytes_est_buf)); 7670 zfs_nicebytes(scan_rate, scan_rate_buf, sizeof (scan_rate_buf)); 7671 zfs_nicebytes(issue_rate, issue_rate_buf, sizeof (issue_rate_buf)); 7672 7673 time_t start = vrs->vrs_start_time; 7674 time_t end = vrs->vrs_end_time; 7675 7676 /* Rebuild is finished or canceled. */ 7677 if (vrs->vrs_state == VDEV_REBUILD_COMPLETE) { 7678 secs_to_dhms(vrs->vrs_scan_time_ms / 1000, time_buf); 7679 (void) printf(gettext("resilvered (%s) %s in %s " 7680 "with %llu errors on %s"), vdev_name, bytes_rebuilt_buf, 7681 time_buf, (u_longlong_t)vrs->vrs_errors, ctime(&end)); 7682 return; 7683 } else if (vrs->vrs_state == VDEV_REBUILD_CANCELED) { 7684 (void) printf(gettext("resilver (%s) canceled on %s"), 7685 vdev_name, ctime(&end)); 7686 return; 7687 } else if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) { 7688 (void) printf(gettext("resilver (%s) in progress since %s"), 7689 vdev_name, ctime(&start)); 7690 } 7691 7692 assert(vrs->vrs_state == VDEV_REBUILD_ACTIVE); 7693 7694 secs_to_dhms(MAX((int64_t)bytes_est - (int64_t)bytes_scanned, 0) / 7695 MAX(scan_rate, 1), time_buf); 7696 7697 (void) printf(gettext("\t%s scanned at %s/s, %s issued %s/s, " 7698 "%s total\n"), bytes_scanned_buf, scan_rate_buf, 7699 bytes_issued_buf, issue_rate_buf, bytes_est_buf); 7700 (void) printf(gettext("\t%s resilvered, %.2f%% done"), 7701 bytes_rebuilt_buf, scan_pct); 7702 7703 if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) { 7704 if (scan_rate >= 10 * 1024 * 1024) { 7705 (void) printf(gettext(", %s to go\n"), time_buf); 7706 } else { 7707 (void) printf(gettext(", no estimated " 7708 "completion time\n")); 7709 } 7710 } else { 7711 (void) printf(gettext("\n")); 7712 } 7713 } 7714 7715 /* 7716 * Print rebuild status for top-level vdevs. 7717 */ 7718 static void 7719 print_rebuild_status(zpool_handle_t *zhp, nvlist_t *nvroot) 7720 { 7721 nvlist_t **child; 7722 uint_t children; 7723 7724 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 7725 &child, &children) != 0) 7726 children = 0; 7727 7728 for (uint_t c = 0; c < children; c++) { 7729 vdev_rebuild_stat_t *vrs; 7730 uint_t i; 7731 7732 if (nvlist_lookup_uint64_array(child[c], 7733 ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs, &i) == 0) { 7734 char *name = zpool_vdev_name(g_zfs, zhp, 7735 child[c], VDEV_NAME_TYPE_ID); 7736 print_rebuild_status_impl(vrs, name); 7737 free(name); 7738 } 7739 } 7740 } 7741 7742 /* 7743 * As we don't scrub checkpointed blocks, we want to warn the user that we 7744 * skipped scanning some blocks if a checkpoint exists or existed at any 7745 * time during the scan. If a sequential instead of healing reconstruction 7746 * was performed then the blocks were reconstructed. However, their checksums 7747 * have not been verified so we still print the warning. 7748 */ 7749 static void 7750 print_checkpoint_scan_warning(pool_scan_stat_t *ps, pool_checkpoint_stat_t *pcs) 7751 { 7752 if (ps == NULL || pcs == NULL) 7753 return; 7754 7755 if (pcs->pcs_state == CS_NONE || 7756 pcs->pcs_state == CS_CHECKPOINT_DISCARDING) 7757 return; 7758 7759 assert(pcs->pcs_state == CS_CHECKPOINT_EXISTS); 7760 7761 if (ps->pss_state == DSS_NONE) 7762 return; 7763 7764 if ((ps->pss_state == DSS_FINISHED || ps->pss_state == DSS_CANCELED) && 7765 ps->pss_end_time < pcs->pcs_start_time) 7766 return; 7767 7768 if (ps->pss_state == DSS_FINISHED || ps->pss_state == DSS_CANCELED) { 7769 (void) printf(gettext(" scan warning: skipped blocks " 7770 "that are only referenced by the checkpoint.\n")); 7771 } else { 7772 assert(ps->pss_state == DSS_SCANNING); 7773 (void) printf(gettext(" scan warning: skipping blocks " 7774 "that are only referenced by the checkpoint.\n")); 7775 } 7776 } 7777 7778 /* 7779 * Returns B_TRUE if there is an active rebuild in progress. Otherwise, 7780 * B_FALSE is returned and 'rebuild_end_time' is set to the end time for 7781 * the last completed (or cancelled) rebuild. 7782 */ 7783 static boolean_t 7784 check_rebuilding(nvlist_t *nvroot, uint64_t *rebuild_end_time) 7785 { 7786 nvlist_t **child; 7787 uint_t children; 7788 boolean_t rebuilding = B_FALSE; 7789 uint64_t end_time = 0; 7790 7791 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 7792 &child, &children) != 0) 7793 children = 0; 7794 7795 for (uint_t c = 0; c < children; c++) { 7796 vdev_rebuild_stat_t *vrs; 7797 uint_t i; 7798 7799 if (nvlist_lookup_uint64_array(child[c], 7800 ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs, &i) == 0) { 7801 7802 if (vrs->vrs_end_time > end_time) 7803 end_time = vrs->vrs_end_time; 7804 7805 if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) { 7806 rebuilding = B_TRUE; 7807 end_time = 0; 7808 break; 7809 } 7810 } 7811 } 7812 7813 if (rebuild_end_time != NULL) 7814 *rebuild_end_time = end_time; 7815 7816 return (rebuilding); 7817 } 7818 7819 /* 7820 * Print the scan status. 7821 */ 7822 static void 7823 print_scan_status(zpool_handle_t *zhp, nvlist_t *nvroot) 7824 { 7825 uint64_t rebuild_end_time = 0, resilver_end_time = 0; 7826 boolean_t have_resilver = B_FALSE, have_scrub = B_FALSE; 7827 boolean_t active_resilver = B_FALSE; 7828 pool_checkpoint_stat_t *pcs = NULL; 7829 pool_scan_stat_t *ps = NULL; 7830 uint_t c; 7831 7832 if (nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS, 7833 (uint64_t **)&ps, &c) == 0) { 7834 if (ps->pss_func == POOL_SCAN_RESILVER) { 7835 resilver_end_time = ps->pss_end_time; 7836 active_resilver = (ps->pss_state == DSS_SCANNING); 7837 } 7838 7839 have_resilver = (ps->pss_func == POOL_SCAN_RESILVER); 7840 have_scrub = (ps->pss_func == POOL_SCAN_SCRUB); 7841 } 7842 7843 boolean_t active_rebuild = check_rebuilding(nvroot, &rebuild_end_time); 7844 boolean_t have_rebuild = (active_rebuild || (rebuild_end_time > 0)); 7845 7846 /* Always print the scrub status when available. */ 7847 if (have_scrub) 7848 print_scan_scrub_resilver_status(ps); 7849 7850 /* 7851 * When there is an active resilver or rebuild print its status. 7852 * Otherwise print the status of the last resilver or rebuild. 7853 */ 7854 if (active_resilver || (!active_rebuild && have_resilver && 7855 resilver_end_time && resilver_end_time > rebuild_end_time)) { 7856 print_scan_scrub_resilver_status(ps); 7857 } else if (active_rebuild || (!active_resilver && have_rebuild && 7858 rebuild_end_time && rebuild_end_time > resilver_end_time)) { 7859 print_rebuild_status(zhp, nvroot); 7860 } 7861 7862 (void) nvlist_lookup_uint64_array(nvroot, 7863 ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c); 7864 print_checkpoint_scan_warning(ps, pcs); 7865 } 7866 7867 /* 7868 * Print out detailed removal status. 7869 */ 7870 static void 7871 print_removal_status(zpool_handle_t *zhp, pool_removal_stat_t *prs) 7872 { 7873 char copied_buf[7], examined_buf[7], total_buf[7], rate_buf[7]; 7874 time_t start, end; 7875 nvlist_t *config, *nvroot; 7876 nvlist_t **child; 7877 uint_t children; 7878 char *vdev_name; 7879 7880 if (prs == NULL || prs->prs_state == DSS_NONE) 7881 return; 7882 7883 /* 7884 * Determine name of vdev. 7885 */ 7886 config = zpool_get_config(zhp, NULL); 7887 nvroot = fnvlist_lookup_nvlist(config, 7888 ZPOOL_CONFIG_VDEV_TREE); 7889 verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 7890 &child, &children) == 0); 7891 assert(prs->prs_removing_vdev < children); 7892 vdev_name = zpool_vdev_name(g_zfs, zhp, 7893 child[prs->prs_removing_vdev], B_TRUE); 7894 7895 printf_color(ANSI_BOLD, gettext("remove: ")); 7896 7897 start = prs->prs_start_time; 7898 end = prs->prs_end_time; 7899 zfs_nicenum(prs->prs_copied, copied_buf, sizeof (copied_buf)); 7900 7901 /* 7902 * Removal is finished or canceled. 7903 */ 7904 if (prs->prs_state == DSS_FINISHED) { 7905 uint64_t minutes_taken = (end - start) / 60; 7906 7907 (void) printf(gettext("Removal of vdev %llu copied %s " 7908 "in %lluh%um, completed on %s"), 7909 (longlong_t)prs->prs_removing_vdev, 7910 copied_buf, 7911 (u_longlong_t)(minutes_taken / 60), 7912 (uint_t)(minutes_taken % 60), 7913 ctime((time_t *)&end)); 7914 } else if (prs->prs_state == DSS_CANCELED) { 7915 (void) printf(gettext("Removal of %s canceled on %s"), 7916 vdev_name, ctime(&end)); 7917 } else { 7918 uint64_t copied, total, elapsed, mins_left, hours_left; 7919 double fraction_done; 7920 uint_t rate; 7921 7922 assert(prs->prs_state == DSS_SCANNING); 7923 7924 /* 7925 * Removal is in progress. 7926 */ 7927 (void) printf(gettext( 7928 "Evacuation of %s in progress since %s"), 7929 vdev_name, ctime(&start)); 7930 7931 copied = prs->prs_copied > 0 ? prs->prs_copied : 1; 7932 total = prs->prs_to_copy; 7933 fraction_done = (double)copied / total; 7934 7935 /* elapsed time for this pass */ 7936 elapsed = time(NULL) - prs->prs_start_time; 7937 elapsed = elapsed > 0 ? elapsed : 1; 7938 rate = copied / elapsed; 7939 rate = rate > 0 ? rate : 1; 7940 mins_left = ((total - copied) / rate) / 60; 7941 hours_left = mins_left / 60; 7942 7943 zfs_nicenum(copied, examined_buf, sizeof (examined_buf)); 7944 zfs_nicenum(total, total_buf, sizeof (total_buf)); 7945 zfs_nicenum(rate, rate_buf, sizeof (rate_buf)); 7946 7947 /* 7948 * do not print estimated time if hours_left is more than 7949 * 30 days 7950 */ 7951 (void) printf(gettext( 7952 "\t%s copied out of %s at %s/s, %.2f%% done"), 7953 examined_buf, total_buf, rate_buf, 100 * fraction_done); 7954 if (hours_left < (30 * 24)) { 7955 (void) printf(gettext(", %lluh%um to go\n"), 7956 (u_longlong_t)hours_left, (uint_t)(mins_left % 60)); 7957 } else { 7958 (void) printf(gettext( 7959 ", (copy is slow, no estimated time)\n")); 7960 } 7961 } 7962 free(vdev_name); 7963 7964 if (prs->prs_mapping_memory > 0) { 7965 char mem_buf[7]; 7966 zfs_nicenum(prs->prs_mapping_memory, mem_buf, sizeof (mem_buf)); 7967 (void) printf(gettext( 7968 "\t%s memory used for removed device mappings\n"), 7969 mem_buf); 7970 } 7971 } 7972 7973 static void 7974 print_checkpoint_status(pool_checkpoint_stat_t *pcs) 7975 { 7976 time_t start; 7977 char space_buf[7]; 7978 7979 if (pcs == NULL || pcs->pcs_state == CS_NONE) 7980 return; 7981 7982 (void) printf(gettext("checkpoint: ")); 7983 7984 start = pcs->pcs_start_time; 7985 zfs_nicenum(pcs->pcs_space, space_buf, sizeof (space_buf)); 7986 7987 if (pcs->pcs_state == CS_CHECKPOINT_EXISTS) { 7988 char *date = ctime(&start); 7989 7990 /* 7991 * ctime() adds a newline at the end of the generated 7992 * string, thus the weird format specifier and the 7993 * strlen() call used to chop it off from the output. 7994 */ 7995 (void) printf(gettext("created %.*s, consumes %s\n"), 7996 (int)(strlen(date) - 1), date, space_buf); 7997 return; 7998 } 7999 8000 assert(pcs->pcs_state == CS_CHECKPOINT_DISCARDING); 8001 8002 (void) printf(gettext("discarding, %s remaining.\n"), 8003 space_buf); 8004 } 8005 8006 static void 8007 print_error_log(zpool_handle_t *zhp) 8008 { 8009 nvlist_t *nverrlist = NULL; 8010 nvpair_t *elem; 8011 char *pathname; 8012 size_t len = MAXPATHLEN * 2; 8013 8014 if (zpool_get_errlog(zhp, &nverrlist) != 0) 8015 return; 8016 8017 (void) printf("errors: Permanent errors have been " 8018 "detected in the following files:\n\n"); 8019 8020 pathname = safe_malloc(len); 8021 elem = NULL; 8022 while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) { 8023 nvlist_t *nv; 8024 uint64_t dsobj, obj; 8025 8026 verify(nvpair_value_nvlist(elem, &nv) == 0); 8027 verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET, 8028 &dsobj) == 0); 8029 verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT, 8030 &obj) == 0); 8031 zpool_obj_to_path(zhp, dsobj, obj, pathname, len); 8032 (void) printf("%7s %s\n", "", pathname); 8033 } 8034 free(pathname); 8035 nvlist_free(nverrlist); 8036 } 8037 8038 static void 8039 print_spares(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t **spares, 8040 uint_t nspares) 8041 { 8042 uint_t i; 8043 char *name; 8044 8045 if (nspares == 0) 8046 return; 8047 8048 (void) printf(gettext("\tspares\n")); 8049 8050 for (i = 0; i < nspares; i++) { 8051 name = zpool_vdev_name(g_zfs, zhp, spares[i], 8052 cb->cb_name_flags); 8053 print_status_config(zhp, cb, name, spares[i], 2, B_TRUE, NULL); 8054 free(name); 8055 } 8056 } 8057 8058 static void 8059 print_l2cache(zpool_handle_t *zhp, status_cbdata_t *cb, nvlist_t **l2cache, 8060 uint_t nl2cache) 8061 { 8062 uint_t i; 8063 char *name; 8064 8065 if (nl2cache == 0) 8066 return; 8067 8068 (void) printf(gettext("\tcache\n")); 8069 8070 for (i = 0; i < nl2cache; i++) { 8071 name = zpool_vdev_name(g_zfs, zhp, l2cache[i], 8072 cb->cb_name_flags); 8073 print_status_config(zhp, cb, name, l2cache[i], 2, 8074 B_FALSE, NULL); 8075 free(name); 8076 } 8077 } 8078 8079 static void 8080 print_dedup_stats(nvlist_t *config) 8081 { 8082 ddt_histogram_t *ddh; 8083 ddt_stat_t *dds; 8084 ddt_object_t *ddo; 8085 uint_t c; 8086 char dspace[6], mspace[6]; 8087 8088 /* 8089 * If the pool was faulted then we may not have been able to 8090 * obtain the config. Otherwise, if we have anything in the dedup 8091 * table continue processing the stats. 8092 */ 8093 if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_OBJ_STATS, 8094 (uint64_t **)&ddo, &c) != 0) 8095 return; 8096 8097 (void) printf("\n"); 8098 (void) printf(gettext(" dedup: ")); 8099 if (ddo->ddo_count == 0) { 8100 (void) printf(gettext("no DDT entries\n")); 8101 return; 8102 } 8103 8104 zfs_nicebytes(ddo->ddo_dspace, dspace, sizeof (dspace)); 8105 zfs_nicebytes(ddo->ddo_mspace, mspace, sizeof (mspace)); 8106 (void) printf("DDT entries %llu, size %s on disk, %s in core\n", 8107 (u_longlong_t)ddo->ddo_count, 8108 dspace, 8109 mspace); 8110 8111 verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS, 8112 (uint64_t **)&dds, &c) == 0); 8113 verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_HISTOGRAM, 8114 (uint64_t **)&ddh, &c) == 0); 8115 zpool_dump_ddt(dds, ddh); 8116 } 8117 8118 /* 8119 * Display a summary of pool status. Displays a summary such as: 8120 * 8121 * pool: tank 8122 * status: DEGRADED 8123 * reason: One or more devices ... 8124 * see: https://openzfs.github.io/openzfs-docs/msg/ZFS-xxxx-01 8125 * config: 8126 * mirror DEGRADED 8127 * c1t0d0 OK 8128 * c2t0d0 UNAVAIL 8129 * 8130 * When given the '-v' option, we print out the complete config. If the '-e' 8131 * option is specified, then we print out error rate information as well. 8132 */ 8133 static int 8134 status_callback(zpool_handle_t *zhp, void *data) 8135 { 8136 status_cbdata_t *cbp = data; 8137 nvlist_t *config, *nvroot; 8138 char *msgid; 8139 zpool_status_t reason; 8140 zpool_errata_t errata; 8141 const char *health; 8142 uint_t c; 8143 vdev_stat_t *vs; 8144 8145 config = zpool_get_config(zhp, NULL); 8146 reason = zpool_get_status(zhp, &msgid, &errata); 8147 8148 cbp->cb_count++; 8149 8150 /* 8151 * If we were given 'zpool status -x', only report those pools with 8152 * problems. 8153 */ 8154 if (cbp->cb_explain && 8155 (reason == ZPOOL_STATUS_OK || 8156 reason == ZPOOL_STATUS_VERSION_OLDER || 8157 reason == ZPOOL_STATUS_FEAT_DISABLED || 8158 reason == ZPOOL_STATUS_COMPATIBILITY_ERR || 8159 reason == ZPOOL_STATUS_INCOMPATIBLE_FEAT)) { 8160 if (!cbp->cb_allpools) { 8161 (void) printf(gettext("pool '%s' is healthy\n"), 8162 zpool_get_name(zhp)); 8163 if (cbp->cb_first) 8164 cbp->cb_first = B_FALSE; 8165 } 8166 return (0); 8167 } 8168 8169 if (cbp->cb_first) 8170 cbp->cb_first = B_FALSE; 8171 else 8172 (void) printf("\n"); 8173 8174 nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 8175 verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS, 8176 (uint64_t **)&vs, &c) == 0); 8177 8178 health = zpool_get_state_str(zhp); 8179 8180 printf(" "); 8181 printf_color(ANSI_BOLD, gettext("pool:")); 8182 printf(" %s\n", zpool_get_name(zhp)); 8183 printf(" "); 8184 printf_color(ANSI_BOLD, gettext("state: ")); 8185 8186 printf_color(health_str_to_color(health), "%s", health); 8187 8188 printf("\n"); 8189 8190 switch (reason) { 8191 case ZPOOL_STATUS_MISSING_DEV_R: 8192 printf_color(ANSI_BOLD, gettext("status: ")); 8193 printf_color(ANSI_YELLOW, gettext("One or more devices could " 8194 "not be opened. Sufficient replicas exist for\n\tthe pool " 8195 "to continue functioning in a degraded state.\n")); 8196 printf_color(ANSI_BOLD, gettext("action: ")); 8197 printf_color(ANSI_YELLOW, gettext("Attach the missing device " 8198 "and online it using 'zpool online'.\n")); 8199 break; 8200 8201 case ZPOOL_STATUS_MISSING_DEV_NR: 8202 printf_color(ANSI_BOLD, gettext("status: ")); 8203 printf_color(ANSI_YELLOW, gettext("One or more devices could " 8204 "not be opened. There are insufficient\n\treplicas for the" 8205 " pool to continue functioning.\n")); 8206 printf_color(ANSI_BOLD, gettext("action: ")); 8207 printf_color(ANSI_YELLOW, gettext("Attach the missing device " 8208 "and online it using 'zpool online'.\n")); 8209 break; 8210 8211 case ZPOOL_STATUS_CORRUPT_LABEL_R: 8212 printf_color(ANSI_BOLD, gettext("status: ")); 8213 printf_color(ANSI_YELLOW, gettext("One or more devices could " 8214 "not be used because the label is missing or\n\tinvalid. " 8215 "Sufficient replicas exist for the pool to continue\n\t" 8216 "functioning in a degraded state.\n")); 8217 printf_color(ANSI_BOLD, gettext("action: ")); 8218 printf_color(ANSI_YELLOW, gettext("Replace the device using " 8219 "'zpool replace'.\n")); 8220 break; 8221 8222 case ZPOOL_STATUS_CORRUPT_LABEL_NR: 8223 printf_color(ANSI_BOLD, gettext("status: ")); 8224 printf_color(ANSI_YELLOW, gettext("One or more devices could " 8225 "not be used because the label is missing \n\tor invalid. " 8226 "There are insufficient replicas for the pool to " 8227 "continue\n\tfunctioning.\n")); 8228 zpool_explain_recover(zpool_get_handle(zhp), 8229 zpool_get_name(zhp), reason, config); 8230 break; 8231 8232 case ZPOOL_STATUS_FAILING_DEV: 8233 printf_color(ANSI_BOLD, gettext("status: ")); 8234 printf_color(ANSI_YELLOW, gettext("One or more devices has " 8235 "experienced an unrecoverable error. An\n\tattempt was " 8236 "made to correct the error. Applications are " 8237 "unaffected.\n")); 8238 printf_color(ANSI_BOLD, gettext("action: ")); 8239 printf_color(ANSI_YELLOW, gettext("Determine if the " 8240 "device needs to be replaced, and clear the errors\n\tusing" 8241 " 'zpool clear' or replace the device with 'zpool " 8242 "replace'.\n")); 8243 break; 8244 8245 case ZPOOL_STATUS_OFFLINE_DEV: 8246 printf_color(ANSI_BOLD, gettext("status: ")); 8247 printf_color(ANSI_YELLOW, gettext("One or more devices has " 8248 "been taken offline by the administrator.\n\tSufficient " 8249 "replicas exist for the pool to continue functioning in " 8250 "a\n\tdegraded state.\n")); 8251 printf_color(ANSI_BOLD, gettext("action: ")); 8252 printf_color(ANSI_YELLOW, gettext("Online the device " 8253 "using 'zpool online' or replace the device with\n\t'zpool " 8254 "replace'.\n")); 8255 break; 8256 8257 case ZPOOL_STATUS_REMOVED_DEV: 8258 printf_color(ANSI_BOLD, gettext("status: ")); 8259 printf_color(ANSI_YELLOW, gettext("One or more devices has " 8260 "been removed by the administrator.\n\tSufficient " 8261 "replicas exist for the pool to continue functioning in " 8262 "a\n\tdegraded state.\n")); 8263 printf_color(ANSI_BOLD, gettext("action: ")); 8264 printf_color(ANSI_YELLOW, gettext("Online the device " 8265 "using zpool online' or replace the device with\n\t'zpool " 8266 "replace'.\n")); 8267 break; 8268 8269 case ZPOOL_STATUS_RESILVERING: 8270 case ZPOOL_STATUS_REBUILDING: 8271 printf_color(ANSI_BOLD, gettext("status: ")); 8272 printf_color(ANSI_YELLOW, gettext("One or more devices is " 8273 "currently being resilvered. The pool will\n\tcontinue " 8274 "to function, possibly in a degraded state.\n")); 8275 printf_color(ANSI_BOLD, gettext("action: ")); 8276 printf_color(ANSI_YELLOW, gettext("Wait for the resilver to " 8277 "complete.\n")); 8278 break; 8279 8280 case ZPOOL_STATUS_REBUILD_SCRUB: 8281 printf_color(ANSI_BOLD, gettext("status: ")); 8282 printf_color(ANSI_YELLOW, gettext("One or more devices have " 8283 "been sequentially resilvered, scrubbing\n\tthe pool " 8284 "is recommended.\n")); 8285 printf_color(ANSI_BOLD, gettext("action: ")); 8286 printf_color(ANSI_YELLOW, gettext("Use 'zpool scrub' to " 8287 "verify all data checksums.\n")); 8288 break; 8289 8290 case ZPOOL_STATUS_CORRUPT_DATA: 8291 printf_color(ANSI_BOLD, gettext("status: ")); 8292 printf_color(ANSI_YELLOW, gettext("One or more devices has " 8293 "experienced an error resulting in data\n\tcorruption. " 8294 "Applications may be affected.\n")); 8295 printf_color(ANSI_BOLD, gettext("action: ")); 8296 printf_color(ANSI_YELLOW, gettext("Restore the file in question" 8297 " if possible. Otherwise restore the\n\tentire pool from " 8298 "backup.\n")); 8299 break; 8300 8301 case ZPOOL_STATUS_CORRUPT_POOL: 8302 printf_color(ANSI_BOLD, gettext("status: ")); 8303 printf_color(ANSI_YELLOW, gettext("The pool metadata is " 8304 "corrupted and the pool cannot be opened.\n")); 8305 zpool_explain_recover(zpool_get_handle(zhp), 8306 zpool_get_name(zhp), reason, config); 8307 break; 8308 8309 case ZPOOL_STATUS_VERSION_OLDER: 8310 printf_color(ANSI_BOLD, gettext("status: ")); 8311 printf_color(ANSI_YELLOW, gettext("The pool is formatted using " 8312 "a legacy on-disk format. The pool can\n\tstill be used, " 8313 "but some features are unavailable.\n")); 8314 printf_color(ANSI_BOLD, gettext("action: ")); 8315 printf_color(ANSI_YELLOW, gettext("Upgrade the pool using " 8316 "'zpool upgrade'. Once this is done, the\n\tpool will no " 8317 "longer be accessible on software that does not support\n\t" 8318 "feature flags.\n")); 8319 break; 8320 8321 case ZPOOL_STATUS_VERSION_NEWER: 8322 printf_color(ANSI_BOLD, gettext("status: ")); 8323 printf_color(ANSI_YELLOW, gettext("The pool has been upgraded " 8324 "to a newer, incompatible on-disk version.\n\tThe pool " 8325 "cannot be accessed on this system.\n")); 8326 printf_color(ANSI_BOLD, gettext("action: ")); 8327 printf_color(ANSI_YELLOW, gettext("Access the pool from a " 8328 "system running more recent software, or\n\trestore the " 8329 "pool from backup.\n")); 8330 break; 8331 8332 case ZPOOL_STATUS_FEAT_DISABLED: 8333 printf_color(ANSI_BOLD, gettext("status: ")); 8334 printf_color(ANSI_YELLOW, gettext("Some supported and " 8335 "requested features are not enabled on the pool.\n\t" 8336 "The pool can still be used, but some features are " 8337 "unavailable.\n")); 8338 printf_color(ANSI_BOLD, gettext("action: ")); 8339 printf_color(ANSI_YELLOW, gettext("Enable all features using " 8340 "'zpool upgrade'. Once this is done,\n\tthe pool may no " 8341 "longer be accessible by software that does not support\n\t" 8342 "the features. See zpool-features(7) for details.\n")); 8343 break; 8344 8345 case ZPOOL_STATUS_COMPATIBILITY_ERR: 8346 printf_color(ANSI_BOLD, gettext("status: ")); 8347 printf_color(ANSI_YELLOW, gettext("This pool has a " 8348 "compatibility list specified, but it could not be\n\t" 8349 "read/parsed at this time. The pool can still be used, " 8350 "but this\n\tshould be investigated.\n")); 8351 printf_color(ANSI_BOLD, gettext("action: ")); 8352 printf_color(ANSI_YELLOW, gettext("Check the value of the " 8353 "'compatibility' property against the\n\t" 8354 "appropriate file in " ZPOOL_SYSCONF_COMPAT_D " or " 8355 ZPOOL_DATA_COMPAT_D ".\n")); 8356 break; 8357 8358 case ZPOOL_STATUS_INCOMPATIBLE_FEAT: 8359 printf_color(ANSI_BOLD, gettext("status: ")); 8360 printf_color(ANSI_YELLOW, gettext("One or more features " 8361 "are enabled on the pool despite not being\n\t" 8362 "requested by the 'compatibility' property.\n")); 8363 printf_color(ANSI_BOLD, gettext("action: ")); 8364 printf_color(ANSI_YELLOW, gettext("Consider setting " 8365 "'compatibility' to an appropriate value, or\n\t" 8366 "adding needed features to the relevant file in\n\t" 8367 ZPOOL_SYSCONF_COMPAT_D " or " ZPOOL_DATA_COMPAT_D ".\n")); 8368 break; 8369 8370 case ZPOOL_STATUS_UNSUP_FEAT_READ: 8371 printf_color(ANSI_BOLD, gettext("status: ")); 8372 printf_color(ANSI_YELLOW, gettext("The pool cannot be accessed " 8373 "on this system because it uses the\n\tfollowing feature(s)" 8374 " not supported on this system:\n")); 8375 zpool_print_unsup_feat(config); 8376 (void) printf("\n"); 8377 printf_color(ANSI_BOLD, gettext("action: ")); 8378 printf_color(ANSI_YELLOW, gettext("Access the pool from a " 8379 "system that supports the required feature(s),\n\tor " 8380 "restore the pool from backup.\n")); 8381 break; 8382 8383 case ZPOOL_STATUS_UNSUP_FEAT_WRITE: 8384 printf_color(ANSI_BOLD, gettext("status: ")); 8385 printf_color(ANSI_YELLOW, gettext("The pool can only be " 8386 "accessed in read-only mode on this system. It\n\tcannot be" 8387 " accessed in read-write mode because it uses the " 8388 "following\n\tfeature(s) not supported on this system:\n")); 8389 zpool_print_unsup_feat(config); 8390 (void) printf("\n"); 8391 printf_color(ANSI_BOLD, gettext("action: ")); 8392 printf_color(ANSI_YELLOW, gettext("The pool cannot be accessed " 8393 "in read-write mode. Import the pool with\n" 8394 "\t\"-o readonly=on\", access the pool from a system that " 8395 "supports the\n\trequired feature(s), or restore the " 8396 "pool from backup.\n")); 8397 break; 8398 8399 case ZPOOL_STATUS_FAULTED_DEV_R: 8400 printf_color(ANSI_BOLD, gettext("status: ")); 8401 printf_color(ANSI_YELLOW, gettext("One or more devices are " 8402 "faulted in response to persistent errors.\n\tSufficient " 8403 "replicas exist for the pool to continue functioning " 8404 "in a\n\tdegraded state.\n")); 8405 printf_color(ANSI_BOLD, gettext("action: ")); 8406 printf_color(ANSI_YELLOW, gettext("Replace the faulted device, " 8407 "or use 'zpool clear' to mark the device\n\trepaired.\n")); 8408 break; 8409 8410 case ZPOOL_STATUS_FAULTED_DEV_NR: 8411 printf_color(ANSI_BOLD, gettext("status: ")); 8412 printf_color(ANSI_YELLOW, gettext("One or more devices are " 8413 "faulted in response to persistent errors. There are " 8414 "insufficient replicas for the pool to\n\tcontinue " 8415 "functioning.\n")); 8416 printf_color(ANSI_BOLD, gettext("action: ")); 8417 printf_color(ANSI_YELLOW, gettext("Destroy and re-create the " 8418 "pool from a backup source. Manually marking the device\n" 8419 "\trepaired using 'zpool clear' may allow some data " 8420 "to be recovered.\n")); 8421 break; 8422 8423 case ZPOOL_STATUS_IO_FAILURE_MMP: 8424 printf_color(ANSI_BOLD, gettext("status: ")); 8425 printf_color(ANSI_YELLOW, gettext("The pool is suspended " 8426 "because multihost writes failed or were delayed;\n\t" 8427 "another system could import the pool undetected.\n")); 8428 printf_color(ANSI_BOLD, gettext("action: ")); 8429 printf_color(ANSI_YELLOW, gettext("Make sure the pool's devices" 8430 " are connected, then reboot your system and\n\timport the " 8431 "pool.\n")); 8432 break; 8433 8434 case ZPOOL_STATUS_IO_FAILURE_WAIT: 8435 case ZPOOL_STATUS_IO_FAILURE_CONTINUE: 8436 printf_color(ANSI_BOLD, gettext("status: ")); 8437 printf_color(ANSI_YELLOW, gettext("One or more devices are " 8438 "faulted in response to IO failures.\n")); 8439 printf_color(ANSI_BOLD, gettext("action: ")); 8440 printf_color(ANSI_YELLOW, gettext("Make sure the affected " 8441 "devices are connected, then run 'zpool clear'.\n")); 8442 break; 8443 8444 case ZPOOL_STATUS_BAD_LOG: 8445 printf_color(ANSI_BOLD, gettext("status: ")); 8446 printf_color(ANSI_YELLOW, gettext("An intent log record " 8447 "could not be read.\n" 8448 "\tWaiting for administrator intervention to fix the " 8449 "faulted pool.\n")); 8450 printf_color(ANSI_BOLD, gettext("action: ")); 8451 printf_color(ANSI_YELLOW, gettext("Either restore the affected " 8452 "device(s) and run 'zpool online',\n" 8453 "\tor ignore the intent log records by running " 8454 "'zpool clear'.\n")); 8455 break; 8456 8457 case ZPOOL_STATUS_NON_NATIVE_ASHIFT: 8458 (void) printf(gettext("status: One or more devices are " 8459 "configured to use a non-native block size.\n" 8460 "\tExpect reduced performance.\n")); 8461 (void) printf(gettext("action: Replace affected devices with " 8462 "devices that support the\n\tconfigured block size, or " 8463 "migrate data to a properly configured\n\tpool.\n")); 8464 break; 8465 8466 case ZPOOL_STATUS_HOSTID_MISMATCH: 8467 printf_color(ANSI_BOLD, gettext("status: ")); 8468 printf_color(ANSI_YELLOW, gettext("Mismatch between pool hostid" 8469 " and system hostid on imported pool.\n\tThis pool was " 8470 "previously imported into a system with a different " 8471 "hostid,\n\tand then was verbatim imported into this " 8472 "system.\n")); 8473 printf_color(ANSI_BOLD, gettext("action: ")); 8474 printf_color(ANSI_YELLOW, gettext("Export this pool on all " 8475 "systems on which it is imported.\n" 8476 "\tThen import it to correct the mismatch.\n")); 8477 break; 8478 8479 case ZPOOL_STATUS_ERRATA: 8480 printf_color(ANSI_BOLD, gettext("status: ")); 8481 printf_color(ANSI_YELLOW, gettext("Errata #%d detected.\n"), 8482 errata); 8483 8484 switch (errata) { 8485 case ZPOOL_ERRATA_NONE: 8486 break; 8487 8488 case ZPOOL_ERRATA_ZOL_2094_SCRUB: 8489 printf_color(ANSI_BOLD, gettext("action: ")); 8490 printf_color(ANSI_YELLOW, gettext("To correct the issue" 8491 " run 'zpool scrub'.\n")); 8492 break; 8493 8494 case ZPOOL_ERRATA_ZOL_6845_ENCRYPTION: 8495 (void) printf(gettext("\tExisting encrypted datasets " 8496 "contain an on-disk incompatibility\n\twhich " 8497 "needs to be corrected.\n")); 8498 printf_color(ANSI_BOLD, gettext("action: ")); 8499 printf_color(ANSI_YELLOW, gettext("To correct the issue" 8500 " backup existing encrypted datasets to new\n\t" 8501 "encrypted datasets and destroy the old ones. " 8502 "'zfs mount -o ro' can\n\tbe used to temporarily " 8503 "mount existing encrypted datasets readonly.\n")); 8504 break; 8505 8506 case ZPOOL_ERRATA_ZOL_8308_ENCRYPTION: 8507 (void) printf(gettext("\tExisting encrypted snapshots " 8508 "and bookmarks contain an on-disk\n\tincompat" 8509 "ibility. This may cause on-disk corruption if " 8510 "they are used\n\twith 'zfs recv'.\n")); 8511 printf_color(ANSI_BOLD, gettext("action: ")); 8512 printf_color(ANSI_YELLOW, gettext("To correct the" 8513 "issue, enable the bookmark_v2 feature. No " 8514 "additional\n\taction is needed if there are no " 8515 "encrypted snapshots or bookmarks.\n\tIf preserving" 8516 "the encrypted snapshots and bookmarks is required," 8517 " use\n\ta non-raw send to backup and restore them." 8518 " Alternately, they may be\n\tremoved to resolve " 8519 "the incompatibility.\n")); 8520 break; 8521 8522 default: 8523 /* 8524 * All errata which allow the pool to be imported 8525 * must contain an action message. 8526 */ 8527 assert(0); 8528 } 8529 break; 8530 8531 default: 8532 /* 8533 * The remaining errors can't actually be generated, yet. 8534 */ 8535 assert(reason == ZPOOL_STATUS_OK); 8536 } 8537 8538 if (msgid != NULL) { 8539 printf(" "); 8540 printf_color(ANSI_BOLD, gettext("see:")); 8541 printf(gettext( 8542 " https://openzfs.github.io/openzfs-docs/msg/%s\n"), 8543 msgid); 8544 } 8545 8546 if (config != NULL) { 8547 uint64_t nerr; 8548 nvlist_t **spares, **l2cache; 8549 uint_t nspares, nl2cache; 8550 pool_checkpoint_stat_t *pcs = NULL; 8551 pool_removal_stat_t *prs = NULL; 8552 8553 print_scan_status(zhp, nvroot); 8554 8555 (void) nvlist_lookup_uint64_array(nvroot, 8556 ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t **)&prs, &c); 8557 print_removal_status(zhp, prs); 8558 8559 (void) nvlist_lookup_uint64_array(nvroot, 8560 ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c); 8561 print_checkpoint_status(pcs); 8562 8563 cbp->cb_namewidth = max_width(zhp, nvroot, 0, 0, 8564 cbp->cb_name_flags | VDEV_NAME_TYPE_ID); 8565 if (cbp->cb_namewidth < 10) 8566 cbp->cb_namewidth = 10; 8567 8568 color_start(ANSI_BOLD); 8569 (void) printf(gettext("config:\n\n")); 8570 (void) printf(gettext("\t%-*s %-8s %5s %5s %5s"), 8571 cbp->cb_namewidth, "NAME", "STATE", "READ", "WRITE", 8572 "CKSUM"); 8573 color_end(); 8574 8575 if (cbp->cb_print_slow_ios) { 8576 printf_color(ANSI_BOLD, " %5s", gettext("SLOW")); 8577 } 8578 8579 if (cbp->vcdl != NULL) 8580 print_cmd_columns(cbp->vcdl, 0); 8581 8582 printf("\n"); 8583 8584 print_status_config(zhp, cbp, zpool_get_name(zhp), nvroot, 0, 8585 B_FALSE, NULL); 8586 8587 print_class_vdevs(zhp, cbp, nvroot, VDEV_ALLOC_BIAS_DEDUP); 8588 print_class_vdevs(zhp, cbp, nvroot, VDEV_ALLOC_BIAS_SPECIAL); 8589 print_class_vdevs(zhp, cbp, nvroot, VDEV_ALLOC_CLASS_LOGS); 8590 8591 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 8592 &l2cache, &nl2cache) == 0) 8593 print_l2cache(zhp, cbp, l2cache, nl2cache); 8594 8595 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 8596 &spares, &nspares) == 0) 8597 print_spares(zhp, cbp, spares, nspares); 8598 8599 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT, 8600 &nerr) == 0) { 8601 nvlist_t *nverrlist = NULL; 8602 8603 /* 8604 * If the approximate error count is small, get a 8605 * precise count by fetching the entire log and 8606 * uniquifying the results. 8607 */ 8608 if (nerr > 0 && nerr < 100 && !cbp->cb_verbose && 8609 zpool_get_errlog(zhp, &nverrlist) == 0) { 8610 nvpair_t *elem; 8611 8612 elem = NULL; 8613 nerr = 0; 8614 while ((elem = nvlist_next_nvpair(nverrlist, 8615 elem)) != NULL) { 8616 nerr++; 8617 } 8618 } 8619 nvlist_free(nverrlist); 8620 8621 (void) printf("\n"); 8622 8623 if (nerr == 0) 8624 (void) printf(gettext("errors: No known data " 8625 "errors\n")); 8626 else if (!cbp->cb_verbose) 8627 (void) printf(gettext("errors: %llu data " 8628 "errors, use '-v' for a list\n"), 8629 (u_longlong_t)nerr); 8630 else 8631 print_error_log(zhp); 8632 } 8633 8634 if (cbp->cb_dedup_stats) 8635 print_dedup_stats(config); 8636 } else { 8637 (void) printf(gettext("config: The configuration cannot be " 8638 "determined.\n")); 8639 } 8640 8641 return (0); 8642 } 8643 8644 /* 8645 * zpool status [-c [script1,script2,...]] [-igLpPstvx] [-T d|u] [pool] ... 8646 * [interval [count]] 8647 * 8648 * -c CMD For each vdev, run command CMD 8649 * -i Display vdev initialization status. 8650 * -g Display guid for individual vdev name. 8651 * -L Follow links when resolving vdev path name. 8652 * -p Display values in parsable (exact) format. 8653 * -P Display full path for vdev name. 8654 * -s Display slow IOs column. 8655 * -v Display complete error logs 8656 * -x Display only pools with potential problems 8657 * -D Display dedup status (undocumented) 8658 * -t Display vdev TRIM status. 8659 * -T Display a timestamp in date(1) or Unix format 8660 * 8661 * Describes the health status of all pools or some subset. 8662 */ 8663 int 8664 zpool_do_status(int argc, char **argv) 8665 { 8666 int c; 8667 int ret; 8668 float interval = 0; 8669 unsigned long count = 0; 8670 status_cbdata_t cb = { 0 }; 8671 char *cmd = NULL; 8672 8673 /* check options */ 8674 while ((c = getopt(argc, argv, "c:igLpPsvxDtT:")) != -1) { 8675 switch (c) { 8676 case 'c': 8677 if (cmd != NULL) { 8678 fprintf(stderr, 8679 gettext("Can't set -c flag twice\n")); 8680 exit(1); 8681 } 8682 8683 if (getenv("ZPOOL_SCRIPTS_ENABLED") != NULL && 8684 !libzfs_envvar_is_set("ZPOOL_SCRIPTS_ENABLED")) { 8685 fprintf(stderr, gettext( 8686 "Can't run -c, disabled by " 8687 "ZPOOL_SCRIPTS_ENABLED.\n")); 8688 exit(1); 8689 } 8690 8691 if ((getuid() <= 0 || geteuid() <= 0) && 8692 !libzfs_envvar_is_set("ZPOOL_SCRIPTS_AS_ROOT")) { 8693 fprintf(stderr, gettext( 8694 "Can't run -c with root privileges " 8695 "unless ZPOOL_SCRIPTS_AS_ROOT is set.\n")); 8696 exit(1); 8697 } 8698 cmd = optarg; 8699 break; 8700 case 'i': 8701 cb.cb_print_vdev_init = B_TRUE; 8702 break; 8703 case 'g': 8704 cb.cb_name_flags |= VDEV_NAME_GUID; 8705 break; 8706 case 'L': 8707 cb.cb_name_flags |= VDEV_NAME_FOLLOW_LINKS; 8708 break; 8709 case 'p': 8710 cb.cb_literal = B_TRUE; 8711 break; 8712 case 'P': 8713 cb.cb_name_flags |= VDEV_NAME_PATH; 8714 break; 8715 case 's': 8716 cb.cb_print_slow_ios = B_TRUE; 8717 break; 8718 case 'v': 8719 cb.cb_verbose = B_TRUE; 8720 break; 8721 case 'x': 8722 cb.cb_explain = B_TRUE; 8723 break; 8724 case 'D': 8725 cb.cb_dedup_stats = B_TRUE; 8726 break; 8727 case 't': 8728 cb.cb_print_vdev_trim = B_TRUE; 8729 break; 8730 case 'T': 8731 get_timestamp_arg(*optarg); 8732 break; 8733 case '?': 8734 if (optopt == 'c') { 8735 print_zpool_script_list("status"); 8736 exit(0); 8737 } else { 8738 fprintf(stderr, 8739 gettext("invalid option '%c'\n"), optopt); 8740 } 8741 usage(B_FALSE); 8742 } 8743 } 8744 8745 argc -= optind; 8746 argv += optind; 8747 8748 get_interval_count(&argc, argv, &interval, &count); 8749 8750 if (argc == 0) 8751 cb.cb_allpools = B_TRUE; 8752 8753 cb.cb_first = B_TRUE; 8754 cb.cb_print_status = B_TRUE; 8755 8756 for (;;) { 8757 if (timestamp_fmt != NODATE) 8758 print_timestamp(timestamp_fmt); 8759 8760 if (cmd != NULL) 8761 cb.vcdl = all_pools_for_each_vdev_run(argc, argv, cmd, 8762 NULL, NULL, 0, 0); 8763 8764 ret = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 8765 cb.cb_literal, status_callback, &cb); 8766 8767 if (cb.vcdl != NULL) 8768 free_vdev_cmd_data_list(cb.vcdl); 8769 8770 if (argc == 0 && cb.cb_count == 0) 8771 (void) fprintf(stderr, gettext("no pools available\n")); 8772 else if (cb.cb_explain && cb.cb_first && cb.cb_allpools) 8773 (void) printf(gettext("all pools are healthy\n")); 8774 8775 if (ret != 0) 8776 return (ret); 8777 8778 if (interval == 0) 8779 break; 8780 8781 if (count != 0 && --count == 0) 8782 break; 8783 8784 (void) fsleep(interval); 8785 } 8786 8787 return (0); 8788 } 8789 8790 typedef struct upgrade_cbdata { 8791 int cb_first; 8792 int cb_argc; 8793 uint64_t cb_version; 8794 char **cb_argv; 8795 } upgrade_cbdata_t; 8796 8797 static int 8798 check_unsupp_fs(zfs_handle_t *zhp, void *unsupp_fs) 8799 { 8800 int zfs_version = (int)zfs_prop_get_int(zhp, ZFS_PROP_VERSION); 8801 int *count = (int *)unsupp_fs; 8802 8803 if (zfs_version > ZPL_VERSION) { 8804 (void) printf(gettext("%s (v%d) is not supported by this " 8805 "implementation of ZFS.\n"), 8806 zfs_get_name(zhp), zfs_version); 8807 (*count)++; 8808 } 8809 8810 zfs_iter_filesystems(zhp, check_unsupp_fs, unsupp_fs); 8811 8812 zfs_close(zhp); 8813 8814 return (0); 8815 } 8816 8817 static int 8818 upgrade_version(zpool_handle_t *zhp, uint64_t version) 8819 { 8820 int ret; 8821 nvlist_t *config; 8822 uint64_t oldversion; 8823 int unsupp_fs = 0; 8824 8825 config = zpool_get_config(zhp, NULL); 8826 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 8827 &oldversion) == 0); 8828 8829 char compat[ZFS_MAXPROPLEN]; 8830 if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY, compat, 8831 ZFS_MAXPROPLEN, NULL, B_FALSE) != 0) 8832 compat[0] = '\0'; 8833 8834 assert(SPA_VERSION_IS_SUPPORTED(oldversion)); 8835 assert(oldversion < version); 8836 8837 ret = zfs_iter_root(zpool_get_handle(zhp), check_unsupp_fs, &unsupp_fs); 8838 if (ret != 0) 8839 return (ret); 8840 8841 if (unsupp_fs) { 8842 (void) fprintf(stderr, gettext("Upgrade not performed due " 8843 "to %d unsupported filesystems (max v%d).\n"), 8844 unsupp_fs, (int)ZPL_VERSION); 8845 return (1); 8846 } 8847 8848 if (strcmp(compat, ZPOOL_COMPAT_LEGACY) == 0) { 8849 (void) fprintf(stderr, gettext("Upgrade not performed because " 8850 "'compatibility' property set to '" 8851 ZPOOL_COMPAT_LEGACY "'.\n")); 8852 return (1); 8853 } 8854 8855 ret = zpool_upgrade(zhp, version); 8856 if (ret != 0) 8857 return (ret); 8858 8859 if (version >= SPA_VERSION_FEATURES) { 8860 (void) printf(gettext("Successfully upgraded " 8861 "'%s' from version %llu to feature flags.\n"), 8862 zpool_get_name(zhp), (u_longlong_t)oldversion); 8863 } else { 8864 (void) printf(gettext("Successfully upgraded " 8865 "'%s' from version %llu to version %llu.\n"), 8866 zpool_get_name(zhp), (u_longlong_t)oldversion, 8867 (u_longlong_t)version); 8868 } 8869 8870 return (0); 8871 } 8872 8873 static int 8874 upgrade_enable_all(zpool_handle_t *zhp, int *countp) 8875 { 8876 int i, ret, count; 8877 boolean_t firstff = B_TRUE; 8878 nvlist_t *enabled = zpool_get_features(zhp); 8879 8880 char compat[ZFS_MAXPROPLEN]; 8881 if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY, compat, 8882 ZFS_MAXPROPLEN, NULL, B_FALSE) != 0) 8883 compat[0] = '\0'; 8884 8885 boolean_t requested_features[SPA_FEATURES]; 8886 if (zpool_do_load_compat(compat, requested_features) != 8887 ZPOOL_COMPATIBILITY_OK) 8888 return (-1); 8889 8890 count = 0; 8891 for (i = 0; i < SPA_FEATURES; i++) { 8892 const char *fname = spa_feature_table[i].fi_uname; 8893 const char *fguid = spa_feature_table[i].fi_guid; 8894 8895 if (!spa_feature_table[i].fi_zfs_mod_supported) 8896 continue; 8897 8898 if (!nvlist_exists(enabled, fguid) && requested_features[i]) { 8899 char *propname; 8900 verify(-1 != asprintf(&propname, "feature@%s", fname)); 8901 ret = zpool_set_prop(zhp, propname, 8902 ZFS_FEATURE_ENABLED); 8903 if (ret != 0) { 8904 free(propname); 8905 return (ret); 8906 } 8907 count++; 8908 8909 if (firstff) { 8910 (void) printf(gettext("Enabled the " 8911 "following features on '%s':\n"), 8912 zpool_get_name(zhp)); 8913 firstff = B_FALSE; 8914 } 8915 (void) printf(gettext(" %s\n"), fname); 8916 free(propname); 8917 } 8918 } 8919 8920 if (countp != NULL) 8921 *countp = count; 8922 return (0); 8923 } 8924 8925 static int 8926 upgrade_cb(zpool_handle_t *zhp, void *arg) 8927 { 8928 upgrade_cbdata_t *cbp = arg; 8929 nvlist_t *config; 8930 uint64_t version; 8931 boolean_t modified_pool = B_FALSE; 8932 int ret; 8933 8934 config = zpool_get_config(zhp, NULL); 8935 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 8936 &version) == 0); 8937 8938 assert(SPA_VERSION_IS_SUPPORTED(version)); 8939 8940 if (version < cbp->cb_version) { 8941 cbp->cb_first = B_FALSE; 8942 ret = upgrade_version(zhp, cbp->cb_version); 8943 if (ret != 0) 8944 return (ret); 8945 modified_pool = B_TRUE; 8946 8947 /* 8948 * If they did "zpool upgrade -a", then we could 8949 * be doing ioctls to different pools. We need 8950 * to log this history once to each pool, and bypass 8951 * the normal history logging that happens in main(). 8952 */ 8953 (void) zpool_log_history(g_zfs, history_str); 8954 log_history = B_FALSE; 8955 } 8956 8957 if (cbp->cb_version >= SPA_VERSION_FEATURES) { 8958 int count; 8959 ret = upgrade_enable_all(zhp, &count); 8960 if (ret != 0) 8961 return (ret); 8962 8963 if (count > 0) { 8964 cbp->cb_first = B_FALSE; 8965 modified_pool = B_TRUE; 8966 } 8967 } 8968 8969 if (modified_pool) { 8970 (void) printf("\n"); 8971 (void) after_zpool_upgrade(zhp); 8972 } 8973 8974 return (0); 8975 } 8976 8977 static int 8978 upgrade_list_older_cb(zpool_handle_t *zhp, void *arg) 8979 { 8980 upgrade_cbdata_t *cbp = arg; 8981 nvlist_t *config; 8982 uint64_t version; 8983 8984 config = zpool_get_config(zhp, NULL); 8985 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 8986 &version) == 0); 8987 8988 assert(SPA_VERSION_IS_SUPPORTED(version)); 8989 8990 if (version < SPA_VERSION_FEATURES) { 8991 if (cbp->cb_first) { 8992 (void) printf(gettext("The following pools are " 8993 "formatted with legacy version numbers and can\n" 8994 "be upgraded to use feature flags. After " 8995 "being upgraded, these pools\nwill no " 8996 "longer be accessible by software that does not " 8997 "support feature\nflags.\n\n" 8998 "Note that setting a pool's 'compatibility' " 8999 "feature to '" ZPOOL_COMPAT_LEGACY "' will\n" 9000 "inhibit upgrades.\n\n")); 9001 (void) printf(gettext("VER POOL\n")); 9002 (void) printf(gettext("--- ------------\n")); 9003 cbp->cb_first = B_FALSE; 9004 } 9005 9006 (void) printf("%2llu %s\n", (u_longlong_t)version, 9007 zpool_get_name(zhp)); 9008 } 9009 9010 return (0); 9011 } 9012 9013 static int 9014 upgrade_list_disabled_cb(zpool_handle_t *zhp, void *arg) 9015 { 9016 upgrade_cbdata_t *cbp = arg; 9017 nvlist_t *config; 9018 uint64_t version; 9019 9020 config = zpool_get_config(zhp, NULL); 9021 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, 9022 &version) == 0); 9023 9024 if (version >= SPA_VERSION_FEATURES) { 9025 int i; 9026 boolean_t poolfirst = B_TRUE; 9027 nvlist_t *enabled = zpool_get_features(zhp); 9028 9029 for (i = 0; i < SPA_FEATURES; i++) { 9030 const char *fguid = spa_feature_table[i].fi_guid; 9031 const char *fname = spa_feature_table[i].fi_uname; 9032 9033 if (!spa_feature_table[i].fi_zfs_mod_supported) 9034 continue; 9035 9036 if (!nvlist_exists(enabled, fguid)) { 9037 if (cbp->cb_first) { 9038 (void) printf(gettext("\nSome " 9039 "supported features are not " 9040 "enabled on the following pools. " 9041 "Once a\nfeature is enabled the " 9042 "pool may become incompatible with " 9043 "software\nthat does not support " 9044 "the feature. See " 9045 "zpool-features(7) for " 9046 "details.\n\n" 9047 "Note that the pool " 9048 "'compatibility' feature can be " 9049 "used to inhibit\nfeature " 9050 "upgrades.\n\n")); 9051 (void) printf(gettext("POOL " 9052 "FEATURE\n")); 9053 (void) printf(gettext("------" 9054 "---------\n")); 9055 cbp->cb_first = B_FALSE; 9056 } 9057 9058 if (poolfirst) { 9059 (void) printf(gettext("%s\n"), 9060 zpool_get_name(zhp)); 9061 poolfirst = B_FALSE; 9062 } 9063 9064 (void) printf(gettext(" %s\n"), fname); 9065 } 9066 /* 9067 * If they did "zpool upgrade -a", then we could 9068 * be doing ioctls to different pools. We need 9069 * to log this history once to each pool, and bypass 9070 * the normal history logging that happens in main(). 9071 */ 9072 (void) zpool_log_history(g_zfs, history_str); 9073 log_history = B_FALSE; 9074 } 9075 } 9076 9077 return (0); 9078 } 9079 9080 static int 9081 upgrade_one(zpool_handle_t *zhp, void *data) 9082 { 9083 boolean_t modified_pool = B_FALSE; 9084 upgrade_cbdata_t *cbp = data; 9085 uint64_t cur_version; 9086 int ret; 9087 9088 if (strcmp("log", zpool_get_name(zhp)) == 0) { 9089 (void) fprintf(stderr, gettext("'log' is now a reserved word\n" 9090 "Pool 'log' must be renamed using export and import" 9091 " to upgrade.\n")); 9092 return (1); 9093 } 9094 9095 cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 9096 if (cur_version > cbp->cb_version) { 9097 (void) printf(gettext("Pool '%s' is already formatted " 9098 "using more current version '%llu'.\n\n"), 9099 zpool_get_name(zhp), (u_longlong_t)cur_version); 9100 return (0); 9101 } 9102 9103 if (cbp->cb_version != SPA_VERSION && cur_version == cbp->cb_version) { 9104 (void) printf(gettext("Pool '%s' is already formatted " 9105 "using version %llu.\n\n"), zpool_get_name(zhp), 9106 (u_longlong_t)cbp->cb_version); 9107 return (0); 9108 } 9109 9110 if (cur_version != cbp->cb_version) { 9111 modified_pool = B_TRUE; 9112 ret = upgrade_version(zhp, cbp->cb_version); 9113 if (ret != 0) 9114 return (ret); 9115 } 9116 9117 if (cbp->cb_version >= SPA_VERSION_FEATURES) { 9118 int count = 0; 9119 ret = upgrade_enable_all(zhp, &count); 9120 if (ret != 0) 9121 return (ret); 9122 9123 if (count != 0) { 9124 modified_pool = B_TRUE; 9125 } else if (cur_version == SPA_VERSION) { 9126 (void) printf(gettext("Pool '%s' already has all " 9127 "supported and requested features enabled.\n"), 9128 zpool_get_name(zhp)); 9129 } 9130 } 9131 9132 if (modified_pool) { 9133 (void) printf("\n"); 9134 (void) after_zpool_upgrade(zhp); 9135 } 9136 9137 return (0); 9138 } 9139 9140 /* 9141 * zpool upgrade 9142 * zpool upgrade -v 9143 * zpool upgrade [-V version] <-a | pool ...> 9144 * 9145 * With no arguments, display downrev'd ZFS pool available for upgrade. 9146 * Individual pools can be upgraded by specifying the pool, and '-a' will 9147 * upgrade all pools. 9148 */ 9149 int 9150 zpool_do_upgrade(int argc, char **argv) 9151 { 9152 int c; 9153 upgrade_cbdata_t cb = { 0 }; 9154 int ret = 0; 9155 boolean_t showversions = B_FALSE; 9156 boolean_t upgradeall = B_FALSE; 9157 char *end; 9158 9159 9160 /* check options */ 9161 while ((c = getopt(argc, argv, ":avV:")) != -1) { 9162 switch (c) { 9163 case 'a': 9164 upgradeall = B_TRUE; 9165 break; 9166 case 'v': 9167 showversions = B_TRUE; 9168 break; 9169 case 'V': 9170 cb.cb_version = strtoll(optarg, &end, 10); 9171 if (*end != '\0' || 9172 !SPA_VERSION_IS_SUPPORTED(cb.cb_version)) { 9173 (void) fprintf(stderr, 9174 gettext("invalid version '%s'\n"), optarg); 9175 usage(B_FALSE); 9176 } 9177 break; 9178 case ':': 9179 (void) fprintf(stderr, gettext("missing argument for " 9180 "'%c' option\n"), optopt); 9181 usage(B_FALSE); 9182 break; 9183 case '?': 9184 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 9185 optopt); 9186 usage(B_FALSE); 9187 } 9188 } 9189 9190 cb.cb_argc = argc; 9191 cb.cb_argv = argv; 9192 argc -= optind; 9193 argv += optind; 9194 9195 if (cb.cb_version == 0) { 9196 cb.cb_version = SPA_VERSION; 9197 } else if (!upgradeall && argc == 0) { 9198 (void) fprintf(stderr, gettext("-V option is " 9199 "incompatible with other arguments\n")); 9200 usage(B_FALSE); 9201 } 9202 9203 if (showversions) { 9204 if (upgradeall || argc != 0) { 9205 (void) fprintf(stderr, gettext("-v option is " 9206 "incompatible with other arguments\n")); 9207 usage(B_FALSE); 9208 } 9209 } else if (upgradeall) { 9210 if (argc != 0) { 9211 (void) fprintf(stderr, gettext("-a option should not " 9212 "be used along with a pool name\n")); 9213 usage(B_FALSE); 9214 } 9215 } 9216 9217 (void) printf(gettext("This system supports ZFS pool feature " 9218 "flags.\n\n")); 9219 if (showversions) { 9220 int i; 9221 9222 (void) printf(gettext("The following features are " 9223 "supported:\n\n")); 9224 (void) printf(gettext("FEAT DESCRIPTION\n")); 9225 (void) printf("----------------------------------------------" 9226 "---------------\n"); 9227 for (i = 0; i < SPA_FEATURES; i++) { 9228 zfeature_info_t *fi = &spa_feature_table[i]; 9229 if (!fi->fi_zfs_mod_supported) 9230 continue; 9231 const char *ro = 9232 (fi->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ? 9233 " (read-only compatible)" : ""; 9234 9235 (void) printf("%-37s%s\n", fi->fi_uname, ro); 9236 (void) printf(" %s\n", fi->fi_desc); 9237 } 9238 (void) printf("\n"); 9239 9240 (void) printf(gettext("The following legacy versions are also " 9241 "supported:\n\n")); 9242 (void) printf(gettext("VER DESCRIPTION\n")); 9243 (void) printf("--- -----------------------------------------" 9244 "---------------\n"); 9245 (void) printf(gettext(" 1 Initial ZFS version\n")); 9246 (void) printf(gettext(" 2 Ditto blocks " 9247 "(replicated metadata)\n")); 9248 (void) printf(gettext(" 3 Hot spares and double parity " 9249 "RAID-Z\n")); 9250 (void) printf(gettext(" 4 zpool history\n")); 9251 (void) printf(gettext(" 5 Compression using the gzip " 9252 "algorithm\n")); 9253 (void) printf(gettext(" 6 bootfs pool property\n")); 9254 (void) printf(gettext(" 7 Separate intent log devices\n")); 9255 (void) printf(gettext(" 8 Delegated administration\n")); 9256 (void) printf(gettext(" 9 refquota and refreservation " 9257 "properties\n")); 9258 (void) printf(gettext(" 10 Cache devices\n")); 9259 (void) printf(gettext(" 11 Improved scrub performance\n")); 9260 (void) printf(gettext(" 12 Snapshot properties\n")); 9261 (void) printf(gettext(" 13 snapused property\n")); 9262 (void) printf(gettext(" 14 passthrough-x aclinherit\n")); 9263 (void) printf(gettext(" 15 user/group space accounting\n")); 9264 (void) printf(gettext(" 16 stmf property support\n")); 9265 (void) printf(gettext(" 17 Triple-parity RAID-Z\n")); 9266 (void) printf(gettext(" 18 Snapshot user holds\n")); 9267 (void) printf(gettext(" 19 Log device removal\n")); 9268 (void) printf(gettext(" 20 Compression using zle " 9269 "(zero-length encoding)\n")); 9270 (void) printf(gettext(" 21 Deduplication\n")); 9271 (void) printf(gettext(" 22 Received properties\n")); 9272 (void) printf(gettext(" 23 Slim ZIL\n")); 9273 (void) printf(gettext(" 24 System attributes\n")); 9274 (void) printf(gettext(" 25 Improved scrub stats\n")); 9275 (void) printf(gettext(" 26 Improved snapshot deletion " 9276 "performance\n")); 9277 (void) printf(gettext(" 27 Improved snapshot creation " 9278 "performance\n")); 9279 (void) printf(gettext(" 28 Multiple vdev replacements\n")); 9280 (void) printf(gettext("\nFor more information on a particular " 9281 "version, including supported releases,\n")); 9282 (void) printf(gettext("see the ZFS Administration Guide.\n\n")); 9283 } else if (argc == 0 && upgradeall) { 9284 cb.cb_first = B_TRUE; 9285 ret = zpool_iter(g_zfs, upgrade_cb, &cb); 9286 if (ret == 0 && cb.cb_first) { 9287 if (cb.cb_version == SPA_VERSION) { 9288 (void) printf(gettext("All pools are already " 9289 "formatted using feature flags.\n\n")); 9290 (void) printf(gettext("Every feature flags " 9291 "pool already has all supported and " 9292 "requested features enabled.\n")); 9293 } else { 9294 (void) printf(gettext("All pools are already " 9295 "formatted with version %llu or higher.\n"), 9296 (u_longlong_t)cb.cb_version); 9297 } 9298 } 9299 } else if (argc == 0) { 9300 cb.cb_first = B_TRUE; 9301 ret = zpool_iter(g_zfs, upgrade_list_older_cb, &cb); 9302 assert(ret == 0); 9303 9304 if (cb.cb_first) { 9305 (void) printf(gettext("All pools are formatted " 9306 "using feature flags.\n\n")); 9307 } else { 9308 (void) printf(gettext("\nUse 'zpool upgrade -v' " 9309 "for a list of available legacy versions.\n")); 9310 } 9311 9312 cb.cb_first = B_TRUE; 9313 ret = zpool_iter(g_zfs, upgrade_list_disabled_cb, &cb); 9314 assert(ret == 0); 9315 9316 if (cb.cb_first) { 9317 (void) printf(gettext("Every feature flags pool has " 9318 "all supported and requested features enabled.\n")); 9319 } else { 9320 (void) printf(gettext("\n")); 9321 } 9322 } else { 9323 ret = for_each_pool(argc, argv, B_FALSE, NULL, ZFS_TYPE_POOL, 9324 B_FALSE, upgrade_one, &cb); 9325 } 9326 9327 return (ret); 9328 } 9329 9330 typedef struct hist_cbdata { 9331 boolean_t first; 9332 boolean_t longfmt; 9333 boolean_t internal; 9334 } hist_cbdata_t; 9335 9336 static void 9337 print_history_records(nvlist_t *nvhis, hist_cbdata_t *cb) 9338 { 9339 nvlist_t **records; 9340 uint_t numrecords; 9341 int i; 9342 9343 verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD, 9344 &records, &numrecords) == 0); 9345 for (i = 0; i < numrecords; i++) { 9346 nvlist_t *rec = records[i]; 9347 char tbuf[64] = ""; 9348 9349 if (nvlist_exists(rec, ZPOOL_HIST_TIME)) { 9350 time_t tsec; 9351 struct tm t; 9352 9353 tsec = fnvlist_lookup_uint64(records[i], 9354 ZPOOL_HIST_TIME); 9355 (void) localtime_r(&tsec, &t); 9356 (void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t); 9357 } 9358 9359 if (nvlist_exists(rec, ZPOOL_HIST_ELAPSED_NS)) { 9360 uint64_t elapsed_ns = fnvlist_lookup_int64(records[i], 9361 ZPOOL_HIST_ELAPSED_NS); 9362 (void) snprintf(tbuf + strlen(tbuf), 9363 sizeof (tbuf) - strlen(tbuf), 9364 " (%lldms)", (long long)elapsed_ns / 1000 / 1000); 9365 } 9366 9367 if (nvlist_exists(rec, ZPOOL_HIST_CMD)) { 9368 (void) printf("%s %s", tbuf, 9369 fnvlist_lookup_string(rec, ZPOOL_HIST_CMD)); 9370 } else if (nvlist_exists(rec, ZPOOL_HIST_INT_EVENT)) { 9371 int ievent = 9372 fnvlist_lookup_uint64(rec, ZPOOL_HIST_INT_EVENT); 9373 if (!cb->internal) 9374 continue; 9375 if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS) { 9376 (void) printf("%s unrecognized record:\n", 9377 tbuf); 9378 dump_nvlist(rec, 4); 9379 continue; 9380 } 9381 (void) printf("%s [internal %s txg:%lld] %s", tbuf, 9382 zfs_history_event_names[ievent], 9383 (longlong_t)fnvlist_lookup_uint64( 9384 rec, ZPOOL_HIST_TXG), 9385 fnvlist_lookup_string(rec, ZPOOL_HIST_INT_STR)); 9386 } else if (nvlist_exists(rec, ZPOOL_HIST_INT_NAME)) { 9387 if (!cb->internal) 9388 continue; 9389 (void) printf("%s [txg:%lld] %s", tbuf, 9390 (longlong_t)fnvlist_lookup_uint64( 9391 rec, ZPOOL_HIST_TXG), 9392 fnvlist_lookup_string(rec, ZPOOL_HIST_INT_NAME)); 9393 if (nvlist_exists(rec, ZPOOL_HIST_DSNAME)) { 9394 (void) printf(" %s (%llu)", 9395 fnvlist_lookup_string(rec, 9396 ZPOOL_HIST_DSNAME), 9397 (u_longlong_t)fnvlist_lookup_uint64(rec, 9398 ZPOOL_HIST_DSID)); 9399 } 9400 (void) printf(" %s", fnvlist_lookup_string(rec, 9401 ZPOOL_HIST_INT_STR)); 9402 } else if (nvlist_exists(rec, ZPOOL_HIST_IOCTL)) { 9403 if (!cb->internal) 9404 continue; 9405 (void) printf("%s ioctl %s\n", tbuf, 9406 fnvlist_lookup_string(rec, ZPOOL_HIST_IOCTL)); 9407 if (nvlist_exists(rec, ZPOOL_HIST_INPUT_NVL)) { 9408 (void) printf(" input:\n"); 9409 dump_nvlist(fnvlist_lookup_nvlist(rec, 9410 ZPOOL_HIST_INPUT_NVL), 8); 9411 } 9412 if (nvlist_exists(rec, ZPOOL_HIST_OUTPUT_NVL)) { 9413 (void) printf(" output:\n"); 9414 dump_nvlist(fnvlist_lookup_nvlist(rec, 9415 ZPOOL_HIST_OUTPUT_NVL), 8); 9416 } 9417 if (nvlist_exists(rec, ZPOOL_HIST_OUTPUT_SIZE)) { 9418 (void) printf(" output nvlist omitted; " 9419 "original size: %lldKB\n", 9420 (longlong_t)fnvlist_lookup_int64(rec, 9421 ZPOOL_HIST_OUTPUT_SIZE) / 1024); 9422 } 9423 if (nvlist_exists(rec, ZPOOL_HIST_ERRNO)) { 9424 (void) printf(" errno: %lld\n", 9425 (longlong_t)fnvlist_lookup_int64(rec, 9426 ZPOOL_HIST_ERRNO)); 9427 } 9428 } else { 9429 if (!cb->internal) 9430 continue; 9431 (void) printf("%s unrecognized record:\n", tbuf); 9432 dump_nvlist(rec, 4); 9433 } 9434 9435 if (!cb->longfmt) { 9436 (void) printf("\n"); 9437 continue; 9438 } 9439 (void) printf(" ["); 9440 if (nvlist_exists(rec, ZPOOL_HIST_WHO)) { 9441 uid_t who = fnvlist_lookup_uint64(rec, ZPOOL_HIST_WHO); 9442 struct passwd *pwd = getpwuid(who); 9443 (void) printf("user %d ", (int)who); 9444 if (pwd != NULL) 9445 (void) printf("(%s) ", pwd->pw_name); 9446 } 9447 if (nvlist_exists(rec, ZPOOL_HIST_HOST)) { 9448 (void) printf("on %s", 9449 fnvlist_lookup_string(rec, ZPOOL_HIST_HOST)); 9450 } 9451 if (nvlist_exists(rec, ZPOOL_HIST_ZONE)) { 9452 (void) printf(":%s", 9453 fnvlist_lookup_string(rec, ZPOOL_HIST_ZONE)); 9454 } 9455 9456 (void) printf("]"); 9457 (void) printf("\n"); 9458 } 9459 } 9460 9461 /* 9462 * Print out the command history for a specific pool. 9463 */ 9464 static int 9465 get_history_one(zpool_handle_t *zhp, void *data) 9466 { 9467 nvlist_t *nvhis; 9468 int ret; 9469 hist_cbdata_t *cb = (hist_cbdata_t *)data; 9470 uint64_t off = 0; 9471 boolean_t eof = B_FALSE; 9472 9473 cb->first = B_FALSE; 9474 9475 (void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp)); 9476 9477 while (!eof) { 9478 if ((ret = zpool_get_history(zhp, &nvhis, &off, &eof)) != 0) 9479 return (ret); 9480 9481 print_history_records(nvhis, cb); 9482 nvlist_free(nvhis); 9483 } 9484 (void) printf("\n"); 9485 9486 return (ret); 9487 } 9488 9489 /* 9490 * zpool history <pool> 9491 * 9492 * Displays the history of commands that modified pools. 9493 */ 9494 int 9495 zpool_do_history(int argc, char **argv) 9496 { 9497 hist_cbdata_t cbdata = { 0 }; 9498 int ret; 9499 int c; 9500 9501 cbdata.first = B_TRUE; 9502 /* check options */ 9503 while ((c = getopt(argc, argv, "li")) != -1) { 9504 switch (c) { 9505 case 'l': 9506 cbdata.longfmt = B_TRUE; 9507 break; 9508 case 'i': 9509 cbdata.internal = B_TRUE; 9510 break; 9511 case '?': 9512 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 9513 optopt); 9514 usage(B_FALSE); 9515 } 9516 } 9517 argc -= optind; 9518 argv += optind; 9519 9520 ret = for_each_pool(argc, argv, B_FALSE, NULL, ZFS_TYPE_POOL, 9521 B_FALSE, get_history_one, &cbdata); 9522 9523 if (argc == 0 && cbdata.first == B_TRUE) { 9524 (void) fprintf(stderr, gettext("no pools available\n")); 9525 return (0); 9526 } 9527 9528 return (ret); 9529 } 9530 9531 typedef struct ev_opts { 9532 int verbose; 9533 int scripted; 9534 int follow; 9535 int clear; 9536 char poolname[ZFS_MAX_DATASET_NAME_LEN]; 9537 } ev_opts_t; 9538 9539 static void 9540 zpool_do_events_short(nvlist_t *nvl, ev_opts_t *opts) 9541 { 9542 char ctime_str[26], str[32], *ptr; 9543 int64_t *tv; 9544 uint_t n; 9545 9546 verify(nvlist_lookup_int64_array(nvl, FM_EREPORT_TIME, &tv, &n) == 0); 9547 memset(str, ' ', 32); 9548 (void) ctime_r((const time_t *)&tv[0], ctime_str); 9549 (void) memcpy(str, ctime_str+4, 6); /* 'Jun 30' */ 9550 (void) memcpy(str+7, ctime_str+20, 4); /* '1993' */ 9551 (void) memcpy(str+12, ctime_str+11, 8); /* '21:49:08' */ 9552 (void) sprintf(str+20, ".%09lld", (longlong_t)tv[1]); /* '.123456789' */ 9553 if (opts->scripted) 9554 (void) printf(gettext("%s\t"), str); 9555 else 9556 (void) printf(gettext("%s "), str); 9557 9558 verify(nvlist_lookup_string(nvl, FM_CLASS, &ptr) == 0); 9559 (void) printf(gettext("%s\n"), ptr); 9560 } 9561 9562 static void 9563 zpool_do_events_nvprint(nvlist_t *nvl, int depth) 9564 { 9565 nvpair_t *nvp; 9566 9567 for (nvp = nvlist_next_nvpair(nvl, NULL); 9568 nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp)) { 9569 9570 data_type_t type = nvpair_type(nvp); 9571 const char *name = nvpair_name(nvp); 9572 9573 boolean_t b; 9574 uint8_t i8; 9575 uint16_t i16; 9576 uint32_t i32; 9577 uint64_t i64; 9578 char *str; 9579 nvlist_t *cnv; 9580 9581 printf(gettext("%*s%s = "), depth, "", name); 9582 9583 switch (type) { 9584 case DATA_TYPE_BOOLEAN: 9585 printf(gettext("%s"), "1"); 9586 break; 9587 9588 case DATA_TYPE_BOOLEAN_VALUE: 9589 (void) nvpair_value_boolean_value(nvp, &b); 9590 printf(gettext("%s"), b ? "1" : "0"); 9591 break; 9592 9593 case DATA_TYPE_BYTE: 9594 (void) nvpair_value_byte(nvp, &i8); 9595 printf(gettext("0x%x"), i8); 9596 break; 9597 9598 case DATA_TYPE_INT8: 9599 (void) nvpair_value_int8(nvp, (void *)&i8); 9600 printf(gettext("0x%x"), i8); 9601 break; 9602 9603 case DATA_TYPE_UINT8: 9604 (void) nvpair_value_uint8(nvp, &i8); 9605 printf(gettext("0x%x"), i8); 9606 break; 9607 9608 case DATA_TYPE_INT16: 9609 (void) nvpair_value_int16(nvp, (void *)&i16); 9610 printf(gettext("0x%x"), i16); 9611 break; 9612 9613 case DATA_TYPE_UINT16: 9614 (void) nvpair_value_uint16(nvp, &i16); 9615 printf(gettext("0x%x"), i16); 9616 break; 9617 9618 case DATA_TYPE_INT32: 9619 (void) nvpair_value_int32(nvp, (void *)&i32); 9620 printf(gettext("0x%x"), i32); 9621 break; 9622 9623 case DATA_TYPE_UINT32: 9624 (void) nvpair_value_uint32(nvp, &i32); 9625 printf(gettext("0x%x"), i32); 9626 break; 9627 9628 case DATA_TYPE_INT64: 9629 (void) nvpair_value_int64(nvp, (void *)&i64); 9630 printf(gettext("0x%llx"), (u_longlong_t)i64); 9631 break; 9632 9633 case DATA_TYPE_UINT64: 9634 (void) nvpair_value_uint64(nvp, &i64); 9635 /* 9636 * translate vdev state values to readable 9637 * strings to aide zpool events consumers 9638 */ 9639 if (strcmp(name, 9640 FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE) == 0 || 9641 strcmp(name, 9642 FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE) == 0) { 9643 printf(gettext("\"%s\" (0x%llx)"), 9644 zpool_state_to_name(i64, VDEV_AUX_NONE), 9645 (u_longlong_t)i64); 9646 } else { 9647 printf(gettext("0x%llx"), (u_longlong_t)i64); 9648 } 9649 break; 9650 9651 case DATA_TYPE_HRTIME: 9652 (void) nvpair_value_hrtime(nvp, (void *)&i64); 9653 printf(gettext("0x%llx"), (u_longlong_t)i64); 9654 break; 9655 9656 case DATA_TYPE_STRING: 9657 (void) nvpair_value_string(nvp, &str); 9658 printf(gettext("\"%s\""), str ? str : "<NULL>"); 9659 break; 9660 9661 case DATA_TYPE_NVLIST: 9662 printf(gettext("(embedded nvlist)\n")); 9663 (void) nvpair_value_nvlist(nvp, &cnv); 9664 zpool_do_events_nvprint(cnv, depth + 8); 9665 printf(gettext("%*s(end %s)"), depth, "", name); 9666 break; 9667 9668 case DATA_TYPE_NVLIST_ARRAY: { 9669 nvlist_t **val; 9670 uint_t i, nelem; 9671 9672 (void) nvpair_value_nvlist_array(nvp, &val, &nelem); 9673 printf(gettext("(%d embedded nvlists)\n"), nelem); 9674 for (i = 0; i < nelem; i++) { 9675 printf(gettext("%*s%s[%d] = %s\n"), 9676 depth, "", name, i, "(embedded nvlist)"); 9677 zpool_do_events_nvprint(val[i], depth + 8); 9678 printf(gettext("%*s(end %s[%i])\n"), 9679 depth, "", name, i); 9680 } 9681 printf(gettext("%*s(end %s)\n"), depth, "", name); 9682 } 9683 break; 9684 9685 case DATA_TYPE_INT8_ARRAY: { 9686 int8_t *val; 9687 uint_t i, nelem; 9688 9689 (void) nvpair_value_int8_array(nvp, &val, &nelem); 9690 for (i = 0; i < nelem; i++) 9691 printf(gettext("0x%x "), val[i]); 9692 9693 break; 9694 } 9695 9696 case DATA_TYPE_UINT8_ARRAY: { 9697 uint8_t *val; 9698 uint_t i, nelem; 9699 9700 (void) nvpair_value_uint8_array(nvp, &val, &nelem); 9701 for (i = 0; i < nelem; i++) 9702 printf(gettext("0x%x "), val[i]); 9703 9704 break; 9705 } 9706 9707 case DATA_TYPE_INT16_ARRAY: { 9708 int16_t *val; 9709 uint_t i, nelem; 9710 9711 (void) nvpair_value_int16_array(nvp, &val, &nelem); 9712 for (i = 0; i < nelem; i++) 9713 printf(gettext("0x%x "), val[i]); 9714 9715 break; 9716 } 9717 9718 case DATA_TYPE_UINT16_ARRAY: { 9719 uint16_t *val; 9720 uint_t i, nelem; 9721 9722 (void) nvpair_value_uint16_array(nvp, &val, &nelem); 9723 for (i = 0; i < nelem; i++) 9724 printf(gettext("0x%x "), val[i]); 9725 9726 break; 9727 } 9728 9729 case DATA_TYPE_INT32_ARRAY: { 9730 int32_t *val; 9731 uint_t i, nelem; 9732 9733 (void) nvpair_value_int32_array(nvp, &val, &nelem); 9734 for (i = 0; i < nelem; i++) 9735 printf(gettext("0x%x "), val[i]); 9736 9737 break; 9738 } 9739 9740 case DATA_TYPE_UINT32_ARRAY: { 9741 uint32_t *val; 9742 uint_t i, nelem; 9743 9744 (void) nvpair_value_uint32_array(nvp, &val, &nelem); 9745 for (i = 0; i < nelem; i++) 9746 printf(gettext("0x%x "), val[i]); 9747 9748 break; 9749 } 9750 9751 case DATA_TYPE_INT64_ARRAY: { 9752 int64_t *val; 9753 uint_t i, nelem; 9754 9755 (void) nvpair_value_int64_array(nvp, &val, &nelem); 9756 for (i = 0; i < nelem; i++) 9757 printf(gettext("0x%llx "), 9758 (u_longlong_t)val[i]); 9759 9760 break; 9761 } 9762 9763 case DATA_TYPE_UINT64_ARRAY: { 9764 uint64_t *val; 9765 uint_t i, nelem; 9766 9767 (void) nvpair_value_uint64_array(nvp, &val, &nelem); 9768 for (i = 0; i < nelem; i++) 9769 printf(gettext("0x%llx "), 9770 (u_longlong_t)val[i]); 9771 9772 break; 9773 } 9774 9775 case DATA_TYPE_STRING_ARRAY: { 9776 char **str; 9777 uint_t i, nelem; 9778 9779 (void) nvpair_value_string_array(nvp, &str, &nelem); 9780 for (i = 0; i < nelem; i++) 9781 printf(gettext("\"%s\" "), 9782 str[i] ? str[i] : "<NULL>"); 9783 9784 break; 9785 } 9786 9787 case DATA_TYPE_BOOLEAN_ARRAY: 9788 case DATA_TYPE_BYTE_ARRAY: 9789 case DATA_TYPE_DOUBLE: 9790 case DATA_TYPE_DONTCARE: 9791 case DATA_TYPE_UNKNOWN: 9792 printf(gettext("<unknown>")); 9793 break; 9794 } 9795 9796 printf(gettext("\n")); 9797 } 9798 } 9799 9800 static int 9801 zpool_do_events_next(ev_opts_t *opts) 9802 { 9803 nvlist_t *nvl; 9804 int zevent_fd, ret, dropped; 9805 char *pool; 9806 9807 zevent_fd = open(ZFS_DEV, O_RDWR); 9808 VERIFY(zevent_fd >= 0); 9809 9810 if (!opts->scripted) 9811 (void) printf(gettext("%-30s %s\n"), "TIME", "CLASS"); 9812 9813 while (1) { 9814 ret = zpool_events_next(g_zfs, &nvl, &dropped, 9815 (opts->follow ? ZEVENT_NONE : ZEVENT_NONBLOCK), zevent_fd); 9816 if (ret || nvl == NULL) 9817 break; 9818 9819 if (dropped > 0) 9820 (void) printf(gettext("dropped %d events\n"), dropped); 9821 9822 if (strlen(opts->poolname) > 0 && 9823 nvlist_lookup_string(nvl, FM_FMRI_ZFS_POOL, &pool) == 0 && 9824 strcmp(opts->poolname, pool) != 0) 9825 continue; 9826 9827 zpool_do_events_short(nvl, opts); 9828 9829 if (opts->verbose) { 9830 zpool_do_events_nvprint(nvl, 8); 9831 printf(gettext("\n")); 9832 } 9833 (void) fflush(stdout); 9834 9835 nvlist_free(nvl); 9836 } 9837 9838 VERIFY(0 == close(zevent_fd)); 9839 9840 return (ret); 9841 } 9842 9843 static int 9844 zpool_do_events_clear(void) 9845 { 9846 int count, ret; 9847 9848 ret = zpool_events_clear(g_zfs, &count); 9849 if (!ret) 9850 (void) printf(gettext("cleared %d events\n"), count); 9851 9852 return (ret); 9853 } 9854 9855 /* 9856 * zpool events [-vHf [pool] | -c] 9857 * 9858 * Displays events logs by ZFS. 9859 */ 9860 int 9861 zpool_do_events(int argc, char **argv) 9862 { 9863 ev_opts_t opts = { 0 }; 9864 int ret; 9865 int c; 9866 9867 /* check options */ 9868 while ((c = getopt(argc, argv, "vHfc")) != -1) { 9869 switch (c) { 9870 case 'v': 9871 opts.verbose = 1; 9872 break; 9873 case 'H': 9874 opts.scripted = 1; 9875 break; 9876 case 'f': 9877 opts.follow = 1; 9878 break; 9879 case 'c': 9880 opts.clear = 1; 9881 break; 9882 case '?': 9883 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 9884 optopt); 9885 usage(B_FALSE); 9886 } 9887 } 9888 argc -= optind; 9889 argv += optind; 9890 9891 if (argc > 1) { 9892 (void) fprintf(stderr, gettext("too many arguments\n")); 9893 usage(B_FALSE); 9894 } else if (argc == 1) { 9895 (void) strlcpy(opts.poolname, argv[0], sizeof (opts.poolname)); 9896 if (!zfs_name_valid(opts.poolname, ZFS_TYPE_POOL)) { 9897 (void) fprintf(stderr, 9898 gettext("invalid pool name '%s'\n"), opts.poolname); 9899 usage(B_FALSE); 9900 } 9901 } 9902 9903 if ((argc == 1 || opts.verbose || opts.scripted || opts.follow) && 9904 opts.clear) { 9905 (void) fprintf(stderr, 9906 gettext("invalid options combined with -c\n")); 9907 usage(B_FALSE); 9908 } 9909 9910 if (opts.clear) 9911 ret = zpool_do_events_clear(); 9912 else 9913 ret = zpool_do_events_next(&opts); 9914 9915 return (ret); 9916 } 9917 9918 static int 9919 get_callback_vdev(zpool_handle_t *zhp, char *vdevname, void *data) 9920 { 9921 zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 9922 char value[ZFS_MAXPROPLEN]; 9923 zprop_source_t srctype; 9924 9925 for (zprop_list_t *pl = cbp->cb_proplist; pl != NULL; 9926 pl = pl->pl_next) { 9927 char *prop_name; 9928 /* 9929 * If the first property is pool name, it is a special 9930 * placeholder that we can skip. This will also skip 9931 * over the name property when 'all' is specified. 9932 */ 9933 if (pl->pl_prop == ZPOOL_PROP_NAME && 9934 pl == cbp->cb_proplist) 9935 continue; 9936 9937 if (pl->pl_prop == ZPROP_INVAL) { 9938 prop_name = pl->pl_user_prop; 9939 } else { 9940 prop_name = (char *)vdev_prop_to_name(pl->pl_prop); 9941 } 9942 if (zpool_get_vdev_prop(zhp, vdevname, pl->pl_prop, 9943 prop_name, value, sizeof (value), &srctype, 9944 cbp->cb_literal) == 0) { 9945 zprop_print_one_property(vdevname, cbp, prop_name, 9946 value, srctype, NULL, NULL); 9947 } 9948 } 9949 9950 return (0); 9951 } 9952 9953 static int 9954 get_callback_vdev_width_cb(void *zhp_data, nvlist_t *nv, void *data) 9955 { 9956 zpool_handle_t *zhp = zhp_data; 9957 zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 9958 char *vdevname = zpool_vdev_name(g_zfs, zhp, nv, 9959 cbp->cb_vdevs.cb_name_flags); 9960 int ret; 9961 9962 /* Adjust the column widths for the vdev properties */ 9963 ret = vdev_expand_proplist(zhp, vdevname, &cbp->cb_proplist); 9964 9965 return (ret); 9966 } 9967 9968 static int 9969 get_callback_vdev_cb(void *zhp_data, nvlist_t *nv, void *data) 9970 { 9971 zpool_handle_t *zhp = zhp_data; 9972 zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 9973 char *vdevname = zpool_vdev_name(g_zfs, zhp, nv, 9974 cbp->cb_vdevs.cb_name_flags); 9975 int ret; 9976 9977 /* Display the properties */ 9978 ret = get_callback_vdev(zhp, vdevname, data); 9979 9980 return (ret); 9981 } 9982 9983 static int 9984 get_callback(zpool_handle_t *zhp, void *data) 9985 { 9986 zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data; 9987 char value[MAXNAMELEN]; 9988 zprop_source_t srctype; 9989 zprop_list_t *pl; 9990 int vid; 9991 9992 if (cbp->cb_type == ZFS_TYPE_VDEV) { 9993 if (strcmp(cbp->cb_vdevs.cb_names[0], "all-vdevs") == 0) { 9994 for_each_vdev(zhp, get_callback_vdev_width_cb, data); 9995 for_each_vdev(zhp, get_callback_vdev_cb, data); 9996 } else { 9997 /* Adjust column widths for vdev properties */ 9998 for (vid = 0; vid < cbp->cb_vdevs.cb_names_count; 9999 vid++) { 10000 vdev_expand_proplist(zhp, 10001 cbp->cb_vdevs.cb_names[vid], 10002 &cbp->cb_proplist); 10003 } 10004 /* Display the properties */ 10005 for (vid = 0; vid < cbp->cb_vdevs.cb_names_count; 10006 vid++) { 10007 get_callback_vdev(zhp, 10008 cbp->cb_vdevs.cb_names[vid], data); 10009 } 10010 } 10011 } else { 10012 assert(cbp->cb_type == ZFS_TYPE_POOL); 10013 for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) { 10014 /* 10015 * Skip the special fake placeholder. This will also 10016 * skip over the name property when 'all' is specified. 10017 */ 10018 if (pl->pl_prop == ZPOOL_PROP_NAME && 10019 pl == cbp->cb_proplist) 10020 continue; 10021 10022 if (pl->pl_prop == ZPROP_INVAL && 10023 (zpool_prop_feature(pl->pl_user_prop) || 10024 zpool_prop_unsupported(pl->pl_user_prop))) { 10025 srctype = ZPROP_SRC_LOCAL; 10026 10027 if (zpool_prop_get_feature(zhp, 10028 pl->pl_user_prop, value, 10029 sizeof (value)) == 0) { 10030 zprop_print_one_property( 10031 zpool_get_name(zhp), cbp, 10032 pl->pl_user_prop, value, srctype, 10033 NULL, NULL); 10034 } 10035 } else { 10036 if (zpool_get_prop(zhp, pl->pl_prop, value, 10037 sizeof (value), &srctype, 10038 cbp->cb_literal) != 0) 10039 continue; 10040 10041 zprop_print_one_property(zpool_get_name(zhp), 10042 cbp, zpool_prop_to_name(pl->pl_prop), 10043 value, srctype, NULL, NULL); 10044 } 10045 } 10046 } 10047 10048 return (0); 10049 } 10050 10051 /* 10052 * zpool get [-Hp] [-o "all" | field[,...]] <"all" | property[,...]> <pool> ... 10053 * 10054 * -H Scripted mode. Don't display headers, and separate properties 10055 * by a single tab. 10056 * -o List of columns to display. Defaults to 10057 * "name,property,value,source". 10058 * -p Display values in parsable (exact) format. 10059 * 10060 * Get properties of pools in the system. Output space statistics 10061 * for each one as well as other attributes. 10062 */ 10063 int 10064 zpool_do_get(int argc, char **argv) 10065 { 10066 zprop_get_cbdata_t cb = { 0 }; 10067 zprop_list_t fake_name = { 0 }; 10068 int ret; 10069 int c, i; 10070 char *value; 10071 char *propstr = NULL; 10072 10073 cb.cb_first = B_TRUE; 10074 10075 /* 10076 * Set up default columns and sources. 10077 */ 10078 cb.cb_sources = ZPROP_SRC_ALL; 10079 cb.cb_columns[0] = GET_COL_NAME; 10080 cb.cb_columns[1] = GET_COL_PROPERTY; 10081 cb.cb_columns[2] = GET_COL_VALUE; 10082 cb.cb_columns[3] = GET_COL_SOURCE; 10083 cb.cb_type = ZFS_TYPE_POOL; 10084 cb.cb_vdevs.cb_name_flags |= VDEV_NAME_TYPE_ID; 10085 current_prop_type = cb.cb_type; 10086 10087 /* check options */ 10088 while ((c = getopt(argc, argv, ":Hpo:")) != -1) { 10089 switch (c) { 10090 case 'p': 10091 cb.cb_literal = B_TRUE; 10092 break; 10093 case 'H': 10094 cb.cb_scripted = B_TRUE; 10095 break; 10096 case 'o': 10097 bzero(&cb.cb_columns, sizeof (cb.cb_columns)); 10098 i = 0; 10099 while (*optarg != '\0') { 10100 static char *col_subopts[] = 10101 { "name", "property", "value", "source", 10102 "all", NULL }; 10103 10104 if (i == ZFS_GET_NCOLS) { 10105 (void) fprintf(stderr, gettext("too " 10106 "many fields given to -o " 10107 "option\n")); 10108 usage(B_FALSE); 10109 } 10110 10111 switch (getsubopt(&optarg, col_subopts, 10112 &value)) { 10113 case 0: 10114 cb.cb_columns[i++] = GET_COL_NAME; 10115 break; 10116 case 1: 10117 cb.cb_columns[i++] = GET_COL_PROPERTY; 10118 break; 10119 case 2: 10120 cb.cb_columns[i++] = GET_COL_VALUE; 10121 break; 10122 case 3: 10123 cb.cb_columns[i++] = GET_COL_SOURCE; 10124 break; 10125 case 4: 10126 if (i > 0) { 10127 (void) fprintf(stderr, 10128 gettext("\"all\" conflicts " 10129 "with specific fields " 10130 "given to -o option\n")); 10131 usage(B_FALSE); 10132 } 10133 cb.cb_columns[0] = GET_COL_NAME; 10134 cb.cb_columns[1] = GET_COL_PROPERTY; 10135 cb.cb_columns[2] = GET_COL_VALUE; 10136 cb.cb_columns[3] = GET_COL_SOURCE; 10137 i = ZFS_GET_NCOLS; 10138 break; 10139 default: 10140 (void) fprintf(stderr, 10141 gettext("invalid column name " 10142 "'%s'\n"), value); 10143 usage(B_FALSE); 10144 } 10145 } 10146 break; 10147 case '?': 10148 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 10149 optopt); 10150 usage(B_FALSE); 10151 } 10152 } 10153 10154 argc -= optind; 10155 argv += optind; 10156 10157 if (argc < 1) { 10158 (void) fprintf(stderr, gettext("missing property " 10159 "argument\n")); 10160 usage(B_FALSE); 10161 } 10162 10163 /* Properties list is needed later by zprop_get_list() */ 10164 propstr = argv[0]; 10165 10166 argc--; 10167 argv++; 10168 10169 if (argc == 0) { 10170 /* No args, so just print the defaults. */ 10171 } else if (are_all_pools(argc, argv)) { 10172 /* All the args are pool names */ 10173 } else if (are_all_pools(1, argv)) { 10174 /* The first arg is a pool name */ 10175 if ((argc == 2 && strcmp(argv[1], "all-vdevs") == 0) || 10176 are_vdevs_in_pool(argc - 1, argv + 1, argv[0], 10177 &cb.cb_vdevs)) { 10178 /* ... and the rest are vdev names */ 10179 cb.cb_vdevs.cb_names = argv + 1; 10180 cb.cb_vdevs.cb_names_count = argc - 1; 10181 cb.cb_type = ZFS_TYPE_VDEV; 10182 argc = 1; /* One pool to process */ 10183 } else { 10184 fprintf(stderr, gettext("Expected a list of vdevs in" 10185 " \"%s\", but got:\n"), argv[0]); 10186 error_list_unresolved_vdevs(argc - 1, argv + 1, 10187 argv[0], &cb.cb_vdevs); 10188 fprintf(stderr, "\n"); 10189 usage(B_FALSE); 10190 return (1); 10191 } 10192 } else { 10193 /* 10194 * The first arg isn't a pool name, 10195 */ 10196 fprintf(stderr, gettext("missing pool name.\n")); 10197 fprintf(stderr, "\n"); 10198 usage(B_FALSE); 10199 return (1); 10200 } 10201 10202 if (zprop_get_list(g_zfs, propstr, &cb.cb_proplist, 10203 cb.cb_type) != 0) { 10204 /* Use correct list of valid properties (pool or vdev) */ 10205 current_prop_type = cb.cb_type; 10206 usage(B_FALSE); 10207 } 10208 10209 if (cb.cb_proplist != NULL) { 10210 fake_name.pl_prop = ZPOOL_PROP_NAME; 10211 fake_name.pl_width = strlen(gettext("NAME")); 10212 fake_name.pl_next = cb.cb_proplist; 10213 cb.cb_proplist = &fake_name; 10214 } 10215 10216 ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist, cb.cb_type, 10217 cb.cb_literal, get_callback, &cb); 10218 10219 if (cb.cb_proplist == &fake_name) 10220 zprop_free_list(fake_name.pl_next); 10221 else 10222 zprop_free_list(cb.cb_proplist); 10223 10224 return (ret); 10225 } 10226 10227 typedef struct set_cbdata { 10228 char *cb_propname; 10229 char *cb_value; 10230 zfs_type_t cb_type; 10231 vdev_cbdata_t cb_vdevs; 10232 boolean_t cb_any_successful; 10233 } set_cbdata_t; 10234 10235 static int 10236 set_pool_callback(zpool_handle_t *zhp, set_cbdata_t *cb) 10237 { 10238 int error; 10239 10240 /* Check if we have out-of-bounds features */ 10241 if (strcmp(cb->cb_propname, ZPOOL_CONFIG_COMPATIBILITY) == 0) { 10242 boolean_t features[SPA_FEATURES]; 10243 if (zpool_do_load_compat(cb->cb_value, features) != 10244 ZPOOL_COMPATIBILITY_OK) 10245 return (-1); 10246 10247 nvlist_t *enabled = zpool_get_features(zhp); 10248 spa_feature_t i; 10249 for (i = 0; i < SPA_FEATURES; i++) { 10250 const char *fguid = spa_feature_table[i].fi_guid; 10251 if (nvlist_exists(enabled, fguid) && !features[i]) 10252 break; 10253 } 10254 if (i < SPA_FEATURES) 10255 (void) fprintf(stderr, gettext("Warning: one or " 10256 "more features already enabled on pool '%s'\n" 10257 "are not present in this compatibility set.\n"), 10258 zpool_get_name(zhp)); 10259 } 10260 10261 /* if we're setting a feature, check it's in compatibility set */ 10262 if (zpool_prop_feature(cb->cb_propname) && 10263 strcmp(cb->cb_value, ZFS_FEATURE_ENABLED) == 0) { 10264 char *fname = strchr(cb->cb_propname, '@') + 1; 10265 spa_feature_t f; 10266 10267 if (zfeature_lookup_name(fname, &f) == 0) { 10268 char compat[ZFS_MAXPROPLEN]; 10269 if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY, 10270 compat, ZFS_MAXPROPLEN, NULL, B_FALSE) != 0) 10271 compat[0] = '\0'; 10272 10273 boolean_t features[SPA_FEATURES]; 10274 if (zpool_do_load_compat(compat, features) != 10275 ZPOOL_COMPATIBILITY_OK) { 10276 (void) fprintf(stderr, gettext("Error: " 10277 "cannot enable feature '%s' on pool '%s'\n" 10278 "because the pool's 'compatibility' " 10279 "property cannot be parsed.\n"), 10280 fname, zpool_get_name(zhp)); 10281 return (-1); 10282 } 10283 10284 if (!features[f]) { 10285 (void) fprintf(stderr, gettext("Error: " 10286 "cannot enable feature '%s' on pool '%s'\n" 10287 "as it is not specified in this pool's " 10288 "current compatibility set.\n" 10289 "Consider setting 'compatibility' to a " 10290 "less restrictive set, or to 'off'.\n"), 10291 fname, zpool_get_name(zhp)); 10292 return (-1); 10293 } 10294 } 10295 } 10296 10297 error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value); 10298 10299 return (error); 10300 } 10301 10302 static int 10303 set_callback(zpool_handle_t *zhp, void *data) 10304 { 10305 int error; 10306 set_cbdata_t *cb = (set_cbdata_t *)data; 10307 10308 if (cb->cb_type == ZFS_TYPE_VDEV) { 10309 error = zpool_set_vdev_prop(zhp, *cb->cb_vdevs.cb_names, 10310 cb->cb_propname, cb->cb_value); 10311 } else { 10312 assert(cb->cb_type == ZFS_TYPE_POOL); 10313 error = set_pool_callback(zhp, cb); 10314 } 10315 10316 cb->cb_any_successful = !error; 10317 return (error); 10318 } 10319 10320 int 10321 zpool_do_set(int argc, char **argv) 10322 { 10323 set_cbdata_t cb = { 0 }; 10324 int error; 10325 10326 current_prop_type = ZFS_TYPE_POOL; 10327 if (argc > 1 && argv[1][0] == '-') { 10328 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 10329 argv[1][1]); 10330 usage(B_FALSE); 10331 } 10332 10333 if (argc < 2) { 10334 (void) fprintf(stderr, gettext("missing property=value " 10335 "argument\n")); 10336 usage(B_FALSE); 10337 } 10338 10339 if (argc < 3) { 10340 (void) fprintf(stderr, gettext("missing pool name\n")); 10341 usage(B_FALSE); 10342 } 10343 10344 if (argc > 4) { 10345 (void) fprintf(stderr, gettext("too many pool names\n")); 10346 usage(B_FALSE); 10347 } 10348 10349 cb.cb_propname = argv[1]; 10350 cb.cb_type = ZFS_TYPE_POOL; 10351 cb.cb_vdevs.cb_name_flags |= VDEV_NAME_TYPE_ID; 10352 cb.cb_value = strchr(cb.cb_propname, '='); 10353 if (cb.cb_value == NULL) { 10354 (void) fprintf(stderr, gettext("missing value in " 10355 "property=value argument\n")); 10356 usage(B_FALSE); 10357 } 10358 10359 *(cb.cb_value) = '\0'; 10360 cb.cb_value++; 10361 argc -= 2; 10362 argv += 2; 10363 10364 if (are_vdevs_in_pool(argc, argv, NULL, &cb.cb_vdevs)) { 10365 /* Argument is a vdev */ 10366 cb.cb_vdevs.cb_names = argv; 10367 cb.cb_vdevs.cb_names_count = 1; 10368 cb.cb_type = ZFS_TYPE_VDEV; 10369 argc = 0; /* No pools to process */ 10370 } else if (are_all_pools(1, argv)) { 10371 /* The first arg is a pool name */ 10372 if (are_vdevs_in_pool(argc - 1, argv + 1, argv[0], 10373 &cb.cb_vdevs)) { 10374 /* 2nd argument is a vdev */ 10375 cb.cb_vdevs.cb_names = argv + 1; 10376 cb.cb_vdevs.cb_names_count = 1; 10377 cb.cb_type = ZFS_TYPE_VDEV; 10378 argc = 1; /* One pool to process */ 10379 } else if (argc > 1) { 10380 (void) fprintf(stderr, 10381 gettext("too many pool names\n")); 10382 usage(B_FALSE); 10383 } 10384 } 10385 10386 error = for_each_pool(argc, argv, B_TRUE, NULL, ZFS_TYPE_POOL, 10387 B_FALSE, set_callback, &cb); 10388 10389 return (error); 10390 } 10391 10392 /* Add up the total number of bytes left to initialize/trim across all vdevs */ 10393 static uint64_t 10394 vdev_activity_remaining(nvlist_t *nv, zpool_wait_activity_t activity) 10395 { 10396 uint64_t bytes_remaining; 10397 nvlist_t **child; 10398 uint_t c, children; 10399 vdev_stat_t *vs; 10400 10401 assert(activity == ZPOOL_WAIT_INITIALIZE || 10402 activity == ZPOOL_WAIT_TRIM); 10403 10404 verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS, 10405 (uint64_t **)&vs, &c) == 0); 10406 10407 if (activity == ZPOOL_WAIT_INITIALIZE && 10408 vs->vs_initialize_state == VDEV_INITIALIZE_ACTIVE) 10409 bytes_remaining = vs->vs_initialize_bytes_est - 10410 vs->vs_initialize_bytes_done; 10411 else if (activity == ZPOOL_WAIT_TRIM && 10412 vs->vs_trim_state == VDEV_TRIM_ACTIVE) 10413 bytes_remaining = vs->vs_trim_bytes_est - 10414 vs->vs_trim_bytes_done; 10415 else 10416 bytes_remaining = 0; 10417 10418 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 10419 &child, &children) != 0) 10420 children = 0; 10421 10422 for (c = 0; c < children; c++) 10423 bytes_remaining += vdev_activity_remaining(child[c], activity); 10424 10425 return (bytes_remaining); 10426 } 10427 10428 /* Add up the total number of bytes left to rebuild across top-level vdevs */ 10429 static uint64_t 10430 vdev_activity_top_remaining(nvlist_t *nv) 10431 { 10432 uint64_t bytes_remaining = 0; 10433 nvlist_t **child; 10434 uint_t children; 10435 int error; 10436 10437 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 10438 &child, &children) != 0) 10439 children = 0; 10440 10441 for (uint_t c = 0; c < children; c++) { 10442 vdev_rebuild_stat_t *vrs; 10443 uint_t i; 10444 10445 error = nvlist_lookup_uint64_array(child[c], 10446 ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs, &i); 10447 if (error == 0) { 10448 if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) { 10449 bytes_remaining += (vrs->vrs_bytes_est - 10450 vrs->vrs_bytes_rebuilt); 10451 } 10452 } 10453 } 10454 10455 return (bytes_remaining); 10456 } 10457 10458 /* Whether any vdevs are 'spare' or 'replacing' vdevs */ 10459 static boolean_t 10460 vdev_any_spare_replacing(nvlist_t *nv) 10461 { 10462 nvlist_t **child; 10463 uint_t c, children; 10464 char *vdev_type; 10465 10466 (void) nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &vdev_type); 10467 10468 if (strcmp(vdev_type, VDEV_TYPE_REPLACING) == 0 || 10469 strcmp(vdev_type, VDEV_TYPE_SPARE) == 0 || 10470 strcmp(vdev_type, VDEV_TYPE_DRAID_SPARE) == 0) { 10471 return (B_TRUE); 10472 } 10473 10474 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 10475 &child, &children) != 0) 10476 children = 0; 10477 10478 for (c = 0; c < children; c++) { 10479 if (vdev_any_spare_replacing(child[c])) 10480 return (B_TRUE); 10481 } 10482 10483 return (B_FALSE); 10484 } 10485 10486 typedef struct wait_data { 10487 char *wd_poolname; 10488 boolean_t wd_scripted; 10489 boolean_t wd_exact; 10490 boolean_t wd_headers_once; 10491 boolean_t wd_should_exit; 10492 /* Which activities to wait for */ 10493 boolean_t wd_enabled[ZPOOL_WAIT_NUM_ACTIVITIES]; 10494 float wd_interval; 10495 pthread_cond_t wd_cv; 10496 pthread_mutex_t wd_mutex; 10497 } wait_data_t; 10498 10499 /* 10500 * Print to stdout a single line, containing one column for each activity that 10501 * we are waiting for specifying how many bytes of work are left for that 10502 * activity. 10503 */ 10504 static void 10505 print_wait_status_row(wait_data_t *wd, zpool_handle_t *zhp, int row) 10506 { 10507 nvlist_t *config, *nvroot; 10508 uint_t c; 10509 int i; 10510 pool_checkpoint_stat_t *pcs = NULL; 10511 pool_scan_stat_t *pss = NULL; 10512 pool_removal_stat_t *prs = NULL; 10513 char *headers[] = {"DISCARD", "FREE", "INITIALIZE", "REPLACE", 10514 "REMOVE", "RESILVER", "SCRUB", "TRIM"}; 10515 int col_widths[ZPOOL_WAIT_NUM_ACTIVITIES]; 10516 10517 /* Calculate the width of each column */ 10518 for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) { 10519 /* 10520 * Make sure we have enough space in the col for pretty-printed 10521 * numbers and for the column header, and then leave a couple 10522 * spaces between cols for readability. 10523 */ 10524 col_widths[i] = MAX(strlen(headers[i]), 6) + 2; 10525 } 10526 10527 /* Print header if appropriate */ 10528 int term_height = terminal_height(); 10529 boolean_t reprint_header = (!wd->wd_headers_once && term_height > 0 && 10530 row % (term_height-1) == 0); 10531 if (!wd->wd_scripted && (row == 0 || reprint_header)) { 10532 for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) { 10533 if (wd->wd_enabled[i]) 10534 (void) printf("%*s", col_widths[i], headers[i]); 10535 } 10536 (void) printf("\n"); 10537 } 10538 10539 /* Bytes of work remaining in each activity */ 10540 int64_t bytes_rem[ZPOOL_WAIT_NUM_ACTIVITIES] = {0}; 10541 10542 bytes_rem[ZPOOL_WAIT_FREE] = 10543 zpool_get_prop_int(zhp, ZPOOL_PROP_FREEING, NULL); 10544 10545 config = zpool_get_config(zhp, NULL); 10546 nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 10547 10548 (void) nvlist_lookup_uint64_array(nvroot, 10549 ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c); 10550 if (pcs != NULL && pcs->pcs_state == CS_CHECKPOINT_DISCARDING) 10551 bytes_rem[ZPOOL_WAIT_CKPT_DISCARD] = pcs->pcs_space; 10552 10553 (void) nvlist_lookup_uint64_array(nvroot, 10554 ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t **)&prs, &c); 10555 if (prs != NULL && prs->prs_state == DSS_SCANNING) 10556 bytes_rem[ZPOOL_WAIT_REMOVE] = prs->prs_to_copy - 10557 prs->prs_copied; 10558 10559 (void) nvlist_lookup_uint64_array(nvroot, 10560 ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&pss, &c); 10561 if (pss != NULL && pss->pss_state == DSS_SCANNING && 10562 pss->pss_pass_scrub_pause == 0) { 10563 int64_t rem = pss->pss_to_examine - pss->pss_issued; 10564 if (pss->pss_func == POOL_SCAN_SCRUB) 10565 bytes_rem[ZPOOL_WAIT_SCRUB] = rem; 10566 else 10567 bytes_rem[ZPOOL_WAIT_RESILVER] = rem; 10568 } else if (check_rebuilding(nvroot, NULL)) { 10569 bytes_rem[ZPOOL_WAIT_RESILVER] = 10570 vdev_activity_top_remaining(nvroot); 10571 } 10572 10573 bytes_rem[ZPOOL_WAIT_INITIALIZE] = 10574 vdev_activity_remaining(nvroot, ZPOOL_WAIT_INITIALIZE); 10575 bytes_rem[ZPOOL_WAIT_TRIM] = 10576 vdev_activity_remaining(nvroot, ZPOOL_WAIT_TRIM); 10577 10578 /* 10579 * A replace finishes after resilvering finishes, so the amount of work 10580 * left for a replace is the same as for resilvering. 10581 * 10582 * It isn't quite correct to say that if we have any 'spare' or 10583 * 'replacing' vdevs and a resilver is happening, then a replace is in 10584 * progress, like we do here. When a hot spare is used, the faulted vdev 10585 * is not removed after the hot spare is resilvered, so parent 'spare' 10586 * vdev is not removed either. So we could have a 'spare' vdev, but be 10587 * resilvering for a different reason. However, we use it as a heuristic 10588 * because we don't have access to the DTLs, which could tell us whether 10589 * or not we have really finished resilvering a hot spare. 10590 */ 10591 if (vdev_any_spare_replacing(nvroot)) 10592 bytes_rem[ZPOOL_WAIT_REPLACE] = bytes_rem[ZPOOL_WAIT_RESILVER]; 10593 10594 if (timestamp_fmt != NODATE) 10595 print_timestamp(timestamp_fmt); 10596 10597 for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) { 10598 char buf[64]; 10599 if (!wd->wd_enabled[i]) 10600 continue; 10601 10602 if (wd->wd_exact) 10603 (void) snprintf(buf, sizeof (buf), "%" PRIi64, 10604 bytes_rem[i]); 10605 else 10606 zfs_nicenum(bytes_rem[i], buf, sizeof (buf)); 10607 10608 if (wd->wd_scripted) 10609 (void) printf(i == 0 ? "%s" : "\t%s", buf); 10610 else 10611 (void) printf(" %*s", col_widths[i] - 1, buf); 10612 } 10613 (void) printf("\n"); 10614 (void) fflush(stdout); 10615 } 10616 10617 static void * 10618 wait_status_thread(void *arg) 10619 { 10620 wait_data_t *wd = (wait_data_t *)arg; 10621 zpool_handle_t *zhp; 10622 10623 if ((zhp = zpool_open(g_zfs, wd->wd_poolname)) == NULL) 10624 return (void *)(1); 10625 10626 for (int row = 0; ; row++) { 10627 boolean_t missing; 10628 struct timespec timeout; 10629 int ret = 0; 10630 (void) clock_gettime(CLOCK_REALTIME, &timeout); 10631 10632 if (zpool_refresh_stats(zhp, &missing) != 0 || missing || 10633 zpool_props_refresh(zhp) != 0) { 10634 zpool_close(zhp); 10635 return (void *)(uintptr_t)(missing ? 0 : 1); 10636 } 10637 10638 print_wait_status_row(wd, zhp, row); 10639 10640 timeout.tv_sec += floor(wd->wd_interval); 10641 long nanos = timeout.tv_nsec + 10642 (wd->wd_interval - floor(wd->wd_interval)) * NANOSEC; 10643 if (nanos >= NANOSEC) { 10644 timeout.tv_sec++; 10645 timeout.tv_nsec = nanos - NANOSEC; 10646 } else { 10647 timeout.tv_nsec = nanos; 10648 } 10649 pthread_mutex_lock(&wd->wd_mutex); 10650 if (!wd->wd_should_exit) 10651 ret = pthread_cond_timedwait(&wd->wd_cv, &wd->wd_mutex, 10652 &timeout); 10653 pthread_mutex_unlock(&wd->wd_mutex); 10654 if (ret == 0) { 10655 break; /* signaled by main thread */ 10656 } else if (ret != ETIMEDOUT) { 10657 (void) fprintf(stderr, gettext("pthread_cond_timedwait " 10658 "failed: %s\n"), strerror(ret)); 10659 zpool_close(zhp); 10660 return (void *)(uintptr_t)(1); 10661 } 10662 } 10663 10664 zpool_close(zhp); 10665 return (void *)(0); 10666 } 10667 10668 int 10669 zpool_do_wait(int argc, char **argv) 10670 { 10671 boolean_t verbose = B_FALSE; 10672 int c; 10673 char *value; 10674 int i; 10675 unsigned long count; 10676 pthread_t status_thr; 10677 int error = 0; 10678 zpool_handle_t *zhp; 10679 10680 wait_data_t wd; 10681 wd.wd_scripted = B_FALSE; 10682 wd.wd_exact = B_FALSE; 10683 wd.wd_headers_once = B_FALSE; 10684 wd.wd_should_exit = B_FALSE; 10685 10686 pthread_mutex_init(&wd.wd_mutex, NULL); 10687 pthread_cond_init(&wd.wd_cv, NULL); 10688 10689 /* By default, wait for all types of activity. */ 10690 for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) 10691 wd.wd_enabled[i] = B_TRUE; 10692 10693 while ((c = getopt(argc, argv, "HpT:t:")) != -1) { 10694 switch (c) { 10695 case 'H': 10696 wd.wd_scripted = B_TRUE; 10697 break; 10698 case 'n': 10699 wd.wd_headers_once = B_TRUE; 10700 break; 10701 case 'p': 10702 wd.wd_exact = B_TRUE; 10703 break; 10704 case 'T': 10705 get_timestamp_arg(*optarg); 10706 break; 10707 case 't': 10708 { 10709 static char *col_subopts[] = { "discard", "free", 10710 "initialize", "replace", "remove", "resilver", 10711 "scrub", "trim", NULL }; 10712 10713 /* Reset activities array */ 10714 bzero(&wd.wd_enabled, sizeof (wd.wd_enabled)); 10715 while (*optarg != '\0') { 10716 int activity = getsubopt(&optarg, col_subopts, 10717 &value); 10718 10719 if (activity < 0) { 10720 (void) fprintf(stderr, 10721 gettext("invalid activity '%s'\n"), 10722 value); 10723 usage(B_FALSE); 10724 } 10725 10726 wd.wd_enabled[activity] = B_TRUE; 10727 } 10728 break; 10729 } 10730 case '?': 10731 (void) fprintf(stderr, gettext("invalid option '%c'\n"), 10732 optopt); 10733 usage(B_FALSE); 10734 } 10735 } 10736 10737 argc -= optind; 10738 argv += optind; 10739 10740 get_interval_count(&argc, argv, &wd.wd_interval, &count); 10741 if (count != 0) { 10742 /* This subcmd only accepts an interval, not a count */ 10743 (void) fprintf(stderr, gettext("too many arguments\n")); 10744 usage(B_FALSE); 10745 } 10746 10747 if (wd.wd_interval != 0) 10748 verbose = B_TRUE; 10749 10750 if (argc < 1) { 10751 (void) fprintf(stderr, gettext("missing 'pool' argument\n")); 10752 usage(B_FALSE); 10753 } 10754 if (argc > 1) { 10755 (void) fprintf(stderr, gettext("too many arguments\n")); 10756 usage(B_FALSE); 10757 } 10758 10759 wd.wd_poolname = argv[0]; 10760 10761 if ((zhp = zpool_open(g_zfs, wd.wd_poolname)) == NULL) 10762 return (1); 10763 10764 if (verbose) { 10765 /* 10766 * We use a separate thread for printing status updates because 10767 * the main thread will call lzc_wait(), which blocks as long 10768 * as an activity is in progress, which can be a long time. 10769 */ 10770 if (pthread_create(&status_thr, NULL, wait_status_thread, &wd) 10771 != 0) { 10772 (void) fprintf(stderr, gettext("failed to create status" 10773 "thread: %s\n"), strerror(errno)); 10774 zpool_close(zhp); 10775 return (1); 10776 } 10777 } 10778 10779 /* 10780 * Loop over all activities that we are supposed to wait for until none 10781 * of them are in progress. Note that this means we can end up waiting 10782 * for more activities to complete than just those that were in progress 10783 * when we began waiting; if an activity we are interested in begins 10784 * while we are waiting for another activity, we will wait for both to 10785 * complete before exiting. 10786 */ 10787 for (;;) { 10788 boolean_t missing = B_FALSE; 10789 boolean_t any_waited = B_FALSE; 10790 10791 for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) { 10792 boolean_t waited; 10793 10794 if (!wd.wd_enabled[i]) 10795 continue; 10796 10797 error = zpool_wait_status(zhp, i, &missing, &waited); 10798 if (error != 0 || missing) 10799 break; 10800 10801 any_waited = (any_waited || waited); 10802 } 10803 10804 if (error != 0 || missing || !any_waited) 10805 break; 10806 } 10807 10808 zpool_close(zhp); 10809 10810 if (verbose) { 10811 uintptr_t status; 10812 pthread_mutex_lock(&wd.wd_mutex); 10813 wd.wd_should_exit = B_TRUE; 10814 pthread_cond_signal(&wd.wd_cv); 10815 pthread_mutex_unlock(&wd.wd_mutex); 10816 (void) pthread_join(status_thr, (void *)&status); 10817 if (status != 0) 10818 error = status; 10819 } 10820 10821 pthread_mutex_destroy(&wd.wd_mutex); 10822 pthread_cond_destroy(&wd.wd_cv); 10823 return (error); 10824 } 10825 10826 static int 10827 find_command_idx(char *command, int *idx) 10828 { 10829 int i; 10830 10831 for (i = 0; i < NCOMMAND; i++) { 10832 if (command_table[i].name == NULL) 10833 continue; 10834 10835 if (strcmp(command, command_table[i].name) == 0) { 10836 *idx = i; 10837 return (0); 10838 } 10839 } 10840 return (1); 10841 } 10842 10843 /* 10844 * Display version message 10845 */ 10846 static int 10847 zpool_do_version(int argc, char **argv) 10848 { 10849 (void) argc, (void) argv; 10850 10851 if (zfs_version_print() == -1) 10852 return (1); 10853 10854 return (0); 10855 } 10856 10857 /* 10858 * Do zpool_load_compat() and print error message on failure 10859 */ 10860 static zpool_compat_status_t 10861 zpool_do_load_compat(const char *compat, boolean_t *list) 10862 { 10863 char report[1024]; 10864 10865 zpool_compat_status_t ret; 10866 10867 ret = zpool_load_compat(compat, list, report, 1024); 10868 switch (ret) { 10869 10870 case ZPOOL_COMPATIBILITY_OK: 10871 break; 10872 10873 case ZPOOL_COMPATIBILITY_NOFILES: 10874 case ZPOOL_COMPATIBILITY_BADFILE: 10875 case ZPOOL_COMPATIBILITY_BADTOKEN: 10876 (void) fprintf(stderr, "Error: %s\n", report); 10877 break; 10878 10879 case ZPOOL_COMPATIBILITY_WARNTOKEN: 10880 (void) fprintf(stderr, "Warning: %s\n", report); 10881 ret = ZPOOL_COMPATIBILITY_OK; 10882 break; 10883 } 10884 return (ret); 10885 } 10886 10887 int 10888 main(int argc, char **argv) 10889 { 10890 int ret = 0; 10891 int i = 0; 10892 char *cmdname; 10893 char **newargv; 10894 10895 (void) setlocale(LC_ALL, ""); 10896 (void) setlocale(LC_NUMERIC, "C"); 10897 (void) textdomain(TEXT_DOMAIN); 10898 srand(time(NULL)); 10899 10900 opterr = 0; 10901 10902 /* 10903 * Make sure the user has specified some command. 10904 */ 10905 if (argc < 2) { 10906 (void) fprintf(stderr, gettext("missing command\n")); 10907 usage(B_FALSE); 10908 } 10909 10910 cmdname = argv[1]; 10911 10912 /* 10913 * Special case '-?' 10914 */ 10915 if ((strcmp(cmdname, "-?") == 0) || strcmp(cmdname, "--help") == 0) 10916 usage(B_TRUE); 10917 10918 /* 10919 * Special case '-V|--version' 10920 */ 10921 if ((strcmp(cmdname, "-V") == 0) || (strcmp(cmdname, "--version") == 0)) 10922 return (zpool_do_version(argc, argv)); 10923 10924 if ((g_zfs = libzfs_init()) == NULL) { 10925 (void) fprintf(stderr, "%s\n", libzfs_error_init(errno)); 10926 return (1); 10927 } 10928 10929 libzfs_print_on_error(g_zfs, B_TRUE); 10930 10931 zfs_save_arguments(argc, argv, history_str, sizeof (history_str)); 10932 10933 /* 10934 * Many commands modify input strings for string parsing reasons. 10935 * We create a copy to protect the original argv. 10936 */ 10937 newargv = malloc((argc + 1) * sizeof (newargv[0])); 10938 for (i = 0; i < argc; i++) 10939 newargv[i] = strdup(argv[i]); 10940 newargv[argc] = NULL; 10941 10942 /* 10943 * Run the appropriate command. 10944 */ 10945 if (find_command_idx(cmdname, &i) == 0) { 10946 current_command = &command_table[i]; 10947 ret = command_table[i].func(argc - 1, newargv + 1); 10948 } else if (strchr(cmdname, '=')) { 10949 verify(find_command_idx("set", &i) == 0); 10950 current_command = &command_table[i]; 10951 ret = command_table[i].func(argc, newargv); 10952 } else if (strcmp(cmdname, "freeze") == 0 && argc == 3) { 10953 /* 10954 * 'freeze' is a vile debugging abomination, so we treat 10955 * it as such. 10956 */ 10957 zfs_cmd_t zc = {"\0"}; 10958 10959 (void) strlcpy(zc.zc_name, argv[2], sizeof (zc.zc_name)); 10960 ret = zfs_ioctl(g_zfs, ZFS_IOC_POOL_FREEZE, &zc); 10961 if (ret != 0) { 10962 (void) fprintf(stderr, 10963 gettext("failed to freeze pool: %d\n"), errno); 10964 ret = 1; 10965 } 10966 10967 log_history = 0; 10968 } else { 10969 (void) fprintf(stderr, gettext("unrecognized " 10970 "command '%s'\n"), cmdname); 10971 usage(B_FALSE); 10972 ret = 1; 10973 } 10974 10975 for (i = 0; i < argc; i++) 10976 free(newargv[i]); 10977 free(newargv); 10978 10979 if (ret == 0 && log_history) 10980 (void) zpool_log_history(g_zfs, history_str); 10981 10982 libzfs_fini(g_zfs); 10983 10984 /* 10985 * The 'ZFS_ABORT' environment variable causes us to dump core on exit 10986 * for the purposes of running ::findleaks. 10987 */ 10988 if (getenv("ZFS_ABORT") != NULL) { 10989 (void) printf("dumping core by request\n"); 10990 abort(); 10991 } 10992 10993 return (ret); 10994 } 10995