rescrubbing only previously detected error block

TulsiJain · TulsiJain · commit 5c29bd7f3a91 · 2019-07-26T13:15:01.000-07:00
Signed-off-by: TulsiJain &lt;tulsi.jain@delphix.com&gt;
diff --git a/.gitignore b/.gitignore
@@ -62,4 +62,7 @@ cscope.*
 *.orig
 *.log
 venv
+# Ignore Eclipse files
+/.cproject
+/.project
 
diff --git a/cmd/zpool/zpool_main.c b/cmd/zpool/zpool_main.c
@@ -381,7 +381,8 @@ get_usage(zpool_help_t idx)
 		return (gettext("\tinitialize [-c | -s] <pool> "
 		    "[<device> ...]\n"));
 	case HELP_SCRUB:
-		return (gettext("\tscrub [-s | -p] <pool> ...\n"));
+		return (gettext("\tscrub [-s | -p | -e | -e -s | -e -p] <pool>"
+		    " ...\n"));
 	case HELP_RESILVER:
 		return (gettext("\tresilver <pool> ...\n"));
 	case HELP_TRIM:
@@ -6691,7 +6692,11 @@ scrub_callback(zpool_handle_t *zhp, void *data)
 		return (1);
 	}
 
-	err = zpool_scan(zhp, cb->cb_type, cb->cb_scrub_cmd);
+	if (cb->cb_type == POOL_RESCRUB) {
+		err = zpool_rescrub(zhp, cb->cb_type, cb->cb_scrub_cmd);
+	} else {
+		err = zpool_scan(zhp, cb->cb_type, cb->cb_scrub_cmd);
+	}
 
 	if (err == 0 && zpool_has_checkpoint(zhp) &&
 	    cb->cb_type == POOL_SCAN_SCRUB) {
@@ -6706,6 +6711,7 @@ scrub_callback(zpool_handle_t *zhp, void *data)
 /*
  * zpool scrub [-s | -p] <pool> ...
  *
+ *	-e	For error blocks. Starts/Resumes error blocks scrubbing.
  *	-s	Stop.  Stops any in-progress scrub.
  *	-p	Pause. Pause in-progress scrub.
  */
@@ -6718,27 +6724,52 @@ zpool_do_scrub(int argc, char **argv)
 	cb.cb_type = POOL_SCAN_SCRUB;
 	cb.cb_scrub_cmd = POOL_SCRUB_NORMAL;
 
+	boolean_t is_error_scrub = B_FALSE;
+	boolean_t is_pause = B_FALSE;
+	boolean_t is_stop = B_FALSE;
 	/* check options */
-	while ((c = getopt(argc, argv, "sp")) != -1) {
+	while ((c = getopt(argc, argv, "eps")) != -1) {
 		switch (c) {
-		case 's':
-			cb.cb_type = POOL_SCAN_NONE;
+		case 'e': {
+			is_error_scrub = B_TRUE;
 			break;
-		case 'p':
-			cb.cb_scrub_cmd = POOL_SCRUB_PAUSE;
+		}
+		case 's': {
+			is_stop = B_TRUE;
+			break;
+		}
+		case 'p': {
+			is_pause = B_TRUE;
 			break;
+		}
 		case '?':
 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
 			    optopt);
 			usage(B_FALSE);
 		}
 	}
 
-	if (cb.cb_type == POOL_SCAN_NONE &&
-	    cb.cb_scrub_cmd == POOL_SCRUB_PAUSE) {
-		(void) fprintf(stderr, gettext("invalid option combination: "
-		    "-s and -p are mutually exclusive\n"));
+	if (is_pause && is_stop) {
+		(void) fprintf(stderr, gettext("invalid option "
+		    "combination :-s and -p are mutually exclusive\n"));
 		usage(B_FALSE);
+	} else {
+		if (is_error_scrub) {
+			cb.cb_type = POOL_RESCRUB;
+			if (is_pause) {
+				cb.cb_scrub_cmd = POOL_RESCRUB_PAUSE;
+			} else if (is_stop) {
+				cb.cb_scrub_cmd = POOL_RESCRUB_STOP;
+			} else {
+				cb.cb_scrub_cmd = POOL_RESCRUB_NORMAL;
+			}
+		} else {
+			if (is_pause) {
+				cb.cb_scrub_cmd = POOL_SCRUB_PAUSE;
+			} else if (is_stop) {
+				cb.cb_type = POOL_SCAN_NONE;
+			}
+		}
 	}
 
 	cb.cb_argc = argc;
diff --git a/include/libzfs.h b/include/libzfs.h
@@ -125,7 +125,10 @@ typedef enum zfs_error {
 	EZFS_THREADCREATEFAILED, /* thread create failed */
 	EZFS_POSTSPLIT_ONLINE,	/* onlining a disk after splitting it */
 	EZFS_SCRUBBING,		/* currently scrubbing */
+	EZFS_RESCRUBBING,	/* currently rescrubbing */
+	EZFS_RESCRUB_PAUSED,	/* rescrub currently paused */
 	EZFS_NO_SCRUB,		/* no active scrub */
+	EZFS_NO_RESCRUB,	/* no active rescrub */
 	EZFS_DIFF,		/* general failure of zfs diff */
 	EZFS_DIFFDATA,		/* bad zfs diff data */
 	EZFS_POOLREADONLY,	/* pool is in read-only mode */
@@ -273,6 +276,7 @@ typedef struct trimflags {
  * Functions to manipulate pool and vdev state
  */
 extern int zpool_scan(zpool_handle_t *, pool_scan_func_t, pool_scrub_cmd_t);
+extern int zpool_rescrub(zpool_handle_t *, pool_scan_func_t, pool_scrub_cmd_t);
 extern int zpool_initialize(zpool_handle_t *, pool_initialize_func_t,
     nvlist_t *);
 extern int zpool_trim(zpool_handle_t *, pool_trim_func_t, nvlist_t *,
diff --git a/include/libzfs_core.h b/include/libzfs_core.h
@@ -130,6 +130,8 @@ int lzc_reopen(const char *, boolean_t);
 int lzc_pool_checkpoint(const char *);
 int lzc_pool_checkpoint_discard(const char *);
 
+int lzc_ioctl(zfs_ioc_t, const char *, nvlist_t *, nvlist_t **);
+
 #ifdef	__cplusplus
 }
 #endif
diff --git a/include/sys/dmu.h b/include/sys/dmu.h
@@ -373,6 +373,7 @@ typedef struct dmu_buf {
 #define	DMU_POOL_DDT_STATS		"DDT-statistics"
 #define	DMU_POOL_CREATION_VERSION	"creation_version"
 #define	DMU_POOL_SCAN			"scan"
+#define	DMU_POOL_RESCRUB		"rescrub"
 #define	DMU_POOL_FREE_BPOBJ		"free_bpobj"
 #define	DMU_POOL_BPTREE_OBJ		"bptree_obj"
 #define	DMU_POOL_EMPTY_BPOBJ		"empty_bpobj"
diff --git a/include/sys/dsl_scan.h b/include/sys/dsl_scan.h
@@ -29,6 +29,7 @@
 
 #include <sys/zfs_context.h>
 #include <sys/zio.h>
+#include <sys/zap.h>
 #include <sys/ddt.h>
 #include <sys/bplist.h>
 
@@ -76,6 +77,18 @@ typedef enum dsl_scan_flags {
 
 #define	DSL_SCAN_FLAGS_MASK (DSF_VISIT_DS_AGAIN)
 
+typedef struct dsl_rescrub_phys {
+	uint64_t rescrub_func; /* pool_scan_func_t */
+	uint64_t rescrub_state; /* dsl_scan_state_t */
+	zap_cursor_t rescrub_cursor; /* zap cursor */
+	uint64_t rescrub_start_time;
+	uint64_t rescrub_end_time;
+	uint64_t rescrub_to_examine; /* total blocks to be rescrubbed */
+	uint64_t rescrub_examined; /* blocks remaining so far */
+	uint64_t rescrub_errors;	/* rescrub I/O error count */
+	uint8_t rescrub_paused_flags; /* flag for paused */
+} dsl_rescrub_phys_t;
+
 /*
  * Every pool will have one dsl_scan_t and this structure will contain
  * in-memory information about the scan and a pointer to the on-disk
@@ -153,6 +166,9 @@ typedef struct dsl_scan {
 	dsl_scan_phys_t scn_phys_cached;
 	avl_tree_t scn_queue;		/* queue of datasets to scan */
 	uint64_t scn_bytes_pending;	/* outstanding data to issue */
+
+	/* members needed for syncing rescrub status to disk */
+	dsl_rescrub_phys_t rescrub_phys; /* on disk representation of rescrub */
 } dsl_scan_t;
 
 typedef struct dsl_scan_io_queue dsl_scan_io_queue_t;
@@ -166,6 +182,11 @@ int dsl_scan_cancel(struct dsl_pool *);
 int dsl_scan(struct dsl_pool *, pool_scan_func_t);
 boolean_t dsl_scan_scrubbing(const struct dsl_pool *dp);
 int dsl_scrub_set_pause_resume(const struct dsl_pool *dp, pool_scrub_cmd_t cmd);
+int dsl_rescrub_set_pause_resume(const struct dsl_pool *dp,
+    pool_scrub_cmd_t cmd);
+int dsl_rescrub(struct dsl_pool *, pool_scan_func_t);
+void dsl_rescrub_sync(struct dsl_pool *, dmu_tx_t *);
+int dsl_rescrub_cancel(struct dsl_pool *);
 void dsl_resilver_restart(struct dsl_pool *, uint64_t txg);
 boolean_t dsl_scan_resilvering(struct dsl_pool *dp);
 boolean_t dsl_dataset_unstable(struct dsl_dataset *ds);
diff --git a/include/sys/fs/zfs.h b/include/sys/fs/zfs.h
@@ -899,6 +899,7 @@ typedef enum pool_scan_func {
 	POOL_SCAN_NONE,
 	POOL_SCAN_SCRUB,
 	POOL_SCAN_RESILVER,
+	POOL_RESCRUB,
 	POOL_SCAN_FUNCS
 } pool_scan_func_t;
 
@@ -908,6 +909,9 @@ typedef enum pool_scan_func {
 typedef enum pool_scrub_cmd {
 	POOL_SCRUB_NORMAL = 0,
 	POOL_SCRUB_PAUSE,
+	POOL_RESCRUB_NORMAL,
+	POOL_RESCRUB_PAUSE,
+	POOL_RESCRUB_STOP,
 	POOL_SCRUB_FLAGS_END
 } pool_scrub_cmd_t;
 
@@ -983,6 +987,7 @@ typedef enum dsl_scan_state {
 	DSS_SCANNING,
 	DSS_FINISHED,
 	DSS_CANCELED,
+	DSS_RESCRUBING,
 	DSS_NUM_STATES
 } dsl_scan_state_t;
 
@@ -1277,6 +1282,7 @@ typedef enum zfs_ioc {
 	ZFS_IOC_POOL_TRIM,			/* 0x5a50 */
 	ZFS_IOC_REDACT,				/* 0x5a51 */
 	ZFS_IOC_GET_BOOKMARK_PROPS,		/* 0x5a52 */
+	ZFS_IOC_POOL_RESCRUB,			/* 0x5a53 */
 
 	/*
 	 * Linux - 3/64 numbers reserved.
diff --git a/include/sys/spa.h b/include/sys/spa.h
@@ -866,6 +866,11 @@ extern int spa_scan(spa_t *spa, pool_scan_func_t func);
 extern int spa_scan_stop(spa_t *spa);
 extern int spa_scrub_pause_resume(spa_t *spa, pool_scrub_cmd_t flag);
 
+/* rescrubing */
+extern int spa_rescrub(spa_t *spa, pool_scan_func_t func);
+extern int spa_rescrub_stop(spa_t *spa);
+extern int spa_rescrub_pause_resume(spa_t *spa, pool_scrub_cmd_t flag);
+
 /* spa syncing */
 extern void spa_sync(spa_t *spa, uint64_t txg); /* only for DMU use */
 extern void spa_sync_allpools(void);
@@ -1176,6 +1181,7 @@ extern void zfs_post_remove(spa_t *spa, vdev_t *vd);
 extern void zfs_post_state_change(spa_t *spa, vdev_t *vd, uint64_t laststate);
 extern void zfs_post_autoreplace(spa_t *spa, vdev_t *vd);
 extern uint64_t spa_get_errlog_size(spa_t *spa);
+extern uint64_t spa_get_last_errlog_size(spa_t *spa);
 extern int spa_get_errlog(spa_t *spa, void *uaddr, size_t *count);
 extern void spa_errlog_rotate(spa_t *spa);
 extern void spa_errlog_drain(spa_t *spa);
diff --git a/include/sys/spa_impl.h b/include/sys/spa_impl.h
@@ -285,6 +285,8 @@ struct spa {
 	uint64_t	spa_scan_pass_exam;	/* examined bytes per pass */
 	uint64_t	spa_scan_pass_issued;	/* issued bytes per pass */
 
+	uint64_t	spa_scan_pass_rescrub_pause; /* rescrub pause time */
+	uint64_t	spa_scan_pass_rescrub_spent_paused; /* total paused */
 	/*
 	 * We are in the middle of a resilver, and another resilver
 	 * is needed once this one completes. This is set iff any
diff --git a/include/sys/sysevent/eventdefs.h b/include/sys/sysevent/eventdefs.h
@@ -123,6 +123,11 @@ extern "C" {
 #define	ESC_ZFS_TRIM_CANCEL		"trim_cancel"
 #define	ESC_ZFS_TRIM_RESUME		"trim_resume"
 #define	ESC_ZFS_TRIM_SUSPEND		"trim_suspend"
+#define	ESC_ZFS_RESCRUB_START		"rescrub_start"
+#define	ESC_ZFS_RESCRUB_FINISH		"rescrub_finish"
+#define	ESC_ZFS_RESCRUB_ABORT		"rescrub_abort"
+#define	ESC_ZFS_RESCRUB_RESUME		"rescrub_resume"
+#define	ESC_ZFS_RESCRUB_PAUSED		"rescrub_paused"
 
 /*
  * datalink subclass definitions.
diff --git a/lib/libzfs/libzfs_pool.c b/lib/libzfs/libzfs_pool.c
@@ -2364,6 +2364,7 @@ zpool_scan(zpool_handle_t *zhp, pool_scan_func_t func, pool_scrub_cmd_t cmd)
 		pool_scan_stat_t *ps = NULL;
 		uint_t psc;
 
+		// needs some improvement because of rescrub
 		verify(nvlist_lookup_nvlist(zhp->zpool_config,
 		    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
 		(void) nvlist_lookup_uint64_array(nvroot,
@@ -2385,6 +2386,84 @@ zpool_scan(zpool_handle_t *zhp, pool_scan_func_t func, pool_scrub_cmd_t cmd)
 	}
 }
 
+
+/*
+ * rescrub the pool.
+ */
+int
+zpool_rescrub(zpool_handle_t *zhp, pool_scan_func_t func, pool_scrub_cmd_t cmd)
+{
+	char msg[1024];
+	int err;
+	libzfs_handle_t *hdl = zhp->zpool_hdl;
+
+	ASSERT3U(func, ==, POOL_RESCRUB);
+
+	nvlist_t *args = fnvlist_alloc();
+	fnvlist_add_uint64(args, "scan_type", (uint64_t)func);
+	fnvlist_add_uint64(args, "rescrub_command", (uint64_t)cmd);
+
+	err = lzc_ioctl(ZFS_IOC_POOL_RESCRUB, zhp->zpool_name, args, NULL);
+	fnvlist_free(args);
+
+	if (err == 0) {
+		return (0);
+	}
+
+	/*
+	 * ECANCELED is returned when either we resumed a paused rescrub or
+	 * has no disk errorlog.
+	 */
+	if (err == ECANCELED && cmd == POOL_RESCRUB_NORMAL)
+		return (0);
+
+	if (err == ENOENT && cmd == POOL_RESCRUB_NORMAL)
+		return (0);
+
+	if (cmd == POOL_RESCRUB_PAUSE) {
+		(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
+		    "cannot pause rescrubbing %s"), zhp->zpool_name);
+	} else if (cmd == POOL_RESCRUB_NORMAL) {
+		(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
+		    "cannot rescrub %s"), zhp->zpool_name);
+	} else {
+		ASSERT3U(cmd, ==, POOL_RESCRUB_STOP);
+		(void) snprintf(msg, sizeof (msg),
+		    dgettext(TEXT_DOMAIN, "cannot cancel rescrubbing "
+		    "%s"), zhp->zpool_name);
+	}
+
+	if (err == EBUSY) {
+		nvlist_t *nvroot;
+		pool_scan_stat_t *ps = NULL;
+		uint_t psc;
+
+		// needs improvement working on it
+		verify(nvlist_lookup_nvlist(zhp->zpool_config,
+		    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
+		(void) nvlist_lookup_uint64_array(nvroot,
+		    ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &psc);
+		if (ps && ps->pss_func == POOL_SCAN_SCRUB) {
+			if (cmd == POOL_SCRUB_PAUSE)
+				return (zfs_error(hdl, EZFS_SCRUB_PAUSED, msg));
+			else
+				return (zfs_error(hdl, EZFS_SCRUBBING, msg));
+		} else if (ps && ps->pss_func == POOL_RESCRUB) {
+			if (cmd == POOL_RESCRUB_PAUSE)
+				return (zfs_error(hdl, EZFS_RESCRUB_PAUSED,
+				    msg));
+			else
+				return (zfs_error(hdl, EZFS_RESCRUBBING, msg));
+		} else {
+			return (zfs_error(hdl, EZFS_RESILVERING, msg));
+		}
+	} else if (err == ENOENT) {
+		return (zfs_error(hdl, EZFS_NO_RESCRUB, msg));
+	} else {
+		return (zpool_standard_error(hdl, err, msg));
+	}
+}
+
 /*
  * Find a vdev that matches the search criteria specified. We use the
  * the nvpair name to determine how we should look for the device.
diff --git a/lib/libzfs/libzfs_util.c b/lib/libzfs/libzfs_util.c
@@ -257,8 +257,16 @@ libzfs_error_description(libzfs_handle_t *hdl)
 	case EZFS_SCRUBBING:
 		return (dgettext(TEXT_DOMAIN, "currently scrubbing; "
 		    "use 'zpool scrub -s' to cancel current scrub"));
+	case EZFS_RESCRUBBING:
+		return (dgettext(TEXT_DOMAIN, "currently rescrubbing; "
+		    "use 'zpool rescrub -s' to cancel current scrub"));
+	case EZFS_RESCRUB_PAUSED:
+		return (dgettext(TEXT_DOMAIN, "scrub is paused; "
+		    "use 'zpool rescrub' to resume"));
 	case EZFS_NO_SCRUB:
 		return (dgettext(TEXT_DOMAIN, "there is no active scrub"));
+	case EZFS_NO_RESCRUB:
+		return (dgettext(TEXT_DOMAIN, "there is no active rescrub"));
 	case EZFS_DIFF:
 		return (dgettext(TEXT_DOMAIN, "unable to generate diffs"));
 	case EZFS_DIFFDATA:
diff --git a/lib/libzfs_core/libzfs_core.c b/lib/libzfs_core/libzfs_core.c
@@ -166,7 +166,7 @@ libzfs_core_fini(void)
 	(void) pthread_mutex_unlock(&g_lock);
 }
 
-static int
+int
 lzc_ioctl(zfs_ioc_t ioc, const char *name,
     nvlist_t *source, nvlist_t **resultp)
 {
diff --git a/module/zfs/dsl_scan.c b/module/zfs/dsl_scan.c
diff --git a/module/zfs/spa.c b/module/zfs/spa.c
diff --git a/module/zfs/spa_errlog.c b/module/zfs/spa_errlog.c
diff --git a/module/zfs/zfs_ioctl.c b/module/zfs/zfs_ioctl.c
diff --git a/tests/zfs-tests/cmd/libzfs_input_check/libzfs_input_check.c b/tests/zfs-tests/cmd/libzfs_input_check/libzfs_input_check.c
diff --git a/tests/zfs-tests/tests/functional/cli_root/zpool_scrub/zpool_scrub.cfg b/tests/zfs-tests/tests/functional/cli_root/zpool_scrub/zpool_scrub.cfg

Original file line number	Diff line number	Diff line change
`@@ -130,6 +130,8 @@ int lzc_reopen(const char *, boolean_t);`
`130`	`130`	`int lzc_pool_checkpoint(const char *);`
`131`	`131`	`int lzc_pool_checkpoint_discard(const char *);`
`132`	`132`
	`133`	`+int lzc_ioctl(zfs_ioc_t, const char , nvlist_t , nvlist_t **);`
	`134`	`+`
`133`	`135`	`#ifdef __cplusplus`
`134`	`136`	`}`
`135`	`137`	`#endif`