2 * Copyright (C) 2011 STRATO. All rights reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
19 #include "kerncompat.h"
21 #include <sys/ioctl.h>
24 #include <sys/types.h>
25 #include <sys/socket.h>
27 #include <sys/syscall.h>
30 #include <uuid/uuid.h>
46 static const char * const scrub_cmd_group_usage
[] = {
47 "btrfs scrub <command> [options] <path>|<device>",
51 #define SCRUB_DATA_FILE "/var/lib/btrfs/scrub.status"
52 #define SCRUB_PROGRESS_SOCKET_PATH "/var/lib/btrfs/scrub.progress"
53 #define SCRUB_FILE_VERSION_PREFIX "scrub status"
54 #define SCRUB_FILE_VERSION "1"
65 /* TBD: replace with #include "linux/ioprio.h" in some years */
66 #if !defined (IOPRIO_H)
67 #define IOPRIO_WHO_PROCESS 1
68 #define IOPRIO_CLASS_SHIFT 13
69 #define IOPRIO_PRIO_VALUE(class, data) \
70 (((class) << IOPRIO_CLASS_SHIFT) | (data))
71 #define IOPRIO_CLASS_IDLE 3
74 struct scrub_progress
{
75 struct btrfs_ioctl_scrub_args scrub_args
;
79 struct scrub_stats stats
;
80 struct scrub_file_record
*resumed
;
82 pthread_mutex_t progress_mutex
;
87 struct scrub_file_record
{
88 u8 fsid
[BTRFS_FSID_SIZE
];
90 struct scrub_stats stats
;
91 struct btrfs_scrub_progress p
;
94 struct scrub_progress_cycle
{
98 struct btrfs_ioctl_fs_info_args
*fi
;
99 struct scrub_progress
*progress
;
100 struct scrub_progress
*shared_progress
;
101 pthread_mutex_t
*write_mutex
;
104 struct scrub_fs_stat
{
105 struct btrfs_scrub_progress p
;
106 struct scrub_stats s
;
110 static void print_scrub_full(struct btrfs_scrub_progress
*sp
)
112 printf("\tdata_extents_scrubbed: %lld\n", sp
->data_extents_scrubbed
);
113 printf("\ttree_extents_scrubbed: %lld\n", sp
->tree_extents_scrubbed
);
114 printf("\tdata_bytes_scrubbed: %lld\n", sp
->data_bytes_scrubbed
);
115 printf("\ttree_bytes_scrubbed: %lld\n", sp
->tree_bytes_scrubbed
);
116 printf("\tread_errors: %lld\n", sp
->read_errors
);
117 printf("\tcsum_errors: %lld\n", sp
->csum_errors
);
118 printf("\tverify_errors: %lld\n", sp
->verify_errors
);
119 printf("\tno_csum: %lld\n", sp
->no_csum
);
120 printf("\tcsum_discards: %lld\n", sp
->csum_discards
);
121 printf("\tsuper_errors: %lld\n", sp
->super_errors
);
122 printf("\tmalloc_errors: %lld\n", sp
->malloc_errors
);
123 printf("\tuncorrectable_errors: %lld\n", sp
->uncorrectable_errors
);
124 printf("\tunverified_errors: %lld\n", sp
->unverified_errors
);
125 printf("\tcorrected_errors: %lld\n", sp
->corrected_errors
);
126 printf("\tlast_physical: %lld\n", sp
->last_physical
);
129 #define ERR(test, ...) do { \
131 fprintf(stderr, __VA_ARGS__); \
134 #define PRINT_SCRUB_ERROR(test, desc) do { \
136 printf(" %s=%llu", desc, test); \
139 static void print_scrub_summary(struct btrfs_scrub_progress
*p
)
144 err_cnt
= p
->read_errors
+
149 err_cnt2
= p
->corrected_errors
+ p
->uncorrectable_errors
;
151 if (p
->malloc_errors
)
152 printf("*** WARNING: memory allocation failed while scrubbing. "
153 "results may be inaccurate\n");
155 printf("\ttotal bytes scrubbed: %s with %llu errors\n",
156 pretty_size(p
->data_bytes_scrubbed
+ p
->tree_bytes_scrubbed
),
157 max(err_cnt
, err_cnt2
));
159 if (err_cnt
|| err_cnt2
) {
160 printf("\terror details:");
161 PRINT_SCRUB_ERROR(p
->read_errors
, "read");
162 PRINT_SCRUB_ERROR(p
->super_errors
, "super");
163 PRINT_SCRUB_ERROR(p
->verify_errors
, "verify");
164 PRINT_SCRUB_ERROR(p
->csum_errors
, "csum");
166 printf("\tcorrected errors: %llu, uncorrectable errors: %llu, "
167 "unverified errors: %llu\n", p
->corrected_errors
,
168 p
->uncorrectable_errors
, p
->unverified_errors
);
172 #define _SCRUB_FS_STAT(p, name, fs_stat) do { \
173 fs_stat->p.name += p->name; \
176 #define _SCRUB_FS_STAT_MIN(ss, name, fs_stat) \
178 if (fs_stat->s.name > ss->name) { \
179 fs_stat->s.name = ss->name; \
183 #define _SCRUB_FS_STAT_ZMIN(ss, name, fs_stat) \
185 if (!fs_stat->s.name || fs_stat->s.name > ss->name) { \
186 fs_stat->s.name = ss->name; \
190 #define _SCRUB_FS_STAT_ZMAX(ss, name, fs_stat) \
192 if (!(fs_stat)->s.name || (fs_stat)->s.name < (ss)->name) { \
193 (fs_stat)->s.name = (ss)->name; \
197 static void add_to_fs_stat(struct btrfs_scrub_progress
*p
,
198 struct scrub_stats
*ss
,
199 struct scrub_fs_stat
*fs_stat
)
201 _SCRUB_FS_STAT(p
, data_extents_scrubbed
, fs_stat
);
202 _SCRUB_FS_STAT(p
, tree_extents_scrubbed
, fs_stat
);
203 _SCRUB_FS_STAT(p
, data_bytes_scrubbed
, fs_stat
);
204 _SCRUB_FS_STAT(p
, tree_bytes_scrubbed
, fs_stat
);
205 _SCRUB_FS_STAT(p
, read_errors
, fs_stat
);
206 _SCRUB_FS_STAT(p
, csum_errors
, fs_stat
);
207 _SCRUB_FS_STAT(p
, verify_errors
, fs_stat
);
208 _SCRUB_FS_STAT(p
, no_csum
, fs_stat
);
209 _SCRUB_FS_STAT(p
, csum_discards
, fs_stat
);
210 _SCRUB_FS_STAT(p
, super_errors
, fs_stat
);
211 _SCRUB_FS_STAT(p
, malloc_errors
, fs_stat
);
212 _SCRUB_FS_STAT(p
, uncorrectable_errors
, fs_stat
);
213 _SCRUB_FS_STAT(p
, corrected_errors
, fs_stat
);
214 _SCRUB_FS_STAT(p
, last_physical
, fs_stat
);
215 _SCRUB_FS_STAT_ZMIN(ss
, t_start
, fs_stat
);
216 _SCRUB_FS_STAT_ZMIN(ss
, t_resumed
, fs_stat
);
217 _SCRUB_FS_STAT_ZMAX(ss
, duration
, fs_stat
);
218 _SCRUB_FS_STAT_ZMAX(ss
, canceled
, fs_stat
);
219 _SCRUB_FS_STAT_MIN(ss
, finished
, fs_stat
);
222 static void init_fs_stat(struct scrub_fs_stat
*fs_stat
)
224 memset(fs_stat
, 0, sizeof(*fs_stat
));
225 fs_stat
->s
.finished
= 1;
228 static void _print_scrub_ss(struct scrub_stats
*ss
)
233 if (!ss
|| !ss
->t_start
) {
234 printf("\tno stats available\n");
238 localtime_r(&ss
->t_resumed
, &tm
);
239 strftime(t
, sizeof(t
), "%c", &tm
);
240 t
[sizeof(t
) - 1] = '\0';
241 printf("\tscrub resumed at %s", t
);
243 localtime_r(&ss
->t_start
, &tm
);
244 strftime(t
, sizeof(t
), "%c", &tm
);
245 t
[sizeof(t
) - 1] = '\0';
246 printf("\tscrub started at %s", t
);
248 if (ss
->finished
&& !ss
->canceled
) {
249 printf(" and finished after %llu seconds\n",
251 } else if (ss
->canceled
) {
252 printf(" and was aborted after %llu seconds\n",
256 printf(", running for %llu seconds\n", ss
->duration
);
258 printf(", interrupted after %llu seconds, not running\n",
263 static void print_scrub_dev(struct btrfs_ioctl_dev_info_args
*di
,
264 struct btrfs_scrub_progress
*p
, int raw
,
265 const char *append
, struct scrub_stats
*ss
)
267 printf("scrub device %s (id %llu) %s\n", di
->path
, di
->devid
,
268 append
? append
: "");
276 print_scrub_summary(p
);
280 static void print_fs_stat(struct scrub_fs_stat
*fs_stat
, int raw
)
282 _print_scrub_ss(&fs_stat
->s
);
285 print_scrub_full(&fs_stat
->p
);
287 print_scrub_summary(&fs_stat
->p
);
290 static void free_history(struct scrub_file_record
**last_scrubs
)
292 struct scrub_file_record
**l
= last_scrubs
;
301 * cancels a running scrub and makes the master process record the current
302 * progress status before exiting.
304 static int cancel_fd
= -1;
305 static void scrub_sigint_record_progress(int signal
)
309 ret
= ioctl(cancel_fd
, BTRFS_IOC_SCRUB_CANCEL
, NULL
);
311 perror("Scrub cancel failed");
314 static int scrub_handle_sigint_parent(void)
316 struct sigaction sa
= {
317 .sa_handler
= SIG_IGN
,
318 .sa_flags
= SA_RESTART
,
321 return sigaction(SIGINT
, &sa
, NULL
);
324 static int scrub_handle_sigint_child(int fd
)
326 struct sigaction sa
= {
327 .sa_handler
= fd
== -1 ? SIG_DFL
: scrub_sigint_record_progress
,
331 return sigaction(SIGINT
, &sa
, NULL
);
334 static int scrub_datafile(const char *fn_base
, const char *fn_local
,
335 const char *fn_tmp
, char *datafile
, int size
)
340 datafile
[end
+ 1] = '\0';
341 strncpy(datafile
, fn_base
, end
);
342 ret
= strlen(datafile
);
348 strncpy(datafile
+ ret
+ 1, fn_local
, end
- ret
- 1);
349 ret
= strlen(datafile
);
356 strncpy(datafile
+ ret
+ 1, fn_tmp
, end
- ret
- 1);
357 ret
= strlen(datafile
);
366 static int scrub_open_file(const char *datafile
, int m
)
371 fd
= open(datafile
, m
, 0600);
375 ret
= flock(fd
, LOCK_EX
|LOCK_NB
);
385 static int scrub_open_file_r(const char *fn_base
, const char *fn_local
)
388 char datafile
[BTRFS_PATH_NAME_MAX
+ 1];
389 ret
= scrub_datafile(fn_base
, fn_local
, NULL
,
390 datafile
, sizeof(datafile
));
393 return scrub_open_file(datafile
, O_RDONLY
);
396 static int scrub_open_file_w(const char *fn_base
, const char *fn_local
,
400 char datafile
[BTRFS_PATH_NAME_MAX
+ 1];
401 ret
= scrub_datafile(fn_base
, fn_local
, tmp
,
402 datafile
, sizeof(datafile
));
405 return scrub_open_file(datafile
, O_WRONLY
|O_CREAT
);
408 static int scrub_rename_file(const char *fn_base
, const char *fn_local
,
412 char datafile_old
[BTRFS_PATH_NAME_MAX
+ 1];
413 char datafile_new
[BTRFS_PATH_NAME_MAX
+ 1];
414 ret
= scrub_datafile(fn_base
, fn_local
, tmp
,
415 datafile_old
, sizeof(datafile_old
));
418 ret
= scrub_datafile(fn_base
, fn_local
, NULL
,
419 datafile_new
, sizeof(datafile_new
));
422 ret
= rename(datafile_old
, datafile_new
);
423 return ret
? -errno
: 0;
426 #define _SCRUB_KVREAD(ret, i, name, avail, l, dest) if (ret == 0) { \
427 ret = scrub_kvread(i, sizeof(#name), avail, l, #name, dest.name); \
431 * returns 0 if the key did not match (nothing was read)
432 * 1 if the key did match (success)
433 * -1 if the key did match and an error occured
435 static int scrub_kvread(int *i
, int len
, int avail
, const char *buf
,
436 const char *key
, u64
*dest
)
440 if (*i
+ len
+ 1 < avail
&& strncmp(&buf
[*i
], key
, len
- 1) == 0) {
445 for (j
= 0; isdigit(buf
[*i
+ j
]) && *i
+ j
< avail
; ++j
)
449 *dest
= atoll(&buf
[*i
]);
457 #define _SCRUB_INVALID do { \
459 fprintf(stderr, "WARNING: invalid data in line %d pos " \
460 "%d state %d (near \"%.*s\") at %s:%d\n", \
461 lineno, i, state, 20 > avail ? avail : 20, \
462 l + i, __FILE__, __LINE__); \
466 static struct scrub_file_record
**scrub_read_file(int fd
, int report_errors
)
479 char empty_uuid
[BTRFS_FSID_SIZE
] = {0};
480 struct scrub_file_record
**p
= NULL
;
483 old_avail
= avail
- i
;
484 BUG_ON(old_avail
< 0);
486 memmove(l
, l
+ i
, old_avail
);
487 avail
= read(fd
, l
+ old_avail
, sizeof(l
) - old_avail
);
490 if (avail
== 0 && old_avail
== 0) {
492 memcmp(p
[curr
]->fsid
, empty_uuid
, BTRFS_FSID_SIZE
) == 0) {
494 } else if (curr
== -1) {
495 p
= ERR_PTR(-ENODATA
);
500 return ERR_PTR(-errno
);
506 case 0: /* start of file */
507 ret
= scrub_kvread(&i
,
508 sizeof(SCRUB_FILE_VERSION_PREFIX
), avail
, l
,
509 SCRUB_FILE_VERSION_PREFIX
, &version
);
512 if (version
!= atoll(SCRUB_FILE_VERSION
))
513 return ERR_PTR(-ENOTSUP
);
516 case 1: /* start of line, alloc */
518 * this state makes sure we have a complete line in
519 * further processing, so we don't need wrap-tracking
522 if (!eof
&& !memchr(l
+ i
, '\n', avail
- i
))
525 if (curr
> -1 && memcmp(p
[curr
]->fsid
, empty_uuid
,
526 BTRFS_FSID_SIZE
) == 0) {
531 p
= realloc(p
, (curr
+ 2) * sizeof(*p
));
533 p
[curr
] = malloc(sizeof(**p
));
535 return ERR_PTR(-errno
);
536 memset(p
[curr
], 0, sizeof(**p
));
540 case 2: /* start of line, skip space */
541 while (isspace(l
[i
]) && i
< avail
) {
547 (!eof
&& !memchr(l
+ i
, '\n', avail
- i
)))
551 case 3: /* read fsid */
554 for (j
= 0; l
[i
+ j
] != ':' && i
+ j
< avail
; ++j
)
556 if (i
+ j
+ 1 >= avail
)
558 if (j
!= BTRFS_UUID_UNPARSED_SIZE
- 1)
561 ret
= uuid_parse(l
+ i
, p
[curr
]->fsid
);
567 case 4: /* read dev id */
568 for (j
= 0; isdigit(l
[i
+ j
]) && i
+j
< avail
; ++j
)
570 if (j
== 0 || i
+ j
+ 1 >= avail
)
572 p
[curr
]->devid
= atoll(&l
[i
]);
576 case 5: /* read key/value pair */
578 _SCRUB_KVREAD(ret
, &i
, data_extents_scrubbed
, avail
, l
,
580 _SCRUB_KVREAD(ret
, &i
, data_extents_scrubbed
, avail
, l
,
582 _SCRUB_KVREAD(ret
, &i
, tree_extents_scrubbed
, avail
, l
,
584 _SCRUB_KVREAD(ret
, &i
, data_bytes_scrubbed
, avail
, l
,
586 _SCRUB_KVREAD(ret
, &i
, tree_bytes_scrubbed
, avail
, l
,
588 _SCRUB_KVREAD(ret
, &i
, read_errors
, avail
, l
,
590 _SCRUB_KVREAD(ret
, &i
, csum_errors
, avail
, l
,
592 _SCRUB_KVREAD(ret
, &i
, verify_errors
, avail
, l
,
594 _SCRUB_KVREAD(ret
, &i
, no_csum
, avail
, l
,
596 _SCRUB_KVREAD(ret
, &i
, csum_discards
, avail
, l
,
598 _SCRUB_KVREAD(ret
, &i
, super_errors
, avail
, l
,
600 _SCRUB_KVREAD(ret
, &i
, malloc_errors
, avail
, l
,
602 _SCRUB_KVREAD(ret
, &i
, uncorrectable_errors
, avail
, l
,
604 _SCRUB_KVREAD(ret
, &i
, corrected_errors
, avail
, l
,
606 _SCRUB_KVREAD(ret
, &i
, last_physical
, avail
, l
,
608 _SCRUB_KVREAD(ret
, &i
, finished
, avail
, l
,
610 _SCRUB_KVREAD(ret
, &i
, t_start
, avail
, l
,
611 (u64
*)&p
[curr
]->stats
);
612 _SCRUB_KVREAD(ret
, &i
, t_resumed
, avail
, l
,
613 (u64
*)&p
[curr
]->stats
);
614 _SCRUB_KVREAD(ret
, &i
, duration
, avail
, l
,
615 (u64
*)&p
[curr
]->stats
);
616 _SCRUB_KVREAD(ret
, &i
, canceled
, avail
, l
,
622 case 6: /* after number */
625 else if (l
[i
] == '\n')
631 case 99: /* skip rest of line */
636 if (l
[i
- 1] == '\n') {
648 static int scrub_write_buf(int fd
, const void *data
, int len
)
651 ret
= write(fd
, data
, len
);
655 static int scrub_writev(int fd
, char *buf
, int max
, const char *fmt
, ...)
656 __attribute__ ((format (printf
, 4, 5)));
657 static int scrub_writev(int fd
, char *buf
, int max
, const char *fmt
, ...)
663 ret
= vsnprintf(buf
, max
, fmt
, args
);
667 return scrub_write_buf(fd
, buf
, ret
);
670 #define _SCRUB_SUM(dest, data, name) dest->scrub_args.progress.name = \
671 data->resumed->p.name + data->scrub_args.progress.name
673 static struct scrub_progress
*scrub_resumed_stats(struct scrub_progress
*data
,
674 struct scrub_progress
*dest
)
676 if (!data
->resumed
|| data
->skip
)
679 _SCRUB_SUM(dest
, data
, data_extents_scrubbed
);
680 _SCRUB_SUM(dest
, data
, tree_extents_scrubbed
);
681 _SCRUB_SUM(dest
, data
, data_bytes_scrubbed
);
682 _SCRUB_SUM(dest
, data
, tree_bytes_scrubbed
);
683 _SCRUB_SUM(dest
, data
, read_errors
);
684 _SCRUB_SUM(dest
, data
, csum_errors
);
685 _SCRUB_SUM(dest
, data
, verify_errors
);
686 _SCRUB_SUM(dest
, data
, no_csum
);
687 _SCRUB_SUM(dest
, data
, csum_discards
);
688 _SCRUB_SUM(dest
, data
, super_errors
);
689 _SCRUB_SUM(dest
, data
, malloc_errors
);
690 _SCRUB_SUM(dest
, data
, uncorrectable_errors
);
691 _SCRUB_SUM(dest
, data
, corrected_errors
);
692 _SCRUB_SUM(dest
, data
, last_physical
);
693 dest
->stats
.canceled
= data
->stats
.canceled
;
694 dest
->stats
.finished
= data
->stats
.finished
;
695 dest
->stats
.t_resumed
= data
->stats
.t_start
;
696 dest
->stats
.t_start
= data
->resumed
->stats
.t_start
;
697 dest
->stats
.duration
= data
->resumed
->stats
.duration
+
698 data
->stats
.duration
;
699 dest
->scrub_args
.devid
= data
->scrub_args
.devid
;
703 #define _SCRUB_KVWRITE(fd, buf, name, use) \
704 scrub_kvwrite(fd, buf, sizeof(buf), #name, \
705 use->scrub_args.progress.name)
707 #define _SCRUB_KVWRITE_STATS(fd, buf, name, use) \
708 scrub_kvwrite(fd, buf, sizeof(buf), #name, \
711 static int scrub_kvwrite(int fd
, char *buf
, int max
, const char *key
, u64 val
)
713 return scrub_writev(fd
, buf
, max
, "|%s:%lld", key
, val
);
716 static int scrub_write_file(int fd
, const char *fsid
,
717 struct scrub_progress
*data
, int n
)
722 struct scrub_progress local
;
723 struct scrub_progress
*use
;
728 /* each -1 is to subtract one \0 byte, the + 2 is for ':' and '\n' */
729 ret
= scrub_write_buf(fd
, SCRUB_FILE_VERSION_PREFIX
":"
730 SCRUB_FILE_VERSION
"\n",
731 (sizeof(SCRUB_FILE_VERSION_PREFIX
) - 1) +
732 (sizeof(SCRUB_FILE_VERSION
) - 1) + 2);
736 for (i
= 0; i
< n
; ++i
) {
737 use
= scrub_resumed_stats(&data
[i
], &local
);
738 if (scrub_write_buf(fd
, fsid
, strlen(fsid
)) ||
739 scrub_write_buf(fd
, ":", 1) ||
740 scrub_writev(fd
, buf
, sizeof(buf
), "%lld",
741 use
->scrub_args
.devid
) ||
742 scrub_write_buf(fd
, buf
, ret
) ||
743 _SCRUB_KVWRITE(fd
, buf
, data_extents_scrubbed
, use
) ||
744 _SCRUB_KVWRITE(fd
, buf
, tree_extents_scrubbed
, use
) ||
745 _SCRUB_KVWRITE(fd
, buf
, data_bytes_scrubbed
, use
) ||
746 _SCRUB_KVWRITE(fd
, buf
, tree_bytes_scrubbed
, use
) ||
747 _SCRUB_KVWRITE(fd
, buf
, read_errors
, use
) ||
748 _SCRUB_KVWRITE(fd
, buf
, csum_errors
, use
) ||
749 _SCRUB_KVWRITE(fd
, buf
, verify_errors
, use
) ||
750 _SCRUB_KVWRITE(fd
, buf
, no_csum
, use
) ||
751 _SCRUB_KVWRITE(fd
, buf
, csum_discards
, use
) ||
752 _SCRUB_KVWRITE(fd
, buf
, super_errors
, use
) ||
753 _SCRUB_KVWRITE(fd
, buf
, malloc_errors
, use
) ||
754 _SCRUB_KVWRITE(fd
, buf
, uncorrectable_errors
, use
) ||
755 _SCRUB_KVWRITE(fd
, buf
, corrected_errors
, use
) ||
756 _SCRUB_KVWRITE(fd
, buf
, last_physical
, use
) ||
757 _SCRUB_KVWRITE_STATS(fd
, buf
, t_start
, use
) ||
758 _SCRUB_KVWRITE_STATS(fd
, buf
, t_resumed
, use
) ||
759 _SCRUB_KVWRITE_STATS(fd
, buf
, duration
, use
) ||
760 _SCRUB_KVWRITE_STATS(fd
, buf
, canceled
, use
) ||
761 _SCRUB_KVWRITE_STATS(fd
, buf
, finished
, use
) ||
762 scrub_write_buf(fd
, "\n", 1)) {
770 static int scrub_write_progress(pthread_mutex_t
*m
, const char *fsid
,
771 struct scrub_progress
*data
, int n
)
778 ret
= pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &old
);
784 ret
= pthread_mutex_lock(m
);
790 fd
= scrub_open_file_w(SCRUB_DATA_FILE
, fsid
, "tmp");
795 err
= scrub_write_file(fd
, fsid
, data
, n
);
798 err
= scrub_rename_file(SCRUB_DATA_FILE
, fsid
, "tmp");
809 ret
= pthread_mutex_unlock(m
);
814 ret
= pthread_setcancelstate(PTHREAD_CANCEL_ENABLE
, &old
);
822 static void *scrub_one_dev(void *ctx
)
824 struct scrub_progress
*sp
= ctx
;
828 sp
->stats
.canceled
= 0;
829 sp
->stats
.duration
= 0;
830 sp
->stats
.finished
= 0;
832 ret
= syscall(SYS_ioprio_set
, IOPRIO_WHO_PROCESS
, 0,
833 IOPRIO_PRIO_VALUE(sp
->ioprio_class
,
834 sp
->ioprio_classdata
));
837 "WARNING: setting ioprio failed: %s (ignored).\n",
840 ret
= ioctl(sp
->fd
, BTRFS_IOC_SCRUB
, &sp
->scrub_args
);
841 gettimeofday(&tv
, NULL
);
843 sp
->stats
.duration
= tv
.tv_sec
- sp
->stats
.t_start
;
844 sp
->stats
.canceled
= !!ret
;
845 sp
->ioctl_errno
= errno
;
846 ret
= pthread_mutex_lock(&sp
->progress_mutex
);
848 return ERR_PTR(-ret
);
849 sp
->stats
.finished
= 1;
850 ret
= pthread_mutex_unlock(&sp
->progress_mutex
);
852 return ERR_PTR(-ret
);
857 static void *progress_one_dev(void *ctx
)
859 struct scrub_progress
*sp
= ctx
;
861 sp
->ret
= ioctl(sp
->fd
, BTRFS_IOC_SCRUB_PROGRESS
, &sp
->scrub_args
);
862 sp
->ioctl_errno
= errno
;
867 /* nb: returns a negative errno via ERR_PTR */
868 static void *scrub_progress_cycle(void *ctx
)
871 int perr
= 0; /* positive / pthread error returns */
874 char fsid
[BTRFS_UUID_UNPARSED_SIZE
];
875 struct scrub_progress
*sp
;
876 struct scrub_progress
*sp_last
;
877 struct scrub_progress
*sp_shared
;
879 struct scrub_progress_cycle
*spc
= ctx
;
880 int ndev
= spc
->fi
->num_devices
;
884 struct pollfd accept_poll_fd
= {
889 struct pollfd write_poll_fd
= {
893 struct sockaddr_un peer
;
894 socklen_t peer_size
= sizeof(peer
);
896 perr
= pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS
, &old
);
900 uuid_unparse(spc
->fi
->fsid
, fsid
);
902 for (i
= 0; i
< ndev
; ++i
) {
903 sp
= &spc
->progress
[i
];
904 sp_last
= &spc
->progress
[i
+ ndev
];
905 sp_shared
= &spc
->shared_progress
[i
];
906 sp
->scrub_args
.devid
= sp_last
->scrub_args
.devid
=
907 sp_shared
->scrub_args
.devid
;
908 sp
->fd
= sp_last
->fd
= spc
->fdmnt
;
909 sp
->stats
.t_start
= sp_last
->stats
.t_start
=
910 sp_shared
->stats
.t_start
;
911 sp
->resumed
= sp_last
->resumed
= sp_shared
->resumed
;
912 sp
->skip
= sp_last
->skip
= sp_shared
->skip
;
913 sp
->stats
.finished
= sp_last
->stats
.finished
=
914 sp_shared
->stats
.finished
;
918 ret
= poll(&accept_poll_fd
, 1, 5 * 1000);
924 peer_fd
= accept(spc
->prg_fd
, (struct sockaddr
*)&peer
,
926 gettimeofday(&tv
, NULL
);
929 for (i
= 0; i
< ndev
; ++i
) {
930 sp
= &spc
->progress
[this * ndev
+ i
];
931 sp_last
= &spc
->progress
[last
* ndev
+ i
];
932 sp_shared
= &spc
->shared_progress
[i
];
933 if (sp
->stats
.finished
)
935 progress_one_dev(sp
);
936 sp
->stats
.duration
= tv
.tv_sec
- sp
->stats
.t_start
;
939 if (sp
->ioctl_errno
!= ENOTCONN
&&
940 sp
->ioctl_errno
!= ENODEV
) {
941 ret
= -sp
->ioctl_errno
;
945 * scrub finished or device removed, check the
946 * finished flag. if unset, just use the last
947 * result we got for the current write and go
948 * on. flag should be set on next cycle, then.
950 perr
= pthread_setcancelstate(
951 PTHREAD_CANCEL_DISABLE
, &old
);
954 perr
= pthread_mutex_lock(&sp_shared
->progress_mutex
);
957 if (!sp_shared
->stats
.finished
) {
958 perr
= pthread_mutex_unlock(
959 &sp_shared
->progress_mutex
);
962 perr
= pthread_setcancelstate(
963 PTHREAD_CANCEL_ENABLE
, &old
);
966 memcpy(sp
, sp_last
, sizeof(*sp
));
969 perr
= pthread_mutex_unlock(&sp_shared
->progress_mutex
);
972 perr
= pthread_setcancelstate(
973 PTHREAD_CANCEL_ENABLE
, &old
);
976 memcpy(sp
, sp_shared
, sizeof(*sp
));
977 memcpy(sp_last
, sp_shared
, sizeof(*sp
));
980 write_poll_fd
.fd
= peer_fd
;
981 ret
= poll(&write_poll_fd
, 1, 0);
987 ret
= scrub_write_file(
989 &spc
->progress
[this * ndev
], ndev
);
998 ret
= scrub_write_progress(spc
->write_mutex
, fsid
,
999 &spc
->progress
[this * ndev
], ndev
);
1008 return ERR_PTR(ret
);
1011 static struct scrub_file_record
*last_dev_scrub(
1012 struct scrub_file_record
*const *const past_scrubs
, u64 devid
)
1016 if (!past_scrubs
|| IS_ERR(past_scrubs
))
1019 for (i
= 0; past_scrubs
[i
]; ++i
)
1020 if (past_scrubs
[i
]->devid
== devid
)
1021 return past_scrubs
[i
];
1026 static int mkdir_p(char *path
)
1031 for (i
= 1; i
< strlen(path
); ++i
) {
1035 ret
= mkdir(path
, 0777);
1036 if (ret
&& errno
!= EEXIST
)
1044 static int is_scrub_running_on_fs(struct btrfs_ioctl_fs_info_args
*fi_args
,
1045 struct btrfs_ioctl_dev_info_args
*di_args
,
1046 struct scrub_file_record
**past_scrubs
)
1050 if (!fi_args
|| !di_args
|| !past_scrubs
)
1053 for (i
= 0; i
< fi_args
->num_devices
; i
++) {
1054 struct scrub_file_record
*sfr
=
1055 last_dev_scrub(past_scrubs
, di_args
[i
].devid
);
1059 if (!(sfr
->stats
.finished
|| sfr
->stats
.canceled
))
1065 static int is_scrub_running_in_kernel(int fd
,
1066 struct btrfs_ioctl_dev_info_args
*di_args
, u64 max_devices
)
1068 struct scrub_progress sp
;
1072 for (i
= 0; i
< max_devices
; i
++) {
1073 memset(&sp
, 0, sizeof(sp
));
1074 sp
.scrub_args
.devid
= di_args
[i
].devid
;
1075 ret
= ioctl(fd
, BTRFS_IOC_SCRUB_PROGRESS
, &sp
.scrub_args
);
1083 static const char * const cmd_scrub_start_usage
[];
1084 static const char * const cmd_scrub_resume_usage
[];
1086 static int scrub_start(int argc
, char **argv
, int resume
)
1096 int e_uncorrectable
= 0;
1097 int e_correctable
= 0;
1100 int do_background
= 1;
1106 int do_stats_per_dev
= 0;
1107 int ioprio_class
= IOPRIO_CLASS_IDLE
;
1108 int ioprio_classdata
= 0;
1112 struct btrfs_ioctl_fs_info_args fi_args
;
1113 struct btrfs_ioctl_dev_info_args
*di_args
= NULL
;
1114 struct scrub_progress
*sp
= NULL
;
1115 struct scrub_fs_stat fs_stat
;
1117 struct sockaddr_un addr
= {
1118 .sun_family
= AF_UNIX
,
1120 pthread_t
*t_devs
= NULL
;
1122 struct scrub_file_record
**past_scrubs
= NULL
;
1123 struct scrub_file_record
*last_scrub
= NULL
;
1124 char *datafile
= strdup(SCRUB_DATA_FILE
);
1125 char fsid
[BTRFS_UUID_UNPARSED_SIZE
];
1126 char sock_path
[BTRFS_PATH_NAME_MAX
+ 1] = "";
1127 struct scrub_progress_cycle spc
;
1128 pthread_mutex_t spc_write_mutex
= PTHREAD_MUTEX_INITIALIZER
;
1131 DIR *dirstream
= NULL
;
1133 int nothing_to_resume
= 0;
1136 while ((c
= getopt(argc
, argv
, "BdqrRc:n:f")) != -1) {
1144 do_stats_per_dev
= 1;
1156 ioprio_class
= (int)strtol(optarg
, NULL
, 10);
1159 ioprio_classdata
= (int)strtol(optarg
, NULL
, 10);
1166 usage(resume
? cmd_scrub_resume_usage
:
1167 cmd_scrub_start_usage
);
1171 /* try to catch most error cases before forking */
1173 if (check_argc_exact(argc
- optind
, 1)) {
1174 usage(resume
? cmd_scrub_resume_usage
:
1175 cmd_scrub_start_usage
);
1178 spc
.progress
= NULL
;
1179 if (do_quiet
&& do_print
)
1182 if (mkdir_p(datafile
)) {
1183 ERR(!do_quiet
, "WARNING: cannot create scrub data "
1184 "file, mkdir %s failed: %s. Status recording "
1185 "disabled\n", datafile
, strerror(errno
));
1190 path
= argv
[optind
];
1192 fdmnt
= open_path_or_dev_mnt(path
, &dirstream
);
1195 if (errno
== EINVAL
)
1197 "ERROR: '%s' is not a mounted btrfs device\n",
1200 ERR(!do_quiet
, "ERROR: can't access '%s': %s\n",
1201 path
, strerror(errno
));
1205 ret
= get_fs_info(path
, &fi_args
, &di_args
);
1207 ERR(!do_quiet
, "ERROR: getting dev info for scrub failed: "
1208 "%s\n", strerror(-ret
));
1212 if (!fi_args
.num_devices
) {
1213 ERR(!do_quiet
, "ERROR: no devices found\n");
1218 uuid_unparse(fi_args
.fsid
, fsid
);
1219 fdres
= scrub_open_file_r(SCRUB_DATA_FILE
, fsid
);
1220 if (fdres
< 0 && fdres
!= -ENOENT
) {
1221 ERR(!do_quiet
, "WARNING: failed to open status file: "
1222 "%s\n", strerror(-fdres
));
1223 } else if (fdres
>= 0) {
1224 past_scrubs
= scrub_read_file(fdres
, !do_quiet
);
1225 if (IS_ERR(past_scrubs
))
1226 ERR(!do_quiet
, "WARNING: failed to read status file: "
1227 "%s\n", strerror(-PTR_ERR(past_scrubs
)));
1232 * Check for stale information in the status file, ie. if it's
1233 * canceled=0, finished=0 but no scrub is running.
1235 if (!is_scrub_running_in_kernel(fdmnt
, di_args
, fi_args
.num_devices
))
1239 * check whether any involved device is already busy running a
1240 * scrub. This would cause damaged status messages and the state
1241 * "aborted" without the explanation that a scrub was already
1242 * running. Therefore check it first, prevent it and give some
1243 * feedback to the user if scrub is already running.
1244 * Note that if scrub is started with a block device as the
1245 * parameter, only that particular block device is checked. It
1246 * is a normal mode of operation to start scrub on multiple
1247 * single devices, there is no reason to prevent this.
1249 if (!force
&& is_scrub_running_on_fs(&fi_args
, di_args
, past_scrubs
)) {
1251 "ERROR: scrub is already running.\n"
1252 "To cancel use 'btrfs scrub cancel %s'.\n"
1253 "To see the status use 'btrfs scrub status [-d] %s'.\n",
1259 t_devs
= malloc(fi_args
.num_devices
* sizeof(*t_devs
));
1260 sp
= calloc(fi_args
.num_devices
, sizeof(*sp
));
1261 spc
.progress
= calloc(fi_args
.num_devices
* 2, sizeof(*spc
.progress
));
1263 if (!t_devs
|| !sp
|| !spc
.progress
) {
1264 ERR(!do_quiet
, "ERROR: scrub failed: %s", strerror(errno
));
1269 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1270 devid
= di_args
[i
].devid
;
1271 ret
= pthread_mutex_init(&sp
[i
].progress_mutex
, NULL
);
1273 ERR(!do_quiet
, "ERROR: pthread_mutex_init failed: "
1274 "%s\n", strerror(ret
));
1278 last_scrub
= last_dev_scrub(past_scrubs
, devid
);
1279 sp
[i
].scrub_args
.devid
= devid
;
1281 if (resume
&& last_scrub
&& (last_scrub
->stats
.canceled
||
1282 !last_scrub
->stats
.finished
)) {
1284 sp
[i
].scrub_args
.start
= last_scrub
->p
.last_physical
;
1285 sp
[i
].resumed
= last_scrub
;
1286 } else if (resume
) {
1289 sp
[i
].resumed
= last_scrub
;
1293 sp
[i
].scrub_args
.start
= 0ll;
1294 sp
[i
].resumed
= NULL
;
1297 sp
[i
].scrub_args
.end
= (u64
)-1ll;
1298 sp
[i
].scrub_args
.flags
= readonly
? BTRFS_SCRUB_READONLY
: 0;
1299 sp
[i
].ioprio_class
= ioprio_class
;
1300 sp
[i
].ioprio_classdata
= ioprio_classdata
;
1303 if (!n_start
&& !n_resume
) {
1305 printf("scrub: nothing to resume for %s, fsid %s\n",
1307 nothing_to_resume
= 1;
1311 ret
= prg_fd
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1313 ret
= scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH
, fsid
, NULL
,
1314 sock_path
, sizeof(sock_path
));
1315 /* ignore EOVERFLOW, try using a shorter path for the socket */
1316 addr
.sun_path
[sizeof(addr
.sun_path
) - 1] = '\0';
1317 strncpy(addr
.sun_path
, sock_path
, sizeof(addr
.sun_path
) - 1);
1318 ret
= bind(prg_fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
1319 if (ret
!= -1 || errno
!= EADDRINUSE
)
1322 * bind failed with EADDRINUSE. so let's see if anyone answers
1323 * when we make a call to the socket ...
1325 ret
= connect(prg_fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
1326 if (!ret
|| errno
!= ECONNREFUSED
) {
1327 /* ... yes, so scrub must be running. error out */
1328 fprintf(stderr
, "ERROR: scrub already running\n");
1334 * ... no, this means someone left us alone with an unused
1335 * socket in the file system. remove it and try again.
1337 ret
= unlink(sock_path
);
1340 ret
= listen(prg_fd
, 100);
1342 ERR(!do_quiet
, "WARNING: failed to open the progress status "
1343 "socket at %s: %s. Progress cannot be queried\n",
1344 sock_path
[0] ? sock_path
: SCRUB_PROGRESS_SOCKET_PATH
,
1355 /* write all-zero progress file for a start */
1356 ret
= scrub_write_progress(&spc_write_mutex
, fsid
, sp
,
1357 fi_args
.num_devices
);
1359 ERR(!do_quiet
, "WARNING: failed to write the progress "
1360 "status file: %s. Status recording disabled\n",
1366 if (do_background
) {
1369 ERR(!do_quiet
, "ERROR: cannot scrub, fork failed: "
1370 "%s\n", strerror(errno
));
1377 scrub_handle_sigint_parent();
1379 printf("scrub %s on %s, fsid %s (pid=%d)\n",
1380 n_start
? "started" : "resumed",
1388 ERR(!do_quiet
, "ERROR: wait failed: (ret=%d) "
1389 "%s\n", ret
, strerror(errno
));
1393 if (!WIFEXITED(stat
) || WEXITSTATUS(stat
)) {
1394 ERR(!do_quiet
, "ERROR: scrub process failed\n");
1395 err
= WIFEXITED(stat
) ? WEXITSTATUS(stat
) : -1;
1403 scrub_handle_sigint_child(fdmnt
);
1405 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1407 sp
[i
].scrub_args
.progress
= sp
[i
].resumed
->p
;
1408 sp
[i
].stats
= sp
[i
].resumed
->stats
;
1410 sp
[i
].stats
.finished
= 1;
1413 devid
= di_args
[i
].devid
;
1414 gettimeofday(&tv
, NULL
);
1415 sp
[i
].stats
.t_start
= tv
.tv_sec
;
1416 ret
= pthread_create(&t_devs
[i
], NULL
,
1417 scrub_one_dev
, &sp
[i
]);
1420 fprintf(stderr
, "ERROR: creating "
1421 "scrub_one_dev[%llu] thread failed: "
1422 "%s\n", devid
, strerror(ret
));
1429 spc
.prg_fd
= prg_fd
;
1430 spc
.do_record
= do_record
;
1431 spc
.write_mutex
= &spc_write_mutex
;
1432 spc
.shared_progress
= sp
;
1434 ret
= pthread_create(&t_prog
, NULL
, scrub_progress_cycle
, &spc
);
1437 fprintf(stderr
, "ERROR: creating progress thread "
1438 "failed: %s\n", strerror(ret
));
1444 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1447 devid
= di_args
[i
].devid
;
1448 ret
= pthread_join(t_devs
[i
], NULL
);
1451 fprintf(stderr
, "ERROR: pthread_join failed "
1452 "for scrub_one_dev[%llu]: %s\n", devid
,
1457 if (sp
[i
].ret
&& sp
[i
].ioctl_errno
== ENODEV
) {
1459 fprintf(stderr
, "WARNING: device %lld not "
1460 "present\n", devid
);
1463 if (sp
[i
].ret
&& sp
[i
].ioctl_errno
== ECANCELED
) {
1465 } else if (sp
[i
].ret
) {
1467 fprintf(stderr
, "ERROR: scrubbing %s failed "
1468 "for device id %lld (%s)\n", path
,
1469 devid
, strerror(sp
[i
].ioctl_errno
));
1473 if (sp
[i
].scrub_args
.progress
.uncorrectable_errors
> 0)
1475 if (sp
[i
].scrub_args
.progress
.corrected_errors
> 0
1476 || sp
[i
].scrub_args
.progress
.unverified_errors
> 0)
1481 const char *append
= "done";
1482 if (!do_stats_per_dev
)
1483 init_fs_stat(&fs_stat
);
1484 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1485 if (do_stats_per_dev
) {
1486 print_scrub_dev(&di_args
[i
],
1487 &sp
[i
].scrub_args
.progress
,
1489 sp
[i
].ret
? "canceled" : "done",
1493 append
= "canceled";
1494 add_to_fs_stat(&sp
[i
].scrub_args
.progress
,
1495 &sp
[i
].stats
, &fs_stat
);
1498 if (!do_stats_per_dev
) {
1499 printf("scrub %s for %s\n", append
, fsid
);
1500 print_fs_stat(&fs_stat
, print_raw
);
1504 ret
= pthread_cancel(t_prog
);
1506 ret
= pthread_join(t_prog
, &terr
);
1508 /* check for errors from the handling of the progress thread */
1509 if (do_print
&& ret
) {
1510 fprintf(stderr
, "ERROR: progress thread handling failed: %s\n",
1514 /* check for errors returned from the progress thread itself */
1515 if (do_print
&& terr
&& terr
!= PTHREAD_CANCELED
) {
1516 fprintf(stderr
, "ERROR: recording progress "
1517 "failed: %s\n", strerror(-PTR_ERR(terr
)));
1521 ret
= scrub_write_progress(&spc_write_mutex
, fsid
, sp
,
1522 fi_args
.num_devices
);
1523 if (ret
&& do_print
) {
1524 fprintf(stderr
, "ERROR: failed to record the result: "
1525 "%s\n", strerror(-ret
));
1529 scrub_handle_sigint_child(-1);
1532 free_history(past_scrubs
);
1542 close_file_or_dir(fdmnt
, dirstream
);
1546 if (nothing_to_resume
)
1548 if (e_uncorrectable
) {
1549 ERR(!do_quiet
, "ERROR: There are uncorrectable errors.\n");
1553 ERR(!do_quiet
, "WARNING: errors detected during scrubbing, corrected.\n");
1558 static const char * const cmd_scrub_start_usage
[] = {
1559 "btrfs scrub start [-BdqrRf] [-c ioprio_class -n ioprio_classdata] <path>|<device>",
1560 "Start a new scrub. If a scrub is already running, the new one fails.",
1562 "-B do not background",
1563 "-d stats per device (-B only)",
1565 "-r read only mode",
1566 "-R raw print mode, print full data instead of summary",
1567 "-c set ioprio class (see ionice(1) manpage)",
1568 "-n set ioprio classdata (see ionice(1) manpage)",
1569 "-f force starting new scrub even if a scrub is already running",
1570 " this is useful when scrub stats record file is damaged",
1574 static int cmd_scrub_start(int argc
, char **argv
)
1576 return scrub_start(argc
, argv
, 0);
1579 static const char * const cmd_scrub_cancel_usage
[] = {
1580 "btrfs scrub cancel <path>|<device>",
1581 "Cancel a running scrub",
1585 static int cmd_scrub_cancel(int argc
, char **argv
)
1590 DIR *dirstream
= NULL
;
1592 if (check_argc_exact(argc
, 2))
1593 usage(cmd_scrub_cancel_usage
);
1597 fdmnt
= open_path_or_dev_mnt(path
, &dirstream
);
1599 if (errno
== EINVAL
)
1601 "ERROR: '%s' is not a mounted btrfs device\n",
1604 fprintf(stderr
, "ERROR: can't access '%s': %s\n",
1605 path
, strerror(errno
));
1610 ret
= ioctl(fdmnt
, BTRFS_IOC_SCRUB_CANCEL
, NULL
);
1613 fprintf(stderr
, "ERROR: scrub cancel failed on %s: %s\n", path
,
1614 errno
== ENOTCONN
? "not running" : strerror(errno
));
1615 if (errno
== ENOTCONN
)
1623 printf("scrub cancelled\n");
1626 close_file_or_dir(fdmnt
, dirstream
);
1630 static const char * const cmd_scrub_resume_usage
[] = {
1631 "btrfs scrub resume [-BdqrR] [-c ioprio_class -n ioprio_classdata] <path>|<device>",
1632 "Resume previously canceled or interrupted scrub",
1634 "-B do not background",
1635 "-d stats per device (-B only)",
1637 "-r read only mode",
1638 "-R raw print mode, print full data instead of summary",
1639 "-c set ioprio class (see ionice(1) manpage)",
1640 "-n set ioprio classdata (see ionice(1) manpage)",
1644 static int cmd_scrub_resume(int argc
, char **argv
)
1646 return scrub_start(argc
, argv
, 1);
1649 static const char * const cmd_scrub_status_usage
[] = {
1650 "btrfs scrub status [-dR] <path>|<device>",
1651 "Show status of running or finished scrub",
1653 "-d stats per device",
1654 "-R print raw stats",
1658 static int cmd_scrub_status(int argc
, char **argv
)
1661 struct btrfs_ioctl_fs_info_args fi_args
;
1662 struct btrfs_ioctl_dev_info_args
*di_args
= NULL
;
1663 struct scrub_file_record
**past_scrubs
= NULL
;
1664 struct scrub_file_record
*last_scrub
;
1665 struct scrub_fs_stat fs_stat
;
1666 struct sockaddr_un addr
= {
1667 .sun_family
= AF_UNIX
,
1674 int do_stats_per_dev
= 0;
1676 char fsid
[BTRFS_UUID_UNPARSED_SIZE
];
1679 DIR *dirstream
= NULL
;
1682 while ((c
= getopt(argc
, argv
, "dR")) != -1) {
1685 do_stats_per_dev
= 1;
1692 usage(cmd_scrub_status_usage
);
1696 if (check_argc_exact(argc
- optind
, 1))
1697 usage(cmd_scrub_status_usage
);
1699 path
= argv
[optind
];
1701 fdmnt
= open_path_or_dev_mnt(path
, &dirstream
);
1704 if (errno
== EINVAL
)
1706 "ERROR: '%s' is not a mounted btrfs device\n",
1709 fprintf(stderr
, "ERROR: can't access '%s': %s\n",
1710 path
, strerror(errno
));
1714 ret
= get_fs_info(path
, &fi_args
, &di_args
);
1716 fprintf(stderr
, "ERROR: getting dev info for scrub failed: "
1717 "%s\n", strerror(-ret
));
1721 if (!fi_args
.num_devices
) {
1722 fprintf(stderr
, "ERROR: no devices found\n");
1727 uuid_unparse(fi_args
.fsid
, fsid
);
1729 fdres
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1731 fprintf(stderr
, "ERROR: failed to create socket to "
1732 "receive progress information: %s\n",
1737 scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH
, fsid
,
1738 NULL
, addr
.sun_path
, sizeof(addr
.sun_path
));
1739 /* ignore EOVERFLOW, just use shorter name and hope for the best */
1740 addr
.sun_path
[sizeof(addr
.sun_path
) - 1] = '\0';
1741 ret
= connect(fdres
, (struct sockaddr
*)&addr
, sizeof(addr
));
1744 fdres
= scrub_open_file_r(SCRUB_DATA_FILE
, fsid
);
1745 if (fdres
< 0 && fdres
!= -ENOENT
) {
1746 fprintf(stderr
, "WARNING: failed to open status file: "
1747 "%s\n", strerror(-fdres
));
1754 past_scrubs
= scrub_read_file(fdres
, 1);
1755 if (IS_ERR(past_scrubs
))
1756 fprintf(stderr
, "WARNING: failed to read status: %s\n",
1757 strerror(-PTR_ERR(past_scrubs
)));
1759 in_progress
= is_scrub_running_in_kernel(fdmnt
, di_args
, fi_args
.num_devices
);
1761 printf("scrub status for %s\n", fsid
);
1763 if (do_stats_per_dev
) {
1764 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1765 last_scrub
= last_dev_scrub(past_scrubs
,
1768 print_scrub_dev(&di_args
[i
], NULL
, print_raw
,
1772 last_scrub
->stats
.in_progress
= in_progress
;
1773 print_scrub_dev(&di_args
[i
], &last_scrub
->p
, print_raw
,
1774 last_scrub
->stats
.finished
?
1775 "history" : "status",
1776 &last_scrub
->stats
);
1779 init_fs_stat(&fs_stat
);
1780 fs_stat
.s
.in_progress
= in_progress
;
1781 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1782 last_scrub
= last_dev_scrub(past_scrubs
,
1786 add_to_fs_stat(&last_scrub
->p
, &last_scrub
->stats
,
1789 print_fs_stat(&fs_stat
, print_raw
);
1793 free_history(past_scrubs
);
1797 close_file_or_dir(fdmnt
, dirstream
);
1802 const struct cmd_group scrub_cmd_group
= {
1803 scrub_cmd_group_usage
, NULL
, {
1804 { "start", cmd_scrub_start
, cmd_scrub_start_usage
, NULL
, 0 },
1805 { "cancel", cmd_scrub_cancel
, cmd_scrub_cancel_usage
, NULL
, 0 },
1806 { "resume", cmd_scrub_resume
, cmd_scrub_resume_usage
, NULL
, 0 },
1807 { "status", cmd_scrub_status
, cmd_scrub_status_usage
, NULL
, 0 },
1812 int cmd_scrub(int argc
, char **argv
)
1814 return handle_command_group(&scrub_cmd_group
, argc
, argv
);