* [PATCH v1 0/3] btrfs-progs: scrub interface
@ 2011-03-12 18:31 Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 1/3] commands added Jan Schmidt
` (3 more replies)
0 siblings, 4 replies; 5+ messages in thread
From: Jan Schmidt @ 2011-03-12 18:31 UTC (permalink / raw)
To: chris.mason, linux-btrfs
This patch set for btrfs-progs is meant to be used together with the scrub kernel patches submitted by Arne Jansen (latest Subject: [PATCH v3 0/6] btrfs: scrub).
Short usage:
A scrub process for all devices of a (mounted) file system can be startet with:
btrfs filesystem scrub start /mnt/btrfs
A running scrub can be canceled with:
btrfs filesystem scrub cancel /mnt/btrfs
A canceled (manually or due to crash) scrub can be resumed with:
btrfs filesystem scrub start -r /mnt/btrfs
Status of running or finished scrub can be obtained with:
btrfs filesystem scrub status /mnt/btrfs
Any scrub sub-command has a short explanation of options when -h is used instead of a file system.
Thanks,
Jan
Jan Schmidt (3):
commands added
scrub ioctls
added scrub functionality
Makefile | 4 +-
btrfs.c | 12 +
btrfs_cmds.c | 3 +-
btrfs_cmds.h | 4 +
ctree.h | 2 +-
ioctl.h | 68 +++-
scrub.c | 1425 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
7 files changed, 1513 insertions(+), 5 deletions(-)
create mode 100644 scrub.c
--
1.7.3.4
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v1 1/3] commands added
2011-03-12 18:31 [PATCH v1 0/3] btrfs-progs: scrub interface Jan Schmidt
@ 2011-03-12 18:31 ` Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 2/3] scrub ioctls Jan Schmidt
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Jan Schmidt @ 2011-03-12 18:31 UTC (permalink / raw)
To: chris.mason, linux-btrfs
- scrub commands added
- open_file_or_dir no longer static (needed by scrub.c)
Signed-off-by: Jan Schmidt <list.btrfs@jan-o-sch.net>
---
Makefile | 4 ++--
btrfs.c | 12 ++++++++++++
btrfs_cmds.c | 3 ++-
btrfs_cmds.h | 4 ++++
4 files changed, 20 insertions(+), 3 deletions(-)
diff --git a/Makefile b/Makefile
index 6e6f6c6..6630887 100644
--- a/Makefile
+++ b/Makefile
@@ -37,8 +37,8 @@ all: version $(progs) manpages
version:
bash version.sh
-btrfs: $(objects) btrfs.o btrfs_cmds.o
- gcc $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o \
+btrfs: $(objects) btrfs.o btrfs_cmds.o scrub.o
+ gcc -lpthread $(CFLAGS) -o btrfs btrfs.o btrfs_cmds.o scrub.o \
$(objects) $(LDFLAGS) $(LIBS)
btrfsctl: $(objects) btrfsctl.o
diff --git a/btrfs.c b/btrfs.c
index 46314cf..e874777 100644
--- a/btrfs.c
+++ b/btrfs.c
@@ -95,6 +95,18 @@ static struct Command commands[] = {
"filesystem balance", "<path>\n"
"Balance the chunks across the device."
},
+ { do_scrub_start, -1,
+ "filesystem scrub start", "[-D] [-w] <path>\n"
+ "Check the underlying media for errors."
+ },
+ { do_scrub_cancel, 1,
+ "filesystem scrub cancel", "<path>\n"
+ "Cancel a running scrub."
+ },
+ { do_scrub_status, -1,
+ "filesystem scrub status", "[-r] <path>\n"
+ "Show status of running or finished scrub."
+ },
{ do_scan,
999, "device scan", "[<device> [<device>..]\n"
"Scan all device for or the passed device for a btrfs\n"
diff --git a/btrfs_cmds.c b/btrfs_cmds.c
index 8031c58..39f84a8 100644
--- a/btrfs_cmds.c
+++ b/btrfs_cmds.c
@@ -90,7 +90,7 @@ static int test_isdir(char *path)
}
-static int open_file_or_dir(const char *fname)
+int open_file_or_dir(const char *fname)
{
int ret;
struct stat st;
@@ -776,6 +776,7 @@ int do_balance(int argc, char **argv)
}
return 0;
}
+
int do_remove_volume(int nargs, char **args)
{
diff --git a/btrfs_cmds.h b/btrfs_cmds.h
index 7bde191..f925970 100644
--- a/btrfs_cmds.h
+++ b/btrfs_cmds.h
@@ -23,6 +23,9 @@ int do_defrag(int argc, char **argv);
int do_show_filesystem(int nargs, char **argv);
int do_add_volume(int nargs, char **args);
int do_balance(int nargs, char **argv);
+int do_scrub_start(int nargs, char **argv);
+int do_scrub_status(int argc, char **argv);
+int do_scrub_cancel(int nargs, char **argv);
int do_remove_volume(int nargs, char **args);
int do_scan(int nargs, char **argv);
int do_resize(int nargs, char **argv);
@@ -32,3 +35,4 @@ int list_subvols(int fd);
int do_df_filesystem(int nargs, char **argv);
int find_updated_files(int fd, u64 root_id, u64 oldest_gen);
int do_find_newer(int argc, char **argv);
+int open_file_or_dir(const char *fname);
--
1.7.3.4
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH v1 2/3] scrub ioctls
2011-03-12 18:31 [PATCH v1 0/3] btrfs-progs: scrub interface Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 1/3] commands added Jan Schmidt
@ 2011-03-12 18:31 ` Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 3/3] added scrub functionality Jan Schmidt
2011-03-12 20:39 ` [PATCH v1 0/3] btrfs-progs: scrub interface Hubert Kario
3 siblings, 0 replies; 5+ messages in thread
From: Jan Schmidt @ 2011-03-12 18:31 UTC (permalink / raw)
To: chris.mason, linux-btrfs
- scrub structs added
- ioctls for scrub
- BTRFS_FSID_SIZE moved
Signed-off-by: Jan Schmidt <list.btrfs@jan-o-sch.net>
---
ctree.h | 2 +-
ioctl.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 68 insertions(+), 2 deletions(-)
diff --git a/ctree.h b/ctree.h
index b79e238..577365e 100644
--- a/ctree.h
+++ b/ctree.h
@@ -24,6 +24,7 @@
#include "radix-tree.h"
#include "extent-cache.h"
#include "extent_io.h"
+#include "ioctl.h"
struct btrfs_root;
struct btrfs_trans_handle;
@@ -250,7 +251,6 @@ static inline unsigned long btrfs_chunk_item_size(int num_stripes)
sizeof(struct btrfs_stripe) * (num_stripes - 1);
}
-#define BTRFS_FSID_SIZE 16
#define BTRFS_HEADER_FLAG_WRITTEN (1ULL << 0)
#define BTRFS_HEADER_FLAG_RELOC (1ULL << 1)
#define BTRFS_SUPER_FLAG_SEEDING (1ULL << 32)
diff --git a/ioctl.h b/ioctl.h
index 776d7a9..0d7dd18 100644
--- a/ioctl.h
+++ b/ioctl.h
@@ -23,13 +23,70 @@
#define BTRFS_IOCTL_MAGIC 0x94
#define BTRFS_VOL_NAME_MAX 255
-#define BTRFS_PATH_NAME_MAX 4087
+/* this should be 4k */
+#define BTRFS_PATH_NAME_MAX 4087
struct btrfs_ioctl_vol_args {
__s64 fd;
char name[BTRFS_PATH_NAME_MAX + 1];
};
+#define BTRFS_FSID_SIZE 16
+#define BTRFS_UUID_SIZE 16
+
+#define BTRFS_SUBVOL_NAME_MAX 4039
+struct btrfs_ioctl_vol_args_v2 {
+ __s64 fd;
+ __u64 transid;
+ __u64 flags;
+ __u64 unused[4];
+ char name[BTRFS_SUBVOL_NAME_MAX + 1];
+};
+
+struct btrfs_scrub_progress {
+ __u64 data_extents_scrubbed;
+ __u64 tree_extents_scrubbed;
+ __u64 data_bytes_scrubbed;
+ __u64 tree_bytes_scrubbed;
+ __u64 read_errors;
+ __u64 csum_errors;
+ __u64 verify_errors;
+ __u64 no_csum;
+ __u64 csum_discards;
+ __u64 super_errors;
+ __u64 malloc_errors;
+ __u64 uncorrectable_errors;
+ __u64 corrected_errors;
+ __u64 last_physical;
+};
+
+struct btrfs_ioctl_scrub_args {
+ __u64 devid; /* in */
+ __u64 start; /* in */
+ __u64 end; /* in */
+ __u64 flags; /* in */
+ struct btrfs_scrub_progress progress; /* out */
+ /* pad to 1k */
+ __u64 unused[(1024-32-sizeof(struct btrfs_scrub_progress))/8];
+};
+
+#define BTRFS_DEVICE_PATH_NAME_MAX 1024
+struct btrfs_ioctl_dev_info_args {
+ __u64 devid; /* in/out */
+ __u8 uuid[BTRFS_UUID_SIZE]; /* in/out */
+ __u64 bytes_used; /* out */
+ __u64 total_bytes; /* out */
+ __u64 unused[379]; /* pad to 4k */
+ __u8 path[BTRFS_DEVICE_PATH_NAME_MAX]; /* out */
+};
+
+struct btrfs_ioctl_fs_info_args {
+ __u64 max_id; /* out */
+ __u64 num_devices; /* out */
+ __u8 fsid[BTRFS_FSID_SIZE]; /* out */
+ __u64 reserved[124]; /* pad to 1k */
+};
+
struct btrfs_ioctl_search_key {
/* which root are we searching. 0 is the tree of tree roots */
__u64 tree_id;
@@ -169,4 +226,13 @@ struct btrfs_ioctl_space_args {
#define BTRFS_IOC_DEFAULT_SUBVOL _IOW(BTRFS_IOCTL_MAGIC, 19, u64)
#define BTRFS_IOC_SPACE_INFO _IOWR(BTRFS_IOCTL_MAGIC, 20, \
struct btrfs_ioctl_space_args)
+#define BTRFS_IOC_SCRUB _IOWR(BTRFS_IOCTL_MAGIC, 27, \
+ struct btrfs_ioctl_scrub_args)
+#define BTRFS_IOC_SCRUB_CANCEL _IO(BTRFS_IOCTL_MAGIC, 28)
+#define BTRFS_IOC_SCRUB_PROGRESS _IOWR(BTRFS_IOCTL_MAGIC, 29, \
+ struct btrfs_ioctl_scrub_args)
+#define BTRFS_IOC_DEV_INFO _IOWR(BTRFS_IOCTL_MAGIC, 30, \
+ struct btrfs_ioctl_dev_info_args)
+#define BTRFS_IOC_FS_INFO _IOR(BTRFS_IOCTL_MAGIC, 31, \
+ struct btrfs_ioctl_fs_info_args)
#endif
--
1.7.3.4
^ permalink raw reply related [flat|nested] 5+ messages in thread
* [PATCH v1 3/3] added scrub functionality
2011-03-12 18:31 [PATCH v1 0/3] btrfs-progs: scrub interface Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 1/3] commands added Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 2/3] scrub ioctls Jan Schmidt
@ 2011-03-12 18:31 ` Jan Schmidt
2011-03-12 20:39 ` [PATCH v1 0/3] btrfs-progs: scrub interface Hubert Kario
3 siblings, 0 replies; 5+ messages in thread
From: Jan Schmidt @ 2011-03-12 18:31 UTC (permalink / raw)
To: chris.mason, linux-btrfs
Known issues:
- "scrub status" has quite some lag as it only reads the status file periodically written by the background process. Next step would be to implement some kind of interaction between both processes to get more up to date results while a scrub is running
- The locking in the code is currently ineffective (read: does nothing useful). It was meant to protect against starting multiple scrubs on a filesystem simultaneously. However, to get consistent status files new files are created and renamed all the time.
Signed-off-by: Jan Schmidt <list.btrfs@jan-o-sch.net>
---
scrub.c | 1425 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1425 insertions(+), 0 deletions(-)
diff --git a/scrub.c b/scrub.c
new file mode 100644
index 0000000..0509548
--- /dev/null
+++ b/scrub.c
@@ -0,0 +1,1425 @@
+
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <uuid/uuid.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <ctype.h>
+#include <signal.h>
+#include <stdarg.h>
+
+#include "ctree.h"
+#include "ioctl.h"
+#include "btrfs_cmds.h"
+#include "utils.h"
+#include "volumes.h"
+#include "disk-io.h"
+
+struct scrub_stats {
+ time_t t_start;
+ time_t t_resumed;
+ u64 duration;
+ u64 finished;
+ u64 canceled;
+};
+
+struct scrub_progress {
+ struct btrfs_ioctl_scrub_args scrub_args;
+ int fd;
+ int ret;
+ int skip;
+ struct scrub_stats stats;
+ struct scrub_file_record *resumed;
+ int ioctl_errno;
+ pthread_mutex_t progress_mutex;
+};
+
+struct scrub_file_record {
+ u8 fsid[BTRFS_FSID_SIZE];
+ u64 devid;
+ struct scrub_stats stats;
+ struct btrfs_scrub_progress p;
+};
+
+struct scrub_progress_cycle {
+ int fdmnt;
+ int do_record;
+ struct btrfs_ioctl_fs_info_args *fi;
+ struct scrub_progress *progress;
+ struct scrub_progress *shared_progress;
+ pthread_mutex_t *write_mutex;
+};
+
+struct scrub_fs_stat {
+ struct btrfs_scrub_progress p;
+ struct scrub_stats s;
+ int i;
+};
+
+static void print_scrub_full(struct btrfs_scrub_progress *sp)
+{
+ printf("\tdata_extents_scrubbed: %lld\n", sp->data_extents_scrubbed);
+ printf("\ttree_extents_scrubbed: %lld\n", sp->tree_extents_scrubbed);
+ printf("\tdata_bytes_scrubbed: %lld\n", sp->data_bytes_scrubbed);
+ printf("\ttree_bytes_scrubbed: %lld\n", sp->tree_bytes_scrubbed);
+ printf("\tread_errors: %lld\n", sp->read_errors);
+ printf("\tcsum_errors: %lld\n", sp->csum_errors);
+ printf("\tverify_errors: %lld\n", sp->verify_errors);
+ printf("\tno_csum: %lld\n", sp->no_csum);
+ printf("\tcsum_discards: %lld\n", sp->csum_discards);
+ printf("\tsuper_errors: %lld\n", sp->super_errors);
+ printf("\tmalloc_errors: %lld\n", sp->malloc_errors);
+ printf("\tuncorrectable_errors: %lld\n", sp->uncorrectable_errors);
+ printf("\tcorrected_errors: %lld\n", sp->corrected_errors);
+ printf("\tlast_physical: %lld\n", sp->last_physical);
+}
+
+#define err(test, ...) do { \
+ if (test) \
+ fprintf(stderr, __VA_ARGS__); \
+} while (0)
+
+#define PRINT_SCRUB_ERROR(test, desc) do { \
+ if (test) \
+ printf(" %s=%llu", desc, test); \
+} while (0)
+static void print_scrub_summary(struct btrfs_scrub_progress *p)
+{
+ u64 err_cnt;
+ u64 err_cnt2;
+
+ err_cnt = p->read_errors +
+ p->csum_errors +
+ p->verify_errors +
+ p->no_csum +
+ p->csum_discards +
+ p->super_errors +
+ p->malloc_errors;
+
+ err_cnt2 = p->corrected_errors + p->uncorrectable_errors;
+
+ printf("\ttotal bytes scrubbed: %s with %llu errors\n",
+ pretty_sizes(p->data_bytes_scrubbed + p->tree_bytes_scrubbed),
+ max(err_cnt, err_cnt2));
+ if (err_cnt || err_cnt2) {
+ printf("\terror details:");
+ PRINT_SCRUB_ERROR(p->read_errors, "read");
+ PRINT_SCRUB_ERROR(p->super_errors, "super");
+ PRINT_SCRUB_ERROR(p->malloc_errors, "malloc");
+ PRINT_SCRUB_ERROR(p->verify_errors, "verify");
+ PRINT_SCRUB_ERROR(p->csum_errors, "csum");
+ PRINT_SCRUB_ERROR(p->no_csum, "csum-missing");
+ PRINT_SCRUB_ERROR(p->csum_discards, "csum-discards");
+ printf("\n");
+ printf("\tcorrected errors: %llu, uncorrectable errors: %llu\n",
+ p->corrected_errors, p->uncorrectable_errors);
+ }
+}
+
+#define _SCRUB_FS_STAT(p, name, fs_stat) fs_stat->p.name += p->name
+#define _SCRUB_FS_STAT_MIN(ss, name, fs_stat) \
+do { \
+ if (fs_stat->s.name > ss->name) { \
+ fs_stat->s.name = ss->name; \
+ } \
+} while (0)
+#define _SCRUB_FS_STAT_ZMIN(ss, name, fs_stat) \
+do { \
+ if (!fs_stat->s.name || fs_stat->s.name > ss->name) { \
+ fs_stat->s.name = ss->name; \
+ } \
+} while (0)
+#define _SCRUB_FS_STAT_MAX(ss, name, fs_stat) \
+do { \
+ if (!fs_stat->s.name || fs_stat->s.name < ss->name) { \
+ fs_stat->s.name = ss->name; \
+ } \
+} while (0)
+static void add_to_fs_stat(struct btrfs_scrub_progress *p,
+ struct scrub_stats *ss,
+ struct scrub_fs_stat *fs_stat)
+{
+ _SCRUB_FS_STAT(p, data_extents_scrubbed, fs_stat);
+ _SCRUB_FS_STAT(p, tree_extents_scrubbed, fs_stat);
+ _SCRUB_FS_STAT(p, data_bytes_scrubbed, fs_stat);
+ _SCRUB_FS_STAT(p, tree_bytes_scrubbed, fs_stat);
+ _SCRUB_FS_STAT(p, read_errors, fs_stat);
+ _SCRUB_FS_STAT(p, csum_errors, fs_stat);
+ _SCRUB_FS_STAT(p, verify_errors, fs_stat);
+ _SCRUB_FS_STAT(p, no_csum, fs_stat);
+ _SCRUB_FS_STAT(p, csum_discards, fs_stat);
+ _SCRUB_FS_STAT(p, super_errors, fs_stat);
+ _SCRUB_FS_STAT(p, malloc_errors, fs_stat);
+ _SCRUB_FS_STAT(p, uncorrectable_errors, fs_stat);
+ _SCRUB_FS_STAT(p, corrected_errors, fs_stat);
+ _SCRUB_FS_STAT(p, last_physical, fs_stat);
+ _SCRUB_FS_STAT_ZMIN(ss, t_start, fs_stat);
+ _SCRUB_FS_STAT_ZMIN(ss, t_resumed, fs_stat);
+ _SCRUB_FS_STAT_MAX(ss, duration, fs_stat);
+ _SCRUB_FS_STAT_MAX(ss, canceled, fs_stat);
+ _SCRUB_FS_STAT_MIN(ss, finished, fs_stat);
+}
+
+static void init_fs_stat(struct scrub_fs_stat *fs_stat)
+{
+ memset(fs_stat, 0, sizeof(*fs_stat));
+ fs_stat->s.finished = 2;
+}
+
+static void _print_scrub_ss(struct scrub_stats *ss)
+{
+ char t[1024];
+ struct tm tm;
+
+ if (!ss || !ss->t_start) {
+ printf("\tno stats available\n");
+ return;
+ }
+ if (ss->t_resumed) {
+ localtime_r(&ss->t_resumed, &tm);
+ strftime(t, sizeof(t), "%c", &tm);
+ printf("\tscrub resumed at %s", t);
+ } else {
+ localtime_r(&ss->t_start, &tm);
+ strftime(t, sizeof(t), "%c", &tm);
+ printf("\tscrub started at %s", t);
+ }
+ if (ss->finished && !ss->canceled) {
+ printf(" and finished after %llu seconds\n",
+ ss->duration);
+ } else if (ss->canceled) {
+ printf(" and was aborted after %llu seconds\n",
+ ss->duration);
+ } else {
+ printf(", running for %llu seconds\n", ss->duration);
+ }
+}
+
+static void print_scrub_dev(struct btrfs_ioctl_dev_info_args *di,
+ struct btrfs_scrub_progress *p, int raw,
+ const char *append, struct scrub_stats *ss)
+{
+ printf("scrub device %s (id %llu) %s\n", di->path, di->devid,
+ append ? append : "");
+
+ _print_scrub_ss(ss);
+
+ if (raw)
+ print_scrub_full(p);
+ else
+ print_scrub_summary(p);
+}
+
+static void print_fs_stat(struct scrub_fs_stat *fs_stat, int raw)
+{
+ _print_scrub_ss(&fs_stat->s);
+
+ if (raw)
+ print_scrub_full(&fs_stat->p);
+ else
+ print_scrub_summary(&fs_stat->p);
+}
+
+static void free_history(struct scrub_file_record **last_scrubs)
+{
+ struct scrub_file_record **l = last_scrubs;
+ if (!l)
+ return;
+ while (*l)
+ free(*l++);
+ free(last_scrubs);
+}
+
+static int cancel_fd = -1;
+static void scrub_sigint_record_progress(int signal)
+{
+ ioctl(cancel_fd, BTRFS_IOC_SCRUB_CANCEL, NULL);
+}
+
+static int scrub_handle_sigint_parent(void)
+{
+ struct sigaction sa = {
+ .sa_handler = SIG_IGN,
+ .sa_flags = SA_RESTART,
+ };
+
+ return sigaction(SIGINT, &sa, NULL);
+}
+
+static int scrub_handle_sigint_child(int fd)
+{
+ struct sigaction sa = {
+ .sa_handler = fd == -1 ? SIG_DFL : scrub_sigint_record_progress,
+ };
+
+ cancel_fd = fd;
+ return sigaction(SIGINT, &sa, NULL);
+}
+
+static int _scrub_datafile(const char *fn_base, const char *fn_local,
+ const char *fn_tmp, char *datafile, int max)
+{
+ int ret;
+
+ strncpy(datafile, fn_base, max);
+ ret = strlen(datafile);
+
+ if (ret + 1 >= max)
+ return -EOVERFLOW;
+
+ datafile[ret] = '.';
+ strncpy(datafile+ret+1, fn_local, max-ret-1);
+ ret = strlen(datafile);
+
+ if (ret + 1 >= max)
+ return -EOVERFLOW;
+
+ if (fn_tmp) {
+ datafile[ret] = '_';
+ strncpy(datafile+ret+1, fn_tmp, max-ret-1);
+ ret = strlen(datafile);
+
+ if (ret >= max)
+ return -EOVERFLOW;
+ }
+
+ return 0;
+}
+
+static int _scrub_open_file(const char *datafile, int m)
+{
+ int fd;
+ int ret;
+
+ fd = open(datafile, m, 0600);
+ if (fd < 0)
+ return -errno;
+
+ ret = flock(fd, LOCK_EX|LOCK_NB);
+ if (ret) {
+ ret = errno;
+ close(fd);
+ return -ret;
+ }
+
+ return fd;
+}
+
+static int scrub_open_file_r(const char *fn_base, const char *fn_local)
+{
+ int ret;
+ char datafile[1024];
+ ret = _scrub_datafile(fn_base, fn_local, NULL,
+ datafile, sizeof(datafile));
+ if (ret < 0)
+ return ret;
+ return _scrub_open_file(datafile, O_RDONLY);
+}
+
+static int scrub_open_file_w(const char *fn_base, const char *fn_local,
+ const char *tmp)
+{
+ int ret;
+ char datafile[1024];
+ ret = _scrub_datafile(fn_base, fn_local, tmp,
+ datafile, sizeof(datafile));
+ if (ret < 0)
+ return ret;
+ return _scrub_open_file(datafile, O_WRONLY|O_CREAT);
+}
+
+static int scrub_rename_file(const char *fn_base, const char *fn_local,
+ const char *tmp)
+{
+ int ret;
+ char datafile_old[1024];
+ char datafile_new[1024];
+ ret = _scrub_datafile(fn_base, fn_local, tmp,
+ datafile_old, sizeof(datafile_old));
+ if (ret < 0)
+ return ret;
+ ret = _scrub_datafile(fn_base, fn_local, NULL,
+ datafile_new, sizeof(datafile_new));
+ if (ret < 0)
+ return ret;
+ ret = rename(datafile_old, datafile_new);
+ return ret ? -errno : 0;
+}
+
+#define SCRUB_DATA_FILE "/var/btrfs/scrub.status"
+#define SCRUB_FILE_VERSION_PREFIX "scrub status:"
+#define SCRUB_FILE_VERSION "1"
+
+#define _SCRUB_KVREAD(i, name, avail, l, dest) \
+ _scrub_kvread(i, sizeof(#name), avail, l, #name, dest.name)
+#define _SCRUB_KVREAD_STATS(i, name, avail, l, dest) \
+ _scrub_kvread(i, sizeof(#name), avail, l, #name, dest->stats.name)
+/*
+ * returns 0 if the key did not match (nothing was read)
+ * 1 if the key did match (success)
+ * -1 if the key did match and an error occured
+ */
+static int _scrub_kvread(int *i, int len, int avail, const char *buf,
+ const char *key, u64 *dest)
+{
+ int j;
+
+ if (*i+len+1 < avail && strncmp(&buf[*i], key, len-1) == 0) {
+ *i += len-1;
+ if (buf[*i] != ':') {
+ return -1;
+ }
+ *i += 1;
+ for (j=0; isdigit(buf[*i+j]) && *i+j < avail; ++j)
+ ;
+ if (*i+j >= avail)
+ return -1;
+ *dest = atoll(&buf[*i]);
+ *i += j;
+ return 1;
+ }
+
+ return 0;
+}
+
+#define _SCRUB_ILLEGAL do { \
+ if (report_errors) { \
+ fprintf(stderr, "WARNING: illegal data in line %d pos " \
+ "%d state %d (near \"%.*s\") at %s:%d\n", \
+ lineno, i, state, 20 > avail ? avail : 20, l+i, \
+ __FILE__, __LINE__); \
+ } \
+ goto skip; \
+} while (0)
+static struct scrub_file_record **scrub_read_file(int fd, int report_errors)
+{
+ int avail = 0;
+ int old_avail = 0;
+ char l[512];
+ int state = 0;
+ int curr = -1;
+ int i = 0;
+ int j;
+ int ret;
+ int eof = 0;
+ int lineno = 0;
+ u64 version;
+ char empty_uuid[BTRFS_FSID_SIZE] = {0};
+ struct scrub_file_record **p = NULL;
+
+ if (fd < 0)
+ return ERR_PTR(-EINVAL);
+
+again:
+ old_avail = avail-i;
+ BUG_ON(old_avail < 0);
+ if (old_avail)
+ memmove(l, l+i, old_avail);
+ avail = read(fd, l+old_avail, sizeof(l)-old_avail);
+ if (avail == 0) {
+ eof = 1;
+ }
+ if (avail + old_avail == 0) {
+ if (curr >= 0 &&
+ memcmp(p[curr]->fsid, empty_uuid, BTRFS_FSID_SIZE) == 0) {
+ p[curr] = NULL;
+ } else if (curr == -1) {
+ p = ERR_PTR(-ENODATA);
+ }
+ return p;
+ }
+ if (avail == -1)
+ return ERR_PTR(-errno);
+ avail += old_avail;
+
+ i = 0;
+ while (i < avail) {
+ switch (state) {
+ case 0: /* start if file */
+ ret = _scrub_kvread(&i,
+ sizeof(SCRUB_FILE_VERSION_PREFIX)-1, avail, l,
+ SCRUB_FILE_VERSION_PREFIX, &version);
+ if (ret != 1)
+ _SCRUB_ILLEGAL;
+ if (version != atoll(SCRUB_FILE_VERSION))
+ return ERR_PTR(-ENOTSUP);
+ state = 6;
+ continue;
+ case 1: /* start of line, alloc */
+ if (!eof && !memchr(l+i, '\n', avail-i))
+ goto again;
+ ++lineno;
+ if (curr > -1 && memcmp(p[curr]->fsid, empty_uuid,
+ BTRFS_FSID_SIZE) == 0) {
+ state = 2;
+ continue;
+ }
+ ++curr;
+ p = realloc(p, (curr+2)*sizeof(*p));
+ if (p)
+ p[curr] = malloc(sizeof(**p));
+ if (!p || !p[curr])
+ return ERR_PTR(-errno);
+ memset(p[curr], 0, sizeof(**p));
+ p[curr+1] = NULL;
+ ++state;
+ case 2: /* start of line, skip space */
+ while (isspace(l[i]) && i<avail) {
+ if (l[i] == '\n')
+ ++lineno;
+ ++i;
+ }
+ if (i >= avail || (!eof && !memchr(l+i, '\n', avail-i)))
+ goto again;
+ ++state;
+ case 3: /* read fsid */
+ if (i == avail)
+ continue;
+ for (j=0; l[i+j] != ':' && i+j < avail; ++j)
+ ;
+ if (i+j+1 >= avail)
+ _SCRUB_ILLEGAL;
+ if (j != 36)
+ _SCRUB_ILLEGAL;
+ l[i+j] = '\0';
+ ret = uuid_parse(l+i, p[curr]->fsid);
+ if (ret)
+ _SCRUB_ILLEGAL;
+ i += j + 1;
+ ++state;
+ case 4: /* read dev id */
+ for (j=0; isdigit(l[i+j]) && i+j < avail; ++j)
+ ;
+ if (!j || i+j+1 >= avail)
+ _SCRUB_ILLEGAL;
+ p[curr]->devid = atoll(&l[i]);
+ i += j + 1;
+ ++state;
+ case 5: /* read key/value pair */
+ ret = _SCRUB_KVREAD(&i, data_extents_scrubbed, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, data_extents_scrubbed, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, tree_extents_scrubbed, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, data_bytes_scrubbed, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, tree_bytes_scrubbed, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, read_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, csum_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, verify_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, no_csum, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, csum_discards, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, super_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, malloc_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, uncorrectable_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, corrected_errors, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, last_physical, avail,
+ l, &p[curr]->p) ||
+ _SCRUB_KVREAD(&i, finished, avail,
+ l, &p[curr]->stats) ||
+ _SCRUB_KVREAD(&i, t_start, avail,
+ l, (u64*)&p[curr]->stats) ||
+ _SCRUB_KVREAD(&i, t_resumed, avail,
+ l, (u64*)&p[curr]->stats) ||
+ _SCRUB_KVREAD(&i, duration, avail,
+ l, (u64*)&p[curr]->stats) ||
+ _SCRUB_KVREAD(&i, canceled, avail,
+ l, &p[curr]->stats);
+ if (ret != 1)
+ _SCRUB_ILLEGAL;
+ ++state;
+ case 6: /* after number */
+ if (l[i] == '|') {
+ state = 5;
+ } else if (l[i] == '\n') {
+ state = 1;
+ } else {
+ _SCRUB_ILLEGAL;
+ }
+ ++i;
+ continue;
+ case 99: /* skip rest of line */
+skip:
+ state = 99;
+ do {
+ ++i;
+ if (l[i-1] == '\n') {
+ state = 1;
+ break;
+ }
+ } while (i < avail);
+ continue;
+ }
+ BUG();
+ }
+ goto again;
+}
+#undef _SCRUB_ILLEGAL
+
+static int _scrub_write_buf(int fd, const void *data, int len)
+{
+ int ret;
+ ret = write(fd, data, len);
+ return ret - len;
+}
+
+static int _scrub_writev(int fd, char *buf, int max, const char *fmt, ...)
+ __attribute__ ((format (printf, 4, 5)));
+static int _scrub_writev(int fd, char *buf, int max, const char *fmt, ...)
+{
+ int ret;
+ va_list args;
+
+ va_start(args, fmt);
+ ret = vsnprintf(buf, max, fmt, args);
+ va_end(args);
+ if (ret >= max)
+ return ret - max;
+ return _scrub_write_buf(fd, buf, ret);
+}
+
+#define _SCRUB_SUM(dest, data, name) dest->scrub_args.progress.name = \
+ data->resumed->p.name + data->scrub_args.progress.name
+static struct scrub_progress *_scrub_resumed_stats(struct scrub_progress *data,
+ struct scrub_progress *dest)
+{
+ if (!data->resumed || data->skip)
+ return data;
+
+ _SCRUB_SUM(dest, data, data_extents_scrubbed);
+ _SCRUB_SUM(dest, data, tree_extents_scrubbed);
+ _SCRUB_SUM(dest, data, data_bytes_scrubbed);
+ _SCRUB_SUM(dest, data, tree_bytes_scrubbed);
+ _SCRUB_SUM(dest, data, read_errors);
+ _SCRUB_SUM(dest, data, csum_errors);
+ _SCRUB_SUM(dest, data, verify_errors);
+ _SCRUB_SUM(dest, data, no_csum);
+ _SCRUB_SUM(dest, data, csum_discards);
+ _SCRUB_SUM(dest, data, super_errors);
+ _SCRUB_SUM(dest, data, malloc_errors);
+ _SCRUB_SUM(dest, data, uncorrectable_errors);
+ _SCRUB_SUM(dest, data, corrected_errors);
+ _SCRUB_SUM(dest, data, last_physical);
+ dest->stats.canceled = data->stats.canceled;
+ dest->stats.finished = data->stats.finished;
+ dest->stats.t_resumed = data->stats.t_start;
+ dest->stats.t_start = data->resumed->stats.t_start;
+ dest->stats.duration = data->resumed->stats.duration +
+ data->stats.duration;
+ dest->scrub_args.devid = data->scrub_args.devid;
+ return dest;
+}
+
+#define _SCRUB_KVWRITE(fd, buf, name, use) \
+ _scrub_kvwrite(fd, buf, sizeof(buf), #name, \
+ use->scrub_args.progress.name)
+#define _SCRUB_KVWRITE_STATS(fd, buf, name, use) \
+ _scrub_kvwrite(fd, buf, sizeof(buf), #name, \
+ use->stats.name)
+static int _scrub_kvwrite(int fd, char *buf, int max,
+ const char *key, u64 val)
+{
+ return _scrub_writev(fd, buf, max, "|%s:%lld", key, val);
+}
+
+static int scrub_write_file(int fd, const char *fsid,
+ struct scrub_progress* data, int n)
+{
+ int ret = 0;
+ int i;
+ char buf[1024];
+ struct scrub_progress local;
+ struct scrub_progress *use;
+
+ if (n < 1) {
+ return -EINVAL;
+ }
+
+ ret = _scrub_write_buf(fd, SCRUB_FILE_VERSION_PREFIX SCRUB_FILE_VERSION
+ "\n", sizeof(SCRUB_FILE_VERSION_PREFIX)-1
+ + sizeof(SCRUB_FILE_VERSION)-1 + 1);
+ if (ret)
+ return -EOVERFLOW;
+
+ for (i=0; i<n; ++i) {
+ use = _scrub_resumed_stats(&data[i], &local);
+ if (_scrub_write_buf(fd, fsid, strlen(fsid)) ||
+ _scrub_write_buf(fd, ":", 1) ||
+ _scrub_writev(fd, buf, sizeof(buf), "%lld",
+ use->scrub_args.devid) ||
+ _scrub_write_buf(fd, buf, ret) ||
+ _SCRUB_KVWRITE(fd, buf, data_extents_scrubbed, use) ||
+ _SCRUB_KVWRITE(fd, buf, tree_extents_scrubbed, use) ||
+ _SCRUB_KVWRITE(fd, buf, data_bytes_scrubbed, use) ||
+ _SCRUB_KVWRITE(fd, buf, tree_bytes_scrubbed, use) ||
+ _SCRUB_KVWRITE(fd, buf, read_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, csum_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, verify_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, no_csum, use) ||
+ _SCRUB_KVWRITE(fd, buf, csum_discards, use) ||
+ _SCRUB_KVWRITE(fd, buf, super_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, malloc_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, uncorrectable_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, corrected_errors, use) ||
+ _SCRUB_KVWRITE(fd, buf, last_physical, use) ||
+ _SCRUB_KVWRITE_STATS(fd, buf, t_start, use) ||
+ _SCRUB_KVWRITE_STATS(fd, buf, t_resumed, use) ||
+ _SCRUB_KVWRITE_STATS(fd, buf, duration, use) ||
+ _SCRUB_KVWRITE_STATS(fd, buf, canceled, use) ||
+ _SCRUB_KVWRITE_STATS(fd, buf, finished, use) ||
+ _scrub_write_buf(fd, "\n", 1)) {
+ return -EOVERFLOW;
+ }
+ }
+
+ return 0;
+}
+#undef _SCRUB_KVWRITE
+
+static int scrub_write_progress(pthread_mutex_t *m, const char *fsid,
+ struct scrub_progress* data, int n)
+{
+ int ret;
+ int fd;
+ int old;
+
+ ret = pthread_mutex_lock(m);
+ if (ret) {
+ ret = -errno;
+ goto out;
+ }
+
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old);
+
+ fd = scrub_open_file_w(SCRUB_DATA_FILE, fsid, "tmp");
+ if (fd < 0) {
+ ret = fd;
+ goto out;
+ }
+ ret = scrub_write_file(fd, fsid, data, n);
+ if (ret)
+ goto out;
+ ret = scrub_rename_file(SCRUB_DATA_FILE, fsid, "tmp");
+ if (ret)
+ goto out;
+ ret = close(fd);
+ if (ret) {
+ ret = -errno;
+ goto out;
+ }
+
+out:
+ if (ret) {
+ pthread_mutex_unlock(m);
+ } else {
+ ret = pthread_mutex_unlock(m);
+ if (ret)
+ ret = -errno;
+ }
+
+ pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old);
+
+ return ret;
+}
+
+static void *scrub_one_dev(void *ctx)
+{
+ struct scrub_progress *sp = ctx;
+ int ret;
+ struct timeval tv;
+
+ sp->stats.canceled = 0;
+ sp->stats.duration = 0;
+ sp->stats.finished = 0;
+
+ ret = ioctl(sp->fd, BTRFS_IOC_SCRUB, &sp->scrub_args);
+ gettimeofday(&tv, NULL);
+ sp->ret = ret;
+ sp->stats.duration = tv.tv_sec - sp->stats.t_start;
+ sp->stats.canceled = !!ret;
+ sp->ioctl_errno = errno;
+ ret = pthread_mutex_lock(&sp->progress_mutex);
+ if (ret)
+ return ERR_PTR(-errno);
+ sp->stats.finished = 1;
+ ret = pthread_mutex_unlock(&sp->progress_mutex);
+ if (ret)
+ return ERR_PTR(-errno);
+
+
+ return NULL;
+}
+
+static void *progress_one_dev(void *ctx)
+{
+ struct scrub_progress *sp = ctx;
+
+ sp->ret = ioctl(sp->fd, BTRFS_IOC_SCRUB_PROGRESS, &sp->scrub_args);
+ sp->ioctl_errno = errno;
+
+ return NULL;
+}
+
+static void *scrub_progress_cycle(void *ctx)
+{
+ int ret;
+ int i;
+ struct scrub_progress *sp;
+ struct scrub_progress *sp_last;
+ struct scrub_progress *sp_shared;
+ struct timeval tv;
+ struct scrub_progress_cycle *spc = ctx;
+ int ndev = spc->fi->num_devices;
+ int this = 1;
+ int last = 0;
+ char fsid[37];
+
+ pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &ret);
+ uuid_unparse(spc->fi->fsid, fsid);
+
+ for (i=0; i<ndev; ++i) {
+ sp = &spc->progress[i];
+ sp_last = &spc->progress[i+ndev];
+ sp_shared = &spc->shared_progress[i];
+ sp->scrub_args.devid = sp_last->scrub_args.devid =
+ sp_shared->scrub_args.devid;
+ sp->fd = sp_last->fd = spc->fdmnt;
+ sp->stats.t_start = sp_last->stats.t_start =
+ sp_shared->stats.t_start;
+ sp->resumed = sp_last->resumed = sp_shared->resumed;
+ sp->skip = sp_last->skip = sp_shared->skip;
+ sp->stats.finished = sp_last->stats.finished =
+ sp_shared->stats.finished;
+ }
+
+ while (1) {
+ sleep(5);
+ gettimeofday(&tv, NULL);
+ this = (this+1)%2;
+ last = (last+1)%2;
+ for (i=0; i<ndev; ++i) {
+ sp = &spc->progress[this*ndev+i];
+ sp_last = &spc->progress[last*ndev+i];
+ sp_shared = &spc->shared_progress[i];
+ if (sp->stats.finished) {
+ continue;
+ }
+ progress_one_dev(sp);
+ sp->stats.duration = tv.tv_sec - sp->stats.t_start;
+ if (!sp->ret)
+ continue;
+ if (sp->ioctl_errno != ENOTCONN &&
+ sp->ioctl_errno != ENODEV)
+ return ERR_PTR(-sp->ioctl_errno);
+ /*
+ * scrub finished or device removed, check the
+ * finished flag. if unset, just use the last
+ * result we got for the current write and go
+ * on. flag should be set on next cycle, then.
+ */
+ ret = pthread_mutex_lock(&sp_shared->progress_mutex);
+ if (ret)
+ return ERR_PTR(-errno);
+ if (!sp_shared->stats.finished) {
+ ret = pthread_mutex_unlock(
+ &sp_shared->progress_mutex);
+ if (ret)
+ return ERR_PTR(-errno);
+ memcpy(sp, sp_last, sizeof(*sp));
+ continue;
+ }
+ ret = pthread_mutex_unlock(&sp_shared->progress_mutex);
+ if (ret)
+ return ERR_PTR(-errno);
+ memcpy(sp, sp_shared, sizeof(*sp));
+ memcpy(sp_last, sp_shared, sizeof(*sp));
+ }
+ if (!spc->do_record)
+ continue;
+ ret = scrub_write_progress(spc->write_mutex, fsid,
+ &spc->progress[this*ndev], ndev);
+ if (ret)
+ return ERR_PTR(ret);
+ }
+}
+
+static struct scrub_file_record *last_dev_scrub(
+ struct scrub_file_record *const *const past_scrubs, u64 devid)
+{
+ int i;
+
+ if (!past_scrubs || IS_ERR(past_scrubs))
+ return NULL;
+
+ for (i=0; past_scrubs[i]; ++i)
+ if (past_scrubs[i]->devid == devid)
+ return past_scrubs[i];
+
+ return NULL;
+}
+
+static int scrub_fs_info(int fd, struct btrfs_ioctl_fs_info_args *fi_args,
+ struct btrfs_ioctl_dev_info_args **di_ret)
+{
+ int ret = 0;
+ int ndevs = 0;
+ int i;
+ struct btrfs_ioctl_dev_info_args *di_args;
+
+ memset(fi_args, 0, sizeof(*fi_args));
+
+ ret = ioctl(fd, BTRFS_IOC_FS_INFO, fi_args);
+ if (ret)
+ return -errno;
+ if (!fi_args->num_devices)
+ return 0;
+
+ di_args = *di_ret = malloc(fi_args->num_devices*sizeof(*di_args));
+ if (!di_args)
+ return -errno;
+
+ for (i=1; i<=fi_args->max_id; ++i) {
+ BUG_ON(ndevs >= fi_args->num_devices);
+ di_args[ndevs].devid = i;
+ memset(&di_args[ndevs].uuid, '\0', sizeof(di_args[ndevs].uuid));
+
+ ret = ioctl(fd, BTRFS_IOC_DEV_INFO, &di_args[ndevs]);
+ if (ret && errno == ENODEV)
+ continue;
+ if (ret)
+ return -errno;
+ ++ndevs;
+ }
+
+ BUG_ON(ndevs == 0);
+
+ return 0;
+}
+
+int mkdir_p(char *path)
+{
+ int i;
+ int ret;
+
+ for (i=1; i<strlen(path); ++i) {
+ if (path[i] != '/')
+ continue;
+ path[i] = '\0';
+ ret = mkdir(path, 0777);
+ if (ret && errno != EEXIST)
+ return 1;
+ path[i] = '/';
+ }
+
+ return 0;
+}
+
+int do_scrub_start(int argc, char **argv)
+{
+ int fdmnt;
+ int fdres = -1;
+ int ret;
+ pid_t pid;
+ int c;
+ int i;
+ int err;
+ int print_raw = 0;
+ char *path;
+ int do_background = 1;
+ int do_wait = 0;
+ int do_print = 0;
+ int do_quiet = 0;
+ int do_record = 1;
+ int do_stats_per_dev = 0;
+ int resume = 0;
+ int verbose = 0;
+ int n_start = 0;
+ int n_skip = 0;
+ int n_resume = 0;
+ struct btrfs_ioctl_fs_info_args fi_args;
+ struct btrfs_ioctl_dev_info_args *di_args = NULL;
+ struct scrub_progress *sp = NULL;
+ struct scrub_fs_stat fs_stat;
+ struct timeval tv;
+ pthread_t *t_devs = NULL;
+ pthread_t t_prog;
+ pthread_attr_t t_attr;
+ struct scrub_file_record **past_scrubs = NULL;
+ struct scrub_file_record *last_scrub = NULL;
+ char *datafile = strdup(SCRUB_DATA_FILE);
+ char fsid[37];
+ struct scrub_progress_cycle spc;
+ pthread_mutex_t spc_write_mutex = PTHREAD_MUTEX_INITIALIZER;
+ void *terr;
+ u64 devid;
+
+ optind = 1;
+ while ((c = getopt(argc, argv, "BdqrRvW")) != -1) {
+ switch(c) {
+ case 'B':
+ do_background = 0;
+ do_wait = 1;
+ do_print = 1;
+ break;
+ case 'd':
+ do_stats_per_dev = 1;
+ break;
+ case 'q':
+ do_quiet = 1;
+ break;
+ case 'R':
+ print_raw = 1;
+ break;
+ case 'r':
+ resume = 1;
+ break;
+ case 'v':
+ verbose = 1;
+ break;
+ case 'W':
+ do_wait = 1;
+ do_print = 1;
+ break;
+ case '?':
+ default:
+ fprintf(stderr, "ERROR: scrub args invalid.\n"
+ " -B do not background (implies -W)\n"
+ " -d stats per device (-B only)\n"
+ " -q quiet\n"
+ " -r resume\n"
+ " -R raw output (-B only)\n"
+ " -v verbose\n"
+ " -W wait for child process\n");
+ return 1;
+ }
+ }
+
+ /* try to catch most error cases before forking */
+
+ spc.progress = NULL;
+ if (do_quiet && do_print)
+ do_print = 0;
+
+ if (mkdir_p(datafile)) {
+ err(!do_quiet, "WARNING: cannot create scrub data "
+ "file, mkdir %s failed: %s. Status recording "
+ "disabled\n", datafile, strerror(errno));
+ do_record = 0;
+ }
+
+ path = argv[optind];
+
+ fdmnt = open_file_or_dir(path);
+ if (fdmnt < 0) {
+ err(!do_quiet, "ERROR: can't access '%s'\n", path);
+ return 12;
+ }
+
+ ret = scrub_fs_info(fdmnt, &fi_args, &di_args);
+ if (ret) {
+ err(!do_quiet, "ERROR: getting dev info for scrub failed: "
+ "%s\n", strerror(-ret));
+ err = 1;
+ goto out;
+ }
+ if (!fi_args.num_devices) {
+ err(!do_quiet, "ERROR: no devices found\n");
+ err = 1;
+ goto out;
+ }
+
+ uuid_unparse(fi_args.fsid, fsid);
+ fdres = scrub_open_file_r(SCRUB_DATA_FILE, fsid);
+ if (fdres < 0 && fdres != -ENOENT) {
+ err(!do_quiet, "WARNING: failed to open status file: "
+ "%s\n", strerror(-fdres));
+ } else if (fdres >= 0) {
+ past_scrubs = scrub_read_file(fdres, verbose);
+ if (IS_ERR(past_scrubs))
+ err(!do_quiet, "WARNING: failed to read status file: "
+ "%s\n", strerror(-PTR_ERR(past_scrubs)));
+ close(fdres);
+ }
+
+ t_devs = malloc(fi_args.num_devices*sizeof(*t_devs));
+ sp = calloc(1, fi_args.num_devices*sizeof(*sp));
+ spc.progress = calloc(1, fi_args.num_devices*2*sizeof(*spc.progress));
+
+ if (!t_devs || !sp || !spc.progress) {
+ err(!do_quiet, "ERROR: scrub failed: %s", strerror(errno));
+ err = 1;
+ goto out;
+ }
+
+ ret = pthread_attr_init(&t_attr);
+ if (ret) {
+ err(!do_quiet, "ERROR: pthread_attr_init failed: %s\n",
+ strerror(ret));
+ err = 1;
+ goto out;
+ }
+
+ for (i = 0; i < fi_args.num_devices; ++i) {
+ devid = di_args[i].devid;
+ ret = pthread_mutex_init(&sp[i].progress_mutex, NULL);
+ if (ret) {
+ err(!do_quiet, "ERROR: pthread_mutex_init failed: "
+ "%s\n", strerror(ret));
+ err = 1;
+ goto out;
+ }
+ last_scrub = last_dev_scrub(past_scrubs, devid);
+ sp[i].scrub_args.devid = devid;
+ sp[i].fd = fdmnt;
+ if (resume && last_scrub && (last_scrub->stats.canceled ||
+ !last_scrub->stats.finished)) {
+ ++n_resume;
+ sp[i].scrub_args.start = last_scrub->p.last_physical;
+ sp[i].resumed = last_scrub;
+ } else if (resume) {
+ ++n_skip;
+ sp[i].skip = 1;
+ sp[i].resumed = last_scrub;
+ continue;
+ } else {
+ ++n_start;
+ sp[i].scrub_args.start = 0ll;
+ sp[i].resumed = NULL;
+ }
+ sp[i].skip = 0;
+ sp[i].scrub_args.end = (u64)-1ll;
+ sp[i].scrub_args.flags = 0;
+ }
+
+ if (!n_start && !n_resume) {
+ if (!do_quiet)
+ printf("scrub: nothing to resume for %s, fsid %s\n",
+ path, fsid);
+ err = 0;
+ goto out;
+ }
+
+ if (do_record) {
+ /* write all-zero progress file for a start */
+ ret = scrub_write_progress(&spc_write_mutex, fsid, sp,
+ fi_args.num_devices);
+ if (ret) {
+ err(!do_quiet, "WARNING: failed to write the progress "
+ "status file: %s. Status recording disabled\n",
+ strerror(-ret));
+ do_record = 0;
+ }
+ }
+
+ if (do_background) {
+ pid = fork();
+ if (pid == -1) {
+ err(!do_quiet, "ERROR: cannot scrub, fork failed: "
+ "%s\n", strerror(errno));
+ err = 1;
+ goto out;
+ }
+
+ if (pid) {
+ int stat;
+ scrub_handle_sigint_parent();
+ if (!do_quiet)
+ printf("scrub %s on %s, fsid %s (pid=%d)\n",
+ n_start ? "started" : "resumed",
+ path, fsid, pid);
+ if (!do_wait) {
+ err = 0;
+ goto out;
+ }
+ ret = wait(&stat);
+ if (ret != pid) {
+ err(!do_quiet, "ERROR: wait failed: (ret=%d) "
+ "%s\n", ret, strerror(errno));
+ err = 1;
+ goto out;
+ }
+ if (!WIFEXITED(stat) || WEXITSTATUS(stat)) {
+ err(!do_quiet, "ERROR: scrub process failed\n");
+ err = WIFEXITED(stat) ? WEXITSTATUS(stat) : -1;
+ goto out;
+ }
+ err = 0;
+ goto out;
+ }
+ }
+
+ scrub_handle_sigint_child(fdmnt);
+
+ for (i = 0; i < fi_args.num_devices; ++i) {
+ if (sp[i].skip) {
+ sp[i].scrub_args.progress = sp[i].resumed->p;
+ sp[i].stats = sp[i].resumed->stats;
+ sp[i].ret = 0;
+ sp[i].stats.finished = 1;
+ continue;
+ }
+ devid = di_args[i].devid;
+ gettimeofday(&tv, NULL);
+ sp[i].stats.t_start = tv.tv_sec;
+ ret = pthread_create(&t_devs[i], &t_attr, scrub_one_dev,&sp[i]);
+ if (ret) {
+ if (do_print)
+ fprintf(stderr, "ERROR: creating "
+ "scrub_one_dev[%llu] thread failed: "
+ "%s\n", devid, strerror(ret));
+ err = 1;
+ goto out;
+ }
+ }
+
+ spc.fdmnt = fdmnt;
+ spc.do_record = do_record;
+ spc.write_mutex = &spc_write_mutex;
+ spc.shared_progress = sp;
+ spc.fi = &fi_args;
+ pthread_create(&t_prog, &t_attr, scrub_progress_cycle, &spc);
+
+ err = 0;
+ for (i = 0; i < fi_args.num_devices; ++i) {
+ if (sp[i].skip)
+ continue;
+ devid = di_args[i].devid;
+ ret = pthread_join(t_devs[i], NULL);
+ if (ret) {
+ if (do_print)
+ fprintf(stderr, "ERROR: pthread_join failed "
+ "for scrub_one_dev[%llu]: %s\n", devid,
+ strerror(ret));
+ err++;
+ continue;
+ }
+ if (sp[i].ret && sp[i].ioctl_errno == ENODEV) {
+ if (do_print)
+ fprintf(stderr, "WARNING: device %lld not "
+ "present\n", devid);
+ continue;
+ }
+ if (sp[i].ret && sp[i].ioctl_errno == ECANCELED) {
+ err++;
+ } else if (sp[i].ret) {
+ if (do_print)
+ fprintf(stderr, "ERROR: scrubbing %s failed "
+ "for device id %lld (%s)\n", path,
+ devid, strerror(sp[i].ioctl_errno));
+ err++;
+ continue;
+ }
+ }
+
+ if (do_print) {
+ const char *append = "done";
+ if (!do_stats_per_dev)
+ init_fs_stat(&fs_stat);
+ for (i = 0; i < fi_args.num_devices; ++i) {
+ if (do_stats_per_dev) {
+ print_scrub_dev(&di_args[i],
+ &sp[i].scrub_args.progress,
+ print_raw,
+ sp[i].ret ? "canceled" : "done",
+ &sp[i].stats);
+ } else {
+ if (sp[i].ret)
+ append = "canceled";
+ add_to_fs_stat(&sp[i].scrub_args.progress,
+ &sp[i].stats, &fs_stat);
+ }
+ }
+ if (!do_stats_per_dev) {
+ printf("scrub %s for %s\n", append, fsid);
+ print_fs_stat(&fs_stat, print_raw);
+ }
+ }
+
+ pthread_cancel(t_prog);
+ ret = pthread_join(t_prog, &terr);
+ if (do_print && terr && terr != PTHREAD_CANCELED) {
+ fprintf(stderr, "ERROR: recording progress "
+ "failed: %s\n", strerror(-PTR_ERR(terr)));
+ }
+
+ if (do_record) {
+ ret = scrub_write_progress(&spc_write_mutex, fsid, sp,
+ fi_args.num_devices);
+ if (ret && do_print) {
+ fprintf(stderr, "ERROR: failed to record the result: "
+ "%s\n", strerror(-ret));
+ }
+ }
+
+ scrub_handle_sigint_child(-1);
+
+out:
+ free_history(past_scrubs);
+ free(di_args);
+ free(t_devs);
+ free(sp);
+ free(spc.progress);
+ close(fdmnt);
+
+ return !!err;
+}
+
+int do_scrub_cancel(int argc, char **argv)
+{
+ char *path = argv[1];
+ int ret;
+ int fdmnt;
+ int err;
+
+ fdmnt = open_file_or_dir(path);
+ if (fdmnt < 0) {
+ fprintf(stderr, "ERROR: scrub cancel failed\n");
+ return 12;
+ }
+
+ ret = ioctl(fdmnt, BTRFS_IOC_SCRUB_CANCEL, NULL);
+ err = errno;
+ close(fdmnt);
+
+ if (ret) {
+ fprintf(stderr, "ERROR: scrub cancel failed: %s\n",
+ err == ENOTCONN ? "not running" : strerror(errno));
+ return 1;
+ }
+
+ printf("scrub cancelled\n");
+
+ return 0;
+}
+
+int do_scrub_status(int argc, char **argv)
+{
+
+ char *path;
+ struct btrfs_ioctl_fs_info_args fi_args;
+ struct btrfs_ioctl_dev_info_args *di_args = NULL;
+ struct scrub_file_record **past_scrubs = NULL;
+ struct scrub_file_record *last_scrub;
+ struct scrub_fs_stat fs_stat;
+ int ret;
+ int fdmnt;
+ int i;
+ optind = 1;
+ int print_raw = 0;
+ int do_stats_per_dev = 0;
+ char c;
+ char fsid[37];
+ int fdres;
+ int verbose = 0;
+ int err = 0;
+
+ while ((c = getopt(argc, argv, "dRv")) != -1) {
+ switch(c) {
+ case 'd':
+ do_stats_per_dev = 1;
+ break;
+ case 'R':
+ print_raw = 1;
+ break;
+ case 'v':
+ verbose = 1;
+ break;
+ case '?':
+ default:
+ fprintf(stderr, "ERROR: scrub status args invalid.\n"
+ " -d stats per device\n"
+ " -R raw output\n"
+ " -v verbose\n");
+ return 1;
+ }
+ }
+
+ path = argv[optind];
+
+ fdmnt = open_file_or_dir(path);
+ if (fdmnt < 0) {
+ fprintf(stderr, "ERROR: can't access to '%s'\n", path);
+ return 12;
+ }
+
+ ret = scrub_fs_info(fdmnt, &fi_args, &di_args);
+ if (ret) {
+ fprintf(stderr, "ERROR: getting dev info for scrub failed: "
+ "%s\n", strerror(-ret));
+ err = 1;
+ goto out;
+ }
+ if (!fi_args.num_devices) {
+ fprintf(stderr, "ERROR: no devices found\n");
+ err = 1;
+ goto out;
+ }
+
+ uuid_unparse(fi_args.fsid, fsid);
+
+ fdres = scrub_open_file_r(SCRUB_DATA_FILE, fsid);
+ if (fdres < 0 && fdres != -ENOENT) {
+ fprintf(stderr, "WARNING: failed to open status file: %s\n",
+ strerror(-fdres));
+ } else if (fdres >= 0) {
+ past_scrubs = scrub_read_file(fdres, verbose);
+ if (IS_ERR(past_scrubs))
+ fprintf(stderr, "WARNING: failed to read status: %s\n",
+ strerror(-PTR_ERR(past_scrubs)));
+ }
+
+ printf("scrub status for %s\n", fsid);
+
+ /*
+ * TODO: rather communicate with scrub process instead of
+ * dumping the file stats for instant results
+ */
+ if (do_stats_per_dev) {
+ for (i = 0; i < fi_args.num_devices; ++i) {
+ last_scrub = last_dev_scrub(past_scrubs,
+ di_args[i].devid);
+ if (!last_scrub) {
+ print_scrub_dev(&di_args[i], NULL, print_raw,
+ NULL, NULL);
+ continue;
+ }
+ print_scrub_dev(&di_args[i], &last_scrub->p, print_raw,
+ last_scrub->stats.finished ?
+ "history" : "status",
+ &last_scrub->stats);
+ }
+ } else {
+ init_fs_stat(&fs_stat);
+ for (i = 0; i < fi_args.num_devices; ++i) {
+ last_scrub = last_dev_scrub(past_scrubs,
+ di_args[i].devid);
+ if (!last_scrub)
+ continue;
+ add_to_fs_stat(&last_scrub->p, &last_scrub->stats,
+ &fs_stat);
+ }
+ print_fs_stat(&fs_stat, print_raw);
+ }
+
+out:
+ free_history(past_scrubs);
+ free(di_args);
+ close(fdmnt);
+
+ return err;
+}
--
1.7.3.4
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v1 0/3] btrfs-progs: scrub interface
2011-03-12 18:31 [PATCH v1 0/3] btrfs-progs: scrub interface Jan Schmidt
` (2 preceding siblings ...)
2011-03-12 18:31 ` [PATCH v1 3/3] added scrub functionality Jan Schmidt
@ 2011-03-12 20:39 ` Hubert Kario
3 siblings, 0 replies; 5+ messages in thread
From: Hubert Kario @ 2011-03-12 20:39 UTC (permalink / raw)
To: Jan Schmidt; +Cc: chris.mason, linux-btrfs
On Saturday 12 of March 2011 19:31:32 Jan Schmidt wrote:
> This patch set for btrfs-progs is meant to be used together with the =
scrub
> kernel patches submitted by Arne Jansen (latest Subject: [PATCH v3 0/=
6]
> btrfs: scrub).
>=20
(snip)
>=20
> Makefile | 4 +-
> btrfs.c | 12 +
> btrfs_cmds.c | 3 +-
> btrfs_cmds.h | 4 +
> ctree.h | 2 +-
> ioctl.h | 68 +++-
> scrub.c | 1425
> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 7 files
> changed, 1513 insertions(+), 5 deletions(-)
> create mode 100644 scrub.c
Please, update the man pages.
Regards,
--=20
Hubert Kario
QBS - Quality Business Software
ul. Ksawer=F3w 30/85
02-656 Warszawa
POLAND
tel. +48 (22) 646-61-51, 646-74-24
fax +48 (22) 646-61-50
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" =
in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2011-03-12 20:39 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-03-12 18:31 [PATCH v1 0/3] btrfs-progs: scrub interface Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 1/3] commands added Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 2/3] scrub ioctls Jan Schmidt
2011-03-12 18:31 ` [PATCH v1 3/3] added scrub functionality Jan Schmidt
2011-03-12 20:39 ` [PATCH v1 0/3] btrfs-progs: scrub interface Hubert Kario
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).