upstream/illumos/illumos-gate: comparison usr/src/cmd/zpool/zpool

equal deleted inserted replaced

-:e16f396f04a1
+:7cf402a7f374
 *
 * CDDL HEADER END
 */
 /*
-* Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
-* Use is subject to license terms.
 */
 #include <assert.h>
 #include <ctype.h>
 #include <dirent.h>
 #include <unistd.h>
 #include <priv.h>
 #include <pwd.h>
 #include <zone.h>
 #include <sys/fs/zfs.h>
 #include <sys/stat.h>
 #include <libzfs.h>
 #include "zpool_util.h"
 	case HELP_IOSTAT:
 		return (gettext("\tiostat [-v] [-T d|u] [pool] ... [interval "
 		    "[count]]\n"));
 	case HELP_LIST:
 		return (gettext("\tlist [-H] [-o property[,...]] "
-		    "[pool] ...\n"));
+		    "[-T d|u] [pool] ... [interval [count]]\n"));
 	case HELP_OFFLINE:
 		return (gettext("\toffline [-t] <pool> <device> ...\n"));
 	case HELP_ONLINE:
 		return (gettext("\tonline <pool> <device> ...\n"));
 	case HELP_REPLACE:
 	case HELP_REMOVE:
 		return (gettext("\tremove <pool> <device> ...\n"));
 	case HELP_SCRUB:
 		return (gettext("\tscrub [-s] <pool> ...\n"));
 	case HELP_STATUS:
-		return (gettext("\tstatus [-vx] [pool] ...\n"));
+		return (gettext("\tstatus [-vx] [-T d|u] [pool] ... [interval "
+		    "[count]]\n"));
 	case HELP_UPGRADE:
 		return (gettext("\tupgrade\n"
 		    "\tupgrade -v\n"
 		    "\tupgrade [-V version] <-a | pool ...>\n"));
 	case HELP_GET:
 	return (ret);
 }
 /*
-* zpool remove <pool> <vdev> ...
+* zpool remove  <pool> <vdev> ...
 *
-* Removes the given vdev from the pool.  Currently, this only supports removing
+* Removes the given vdev from the pool.  Currently, this supports removing
-* spares and cache devices from the pool.  Eventually, we'll want to support
+* spares, cache, and log devices from the pool.
-* removing leaf vdevs (as an alias for 'detach') as well as toplevel vdevs.
 */
 int
 zpool_do_remove(int argc, char **argv)
 {
 	char *poolname;
 print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv,
 int namewidth, int depth, boolean_t isspare)
 {
 	nvlist_t **child;
 	uint_t c, children;
+	pool_scan_stat_t *ps = NULL;
 	vdev_stat_t *vs;
-	char rbuf[6], wbuf[6], cbuf[6], repaired[7];
+	char rbuf[6], wbuf[6], cbuf[6];
 	char *vname;
 	uint64_t notpresent;
 	spare_cbdata_t cb;
 	char *state;
-	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS,
-	    (uint64_t **)&vs, &c) == 0);
 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 	    &child, &children) != 0)
 		children = 0;
+	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
+	    (uint64_t **)&vs, &c) == 0);
 	state = zpool_state_to_name(vs->vs_state, vs->vs_aux);
 	if (isspare) {
 		/*
 		 * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for
 		default:
 			(void) printf(gettext("corrupted data"));
 			break;
 		}
-	} else if (vs->vs_scrub_repaired != 0 && children == 0) {
+	}
-		/*
-		 * Report bytes resilvered/repaired on leaf devices.
+	(void) nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_SCAN_STATS,
-		 */
+	    (uint64_t **)&ps, &c);
-		zfs_nicenum(vs->vs_scrub_repaired, repaired, sizeof (repaired));
-		(void) printf(gettext("  %s %s"), repaired,
+	if (ps && ps->pss_state == DSS_SCANNING &&
-		    (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ?
+	    vs->vs_scan_processed != 0 && children == 0) {
-		    "resilvered" : "repaired");
+		(void) printf(gettext("  (%s)"),
+		    (ps->pss_func == POOL_SCAN_RESILVER) ?
+		    "resilvering" : "repairing");
 	}
 	(void) printf("\n");
 	for (c = 0; c < children; c++) {
 	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
 	if (strcmp(type, VDEV_TYPE_MISSING) == 0 ||
 	    strcmp(type, VDEV_TYPE_HOLE) == 0)
 		return;
-	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS,
+	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
 	    (uint64_t **)&vs, &c) == 0);
 	(void) printf("\t%*s%-*s", depth, "", namewidth - depth, name);
 	(void) printf("  %s", zpool_state_to_name(vs->vs_state, vs->vs_aux));
 	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
 	    &pool_state) == 0);
 	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
 	    &nvroot) == 0);
-	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
+	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
 	    (uint64_t **)&vs, &vsc) == 0);
 	health = zpool_state_to_name(vs->vs_state, vs->vs_aux);
 	reason = zpool_import_status(config, &msgid);
 		break;
 	case ZPOOL_STATUS_BAD_LOG:
 		(void) printf(gettext("status: An intent log record cannot be "
 		    "read.\n"));
+		break;
+	case ZPOOL_STATUS_RESILVERING:
+		(void) printf(gettext("status: One or more devices were being "
+		    "resilvered.\n"));
 		break;
 	default:
 		/*
 		 * No other status can be seen when importing pools.
 	uint64_t tdelta;
 	double scale;
 	char *vname;
 	if (oldnv != NULL) {
-		verify(nvlist_lookup_uint64_array(oldnv, ZPOOL_CONFIG_STATS,
+		verify(nvlist_lookup_uint64_array(oldnv,
-		    (uint64_t **)&oldvs, &c) == 0);
+		    ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&oldvs, &c) == 0);
 	} else {
 		oldvs = &zerovs;
 	}
-	verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_STATS,
+	verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_VDEV_STATS,
 	    (uint64_t **)&newvs, &c) == 0);
 	if (strlen(name) + depth > cb->cb_namewidth)
 		(void) printf("%*s%s", depth, "", name);
 	else
 	if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN,
 	    &oldchild, &c) != 0)
 		return;
 	for (c = 0; c < children; c++) {
+		uint64_t ishole = B_FALSE;
+		if (nvlist_lookup_uint64(newchild[c],
+		    ZPOOL_CONFIG_IS_HOLE, &ishole) == 0 && ishole)
+			continue;
 		vname = zpool_vdev_name(g_zfs, zhp, newchild[c], B_FALSE);
 		print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL,
 		    newchild[c], cb, depth + 2);
 		free(vname);
 	}
 	return (0);
 }
 /*
-* zpool iostat [-T d|u] [-v] [pool] ... [interval [count]]
+* Parse the input string, get the 'interval' and 'count' value if there is one.
-*
-*	-T	Display a timestamp in date(1) or Unix format
-*	-v	Display statistics for individual vdevs
-*
-* This command can be tricky because we want to be able to deal with pool
-* creation/destruction as well as vdev configuration changes.  The bulk of this
-* processing is handled by the pool_list_* routines in zpool_iter.c.  We rely
-* on pool_list_update() to detect the addition of new pools.  Configuration
-* changes are all handled within libzfs.
 */
-int
+static void
-zpool_do_iostat(int argc, char **argv)
+get_interval_count(int *argcp, char **argv, unsigned long *iv,
-{
+unsigned long *cnt)
-	int c;
+{
-	int ret;
-	int npools;
 	unsigned long interval = 0, count = 0;
-	zpool_list_t *list;
+	int argc = *argcp, errno;
-	boolean_t verbose = B_FALSE;
-	iostat_cbdata_t cb;
-	/* check options */
-	while ((c = getopt(argc, argv, "T:v")) != -1) {
-		switch (c) {
-		case 'T':
-			if (optarg) {
-				if (*optarg == 'u')
-					timestamp_fmt = UDATE;
-				else if (*optarg == 'd')
-					timestamp_fmt = DDATE;
-				else
-					usage(B_FALSE);
-			} else {
-				usage(B_FALSE);
-			}
-			break;
-		case 'v':
-			verbose = B_TRUE;
-			break;
-		case '?':
-			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
-			    optopt);
-			usage(B_FALSE);
-		}
-	}
-	argc -= optind;
-	argv += optind;
 	/*
 	 * Determine if the last argument is an integer or a pool name
 	 */
 	if (argc > 0 && isdigit(argv[argc - 1][0])) {
 			if (interval == 0) {
 				(void) fprintf(stderr, gettext("interval "
 				    "cannot be zero\n"));
 				usage(B_FALSE);
 			}
 			/*
 			 * Ignore the last parameter
 			 */
 			argc--;
 		} else {
 		}
 	}
 	/*
 	 * If the last argument is also an integer, then we have both a count
-	 * and an integer.
+	 * and an interval.
 	 */
 	if (argc > 0 && isdigit(argv[argc - 1][0])) {
 		char *end;
 		errno = 0;
 			argc--;
 		} else {
 			interval = 0;
 		}
 	}
+	*iv = interval;
+	*cnt = count;
+	*argcp = argc;
+}
+static void
+get_timestamp_arg(char c)
+{
+	if (c == 'u')
+		timestamp_fmt = UDATE;
+	else if (c == 'd')
+		timestamp_fmt = DDATE;
+	else
+		usage(B_FALSE);
+}
+/*
+* zpool iostat [-v] [-T d|u] [pool] ... [interval [count]]
+*
+*	-v	Display statistics for individual vdevs
+*	-T	Display a timestamp in date(1) or Unix format
+*
+* This command can be tricky because we want to be able to deal with pool
+* creation/destruction as well as vdev configuration changes.  The bulk of this
+* processing is handled by the pool_list_* routines in zpool_iter.c.  We rely
+* on pool_list_update() to detect the addition of new pools.  Configuration
+* changes are all handled within libzfs.
+*/
+int
+zpool_do_iostat(int argc, char **argv)
+{
+	int c;
+	int ret;
+	int npools;
+	unsigned long interval = 0, count = 0;
+	zpool_list_t *list;
+	boolean_t verbose = B_FALSE;
+	iostat_cbdata_t cb;
+	/* check options */
+	while ((c = getopt(argc, argv, "T:v")) != -1) {
+		switch (c) {
+		case 'T':
+			get_timestamp_arg(*optarg);
+			break;
+		case 'v':
+			verbose = B_TRUE;
+			break;
+		case '?':
+			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
+			    optopt);
+			usage(B_FALSE);
+		}
+	}
+	argc -= optind;
+	argv += optind;
+	get_interval_count(&argc, argv, &interval, &count);
 	/*
 	 * Construct the list of all interesting pools.
 	 */
 	ret = 0;
 	return (0);
 }
 /*
-* zpool list [-H] [-o prop[,prop]*] [pool] ...
+* zpool list [-H] [-o prop[,prop]*] [-T d|u] [pool] ... [interval [count]]
 *
 *	-H	Scripted mode.  Don't display headers, and separate properties
 *		by a single tab.
 *	-o	List of properties to display.  Defaults to
 *		"name,size,allocated,free,capacity,health,altroot"
+*	-T	Display a timestamp in date(1) or Unix format
 *
 * List all pools in the system, whether or not they're healthy.  Output space
 * statistics for each one, as well as health status summary.
 */
 int
 	int ret;
 	list_cbdata_t cb = { 0 };
 	static char default_props[] =
 	    "name,size,allocated,free,capacity,dedupratio,health,altroot";
 	char *props = default_props;
+	unsigned long interval = 0, count = 0;
 	/* check options */
-	while ((c = getopt(argc, argv, ":Ho:")) != -1) {
+	while ((c = getopt(argc, argv, ":Ho:T:")) != -1) {
 		switch (c) {
 		case 'H':
 			cb.cb_scripted = B_TRUE;
 			break;
 		case 'o':
 			props = optarg;
+			break;
+		case 'T':
+			get_timestamp_arg(*optarg);
 			break;
 		case ':':
 			(void) fprintf(stderr, gettext("missing argument for "
 			    "'%c' option\n"), optopt);
 			usage(B_FALSE);
 	}
 	argc -= optind;
 	argv += optind;
+	get_interval_count(&argc, argv, &interval, &count);
 	if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0)
 		usage(B_FALSE);
 	cb.cb_first = B_TRUE;
-	ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist,
+	for (;;) {
-	    list_callback, &cb);
+		if (timestamp_fmt != NODATE)
+			print_timestamp(timestamp_fmt);
+		ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist,
+		    list_callback, &cb);
+		if (argc == 0 && cb.cb_first && !cb.cb_scripted) {
+			(void) printf(gettext("no pools available\n"));
+			zprop_free_list(cb.cb_proplist);
+			return (0);
+		}
+		if (interval == 0)
+			break;
+		if (count != 0 && --count == 0)
+			break;
+		(void) sleep(interval);
+	}
 	zprop_free_list(cb.cb_proplist);
-	if (argc == 0 && cb.cb_first && !cb.cb_scripted) {
-		(void) printf(gettext("no pools available\n"));
-		return (0);
-	}
 	return (ret);
 }
 static nvlist_t *
 zpool_get_vdev_by_name(nvlist_t *nv, char *name)
 		(void) fprintf(stderr, gettext("cannot scrub '%s': pool is "
 		    "currently unavailable\n"), zpool_get_name(zhp));
 		return (1);
 	}
-	err = zpool_scrub(zhp, cb->cb_type);
+	err = zpool_scan(zhp, cb->cb_type);
 	return (err != 0);
 }
 /*
 zpool_do_scrub(int argc, char **argv)
 {
 	int c;
 	scrub_cbdata_t cb;
-	cb.cb_type = POOL_SCRUB_EVERYTHING;
+	cb.cb_type = POOL_SCAN_SCRUB;
 	/* check options */
 	while ((c = getopt(argc, argv, "s")) != -1) {
 		switch (c) {
 		case 's':
-			cb.cb_type = POOL_SCRUB_NONE;
+			cb.cb_type = POOL_SCAN_NONE;
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 /*
 * Print out detailed scrub status.
 */
 void
-print_scrub_status(nvlist_t *nvroot)
+print_scan_status(pool_scan_stat_t *ps)
 {
-	vdev_stat_t *vs;
+	time_t start, end;
-	uint_t vsc;
+	uint64_t elapsed, mins_left;
-	time_t start, end, now;
+	uint64_t pass_exam, examined, total;
+	uint_t rate;
 	double fraction_done;
-	uint64_t examined, total, minutes_left, minutes_taken;
+	char processed_buf[7], examined_buf[7], total_buf[7], rate_buf[7];
-	char *scrub_type;
+	(void) printf(gettext(" scan: "));
-	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
-	    (uint64_t **)&vs, &vsc) == 0);
+	/* If there's never been a scan, there's not much to say. */
+	if (ps == NULL || ps->pss_func == POOL_SCAN_NONE ||
-	/*
+	    ps->pss_func >= POOL_SCAN_FUNCS) {
-	 * If there's never been a scrub, there's not much to say.
-	 */
-	if (vs->vs_scrub_end == 0 && vs->vs_scrub_type == POOL_SCRUB_NONE) {
 		(void) printf(gettext("none requested\n"));
 		return;
 	}
-	scrub_type = (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ?
+	start = ps->pss_start_time;
-	    "resilver" : "scrub";
+	end = ps->pss_end_time;
+	zfs_nicenum(ps->pss_processed, processed_buf, sizeof (processed_buf));
-	start = vs->vs_scrub_start;
-	end = vs->vs_scrub_end;
+	assert(ps->pss_func == POOL_SCAN_SCRUB ||
-	now = time(NULL);
+	    ps->pss_func == POOL_SCAN_RESILVER);
-	examined = vs->vs_scrub_examined;
+	/*
-	total = vs->vs_alloc;
+	 * Scan is finished or canceled.
+	 */
-	if (end != 0) {
+	if (ps->pss_state == DSS_FINISHED) {
-		minutes_taken = (uint64_t)((end - start) / 60);
+		uint64_t minutes_taken = (end - start) / 60;
+		char *fmt;
-		(void) printf(gettext("%s %s after %lluh%um with %llu errors "
-		    "on %s"),
+		if (ps->pss_func == POOL_SCAN_SCRUB) {
-		    scrub_type, vs->vs_scrub_complete ? "completed" : "stopped",
+			fmt = gettext("scrub repaired %s in %lluh%um with "
+			    "%llu errors on %s");
+		} else if (ps->pss_func == POOL_SCAN_RESILVER) {
+			fmt = gettext("resilvered %s in %lluh%um with "
+			    "%llu errors on %s");
+		}
+		/* LINTED */
+		(void) printf(fmt, processed_buf,
 		    (u_longlong_t)(minutes_taken / 60),
 		    (uint_t)(minutes_taken % 60),
-		    (u_longlong_t)vs->vs_scrub_errors, ctime(&end));
+		    (u_longlong_t)ps->pss_errors,
+		    ctime((time_t *)&end));
 		return;
-	}
+	} else if (ps->pss_state == DSS_CANCELED) {
+		if (ps->pss_func == POOL_SCAN_SCRUB) {
-	if (examined == 0)
+			(void) printf(gettext("scrub canceled on %s"),
-		examined = 1;
+			    ctime(&end));
-	if (examined > total)
+		} else if (ps->pss_func == POOL_SCAN_RESILVER) {
-		total = examined;
+			(void) printf(gettext("resilver canceled on %s"),
+			    ctime(&end));
+		}
+		return;
+	}
+	assert(ps->pss_state == DSS_SCANNING);
+	/*
+	 * Scan is in progress.
+	 */
+	if (ps->pss_func == POOL_SCAN_SCRUB) {
+		(void) printf(gettext("scrub in progress since %s"),
+		    ctime(&start));
+	} else if (ps->pss_func == POOL_SCAN_RESILVER) {
+		(void) printf(gettext("resilver in progress since %s"),
+		    ctime(&start));
+	}
+	examined = ps->pss_examined ? ps->pss_examined : 1;
+	total = ps->pss_to_examine;
 	fraction_done = (double)examined / total;
-	minutes_left = (uint64_t)((now - start) *
-	    (1 - fraction_done) / fraction_done / 60);
+	/* elapsed time for this pass */
-	minutes_taken = (uint64_t)((now - start) / 60);
+	elapsed = time(NULL) - ps->pss_pass_start;
+	elapsed = elapsed ? elapsed : 1;
-	(void) printf(gettext("%s in progress for %lluh%um, %.2f%% done, "
+	pass_exam = ps->pss_pass_exam ? ps->pss_pass_exam : 1;
-	    "%lluh%um to go\n"),
+	rate = pass_exam / elapsed;
-	    scrub_type, (u_longlong_t)(minutes_taken / 60),
+	rate = rate ? rate : 1;
-	    (uint_t)(minutes_taken % 60), 100 * fraction_done,
+	mins_left = ((total - examined) / rate) / 60;
-	    (u_longlong_t)(minutes_left / 60), (uint_t)(minutes_left % 60));
+	zfs_nicenum(examined, examined_buf, sizeof (examined_buf));
+	zfs_nicenum(total, total_buf, sizeof (total_buf));
+	zfs_nicenum(rate, rate_buf, sizeof (rate_buf));
+	(void) printf(gettext("    %s scanned out of %s at "
+	    "%s/s, %lluh%um to go\n"), examined_buf, total_buf, rate_buf,
+	    (u_longlong_t)(mins_left / 60),
+	    (uint_t)(mins_left % 60));
+	if (ps->pss_func == POOL_SCAN_RESILVER) {
+		(void) printf(gettext("    %s resilvered, %.2f%% done\n"),
+		    processed_buf, 100 * fraction_done);
+	} else if (ps->pss_func == POOL_SCAN_SCRUB) {
+		(void) printf(gettext("    %s repaired, %.2f%% done\n"),
+		    processed_buf, 100 * fraction_done);
+	}
 }
 static void
 print_error_log(zpool_handle_t *zhp)
 {
 	else
 		(void) printf("\n");
 	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
 	    &nvroot) == 0);
-	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
+	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
 	    (uint64_t **)&vs, &c) == 0);
 	health = zpool_state_to_name(vs->vs_state, vs->vs_aux);
 	(void) printf(gettext("  pool: %s\n"), zpool_get_name(zhp));
 	(void) printf(gettext(" state: %s\n"), health);
 		(void) printf(gettext("action: Online the device using "
 		    "'zpool online' or replace the device with\n\t'zpool "
 		    "replace'.\n"));
 		break;
 	case ZPOOL_STATUS_RESILVERING:
 		(void) printf(gettext("status: One or more devices is "
 		    "currently being resilvered.  The pool will\n\tcontinue "
 		    "to function, possibly in a degraded state.\n"));
 		(void) printf(gettext("action: Wait for the resilver to "
 	if (config != NULL) {
 		int namewidth;
 		uint64_t nerr;
 		nvlist_t **spares, **l2cache;
 		uint_t nspares, nl2cache;
+		pool_scan_stat_t *ps = NULL;
-		(void) printf(gettext(" scrub: "));
+		(void) nvlist_lookup_uint64_array(nvroot,
-		print_scrub_status(nvroot);
+		    ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &c);
+		print_scan_status(ps);
 		namewidth = max_width(zhp, nvroot, 0, 0);
 		if (namewidth < 10)
 			namewidth = 10;
 	return (0);
 }
 /*
-* zpool status [-vx] [pool] ...
+* zpool status [-vx] [-T d|u] [pool] ... [interval [count]]
 *
 *	-v	Display complete error logs
 *	-x	Display only pools with potential problems
 *	-D	Display dedup status (undocumented)
+*	-T	Display a timestamp in date(1) or Unix format
 *
 * Describes the health status of all pools or some subset.
 */
 int
 zpool_do_status(int argc, char **argv)
 {
 	int c;
 	int ret;
+	unsigned long interval = 0, count = 0;
 	status_cbdata_t cb = { 0 };
 	/* check options */
-	while ((c = getopt(argc, argv, "vxD")) != -1) {
+	while ((c = getopt(argc, argv, "vxDT:")) != -1) {
 		switch (c) {
 		case 'v':
 			cb.cb_verbose = B_TRUE;
 			break;
 		case 'x':
 			cb.cb_explain = B_TRUE;
 			break;
 		case 'D':
 			cb.cb_dedup_stats = B_TRUE;
+			break;
+		case 'T':
+			get_timestamp_arg(*optarg);
 			break;
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 	}
 	argc -= optind;
 	argv += optind;
-	cb.cb_first = B_TRUE;
+	get_interval_count(&argc, argv, &interval, &count);
 	if (argc == 0)
 		cb.cb_allpools = B_TRUE;
-	ret = for_each_pool(argc, argv, B_TRUE, NULL, status_callback, &cb);
+	cb.cb_first = B_TRUE;
-	if (argc == 0 && cb.cb_count == 0)
+	for (;;) {
-		(void) printf(gettext("no pools available\n"));
+		if (timestamp_fmt != NODATE)
-	else if (cb.cb_explain && cb.cb_first && cb.cb_allpools)
+			print_timestamp(timestamp_fmt);
-		(void) printf(gettext("all pools are healthy\n"));
+		ret = for_each_pool(argc, argv, B_TRUE, NULL,
-	return (ret);
+		    status_callback, &cb);
+		if (argc == 0 && cb.cb_count == 0)
+			(void) printf(gettext("no pools available\n"));
+		else if (cb.cb_explain && cb.cb_first && cb.cb_allpools)
+			(void) printf(gettext("all pools are healthy\n"));
+		if (ret != 0)
+			return (ret);
+		if (interval == 0)
+			break;
+		if (count != 0 && --count == 0)
+			break;
+		(void) sleep(interval);
+	}
+	return (0);
 }
 typedef struct upgrade_cbdata {
 	int	cb_all;
 	int	cb_first;
 		    "(zero-length encoding)\n"));
 		(void) printf(gettext(" 21  Deduplication\n"));
 		(void) printf(gettext(" 22  Received properties\n"));
 		(void) printf(gettext(" 23  Slim ZIL\n"));
 		(void) printf(gettext(" 24  System attributes\n"));
+		(void) printf(gettext(" 25  Improved scrub stats\n"));
 		(void) printf(gettext("\nFor more information on a particular "
 		    "version, including supported releases, see:\n\n"));
 		(void) printf("http://www.opensolaris.org/os/community/zfs/"
 		    "version/N\n\n");
 		(void) printf(gettext("Where 'N' is the version number.\n"));
 			if (ievent >= LOG_END)
 				continue;
 			(void) snprintf(internalstr,
 			    sizeof (internalstr),
 			    "[internal %s txg:%lld] %s",
-			    hist_event_table[ievent], txg,
+			    zfs_history_event_names[ievent], txg,
 			    pathstr);
 			cmdstr = internalstr;
 		}
 		tsec = dst_time;
 		(void) localtime_r(&tsec, &t);

changeset 12296	7cf402a7f374
parent 11935	538c866aaac6
child 12321	c2943f5c6eb9