| blob | f99145da9632f46bdc7361da4f9ebf59dedf5463 |
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 */
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, 2015 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 */
33 #include <assert.h>
34 #include <ctype.h>
35 #include <dirent.h>
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <libgen.h>
39 #include <libintl.h>
40 #include <libuutil.h>
41 #include <locale.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <strings.h>
46 #include <unistd.h>
47 #include <pwd.h>
48 #include <zone.h>
49 #include <sys/wait.h>
50 #include <zfs_prop.h>
51 #include <sys/fs/zfs.h>
52 #include <sys/stat.h>
53 #include <sys/fm/fs/zfs.h>
54 #include <sys/fm/util.h>
55 #include <sys/fm/protocol.h>
56 #include <sys/zfs_ioctl.h>
58 #include <math.h>
60 #include <libzfs.h>
106 /*
107 * These libumem hooks provide a reasonable set of defaults for the allocator's
108 * debugging facilities.
109 */
111 #ifdef DEBUG
114 {
116 }
120 {
122 }
123 #endif
126 HELP_ADD,
127 HELP_ATTACH,
128 HELP_CLEAR,
129 HELP_CREATE,
130 HELP_DESTROY,
131 HELP_DETACH,
132 HELP_EXPORT,
133 HELP_HISTORY,
134 HELP_IMPORT,
135 HELP_IOSTAT,
136 HELP_LABELCLEAR,
137 HELP_LIST,
138 HELP_OFFLINE,
139 HELP_ONLINE,
140 HELP_REPLACE,
141 HELP_REMOVE,
142 HELP_SCRUB,
143 HELP_STATUS,
144 HELP_UPGRADE,
145 HELP_EVENTS,
146 HELP_GET,
147 HELP_SET,
148 HELP_SPLIT,
149 HELP_SYNC,
150 HELP_REGUID,
151 HELP_REOPEN
155 /*
156 * Flags for stats to display with "zpool iostats"
157 */
165 };
167 /* iostat_type entries as bitmasks */
168 #define IOS_DEFAULT_M (1ULL << IOS_DEFAULT)
169 #define IOS_LATENCY_M (1ULL << IOS_LATENCY)
170 #define IOS_QUEUES_M (1ULL << IOS_QUEUES)
171 #define IOS_L_HISTO_M (1ULL << IOS_L_HISTO)
172 #define IOS_RQ_HISTO_M (1ULL << IOS_RQ_HISTO)
174 /* Mask of all the histo bits */
175 #define IOS_ANYHISTO_M (IOS_L_HISTO_M | IOS_RQ_HISTO_M)
177 /*
178 * Lookup table for iostat flags to nvlist names. Basically a list
179 * of all the nvlists a flag requires. Also specifies the order in
180 * which data gets printed in zpool iostat.
181 */
184 ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
185 ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
186 ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
187 ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
188 ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
189 ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
190 ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
191 ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
192 ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
193 NULL},
195 ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
196 ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
197 ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
198 ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
199 NULL},
201 ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
202 ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
203 ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
204 ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
205 ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
206 NULL},
208 ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO,
209 ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO,
210 ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO,
211 ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO,
212 ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO,
213 ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO,
214 ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO,
215 ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO,
216 ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO,
217 ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO,
218 NULL},
219 };
222 /*
223 * Given a cb->cb_flags with a histogram bit set, return the iostat_type.
224 * Right now, only one histo bit is ever set at one time, so we can
225 * just do a highbit64(a)
226 */
227 #define IOS_HISTO_IDX(a) (highbit64(a & IOS_ANYHISTO_M) - 1)
232 zpool_help_t usage;
235 /*
236 * Master command table. Each ZFS command has a name, associated function, and
237 * usage message. The usage messages need to be internationalized, so we have
238 * to have a function to return the usage message based on a command index.
239 *
240 * These commands are organized according to how they are displayed in the usage
241 * message. An empty command (one with a NULL name) indicates an empty line in
242 * the generic usage message.
243 */
280 };
282 #define NCOMMAND (ARRAY_SIZE(command_table))
291 {
368 }
371 /* NOTREACHED */
372 }
375 /*
376 * Callback routine that will print out a pool property value.
377 */
378 static int
380 {
387 else
392 else
396 }
398 /*
399 * Display usage message. If we're inside a command, display only the usage for
400 * that command. Otherwise, iterate over the entire command table and display
401 * a complete usage message.
402 */
403 void
405 {
418 else
421 }
425 }
438 /* Iterate over all properties */
440 ZFS_TYPE_POOL);
447 }
449 /*
450 * See comments at end of main().
451 */
455 }
458 }
460 void
463 {
487 }
488 }
490 static boolean_t
492 {
498 }
500 }
502 /*
503 * Add a property pair (name, string-value) into a property nvlist.
504 */
505 static int
507 boolean_t poolprop)
508 {
510 zfs_prop_t fprop;
520 }
532 }
534 /*
535 * feature@ properties and version should not be specified
536 * at the same time.
537 */
543 "'version' properties cannot be specified "
546 }
551 else
558 }
559 }
566 }
572 }
575 }
577 /*
578 * Set a default property pair (name, string-value) in a property nvlist
579 */
580 static int
582 boolean_t poolprop)
583 {
590 }
592 /*
593 * zpool add [-fgLnP] [-o property=value] <pool> <vdev> ...
594 *
595 * -f Force addition of devices, even if they appear in use
596 * -g Display guid for individual vdev name.
597 * -L Follow links when resolving vdev path name.
598 * -n Do not add the devices, but display the resulting layout if
599 * they were to be added.
600 * -o Set property=value.
601 * -P Display full path for vdev name.
602 *
603 * Adds the given vdevs to 'pool'. As with create, the bulk of this work is
604 * handled by get_vdev_spec(), which constructs the nvlist needed to pass to
605 * libzfs.
606 */
607 int
609 {
622 /* check options */
642 }
644 propval++;
655 optopt);
657 }
658 }
663 /* get pool name and check number of arguments */
667 }
671 }
675 argc--;
676 argv++;
683 poolname);
686 }
688 /* unless manually specified use "ashift" pool property (if set) */
691 zprop_source_t src;
699 }
700 }
702 /* pass off to get_vdev_spec for processing */
708 }
723 /* print original main pool and new tree */
725 name_flags);
728 /* Do the same for the logs */
731 name_flags);
733 name_flags);
736 name_flags);
737 }
739 /* Do the same for the caches */
749 }
750 }
760 }
761 }
766 }
773 }
775 /*
776 * zpool remove <pool> <vdev> ...
777 *
778 * Removes the given vdev from the pool. Currently, this supports removing
779 * spares, cache, and log devices from the pool.
780 */
781 int
783 {
788 argc--;
789 argv++;
791 /* get pool name and check number of arguments */
795 }
799 }
809 }
813 }
815 /*
816 * zpool labelclear [-f] <vdev>
817 *
818 * -f Force clearing the label for the vdevs which are members of
819 * the exported or foreign pools.
820 *
821 * Verifies that the vdev is not active and zeros out the label information
822 * on the device.
823 */
824 int
826 {
832 pool_state_t state;
836 /* check options */
844 optopt);
846 }
847 }
852 /* get vdev name */
856 }
860 }
862 /*
863 * Check if we were given absolute path and use it as is.
864 * Otherwise if the provided vdev name doesn't point to a file,
865 * try prepending expected disk paths and partition numbers.
866 */
875 }
879 "failed to find device %s, try specifying absolute "
882 }
883 }
889 }
899 }
907 }
944 /* inuse should never be set for a destroyed pool */
947 }
949 wipe_label:
954 }
956 errout:
961 }
963 /*
964 * zpool create [-fnd] [-o property=value] ...
965 * [-O file-system-property=value] ...
966 * [-R root] [-m mountpoint] <pool> <dev> ...
967 *
968 * -f Force creation, even if devices appear in use
969 * -n Do not create the pool, but display the resulting layout if it
970 * were to be created.
971 * -R Create a pool under an alternate root
972 * -m Set default mountpoint for the root dataset. By default it's
973 * '/<pool>'
974 * -o Set property=value.
975 * -o Set feature@feature=enabled|disabled.
976 * -d Don't automatically enable all supported pool features
977 * (individual features can be enabled with -o).
978 * -O Set fsproperty=value in the pool's root file system
979 *
980 * Creates the named pool according to the given vdev specification. The
981 * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c. Once
982 * we get the nvlist back from get_vdev_spec(), we either print out the contents
983 * (if '-n' was specified), or pass it to libzfs to do the creation.
984 */
985 int
987 {
1002 /* check options */
1024 /* Equivalent to -O mountpoint=optarg */
1032 }
1034 propval++;
1039 /*
1040 * If the user is creating a pool that doesn't support
1041 * feature flags, don't enable any features.
1042 */
1045 u_longlong_t ver;
1051 }
1052 }
1061 }
1063 propval++;
1065 /*
1066 * Mountpoints are checked and then added later.
1067 * Uniquely among properties, they can be specified
1068 * more than once, to avoid conflict with -m.
1069 */
1074 B_FALSE)) {
1076 }
1079 /*
1080 * Sanity check temporary pool name.
1081 */
1084 "'%s': invalid character '/' in temporary "
1089 }
1105 optopt);
1107 }
1108 }
1113 /* get pool name and check number of arguments */
1117 }
1121 }
1125 /*
1126 * As a special case, check for use of '/' in the name, and direct the
1127 * user to use 'zfs create' instead.
1128 */
1135 }
1137 /* pass off to get_vdev_spec for bulk processing */
1143 /* make_root_vdev() allows 0 toplevel children if there are spares */
1146 "specification: at least one toplevel vdev must be "
1149 }
1155 }
1157 /*
1158 * Check the validity of the mountpoint and direct the user to use the
1159 * '-m' mountpoint option if it looks like its in use.
1160 */
1169 "'%s': must be an absolute path, 'legacy', or "
1172 }
1178 else
1180 poolname);
1185 else
1187 mountpoint);
1188 }
1200 count++;
1207 "option to provide a "
1210 }
1211 }
1212 }
1214 /*
1215 * Now that the mountpoint's validity has been checked, ensure that
1216 * the property is set appropriately prior to creating the pool.
1217 */
1223 }
1227 /*
1228 * For a dry run invocation, print out a basic message and run
1229 * through all the vdevs in the list and print out in an
1230 * appropriate hierarchy.
1231 */
1241 /*
1242 * Hand off to libzfs.
1243 */
1244 spa_feature_t i;
1253 /*
1254 * Only features contained in props will be enabled:
1255 * remove from the nvlist every ZFS_FEATURE_DISABLED
1256 * value and add every missing ZFS_FEATURE_ENABLED if
1257 * enable_all_pool_feat is set.
1258 */
1262 propname);
1268 }
1269 }
1280 }
1284 }
1285 }
1287 errout:
1292 badusage:
1297 }
1299 /*
1300 * zpool destroy <pool>
1301 *
1302 * -f Forcefully unmount any datasets
1303 *
1304 * Destroy the given pool. Automatically unmounts any datasets in the pool.
1305 */
1306 int
1308 {
1315 /* check options */
1323 optopt);
1325 }
1326 }
1331 /* check arguments */
1335 }
1339 }
1344 /*
1345 * As a special case, check for use of '/' in the name, and
1346 * direct the user to use 'zfs destroy' instead.
1347 */
1352 }
1359 }
1361 /* The history must be logged as part of the export */
1369 }
1372 boolean_t force;
1373 boolean_t hardforce;
1376 /*
1377 * Export one pool
1378 */
1379 int
1381 {
1387 /* The history must be logged as part of the export */
1395 }
1398 }
1400 /*
1401 * zpool export [-f] <pool> ...
1402 *
1403 * -a Export all pools
1404 * -f Forcefully unmount datasets
1405 *
1406 * Export the given pools. By default, the command will attempt to cleanly
1407 * unmount any active datasets within the pool. If the '-f' flag is specified,
1408 * then the datasets will be forcefully unmounted.
1409 */
1410 int
1412 {
1413 export_cbdata_t cb;
1419 /* check options */
1433 optopt);
1435 }
1436 }
1447 }
1451 }
1453 /* check arguments */
1457 }
1462 }
1464 /*
1465 * Given a vdev configuration, determine the maximum width needed for the device
1466 * name column.
1467 */
1468 static int
1471 {
1489 }
1497 }
1505 }
1508 }
1515 static boolean_t
1517 {
1531 }
1534 }
1536 static int
1538 {
1549 }
1553 }
1559 boolean_t cb_allpools;
1560 boolean_t cb_verbose;
1561 boolean_t cb_explain;
1562 boolean_t cb_first;
1563 boolean_t cb_dedup_stats;
1564 boolean_t cb_print_status;
1568 /* Return 1 if string is NULL, empty, or whitespace; return 0 otherwise. */
1569 static int
1571 {
1575 str++;
1576 }
1578 }
1580 /* Print command output lines for specific vdev in a specific pool */
1581 static void
1583 {
1591 /* Not the vdev we're looking for */
1593 }
1596 /* Print out all the output values for this vdev */
1599 /* Does this vdev have values for this column? */
1603 /* yes it does, record the value */
1606 }
1607 }
1608 /*
1609 * Mark empty values with dashes to make output
1610 * awk-able.
1611 */
1618 }
1620 /* Print out any values that aren't in a column at the end */
1622 /* Did we have any columns? If so print a spacer. */
1628 }
1630 }
1631 }
1633 /*
1634 * Print out configuration state as requested by status_callback.
1635 */
1636 static void
1639 {
1647 spare_cbdata_t spare_cb;
1660 /*
1661 * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for
1662 * online drives.
1663 */
1668 }
1678 }
1716 else
1723 }
1749 }
1750 }
1760 }
1766 }
1767 }
1774 /* Don't print logs or holes here */
1784 isspare);
1786 }
1787 }
1789 /*
1790 * Print the configuration of an exported pool. Iterate over all vdevs in the
1791 * pool, printing out the name and status for each one.
1792 */
1793 static void
1796 {
1844 }
1845 }
1864 }
1874 }
1875 }
1885 }
1886 }
1887 }
1889 /*
1890 * Print log vdevs.
1891 * Logs are recorded as top level vdevs in the main pool child array
1892 * but with "is_log" set to 1. We use either print_status_config() or
1893 * print_import_config() to print the top level logs then any log
1894 * children (eg mirrored slogs) are printed recursively - which
1895 * works because only the top level vdev is marked "is_log"
1896 */
1897 static void
1899 {
1921 B_FALSE);
1922 else
1925 }
1926 }
1928 /*
1929 * Display the status for the given pool.
1930 */
1931 static void
1933 {
1940 zpool_status_t reason;
1941 zpool_errata_t errata;
1943 uint_t vsc;
2022 "accessed in read-write mode because it uses the "
2050 errata);
2054 /*
2055 * No other status can be seen when importing pools.
2056 */
2058 }
2060 /*
2061 * Print out an action according to the overall state of the pool.
2062 */
2067 "imported using its name or numeric identifier, "
2072 "imported using its name or numeric "
2081 "be imported using its name or numeric "
2083 "ibility issue which should be corrected"
2089 "not be imported with this version of ZFS "
2092 "allow the destroy to complete before "
2097 /*
2098 * All errata must contain an action message.
2099 */
2101 }
2104 "imported using its name or numeric "
2106 }
2115 "imported. Access the pool on a system running "
2121 "imported. Access the pool on a system that "
2127 "imported in read-write mode. Import the pool "
2143 }
2144 }
2146 /* Print the comment attached to the pool. */
2150 /*
2151 * If the state is "closed" or "can't open", and the aux state
2152 * is "corrupt data":
2153 */
2164 }
2168 msgid);
2184 }
2185 }
2187 /*
2188 * Perform the import for the given configuration. This passes the heavy
2189 * lifting off to zpool_import_props(), and then mounts the datasets contained
2190 * within the pool.
2191 */
2192 static int
2195 {
2231 "'%s': pool may be in use from other "
2232 "system, it was last accessed by %s "
2239 }
2240 }
2256 }
2260 }
2262 /*
2263 * zpool import [-d dir] [-D]
2264 * import [-o mntopts] [-o prop=value] ... [-R root] [-D]
2265 * [-d dir | -c cachefile] [-f] -a
2266 * import [-o mntopts] [-o prop=value] ... [-R root] [-D]
2267 * [-d dir | -c cachefile] [-f] [-n] [-F] <pool | id> [newpool]
2268 *
2269 * -c Read pool information from a cachefile instead of searching
2270 * devices.
2271 *
2272 * -d Scan in a specific directory, other than /dev/. More than
2273 * one directory can be specified using multiple '-d' options.
2274 *
2275 * -D Scan for previously destroyed pools or import all or only
2276 * specified destroyed pools.
2277 *
2278 * -R Temporarily import the pool, with all mountpoints relative to
2279 * the given root. The pool will remain exported when the machine
2280 * is rebooted.
2281 *
2282 * -V Import even in the presence of faulted vdevs. This is an
2283 * intentionally undocumented option for testing purposes, and
2284 * treats the pool configuration as complete, leaving any bad
2285 * vdevs in the FAULTED state. In other words, it does verbatim
2286 * import.
2287 *
2288 * -f Force import, even if it appears that the pool is active.
2289 *
2290 * -F Attempt rewind if necessary.
2291 *
2292 * -n See if rewind would work, but don't actually rewind.
2293 *
2294 * -N Import the pool but don't mount datasets.
2295 *
2296 * -T Specify a starting txg to use for import. This option is
2297 * intentionally undocumented option for testing purposes.
2298 *
2299 * -a Import all pools found.
2300 *
2301 * -o Set property=value and/or temporary mount options (without '=').
2302 *
2303 * -s Scan using the default search path, the libblkid cache will
2304 * not be consulted.
2305 *
2306 * The import command scans for pools to import, and import pools based on pool
2307 * name and GUID. The pool can also be renamed as part of the import process.
2308 */
2309 int
2311 {
2329 boolean_t first;
2341 /* check options */
2360 }
2384 propval++;
2390 }
2417 }
2433 optopt);
2435 }
2436 }
2444 }
2450 }
2458 /* In the future, we can capture further policy and include it here */
2464 /* check argument count */
2469 }
2474 }
2475 }
2477 /*
2478 * Check for the effective uid. We do this explicitly here because
2479 * otherwise any attempt to discover pools will silently fail.
2480 */
2490 }
2492 /*
2493 * Depending on the arguments given, we do one of the following:
2494 *
2495 * <none> Iterate through all pools and display information about
2496 * each one.
2497 *
2498 * -a Iterate through all pools and try to import each one.
2499 *
2500 * <id> Find the pool that corresponds to the given GUID/pool
2501 * name and import that one.
2502 *
2503 * -D Above options applies only to destroyed pools.
2504 */
2513 }
2516 /*
2517 * User specified a name or guid. Ensure it's unique.
2518 */
2520 }
2522 /*
2523 * Check the environment for the preferred search path.
2524 */
2541 }
2544 }
2545 }
2554 /*
2555 * Under Linux the zpool_find_import_impl() function leverages the
2556 * taskq implementation to parallelize device scanning. It is
2557 * therefore necessary to initialize this functionality for the
2558 * duration of the zpool_search_import() function.
2559 */
2584 }
2586 }
2597 }
2599 /*
2600 * At this point we have a list of import candidate configs. Even if
2601 * we were searching by pool name or guid, we still need to
2602 * post-process the list to deal with pool state and possible
2603 * duplicate names.
2604 */
2633 }
2637 /*
2638 * We are searching for a pool based on name.
2639 */
2646 "cannot import '%s': more than "
2651 }
2653 }
2657 /*
2658 * Search for a pool by guid.
2659 */
2665 }
2666 }
2668 /*
2669 * If we were searching for a specific pool, verify that we found a
2670 * pool, and then do the import.
2671 */
2680 }
2681 }
2683 /*
2684 * If we were just looking for pools, report an error if none were
2685 * found.
2686 */
2691 error:
2701 }
2703 /*
2704 * zpool sync [-f] [pool] ...
2705 *
2706 * -f (undocumented) force uberblock (and config including zpool cache file)
2707 * update.
2708 *
2709 * Sync the specified pool(s).
2710 * Without arguments "zpool sync" will sync all pools.
2711 * This command initiates TXG sync(s) and will return after the TXG(s) commit.
2712 *
2713 */
2714 static int
2716 {
2720 /* check options */
2728 optopt);
2730 }
2731 }
2736 /* if argc == 0 we will execute zpool_sync_one on all pools */
2740 }
2749 boolean_t cb_verbose;
2750 boolean_t cb_literal;
2751 boolean_t cb_scripted;
2756 /* iostat labels */
2765 {
2778 };
2780 /* Shorthand - if "columns" field not set, default to 1 column */
2782 {
2793 };
2798 };
2800 /*
2801 * Return the number of labels in a null-terminated name_and_columns_t
2802 * array.
2803 *
2804 */
2805 static unsigned int
2807 {
2811 i++;
2814 }
2816 /*
2817 * Return the number of strings in a null-terminated string array.
2818 * For example:
2819 *
2820 * const char foo[] = {"bar", "baz", NULL}
2821 *
2822 * returns 2
2823 */
2824 static uint64_t
2826 {
2829 i++;
2832 }
2835 /*
2836 * Return a default column width for default/latency/queue columns. This does
2837 * not include histograms, which have their columns autosized.
2838 */
2839 static unsigned int
2841 {
2844 /*
2845 * Choose some sane default column sizes for printing the
2846 * raw numbers.
2847 */
2851 };
2857 }
2859 /*
2860 * Print the column labels, i.e:
2861 *
2862 * capacity operations bandwidth
2863 * alloc free read write read write ...
2864 *
2865 * If force_column_width is set, use it for the column width. If not set, use
2866 * the default column width.
2867 */
2868 void
2871 {
2878 /* For each bit set in flags */
2883 /* Print our top labels centered over "read write" label. */
2886 /*
2887 * We treat labels[][].columns == 0 as shorthand
2888 * for one column. It makes writing out the label
2889 * tables more concise.
2890 */
2902 /* Space from beginning of column to label */
2908 /* Print space after label to end of column */
2913 }
2914 }
2915 }
2918 /*
2919 * print_cmd_columns - Print custom column titles from -c
2920 *
2921 * If the user specified the "zpool status|iostat -c" then print their custom
2922 * column titles in the header. For example, print_cmd_columns() would print
2923 * the " col1 col2" part of this:
2924 *
2925 * $ zpool iostat -vc 'echo col1=val1; echo col2=val2'
2926 * ...
2927 * capacity operations bandwidth
2928 * pool alloc free read write read write col1 col2
2929 * ---------- ----- ----- ----- ----- ----- ----- ---- ----
2930 * mypool 269K 1008M 0 0 107 946
2931 * mirror 269K 1008M 0 0 107 946
2932 * sdb - - 0 0 102 473 val1 val2
2933 * sdc - - 0 0 5 473 val1 val2
2934 * ---------- ----- ----- ----- ----- ----- ----- ---- ----
2935 */
2936 void
2938 {
2945 /*
2946 * Each vdev cmd should have the same column names unless the user did
2947 * something weird with their cmd. Just take the column names from the
2948 * first vdev and assume it works for all of them.
2949 */
2958 }
2959 }
2960 }
2963 /*
2964 * Utility function to print out a line of dashes like:
2965 *
2966 * -------------------------------- ----- ----- ----- ----- -----
2967 *
2968 * ...or a dashed named-row line like:
2969 *
2970 * logs - - - - -
2971 *
2972 * @cb: iostat data
2973 *
2974 * @force_column_width If non-zero, use the value as the column width.
2975 * Otherwise use the default column widths.
2976 *
2977 * @name: Print a dashed named-row line starting
2978 * with @name. Otherwise, print a regular
2979 * dashed line.
2980 */
2981 static void
2984 {
3000 }
3011 }
3013 /* For each bit in flags */
3019 else
3026 else
3029 }
3030 }
3031 }
3034 static void
3037 {
3039 }
3041 static void
3043 {
3045 }
3047 static void
3050 {
3060 }
3067 else
3088 }
3090 static void
3092 {
3094 }
3097 /*
3098 * Display a single statistic.
3099 */
3100 static void
3103 {
3110 else
3112 }
3114 /*
3115 * Calculate the default vdev stats
3116 *
3117 * Subtract oldvs from newvs, apply a scaling factor, and save the resulting
3118 * stats into calcvs.
3119 */
3120 static void
3123 {
3132 }
3134 /*
3135 * Internal representation of the extended iostats data.
3136 *
3137 * The extended iostat stats are exported in nvlists as either uint64_t arrays
3138 * or single uint64_t's. We make both look like arrays to make them easier
3139 * to process. In order to make single uint64_t's look like arrays, we set
3140 * __data to the stat data, and then set *data = &__data with count = 1. Then,
3141 * we can just use *data and count.
3142 */
3147 };
3149 static uint64_t
3151 {
3158 }
3160 /*
3161 * Helper function to lookup a uint64_t array or uint64_t value and store its
3162 * data as a stat_array. If the nvpair is a single uint64_t value, then we make
3163 * it look like a one element array to make it easier to process.
3164 */
3165 static int
3168 {
3183 /* Not a uint64_t */
3186 }
3189 }
3191 /*
3192 * Given a list of nvlist names, look up the extended stats in newnv and oldnv,
3193 * subtract them, and return the results in a newly allocated stat_array.
3194 * You must free the returned array after you are done with it with
3195 * free_calc_stats().
3196 *
3197 * Additionally, you can set "oldnv" to NULL if you simply want the newnv
3198 * values.
3199 */
3203 {
3209 /* Extract our extended stats nvlist from the main list */
3215 }
3234 }
3235 }
3239 }
3241 static void
3243 {
3249 }
3251 static void
3255 {
3265 else
3268 /* All these histos are the same size, so just use nva[0].count */
3272 /* Start at 512 - req size should never be lower than this */
3276 }
3279 /* Print histogram bucket label */
3281 /* Ending range of this bucket */
3285 /* Request size (starting range of bucket) */
3288 }
3292 else
3295 /* Print the values on the line */
3299 }
3301 }
3302 }
3304 static void
3306 {
3310 }
3312 static void
3315 {
3324 /* What type of histo are we? */
3327 /* Get NULL-terminated array of nvlist names for our histo */
3338 }
3343 /*
3344 * Calculate the entire line width of what we're printing. The
3345 * +2 is for the two spaces between columns:
3346 */
3347 /* read write */
3348 /* ----- ----- */
3349 /* |___| <---------- column_width */
3350 /* */
3351 /* |__________| <--- entire_width */
3352 /* */
3358 else
3367 }
3369 /*
3370 * Calculate the average latency of a power-of-two latency histogram
3371 */
3372 static uint64_t
3374 {
3379 /*
3380 * Our buckets are power-of-two latency ranges. Use the
3381 * midpoint latency of each bucket to calculate the average.
3382 * For example:
3383 *
3384 * Bucket Midpoint
3385 * 8ns-15ns: 12ns
3386 * 16ns-31ns: 24ns
3387 * ...
3388 */
3392 }
3393 }
3395 /* Prevent divide by zero */
3397 }
3399 static void
3402 {
3406 ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE,
3407 ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
3408 ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE,
3409 ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
3410 ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE,
3411 ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
3412 ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE,
3413 ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
3414 ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE,
3415 ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
3416 };
3427 else
3433 }
3436 }
3438 static void
3441 {
3445 ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
3446 ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
3447 ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
3448 ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
3449 ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
3450 ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
3451 ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
3452 ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
3453 ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
3454 };
3464 else
3467 /* Print our avg latencies on the line */
3469 /* Compute average latency for a latency histo */
3472 }
3474 }
3476 /*
3477 * Print default statistics (capacity/operations/bandwidth)
3478 */
3479 static void
3481 {
3492 }
3494 /* only toplevel vdevs have capacity stats */
3498 else
3500 na);
3506 }
3516 }
3518 /*
3519 * Print out all the statistics for the given vdev. This can either be the
3520 * toplevel configuration, or called recursively. If 'name' is NULL, then this
3521 * is a verbose output, and we don't want to display the toplevel pool stats.
3522 *
3523 * Returns the number of stat lines printed.
3524 */
3525 unsigned int
3528 {
3546 }
3548 /* Do we only want to see a specific vdev? */
3550 /* Yes we do. Is this the vdev? */
3552 /*
3553 * This is our vdev. Since it is the only vdev we
3554 * will be displaying, make depth = 0 so that it
3555 * doesn't get indented.
3556 */
3559 }
3560 }
3563 /* Couldn't match the name */
3565 }
3571 /*
3572 * Print the vdev name unless it's is a histogram. Histograms
3573 * display the vdev name in the header itself.
3574 */
3581 else
3585 }
3586 }
3588 /* Calculate our scaling factor */
3591 /*
3592 * If we specify printing histograms with no time interval, then
3593 * print the histogram numbers over the entire lifetime of the
3594 * vdev.
3595 */
3600 else
3602 }
3607 }
3615 }
3623 }
3624 }
3629 ret++;
3631 children:
3663 }
3665 /*
3666 * Log device section
3667 */
3673 }
3688 }
3689 }
3691 }
3693 /*
3694 * Include level 2 ARC devices in iostat output
3695 */
3708 }
3717 }
3718 }
3721 }
3723 static int
3725 {
3727 boolean_t missing;
3729 /*
3730 * If the pool has disappeared, remove it from the list and continue.
3731 */
3739 }
3741 /*
3742 * Callback to print out the iostats for the given pool.
3743 */
3744 int
3746 {
3762 else
3773 }
3775 }
3778 }
3780 static int
3782 {
3793 }
3796 }
3798 int
3800 {
3811 else
3815 }
3816 /*
3817 * The width must be at least 10, but may be as large as the
3818 * column width - 42 so that we can still fit in one line.
3819 */
3828 }
3830 /*
3831 * Parse the input string, get the 'interval' and 'count' value if there is one.
3832 */
3833 static void
3836 {
3841 /*
3842 * Determine if the last argument is an integer or a pool name
3843 */
3855 }
3856 /*
3857 * Ignore the last parameter
3858 */
3859 argc--;
3861 /*
3862 * If this is not a valid number, just plow on. The
3863 * user will get a more informative error message later
3864 * on.
3865 */
3867 }
3868 }
3870 /*
3871 * If the last argument is also an integer, then we have both a count
3872 * and an interval.
3873 */
3886 }
3888 /*
3889 * Ignore the last parameter
3890 */
3891 argc--;
3894 }
3895 }
3900 }
3902 static void
3904 {
3909 else
3911 }
3913 /*
3914 * Return stat flags that are supported by all pools by both the module and
3915 * zpool iostat. "*data" should be initialized to all 0xFFs before running.
3916 * It will get ANDed down until only the flags that are supported on all pools
3917 * remain.
3918 */
3919 static int
3921 {
3931 /* Default stats are always supported, but for completeness.. */
3935 /* Get our extended stats nvlist from the main list */
3938 /*
3939 * No extended stats; they're probably running an older
3940 * module. No big deal, we support that too.
3941 */
3943 }
3945 /* For each extended stat, make sure all its nvpairs are supported */
3950 /* Start off by assuming the flag is supported, then check */
3954 /* flag isn't supported */
3957 }
3958 }
3959 }
3960 end:
3963 }
3965 /*
3966 * Return a bitmask of stats that are supported on all pools by both the module
3967 * and zpool iostat.
3968 */
3969 static uint64_t
3971 {
3974 /*
3975 * get_stat_flags_cb() will lop off bits from "mask" until only the
3976 * flags that are supported on all pools remain.
3977 */
3980 }
3982 /*
3983 * Return 1 if cb_data->cb_vdev_names[0] is this vdev's name, 0 otherwise.
3984 */
3985 static int
3987 {
3999 }
4001 /*
4002 * Returns 1 if cb_data->cb_vdev_names[0] is a vdev name, 0 otherwise.
4003 */
4004 static int
4006 {
4008 }
4010 /*
4011 * Check if vdevs are in a pool
4012 *
4013 * Return 1 if all argv[] strings are vdev names in pool "pool_name". Otherwise
4014 * return 0. If pool_name is NULL, then search all pools.
4015 */
4016 static int
4019 {
4031 /* Temporarily hijack cb_vdev_names for a second... */
4034 /* Go though our list of prospective vdev names */
4038 /* Is this name a vdev in our pools? */
4042 /* No match */
4044 }
4045 }
4050 }
4052 static int
4054 {
4060 }
4062 /*
4063 * Do we have a pool named *name? If so, return 1, otherwise 0.
4064 */
4065 static int
4067 {
4069 }
4071 /* Are all our argv[] strings pool names? If so return 1, 0 otherwise. */
4072 static int
4074 {
4083 }
4085 /*
4086 * Helper function to print out vdev/pool names we can't resolve. Used for an
4087 * error message.
4088 */
4089 static void
4092 {
4105 else
4109 }
4110 }
4112 /*
4113 * Same as get_interval_count(), but with additional checks to not misinterpret
4114 * guids as interval/count values. Assumes VDEV_NAME_GUID is set in
4115 * cb.cb_name_flags.
4116 */
4117 static void
4120 {
4124 /* Is the last arg an interval value? Or a guid? */
4126 /*
4127 * The last arg is not a guid, so it's probably an
4128 * interval value.
4129 */
4130 argc_for_interval++;
4134 /*
4135 * The 2nd to last arg is not a guid, so it's probably
4136 * an interval value.
4137 */
4138 argc_for_interval++;
4139 }
4140 }
4142 /* Point to our list of possible intervals */
4148 }
4150 /*
4151 * Floating point sleep(). Allows you to pass in a floating point value for
4152 * seconds.
4153 */
4154 static void
4156 {
4161 }
4163 /*
4164 * Run one of the zpool status/iostat -c scripts with the help (-h) option and
4165 * print the result.
4166 *
4167 * name: Short name of the script ('iostat').
4168 * path: Full path to the script ('/usr/local/etc/zfs/zpool.d/iostat');
4169 */
4170 static void
4172 {
4184 }
4191 }
4194 /*
4195 * Go though the list of all the zpool status/iostat -c scripts, run their
4196 * help option (-h), and print out the results.
4197 */
4198 static void
4200 {
4208 /* print all the files and directories within directory */
4213 /* Print the scripts */
4218 fullpath);
4219 }
4224 ZPOOL_SCRIPTS_DIR);
4225 }
4226 }
4228 /*
4229 * zpool iostat [[-c [script1,script2,...]] [-lq]|[-rw]] [-ghHLpPvy] [-n name]
4230 * [-T d|u] [[ pool ...]|[pool vdev ...]|[vdev ...]]
4231 * [interval [count]]
4232 *
4233 * -c CMD For each vdev, run command CMD
4234 * -g Display guid for individual vdev name.
4235 * -L Follow links when resolving vdev path name.
4236 * -P Display full path for vdev name.
4237 * -v Display statistics for individual vdevs
4238 * -h Display help
4239 * -p Display values in parsable (exact) format.
4240 * -H Scripted mode. Don't display headers, and separate properties
4241 * by a single tab.
4242 * -l Display average latency
4243 * -q Display queue depths
4244 * -w Display latency histograms
4245 * -r Display request size histogram
4246 * -T Display a timestamp in date(1) or Unix format
4247 *
4248 * This command can be tricky because we want to be able to deal with pool
4249 * creation/destruction as well as vdev configuration changes. The bulk of this
4250 * processing is handled by the pool_list_* routines in zpool_iter.c. We rely
4251 * on pool_list_update() to detect the addition of new pools. Configuration
4252 * changes are all handled within libzfs.
4253 */
4254 int
4256 {
4273 /* Used for printing error message */
4279 /* check options */
4287 }
4291 "Can't run -c with root privileges "
4294 }
4341 ZPOOL_SCRIPTS_DIR);
4347 }
4349 }
4350 }
4368 /* Get our interval and count values (if any) */
4374 }
4377 /* No args, so just print the defaults. */
4379 /* All the args are pool names */
4381 /* All the args are vdevs */
4386 /* The first arg is a pool name */
4388 /* ...and the rest are vdev names */
4402 }
4404 /*
4405 * The args don't make sense. The first arg isn't a pool name,
4406 * nor are all the args vdevs.
4407 */
4411 }
4414 /*
4415 * If user specified vdevs, it implies verbose.
4416 */
4418 }
4420 /*
4421 * Construct the list of all interesting pools.
4422 */
4430 }
4436 }
4444 }
4452 }
4454 /*
4455 * Enter the main iostat loop.
4456 */
4460 /*
4461 * Histograms tables look out of place when you try to display
4462 * them with the other stats, so make a rule that you can only
4463 * print histograms by themselves.
4464 */
4474 }
4476 /*
4477 * See if the module supports all the stats we want to display.
4478 */
4486 /* for each bit set in unsupported_flags */
4490 }
4496 }
4502 /*
4503 * If this is the first iteration and -y was supplied
4504 * we skip any printing.
4505 */
4509 /*
4510 * Refresh all statistics. This is done as an
4511 * explicit step before calculating the maximum name
4512 * width, so that any * configuration changes are
4513 * properly accounted for.
4514 */
4518 /*
4519 * Iterate over all pools to determine the maximum width
4520 * for the pool / device name column across all pools.
4521 */
4536 }
4538 /*
4539 * If it's the first time and we're not skipping it,
4540 * or either skip or verbose mode, print the header.
4541 *
4542 * The histogram code explicitly prints its header on
4543 * every vdev, so skip this for histograms.
4544 */
4554 }
4559 /*
4560 * If there's more than one pool, and we're not in
4561 * verbose mode (which prints a separator for us),
4562 * then print a separator.
4563 *
4564 * In addition, if we're printing specific vdevs then
4565 * we also want an ending separator.
4566 */
4576 }
4581 }
4583 /*
4584 * Flush the output so that redirection to a file isn't buffered
4585 * indefinitely.
4586 */
4596 }
4601 }
4604 boolean_t cb_verbose;
4607 boolean_t cb_scripted;
4609 boolean_t cb_literal;
4612 /*
4613 * Given a list of columns to display, output appropriate headers for each one.
4614 */
4615 static void
4617 {
4622 boolean_t right_justify;
4628 /*
4629 * Reset the width to accommodate the verbose listing
4630 * of devices.
4631 */
4633 }
4637 else
4651 }
4657 else
4659 }
4662 }
4664 /*
4665 * Given a pool and a list of properties, print out all the properties according
4666 * to the described layout.
4667 */
4668 static void
4670 {
4675 boolean_t right_justify;
4682 /*
4683 * Reset the width to accommodate the verbose listing
4684 * of devices.
4685 */
4687 }
4692 else
4696 }
4703 else
4714 }
4717 /*
4718 * If this is being called in scripted mode, or if this is the
4719 * last column and it is left-justified, don't include a width
4720 * format specifier.
4721 */
4726 else
4728 }
4731 }
4733 static void
4736 {
4738 boolean_t fixed;
4745 else
4747 format);
4758 }
4764 else
4770 }
4777 else
4779 }
4781 void
4784 {
4804 else
4811 else
4815 /*
4816 * Print the properties for the individual vdevs. Some
4817 * properties are only applicable to toplevel vdevs. The
4818 * 'toplevel' boolean value is passed to the print_one_column()
4819 * to indicate that the value is valid.
4820 */
4832 format);
4836 format);
4838 }
4855 }
4861 }
4864 /* LINTED E_SEC_PRINTF_VAR_FMT */
4874 }
4875 }
4879 /* LINTED E_SEC_PRINTF_VAR_FMT */
4886 }
4887 }
4891 /* LINTED E_SEC_PRINTF_VAR_FMT */
4898 }
4899 }
4900 }
4903 /*
4904 * Generic callback function to list a pool.
4905 */
4906 int
4908 {
4924 }
4926 /*
4927 * zpool list [-gHLpP] [-o prop[,prop]*] [-T d|u] [pool] ... [interval [count]]
4928 *
4929 * -g Display guid for individual vdev name.
4930 * -H Scripted mode. Don't display headers, and separate properties
4931 * by a single tab.
4932 * -L Follow links when resolving vdev path name.
4933 * -o List of properties to display. Defaults to
4934 * "name,size,allocated,free,expandsize,fragmentation,capacity,"
4935 * "dedupratio,health,altroot"
4936 * -p Display values in parsable (exact) format.
4937 * -P Display full path for vdev name.
4938 * -T Display a timestamp in date(1) or Unix format
4939 *
4940 * List all pools in the system, whether or not they're healthy. Output space
4941 * statistics for each one, as well as health status summary.
4942 */
4943 int
4945 {
4950 "name,size,allocated,free,expandsize,fragmentation,capacity,"
4958 /* check options */
4992 optopt);
4994 }
4995 }
5019 }
5030 }
5035 }
5040 }
5042 static int
5044 {
5054 /* check options */
5065 }
5067 propval++;
5075 optopt);
5077 }
5078 }
5083 /* get pool name and check number of arguments */
5087 }
5095 }
5104 }
5112 }
5117 }
5122 }
5126 poolname);
5130 }
5132 /* unless manually specified use "ashift" pool property (if set) */
5135 zprop_source_t src;
5143 }
5144 }
5152 }
5161 }
5163 /*
5164 * zpool replace [-f] <pool> <device> <new_device>
5165 *
5166 * -f Force attach, even if <new_device> appears to be in use.
5167 *
5168 * Replace <device> with <new_device>.
5169 */
5170 /* ARGSUSED */
5171 int
5173 {
5175 }
5177 /*
5178 * zpool attach [-f] [-o property=value] <pool> <device> <new_device>
5179 *
5180 * -f Force attach, even if <new_device> appears to be in use.
5181 * -o Set property=value.
5182 *
5183 * Attach <new_device> to the mirror containing <device>. If <device> is not
5184 * part of a mirror, then <device> will be transformed into a mirror of
5185 * <device> and <new_device>. In either case, <new_device> will begin life
5186 * with a DTL of [0, now], and will immediately begin to resilver itself.
5187 */
5188 int
5190 {
5192 }
5194 /*
5195 * zpool detach [-f] <pool> <device>
5196 *
5197 * -f Force detach of <device>, even if DTLs argue against it
5198 * (not supported yet)
5199 *
5200 * Detach a device from a mirror. The operation will be refused if <device>
5201 * is the last device in the mirror, or if the DTLs indicate that this device
5202 * has the only valid copy of some data.
5203 */
5204 /* ARGSUSED */
5205 int
5207 {
5213 /* check options */
5219 optopt);
5221 }
5222 }
5227 /* get pool name and check number of arguments */
5231 }
5237 }
5250 }
5252 /*
5253 * zpool split [-gLnP] [-o prop=val] ...
5254 * [-o mntopt] ...
5255 * [-R altroot] <pool> <newpool> [<device> ...]
5256 *
5257 * -g Display guid for individual vdev name.
5258 * -L Follow links when resolving vdev path name.
5259 * -n Do not split the pool, but display the resulting layout if
5260 * it were to be split.
5261 * -o Set property=value, or set mount options.
5262 * -P Display full path for vdev name.
5263 * -R Mount the split-off pool under an alternate root.
5264 *
5265 * Splits the named pool and gives it the new pool name. Devices to be split
5266 * off may be listed, provided that no more than one device is specified
5267 * per top-level vdev mirror. The newly split pool is left in an exported
5268 * state unless -R is specified.
5269 *
5270 * Restrictions: the top-level of the pool pool must only be made up of
5271 * mirrors; all devices in the pool must be healthy; no device may be
5272 * undergoing a resilvering operation.
5273 */
5274 int
5276 {
5279 splitflags_t flags;
5288 /* check options */
5304 }
5312 propval++;
5317 }
5320 }
5332 optopt);
5335 }
5336 }
5342 }
5350 }
5354 }
5365 }
5376 }
5377 }
5385 }
5387 /*
5388 * The split was successful. Now we need to open the new
5389 * pool and import it.
5390 */
5395 }
5403 }
5409 }
5413 /*
5414 * zpool online <pool> <device> ...
5415 */
5416 int
5418 {
5423 vdev_state_t newstate;
5426 /* check options */
5435 optopt);
5437 }
5438 }
5443 /* get pool name and check number of arguments */
5447 }
5451 }
5466 "clear' to restore a faulted "
5468 else
5470 "replace' to replace devices "
5472 }
5475 }
5476 }
5481 }
5483 /*
5484 * zpool offline [-ft] <pool> <device> ...
5485 *
5486 * -f Force the device into a faulted state.
5487 *
5488 * -t Only take the device off-line temporarily. The offline/faulted
5489 * state will not be persistent across reboots.
5490 */
5491 /* ARGSUSED */
5492 int
5494 {
5502 /* check options */
5513 optopt);
5515 }
5516 }
5521 /* get pool name and check number of arguments */
5525 }
5529 }
5539 vdev_aux_t aux;
5541 /* Force the fault to persist across imports */
5545 }
5552 }
5553 }
5558 }
5560 /*
5561 * zpool clear <pool> [device]
5562 *
5563 * Clear all errors associated with a pool or a particular device.
5564 */
5565 int
5567 {
5578 /* check options */
5592 optopt);
5594 }
5595 }
5603 }
5608 }
5614 }
5622 /* In future, further rewind policy choices can be passed along here */
5633 }
5643 }
5645 /*
5646 * zpool reguid <pool>
5647 */
5648 int
5650 {
5656 /* check options */
5661 optopt);
5663 }
5664 }
5669 /* get pool name and check number of arguments */
5673 }
5678 }
5688 }
5691 /*
5692 * zpool reopen <pool>
5693 *
5694 * Reopen the pool so that the kernel can update the sizes of all vdevs.
5695 */
5696 int
5698 {
5704 /* check options */
5709 optopt);
5711 }
5712 }
5714 argc--;
5715 argv++;
5720 }
5725 }
5734 }
5742 int
5744 {
5748 /*
5749 * Ignore faulted pools.
5750 */
5755 }
5760 }
5762 /*
5763 * zpool scrub [-s] <pool> ...
5764 *
5765 * -s Stop. Stops any in-progress scrub.
5766 */
5767 int
5769 {
5771 scrub_cbdata_t cb;
5775 /* check options */
5783 optopt);
5785 }
5786 }
5796 }
5799 }
5801 /*
5802 * Print out detailed scrub status.
5803 */
5804 void
5806 {
5810 uint_t rate;
5816 /* If there's never been a scan, there's not much to say. */
5821 }
5829 /*
5830 * Scan is finished or canceled.
5831 */
5842 }
5843 /* LINTED */
5857 }
5859 }
5863 /*
5864 * Scan is in progress.
5865 */
5872 }
5878 /* elapsed time for this pass */
5891 /*
5892 * do not print estimated time if hours_left is more than 30 days
5893 */
5902 }
5910 }
5911 }
5913 static void
5915 {
5940 }
5943 }
5945 static void
5947 uint_t nspares)
5948 {
5949 uint_t i;
5962 }
5963 }
5965 static void
5967 uint_t nl2cache)
5968 {
5969 uint_t i;
5982 }
5983 }
5985 static void
5987 {
5991 uint_t c;
5994 /*
5995 * If the pool was faulted then we may not have been able to
5996 * obtain the config. Otherwise, if we have anything in the dedup
5997 * table continue processing the stats.
5998 */
6008 }
6014 dspace,
6015 mspace);
6022 }
6024 /*
6025 * Display a summary of pool status. Displays a summary such as:
6026 *
6027 * pool: tank
6028 * status: DEGRADED
6029 * reason: One or more devices ...
6030 * see: http://zfsonlinux.org/msg/ZFS-xxxx-01
6031 * config:
6032 * mirror DEGRADED
6033 * c1t0d0 OK
6034 * c2t0d0 UNAVAIL
6035 *
6036 * When given the '-v' option, we print out the complete config. If the '-e'
6037 * option is specified, then we print out error rate information as well.
6038 */
6039 int
6041 {
6045 zpool_status_t reason;
6046 zpool_errata_t errata;
6048 uint_t c;
6056 /*
6057 * If we were given 'zpool status -x', only report those pools with
6058 * problems.
6059 */
6069 }
6071 }
6075 else
6116 "There are insufficient replicas for the pool to "
6125 "made to correct the error. Applications are "
6129 "'zpool clear' or replace the device with 'zpool "
6136 "replicas exist for the pool to continue functioning in "
6146 "replicas exist for the pool to continue functioning in "
6220 "accessed in read-write mode because it uses the "
6234 "replicas exist for the pool to continue functioning "
6242 "faulted in response to persistent errors. There are "
6273 "previously imported into a system with a different "
6283 errata);
6295 /*
6296 * All errata which allow the pool to be imported
6297 * must contain an action message.
6298 */
6300 }
6304 /*
6305 * The remaining errors can't actually be generated, yet.
6306 */
6308 }
6312 msgid);
6339 B_FALSE);
6355 /*
6356 * If the approximate error count is small, get a
6357 * precise count by fetching the entire log and
6358 * uniquifying the results.
6359 */
6368 nerr++;
6369 }
6370 }
6382 else
6384 }
6391 }
6394 }
6396 /*
6397 * zpool status [-c [script1,script2,...]] [-gLPvx] [-T d|u] [pool] ...
6398 * [interval [count]]
6399 *
6400 * -c CMD For each vdev, run command CMD
6401 * -g Display guid for individual vdev name.
6402 * -L Follow links when resolving vdev path name.
6403 * -P Display full path for vdev name.
6404 * -v Display complete error logs
6405 * -x Display only pools with potential problems
6406 * -D Display dedup status (undocumented)
6407 * -T Display a timestamp in date(1) or Unix format
6408 *
6409 * Describes the health status of all pools or some subset.
6410 */
6411 int
6413 {
6421 /* check options */
6429 }
6433 "Can't run -c with root privileges "
6436 }
6464 ZPOOL_SCRIPTS_DIR);
6470 }
6472 }
6473 }
6515 }
6518 }
6527 static int
6529 {
6538 }
6545 }
6547 static int
6549 {
6571 }
6586 }
6589 }
6591 static int
6593 {
6606 ZFS_FEATURE_ENABLED);
6610 }
6611 count++;
6618 }
6621 }
6622 }
6627 }
6629 static int
6631 {
6651 /*
6652 * If they did "zpool upgrade -a", then we could
6653 * be doing ioctls to different pools. We need
6654 * to log this history once to each pool, and bypass
6655 * the normal history logging that happens in main().
6656 */
6659 }
6670 }
6671 }
6675 }
6678 }
6680 static int
6682 {
6697 "be upgraded to use feature flags. After "
6699 "longer be accessible by software that does not "
6704 }
6708 }
6711 }
6713 static int
6715 {
6735 "supported features are not "
6736 "enabled on the following pools. "
6738 "pool may become incompatible with "
6740 "the feature. See "
6741 "zpool-features(5) for "
6748 }
6754 }
6757 }
6758 /*
6759 * If they did "zpool upgrade -a", then we could
6760 * be doing ioctls to different pools. We need
6761 * to log this history once to each pool, and bypass
6762 * the normal history logging that happens in main().
6763 */
6766 }
6767 }
6770 }
6772 /* ARGSUSED */
6773 static int
6775 {
6783 "Pool 'log' must be renamed using export and import"
6786 }
6794 }
6801 }
6808 }
6822 }
6823 }
6827 }
6830 }
6832 /*
6833 * zpool upgrade
6834 * zpool upgrade -v
6835 * zpool upgrade [-V version] <-a | pool ...>
6836 *
6837 * With no arguments, display downrev'd ZFS pool available for upgrade.
6838 * Individual pools can be upgraded by specifying the pool, and '-a' will
6839 * upgrade all pools.
6840 */
6841 int
6843 {
6852 /* check options */
6868 }
6877 optopt);
6879 }
6880 }
6893 }
6900 }
6906 }
6907 }
6927 }
6981 "pool already has all supported features "
6987 }
6988 }
7000 }
7011 }
7015 }
7018 }
7021 boolean_t first;
7022 boolean_t longfmt;
7023 boolean_t internal;
7026 /*
7027 * Print out the command history for a specific pool.
7028 */
7029 static int
7031 {
7034 uint_t numrecords;
7056 ZPOOL_HIST_TIME);
7059 }
7071 tbuf);
7074 }
7090 ZPOOL_HIST_DSNAME),
7092 ZPOOL_HIST_DSID));
7093 }
7095 ZPOOL_HIST_INT_STR));
7105 }
7110 }
7116 }
7121 }
7129 }
7133 }
7137 }
7141 }
7146 }
7148 /*
7149 * zpool history <pool>
7150 *
7151 * Displays the history of commands that modified pools.
7152 */
7153 int
7155 {
7161 /* check options */
7172 optopt);
7174 }
7175 }
7185 }
7188 }
7197 static void
7199 {
7202 uint_t n;
7215 }
7217 static void
7219 {
7228 boolean_t b;
7290 /*
7291 * translate vdev state values to readable
7292 * strings to aide zpool events consumers
7293 */
7303 }
7335 }
7337 }
7349 }
7360 }
7371 }
7382 }
7393 }
7404 }
7416 }
7428 }
7440 }
7448 }
7451 }
7452 }
7454 static int
7456 {
7480 }
7484 }
7489 }
7491 static int
7493 {
7501 }
7503 /*
7504 * zpool events [-vfc]
7505 *
7506 * Displays events logs by ZFS.
7507 */
7508 int
7510 {
7515 /* check options */
7532 optopt);
7534 }
7535 }
7541 else
7545 }
7547 static int
7549 {
7552 zprop_source_t srctype;
7557 /*
7558 * Skip the special fake placeholder. This will also skip
7559 * over the name property when 'all' is specified.
7560 */
7575 }
7584 }
7585 }
7587 }
7589 /*
7590 * zpool get [-Hp] [-o "all" | field[,...]] <"all" | property[,...]> <pool> ...
7591 *
7592 * -H Scripted mode. Don't display headers, and separate properties
7593 * by a single tab.
7594 * -o List of columns to display. Defaults to
7595 * "name,property,value,source".
7596 * -p Display values in parsable (exact) format.
7597 *
7598 * Get properties of pools in the system. Output space statistics
7599 * for each one as well as other attributes.
7600 */
7601 int
7603 {
7612 /*
7613 * Set up default columns and sources.
7614 */
7622 /* check options */
7641 "many fields given to -o "
7644 }
7664 "with specific fields "
7667 }
7679 }
7680 }
7684 optopt);
7686 }
7687 }
7696 }
7702 argc--;
7703 argv++;
7710 }
7717 else
7721 }
7726 boolean_t cb_any_successful;
7729 int
7731 {
7741 }
7743 int
7745 {
7753 }
7759 }
7764 }
7769 }
7777 }
7786 }
7788 static int
7790 {
7800 }
7801 }
7803 }
7805 int
7807 {
7820 /*
7821 * Make sure the user has specified some command.
7822 */
7826 }
7830 /*
7831 * Special case '-?'
7832 */
7839 }
7845 /*
7846 * Run the appropriate command.
7847 */
7856 /*
7857 * 'freeze' is a vile debugging abomination, so we treat
7858 * it as such.
7859 */
7869 }
7876 /*
7877 * The 'ZFS_ABORT' environment variable causes us to dump core on exit
7878 * for the purposes of running ::findleaks.
7879 */
7883 }
7886 }