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 <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
27 #include <uuid/uuid.h>
37 #include "btrfs_cmds.h"
42 #define SCRUB_DATA_FILE "/var/lib/btrfs/scrub.status"
43 #define SCRUB_PROGRESS_SOCKET_PATH "/var/lib/btrfs/scrub.progress"
44 #define SCRUB_FILE_VERSION_PREFIX "scrub status"
45 #define SCRUB_FILE_VERSION "1"
55 struct scrub_progress
{
56 struct btrfs_ioctl_scrub_args scrub_args
;
60 struct scrub_stats stats
;
61 struct scrub_file_record
*resumed
;
63 pthread_mutex_t progress_mutex
;
66 struct scrub_file_record
{
67 u8 fsid
[BTRFS_FSID_SIZE
];
69 struct scrub_stats stats
;
70 struct btrfs_scrub_progress p
;
73 struct scrub_progress_cycle
{
77 struct btrfs_ioctl_fs_info_args
*fi
;
78 struct scrub_progress
*progress
;
79 struct scrub_progress
*shared_progress
;
80 pthread_mutex_t
*write_mutex
;
83 struct scrub_fs_stat
{
84 struct btrfs_scrub_progress p
;
89 static void print_scrub_full(struct btrfs_scrub_progress
*sp
)
91 printf("\tdata_extents_scrubbed: %lld\n", sp
->data_extents_scrubbed
);
92 printf("\ttree_extents_scrubbed: %lld\n", sp
->tree_extents_scrubbed
);
93 printf("\tdata_bytes_scrubbed: %lld\n", sp
->data_bytes_scrubbed
);
94 printf("\ttree_bytes_scrubbed: %lld\n", sp
->tree_bytes_scrubbed
);
95 printf("\tread_errors: %lld\n", sp
->read_errors
);
96 printf("\tcsum_errors: %lld\n", sp
->csum_errors
);
97 printf("\tverify_errors: %lld\n", sp
->verify_errors
);
98 printf("\tno_csum: %lld\n", sp
->no_csum
);
99 printf("\tcsum_discards: %lld\n", sp
->csum_discards
);
100 printf("\tsuper_errors: %lld\n", sp
->super_errors
);
101 printf("\tmalloc_errors: %lld\n", sp
->malloc_errors
);
102 printf("\tuncorrectable_errors: %lld\n", sp
->uncorrectable_errors
);
103 printf("\tunverified_errors: %lld\n", sp
->unverified_errors
);
104 printf("\tcorrected_errors: %lld\n", sp
->corrected_errors
);
105 printf("\tlast_physical: %lld\n", sp
->last_physical
);
108 #define ERR(test, ...) do { \
110 fprintf(stderr, __VA_ARGS__); \
113 #define PRINT_SCRUB_ERROR(test, desc) do { \
115 printf(" %s=%llu", desc, test); \
118 static void print_scrub_summary(struct btrfs_scrub_progress
*p
)
124 err_cnt
= p
->read_errors
+
129 err_cnt2
= p
->corrected_errors
+ p
->uncorrectable_errors
;
131 if (p
->malloc_errors
)
132 printf("*** WARNING: memory allocation failed while scrubbing. "
133 "results may be inaccurate\n");
134 bytes
= pretty_sizes(p
->data_bytes_scrubbed
+ p
->tree_bytes_scrubbed
);
135 printf("\ttotal bytes scrubbed: %s with %llu errors\n", bytes
,
136 max(err_cnt
, err_cnt2
));
138 if (err_cnt
|| err_cnt2
) {
139 printf("\terror details:");
140 PRINT_SCRUB_ERROR(p
->read_errors
, "read");
141 PRINT_SCRUB_ERROR(p
->super_errors
, "super");
142 PRINT_SCRUB_ERROR(p
->verify_errors
, "verify");
143 PRINT_SCRUB_ERROR(p
->csum_errors
, "csum");
145 printf("\tcorrected errors: %llu, uncorrectable errors: %llu, "
146 "unverified errors: %llu\n", p
->corrected_errors
,
147 p
->uncorrectable_errors
, p
->unverified_errors
);
151 #define _SCRUB_FS_STAT(p, name, fs_stat) do { \
152 fs_stat->p.name += p->name; \
155 #define _SCRUB_FS_STAT_MIN(ss, name, fs_stat) \
157 if (fs_stat->s.name > ss->name) { \
158 fs_stat->s.name = ss->name; \
162 #define _SCRUB_FS_STAT_ZMIN(ss, name, fs_stat) \
164 if (!fs_stat->s.name || fs_stat->s.name > ss->name) { \
165 fs_stat->s.name = ss->name; \
169 #define _SCRUB_FS_STAT_ZMAX(ss, name, fs_stat) \
171 if (!(fs_stat)->s.name || (fs_stat)->s.name < (ss)->name) { \
172 (fs_stat)->s.name = (ss)->name; \
176 static void add_to_fs_stat(struct btrfs_scrub_progress
*p
,
177 struct scrub_stats
*ss
,
178 struct scrub_fs_stat
*fs_stat
)
180 _SCRUB_FS_STAT(p
, data_extents_scrubbed
, fs_stat
);
181 _SCRUB_FS_STAT(p
, tree_extents_scrubbed
, fs_stat
);
182 _SCRUB_FS_STAT(p
, data_bytes_scrubbed
, fs_stat
);
183 _SCRUB_FS_STAT(p
, tree_bytes_scrubbed
, fs_stat
);
184 _SCRUB_FS_STAT(p
, read_errors
, fs_stat
);
185 _SCRUB_FS_STAT(p
, csum_errors
, fs_stat
);
186 _SCRUB_FS_STAT(p
, verify_errors
, fs_stat
);
187 _SCRUB_FS_STAT(p
, no_csum
, fs_stat
);
188 _SCRUB_FS_STAT(p
, csum_discards
, fs_stat
);
189 _SCRUB_FS_STAT(p
, super_errors
, fs_stat
);
190 _SCRUB_FS_STAT(p
, malloc_errors
, fs_stat
);
191 _SCRUB_FS_STAT(p
, uncorrectable_errors
, fs_stat
);
192 _SCRUB_FS_STAT(p
, corrected_errors
, fs_stat
);
193 _SCRUB_FS_STAT(p
, last_physical
, fs_stat
);
194 _SCRUB_FS_STAT_ZMIN(ss
, t_start
, fs_stat
);
195 _SCRUB_FS_STAT_ZMIN(ss
, t_resumed
, fs_stat
);
196 _SCRUB_FS_STAT_ZMAX(ss
, duration
, fs_stat
);
197 _SCRUB_FS_STAT_ZMAX(ss
, canceled
, fs_stat
);
198 _SCRUB_FS_STAT_MIN(ss
, finished
, fs_stat
);
201 static void init_fs_stat(struct scrub_fs_stat
*fs_stat
)
203 memset(fs_stat
, 0, sizeof(*fs_stat
));
204 fs_stat
->s
.finished
= 1;
207 static void _print_scrub_ss(struct scrub_stats
*ss
)
212 if (!ss
|| !ss
->t_start
) {
213 printf("\tno stats available\n");
217 localtime_r(&ss
->t_resumed
, &tm
);
218 strftime(t
, sizeof(t
), "%c", &tm
);
219 t
[sizeof(t
) - 1] = '\0';
220 printf("\tscrub resumed at %s", t
);
222 localtime_r(&ss
->t_start
, &tm
);
223 strftime(t
, sizeof(t
), "%c", &tm
);
224 t
[sizeof(t
) - 1] = '\0';
225 printf("\tscrub started at %s", t
);
227 if (ss
->finished
&& !ss
->canceled
) {
228 printf(" and finished after %llu seconds\n",
230 } else if (ss
->canceled
) {
231 printf(" and was aborted after %llu seconds\n",
234 printf(", running for %llu seconds\n", ss
->duration
);
238 static void print_scrub_dev(struct btrfs_ioctl_dev_info_args
*di
,
239 struct btrfs_scrub_progress
*p
, int raw
,
240 const char *append
, struct scrub_stats
*ss
)
242 printf("scrub device %s (id %llu) %s\n", di
->path
, di
->devid
,
243 append
? append
: "");
251 print_scrub_summary(p
);
255 static void print_fs_stat(struct scrub_fs_stat
*fs_stat
, int raw
)
257 _print_scrub_ss(&fs_stat
->s
);
260 print_scrub_full(&fs_stat
->p
);
262 print_scrub_summary(&fs_stat
->p
);
265 static void free_history(struct scrub_file_record
**last_scrubs
)
267 struct scrub_file_record
**l
= last_scrubs
;
276 * cancels a running scrub and makes the master process record the current
277 * progress status before exiting.
279 static int cancel_fd
= -1;
280 static void scrub_sigint_record_progress(int signal
)
282 ioctl(cancel_fd
, BTRFS_IOC_SCRUB_CANCEL
, NULL
);
285 static int scrub_handle_sigint_parent(void)
287 struct sigaction sa
= {
288 .sa_handler
= SIG_IGN
,
289 .sa_flags
= SA_RESTART
,
292 return sigaction(SIGINT
, &sa
, NULL
);
295 static int scrub_handle_sigint_child(int fd
)
297 struct sigaction sa
= {
298 .sa_handler
= fd
== -1 ? SIG_DFL
: scrub_sigint_record_progress
,
302 return sigaction(SIGINT
, &sa
, NULL
);
305 static int scrub_datafile(const char *fn_base
, const char *fn_local
,
306 const char *fn_tmp
, char *datafile
, int size
)
311 datafile
[end
+ 1] = '\0';
312 strncpy(datafile
, fn_base
, end
);
313 ret
= strlen(datafile
);
319 strncpy(datafile
+ ret
+ 1, fn_local
, end
- ret
- 1);
320 ret
= strlen(datafile
);
327 strncpy(datafile
+ ret
+ 1, fn_tmp
, end
- ret
- 1);
328 ret
= strlen(datafile
);
337 static int scrub_open_file(const char *datafile
, int m
)
342 fd
= open(datafile
, m
, 0600);
346 ret
= flock(fd
, LOCK_EX
|LOCK_NB
);
356 static int scrub_open_file_r(const char *fn_base
, const char *fn_local
)
359 char datafile
[BTRFS_PATH_NAME_MAX
+ 1];
360 ret
= scrub_datafile(fn_base
, fn_local
, NULL
,
361 datafile
, sizeof(datafile
));
364 return scrub_open_file(datafile
, O_RDONLY
);
367 static int scrub_open_file_w(const char *fn_base
, const char *fn_local
,
371 char datafile
[BTRFS_PATH_NAME_MAX
+ 1];
372 ret
= scrub_datafile(fn_base
, fn_local
, tmp
,
373 datafile
, sizeof(datafile
));
376 return scrub_open_file(datafile
, O_WRONLY
|O_CREAT
);
379 static int scrub_rename_file(const char *fn_base
, const char *fn_local
,
383 char datafile_old
[BTRFS_PATH_NAME_MAX
+ 1];
384 char datafile_new
[BTRFS_PATH_NAME_MAX
+ 1];
385 ret
= scrub_datafile(fn_base
, fn_local
, tmp
,
386 datafile_old
, sizeof(datafile_old
));
389 ret
= scrub_datafile(fn_base
, fn_local
, NULL
,
390 datafile_new
, sizeof(datafile_new
));
393 ret
= rename(datafile_old
, datafile_new
);
394 return ret
? -errno
: 0;
397 #define _SCRUB_KVREAD(ret, i, name, avail, l, dest) if (ret == 0) { \
398 ret = scrub_kvread(i, sizeof(#name), avail, l, #name, dest.name); \
402 * returns 0 if the key did not match (nothing was read)
403 * 1 if the key did match (success)
404 * -1 if the key did match and an error occured
406 static int scrub_kvread(int *i
, int len
, int avail
, const char *buf
,
407 const char *key
, u64
*dest
)
411 if (*i
+ len
+ 1 < avail
&& strncmp(&buf
[*i
], key
, len
- 1) == 0) {
416 for (j
= 0; isdigit(buf
[*i
+ j
]) && *i
+ j
< avail
; ++j
)
420 *dest
= atoll(&buf
[*i
]);
428 #define _SCRUB_INVALID do { \
430 fprintf(stderr, "WARNING: invalid data in line %d pos " \
431 "%d state %d (near \"%.*s\") at %s:%d\n", \
432 lineno, i, state, 20 > avail ? avail : 20, \
433 l + i, __FILE__, __LINE__); \
437 static struct scrub_file_record
**scrub_read_file(int fd
, int report_errors
)
450 char empty_uuid
[BTRFS_FSID_SIZE
] = {0};
451 struct scrub_file_record
**p
= NULL
;
454 return ERR_PTR(-EINVAL
);
457 old_avail
= avail
- i
;
458 BUG_ON(old_avail
< 0);
460 memmove(l
, l
+ i
, old_avail
);
461 avail
= read(fd
, l
+ old_avail
, sizeof(l
) - old_avail
);
464 if (avail
== 0 && old_avail
== 0) {
466 memcmp(p
[curr
]->fsid
, empty_uuid
, BTRFS_FSID_SIZE
) == 0) {
468 } else if (curr
== -1) {
469 p
= ERR_PTR(-ENODATA
);
474 return ERR_PTR(-errno
);
480 case 0: /* start of file */
481 ret
= scrub_kvread(&i
,
482 sizeof(SCRUB_FILE_VERSION_PREFIX
), avail
, l
,
483 SCRUB_FILE_VERSION_PREFIX
, &version
);
486 if (version
!= atoll(SCRUB_FILE_VERSION
))
487 return ERR_PTR(-ENOTSUP
);
490 case 1: /* start of line, alloc */
492 * this state makes sure we have a complete line in
493 * further processing, so we don't need wrap-tracking
496 if (!eof
&& !memchr(l
+ i
, '\n', avail
- i
))
499 if (curr
> -1 && memcmp(p
[curr
]->fsid
, empty_uuid
,
500 BTRFS_FSID_SIZE
) == 0) {
505 p
= realloc(p
, (curr
+ 2) * sizeof(*p
));
507 p
[curr
] = malloc(sizeof(**p
));
509 return ERR_PTR(-errno
);
510 memset(p
[curr
], 0, sizeof(**p
));
514 case 2: /* start of line, skip space */
515 while (isspace(l
[i
]) && i
< avail
) {
521 (!eof
&& !memchr(l
+ i
, '\n', avail
- i
)))
525 case 3: /* read fsid */
528 for (j
= 0; l
[i
+ j
] != ':' && i
+ j
< avail
; ++j
)
530 if (i
+ j
+ 1 >= avail
)
535 ret
= uuid_parse(l
+ i
, p
[curr
]->fsid
);
541 case 4: /* read dev id */
542 for (j
= 0; isdigit(l
[i
+ j
]) && i
+j
< avail
; ++j
)
544 if (j
== 0 || i
+ j
+ 1 >= avail
)
546 p
[curr
]->devid
= atoll(&l
[i
]);
550 case 5: /* read key/value pair */
552 _SCRUB_KVREAD(ret
, &i
, data_extents_scrubbed
, avail
, l
,
554 _SCRUB_KVREAD(ret
, &i
, data_extents_scrubbed
, avail
, l
,
556 _SCRUB_KVREAD(ret
, &i
, tree_extents_scrubbed
, avail
, l
,
558 _SCRUB_KVREAD(ret
, &i
, data_bytes_scrubbed
, avail
, l
,
560 _SCRUB_KVREAD(ret
, &i
, tree_bytes_scrubbed
, avail
, l
,
562 _SCRUB_KVREAD(ret
, &i
, read_errors
, avail
, l
,
564 _SCRUB_KVREAD(ret
, &i
, csum_errors
, avail
, l
,
566 _SCRUB_KVREAD(ret
, &i
, verify_errors
, avail
, l
,
568 _SCRUB_KVREAD(ret
, &i
, no_csum
, avail
, l
,
570 _SCRUB_KVREAD(ret
, &i
, csum_discards
, avail
, l
,
572 _SCRUB_KVREAD(ret
, &i
, super_errors
, avail
, l
,
574 _SCRUB_KVREAD(ret
, &i
, malloc_errors
, avail
, l
,
576 _SCRUB_KVREAD(ret
, &i
, uncorrectable_errors
, avail
, l
,
578 _SCRUB_KVREAD(ret
, &i
, corrected_errors
, avail
, l
,
580 _SCRUB_KVREAD(ret
, &i
, last_physical
, avail
, l
,
582 _SCRUB_KVREAD(ret
, &i
, finished
, avail
, l
,
584 _SCRUB_KVREAD(ret
, &i
, t_start
, avail
, l
,
585 (u64
*)&p
[curr
]->stats
);
586 _SCRUB_KVREAD(ret
, &i
, t_resumed
, avail
, l
,
587 (u64
*)&p
[curr
]->stats
);
588 _SCRUB_KVREAD(ret
, &i
, duration
, avail
, l
,
589 (u64
*)&p
[curr
]->stats
);
590 _SCRUB_KVREAD(ret
, &i
, canceled
, avail
, l
,
596 case 6: /* after number */
599 else if (l
[i
] == '\n')
605 case 99: /* skip rest of line */
610 if (l
[i
- 1] == '\n') {
622 static int scrub_write_buf(int fd
, const void *data
, int len
)
625 ret
= write(fd
, data
, len
);
629 static int scrub_writev(int fd
, char *buf
, int max
, const char *fmt
, ...)
630 __attribute__ ((format (printf
, 4, 5)));
631 static int scrub_writev(int fd
, char *buf
, int max
, const char *fmt
, ...)
637 ret
= vsnprintf(buf
, max
, fmt
, args
);
641 return scrub_write_buf(fd
, buf
, ret
);
644 #define _SCRUB_SUM(dest, data, name) dest->scrub_args.progress.name = \
645 data->resumed->p.name + data->scrub_args.progress.name
647 static struct scrub_progress
*scrub_resumed_stats(struct scrub_progress
*data
,
648 struct scrub_progress
*dest
)
650 if (!data
->resumed
|| data
->skip
)
653 _SCRUB_SUM(dest
, data
, data_extents_scrubbed
);
654 _SCRUB_SUM(dest
, data
, tree_extents_scrubbed
);
655 _SCRUB_SUM(dest
, data
, data_bytes_scrubbed
);
656 _SCRUB_SUM(dest
, data
, tree_bytes_scrubbed
);
657 _SCRUB_SUM(dest
, data
, read_errors
);
658 _SCRUB_SUM(dest
, data
, csum_errors
);
659 _SCRUB_SUM(dest
, data
, verify_errors
);
660 _SCRUB_SUM(dest
, data
, no_csum
);
661 _SCRUB_SUM(dest
, data
, csum_discards
);
662 _SCRUB_SUM(dest
, data
, super_errors
);
663 _SCRUB_SUM(dest
, data
, malloc_errors
);
664 _SCRUB_SUM(dest
, data
, uncorrectable_errors
);
665 _SCRUB_SUM(dest
, data
, corrected_errors
);
666 _SCRUB_SUM(dest
, data
, last_physical
);
667 dest
->stats
.canceled
= data
->stats
.canceled
;
668 dest
->stats
.finished
= data
->stats
.finished
;
669 dest
->stats
.t_resumed
= data
->stats
.t_start
;
670 dest
->stats
.t_start
= data
->resumed
->stats
.t_start
;
671 dest
->stats
.duration
= data
->resumed
->stats
.duration
+
672 data
->stats
.duration
;
673 dest
->scrub_args
.devid
= data
->scrub_args
.devid
;
677 #define _SCRUB_KVWRITE(fd, buf, name, use) \
678 scrub_kvwrite(fd, buf, sizeof(buf), #name, \
679 use->scrub_args.progress.name)
681 #define _SCRUB_KVWRITE_STATS(fd, buf, name, use) \
682 scrub_kvwrite(fd, buf, sizeof(buf), #name, \
685 static int scrub_kvwrite(int fd
, char *buf
, int max
, const char *key
, u64 val
)
687 return scrub_writev(fd
, buf
, max
, "|%s:%lld", key
, val
);
690 static int scrub_write_file(int fd
, const char *fsid
,
691 struct scrub_progress
*data
, int n
)
696 struct scrub_progress local
;
697 struct scrub_progress
*use
;
702 /* each -1 is to subtract one \0 byte, the + 2 is for ':' and '\n' */
703 ret
= scrub_write_buf(fd
, SCRUB_FILE_VERSION_PREFIX
":"
704 SCRUB_FILE_VERSION
"\n",
705 (sizeof(SCRUB_FILE_VERSION_PREFIX
) - 1) +
706 (sizeof(SCRUB_FILE_VERSION
) - 1) + 2);
710 for (i
= 0; i
< n
; ++i
) {
711 use
= scrub_resumed_stats(&data
[i
], &local
);
712 if (scrub_write_buf(fd
, fsid
, strlen(fsid
)) ||
713 scrub_write_buf(fd
, ":", 1) ||
714 scrub_writev(fd
, buf
, sizeof(buf
), "%lld",
715 use
->scrub_args
.devid
) ||
716 scrub_write_buf(fd
, buf
, ret
) ||
717 _SCRUB_KVWRITE(fd
, buf
, data_extents_scrubbed
, use
) ||
718 _SCRUB_KVWRITE(fd
, buf
, tree_extents_scrubbed
, use
) ||
719 _SCRUB_KVWRITE(fd
, buf
, data_bytes_scrubbed
, use
) ||
720 _SCRUB_KVWRITE(fd
, buf
, tree_bytes_scrubbed
, use
) ||
721 _SCRUB_KVWRITE(fd
, buf
, read_errors
, use
) ||
722 _SCRUB_KVWRITE(fd
, buf
, csum_errors
, use
) ||
723 _SCRUB_KVWRITE(fd
, buf
, verify_errors
, use
) ||
724 _SCRUB_KVWRITE(fd
, buf
, no_csum
, use
) ||
725 _SCRUB_KVWRITE(fd
, buf
, csum_discards
, use
) ||
726 _SCRUB_KVWRITE(fd
, buf
, super_errors
, use
) ||
727 _SCRUB_KVWRITE(fd
, buf
, malloc_errors
, use
) ||
728 _SCRUB_KVWRITE(fd
, buf
, uncorrectable_errors
, use
) ||
729 _SCRUB_KVWRITE(fd
, buf
, corrected_errors
, use
) ||
730 _SCRUB_KVWRITE(fd
, buf
, last_physical
, use
) ||
731 _SCRUB_KVWRITE_STATS(fd
, buf
, t_start
, use
) ||
732 _SCRUB_KVWRITE_STATS(fd
, buf
, t_resumed
, use
) ||
733 _SCRUB_KVWRITE_STATS(fd
, buf
, duration
, use
) ||
734 _SCRUB_KVWRITE_STATS(fd
, buf
, canceled
, use
) ||
735 _SCRUB_KVWRITE_STATS(fd
, buf
, finished
, use
) ||
736 scrub_write_buf(fd
, "\n", 1)) {
744 static int scrub_write_progress(pthread_mutex_t
*m
, const char *fsid
,
745 struct scrub_progress
*data
, int n
)
752 ret
= pthread_mutex_lock(m
);
758 ret
= pthread_setcancelstate(PTHREAD_CANCEL_DISABLE
, &old
);
764 fd
= scrub_open_file_w(SCRUB_DATA_FILE
, fsid
, "tmp");
769 err
= scrub_write_file(fd
, fsid
, data
, n
);
772 err
= scrub_rename_file(SCRUB_DATA_FILE
, fsid
, "tmp");
783 ret
= pthread_mutex_unlock(m
);
787 ret
= pthread_setcancelstate(PTHREAD_CANCEL_ENABLE
, &old
);
794 static void *scrub_one_dev(void *ctx
)
796 struct scrub_progress
*sp
= ctx
;
800 sp
->stats
.canceled
= 0;
801 sp
->stats
.duration
= 0;
802 sp
->stats
.finished
= 0;
804 ret
= ioctl(sp
->fd
, BTRFS_IOC_SCRUB
, &sp
->scrub_args
);
805 gettimeofday(&tv
, NULL
);
807 sp
->stats
.duration
= tv
.tv_sec
- sp
->stats
.t_start
;
808 sp
->stats
.canceled
= !!ret
;
809 sp
->ioctl_errno
= errno
;
810 ret
= pthread_mutex_lock(&sp
->progress_mutex
);
812 return ERR_PTR(-ret
);
813 sp
->stats
.finished
= 1;
814 ret
= pthread_mutex_unlock(&sp
->progress_mutex
);
816 return ERR_PTR(-ret
);
821 static void *progress_one_dev(void *ctx
)
823 struct scrub_progress
*sp
= ctx
;
825 sp
->ret
= ioctl(sp
->fd
, BTRFS_IOC_SCRUB_PROGRESS
, &sp
->scrub_args
);
826 sp
->ioctl_errno
= errno
;
831 static void *scrub_progress_cycle(void *ctx
)
837 struct scrub_progress
*sp
;
838 struct scrub_progress
*sp_last
;
839 struct scrub_progress
*sp_shared
;
841 struct scrub_progress_cycle
*spc
= ctx
;
842 int ndev
= spc
->fi
->num_devices
;
846 struct pollfd accept_poll_fd
= {
851 struct pollfd write_poll_fd
= {
855 struct sockaddr_un peer
;
856 socklen_t peer_size
= sizeof(peer
);
858 ret
= pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS
, &old
);
860 return ERR_PTR(-ret
);
862 uuid_unparse(spc
->fi
->fsid
, fsid
);
864 for (i
= 0; i
< ndev
; ++i
) {
865 sp
= &spc
->progress
[i
];
866 sp_last
= &spc
->progress
[i
+ ndev
];
867 sp_shared
= &spc
->shared_progress
[i
];
868 sp
->scrub_args
.devid
= sp_last
->scrub_args
.devid
=
869 sp_shared
->scrub_args
.devid
;
870 sp
->fd
= sp_last
->fd
= spc
->fdmnt
;
871 sp
->stats
.t_start
= sp_last
->stats
.t_start
=
872 sp_shared
->stats
.t_start
;
873 sp
->resumed
= sp_last
->resumed
= sp_shared
->resumed
;
874 sp
->skip
= sp_last
->skip
= sp_shared
->skip
;
875 sp
->stats
.finished
= sp_last
->stats
.finished
=
876 sp_shared
->stats
.finished
;
880 ret
= poll(&accept_poll_fd
, 1, 5 * 1000);
882 return ERR_PTR(-errno
);
884 peer_fd
= accept(spc
->prg_fd
, (struct sockaddr
*)&peer
,
886 gettimeofday(&tv
, NULL
);
889 for (i
= 0; i
< ndev
; ++i
) {
890 sp
= &spc
->progress
[this * ndev
+ i
];
891 sp_last
= &spc
->progress
[last
* ndev
+ i
];
892 sp_shared
= &spc
->shared_progress
[i
];
893 if (sp
->stats
.finished
)
895 progress_one_dev(sp
);
896 sp
->stats
.duration
= tv
.tv_sec
- sp
->stats
.t_start
;
899 if (sp
->ioctl_errno
!= ENOTCONN
&&
900 sp
->ioctl_errno
!= ENODEV
)
901 return ERR_PTR(-sp
->ioctl_errno
);
903 * scrub finished or device removed, check the
904 * finished flag. if unset, just use the last
905 * result we got for the current write and go
906 * on. flag should be set on next cycle, then.
908 ret
= pthread_mutex_lock(&sp_shared
->progress_mutex
);
910 return ERR_PTR(-ret
);
911 if (!sp_shared
->stats
.finished
) {
912 ret
= pthread_mutex_unlock(
913 &sp_shared
->progress_mutex
);
915 return ERR_PTR(-ret
);
916 memcpy(sp
, sp_last
, sizeof(*sp
));
919 ret
= pthread_mutex_unlock(&sp_shared
->progress_mutex
);
921 return ERR_PTR(-ret
);
922 memcpy(sp
, sp_shared
, sizeof(*sp
));
923 memcpy(sp_last
, sp_shared
, sizeof(*sp
));
926 write_poll_fd
.fd
= peer_fd
;
927 ret
= poll(&write_poll_fd
, 1, 0);
929 return ERR_PTR(-errno
);
931 ret
= scrub_write_file(
933 &spc
->progress
[this * ndev
], ndev
);
942 ret
= scrub_write_progress(spc
->write_mutex
, fsid
,
943 &spc
->progress
[this * ndev
], ndev
);
949 static struct scrub_file_record
*last_dev_scrub(
950 struct scrub_file_record
*const *const past_scrubs
, u64 devid
)
954 if (!past_scrubs
|| IS_ERR(past_scrubs
))
957 for (i
= 0; past_scrubs
[i
]; ++i
)
958 if (past_scrubs
[i
]->devid
== devid
)
959 return past_scrubs
[i
];
964 static int scrub_device_info(int fd
, u64 devid
,
965 struct btrfs_ioctl_dev_info_args
*di_args
)
969 di_args
->devid
= devid
;
970 memset(&di_args
->uuid
, '\0', sizeof(di_args
->uuid
));
972 ret
= ioctl(fd
, BTRFS_IOC_DEV_INFO
, di_args
);
973 return ret
? -errno
: 0;
976 static int scrub_fs_info(int fd
, char *path
,
977 struct btrfs_ioctl_fs_info_args
*fi_args
,
978 struct btrfs_ioctl_dev_info_args
**di_ret
)
983 struct btrfs_fs_devices
*fs_devices_mnt
= NULL
;
984 struct btrfs_ioctl_dev_info_args
*di_args
;
985 char mp
[BTRFS_PATH_NAME_MAX
+ 1];
987 memset(fi_args
, 0, sizeof(*fi_args
));
989 ret
= ioctl(fd
, BTRFS_IOC_FS_INFO
, fi_args
);
990 if (ret
&& errno
== EINVAL
) {
991 /* path is no mounted btrfs. try if it's a device */
992 ret
= check_mounted_where(fd
, path
, mp
, sizeof(mp
),
998 fi_args
->num_devices
= 1;
999 fi_args
->max_id
= fs_devices_mnt
->latest_devid
;
1000 i
= fs_devices_mnt
->latest_devid
;
1001 memcpy(fi_args
->fsid
, fs_devices_mnt
->fsid
, BTRFS_FSID_SIZE
);
1003 fd
= open_file_or_dir(mp
);
1010 if (!fi_args
->num_devices
)
1013 di_args
= *di_ret
= malloc(fi_args
->num_devices
* sizeof(*di_args
));
1017 for (; i
<= fi_args
->max_id
; ++i
) {
1018 BUG_ON(ndevs
>= fi_args
->num_devices
);
1019 ret
= scrub_device_info(fd
, i
, &di_args
[ndevs
]);
1032 int mkdir_p(char *path
)
1037 for (i
= 1; i
< strlen(path
); ++i
) {
1041 ret
= mkdir(path
, 0777);
1042 if (ret
&& errno
!= EEXIST
)
1050 static int scrub_start(int argc
, char **argv
, int resume
)
1060 int e_uncorrectable
= 0;
1061 int e_correctable
= 0;
1064 int do_background
= 1;
1070 int do_stats_per_dev
= 0;
1074 struct btrfs_ioctl_fs_info_args fi_args
;
1075 struct btrfs_ioctl_dev_info_args
*di_args
= NULL
;
1076 struct scrub_progress
*sp
= NULL
;
1077 struct scrub_fs_stat fs_stat
;
1079 struct sockaddr_un addr
= {
1080 .sun_family
= AF_UNIX
,
1082 pthread_t
*t_devs
= NULL
;
1084 pthread_attr_t t_attr
;
1085 struct scrub_file_record
**past_scrubs
= NULL
;
1086 struct scrub_file_record
*last_scrub
= NULL
;
1087 char *datafile
= strdup(SCRUB_DATA_FILE
);
1089 char sock_path
[BTRFS_PATH_NAME_MAX
+ 1] = "";
1090 struct scrub_progress_cycle spc
;
1091 pthread_mutex_t spc_write_mutex
= PTHREAD_MUTEX_INITIALIZER
;
1096 while ((c
= getopt(argc
, argv
, "BdqrR")) != -1) {
1104 do_stats_per_dev
= 1;
1117 fprintf(stderr
, "ERROR: scrub args invalid.\n"
1118 " -B do not background\n"
1119 " -d stats per device (-B only)\n"
1121 " -r read only mode\n");
1126 /* try to catch most error cases before forking */
1128 if (optind
+ 1 != argc
) {
1129 fprintf(stderr
, "ERROR: scrub start needs path as last "
1134 spc
.progress
= NULL
;
1135 if (do_quiet
&& do_print
)
1138 if (mkdir_p(datafile
)) {
1139 ERR(!do_quiet
, "WARNING: cannot create scrub data "
1140 "file, mkdir %s failed: %s. Status recording "
1141 "disabled\n", datafile
, strerror(errno
));
1146 path
= argv
[optind
];
1148 fdmnt
= open_file_or_dir(path
);
1150 ERR(!do_quiet
, "ERROR: can't access '%s'\n", path
);
1154 ret
= scrub_fs_info(fdmnt
, path
, &fi_args
, &di_args
);
1156 ERR(!do_quiet
, "ERROR: getting dev info for scrub failed: "
1157 "%s\n", strerror(-ret
));
1161 if (!fi_args
.num_devices
) {
1162 ERR(!do_quiet
, "ERROR: no devices found\n");
1167 uuid_unparse(fi_args
.fsid
, fsid
);
1168 fdres
= scrub_open_file_r(SCRUB_DATA_FILE
, fsid
);
1169 if (fdres
< 0 && fdres
!= -ENOENT
) {
1170 ERR(!do_quiet
, "WARNING: failed to open status file: "
1171 "%s\n", strerror(-fdres
));
1172 } else if (fdres
>= 0) {
1173 past_scrubs
= scrub_read_file(fdres
, !do_quiet
);
1174 if (IS_ERR(past_scrubs
))
1175 ERR(!do_quiet
, "WARNING: failed to read status file: "
1176 "%s\n", strerror(-PTR_ERR(past_scrubs
)));
1180 t_devs
= malloc(fi_args
.num_devices
* sizeof(*t_devs
));
1181 sp
= calloc(fi_args
.num_devices
, sizeof(*sp
));
1182 spc
.progress
= calloc(fi_args
.num_devices
* 2, sizeof(*spc
.progress
));
1184 if (!t_devs
|| !sp
|| !spc
.progress
) {
1185 ERR(!do_quiet
, "ERROR: scrub failed: %s", strerror(errno
));
1190 ret
= pthread_attr_init(&t_attr
);
1192 ERR(!do_quiet
, "ERROR: pthread_attr_init failed: %s\n",
1198 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1199 devid
= di_args
[i
].devid
;
1200 ret
= pthread_mutex_init(&sp
[i
].progress_mutex
, NULL
);
1202 ERR(!do_quiet
, "ERROR: pthread_mutex_init failed: "
1203 "%s\n", strerror(ret
));
1207 last_scrub
= last_dev_scrub(past_scrubs
, devid
);
1208 sp
[i
].scrub_args
.devid
= devid
;
1210 if (resume
&& last_scrub
&& (last_scrub
->stats
.canceled
||
1211 !last_scrub
->stats
.finished
)) {
1213 sp
[i
].scrub_args
.start
= last_scrub
->p
.last_physical
;
1214 sp
[i
].resumed
= last_scrub
;
1215 } else if (resume
) {
1218 sp
[i
].resumed
= last_scrub
;
1222 sp
[i
].scrub_args
.start
= 0ll;
1223 sp
[i
].resumed
= NULL
;
1226 sp
[i
].scrub_args
.end
= (u64
)-1ll;
1227 sp
[i
].scrub_args
.flags
= readonly
? BTRFS_SCRUB_READONLY
: 0;
1230 if (!n_start
&& !n_resume
) {
1232 printf("scrub: nothing to resume for %s, fsid %s\n",
1238 ret
= prg_fd
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1240 ret
= scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH
, fsid
, NULL
,
1241 sock_path
, sizeof(sock_path
));
1242 /* ignore EOVERFLOW, try using a shorter path for the socket */
1243 addr
.sun_path
[sizeof(addr
.sun_path
) - 1] = '\0';
1244 strncpy(addr
.sun_path
, sock_path
, sizeof(addr
.sun_path
) - 1);
1245 ret
= bind(prg_fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
1246 if (ret
!= -1 || errno
!= EADDRINUSE
)
1249 * bind failed with EADDRINUSE. so let's see if anyone answers
1250 * when we make a call to the socket ...
1252 ret
= connect(prg_fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
1253 if (!ret
|| errno
!= ECONNREFUSED
) {
1254 /* ... yes, so scrub must be running. error out */
1255 fprintf(stderr
, "ERROR: scrub already running\n");
1260 * ... no, this means someone left us alone with an unused
1261 * socket in the file system. remove it and try again.
1263 ret
= unlink(sock_path
);
1266 ret
= listen(prg_fd
, 100);
1268 ERR(!do_quiet
, "WARNING: failed to open the progress status "
1269 "socket at %s: %s. Progress cannot be queried\n",
1270 sock_path
[0] ? sock_path
: SCRUB_PROGRESS_SOCKET_PATH
,
1281 /* write all-zero progress file for a start */
1282 ret
= scrub_write_progress(&spc_write_mutex
, fsid
, sp
,
1283 fi_args
.num_devices
);
1285 ERR(!do_quiet
, "WARNING: failed to write the progress "
1286 "status file: %s. Status recording disabled\n",
1292 if (do_background
) {
1295 ERR(!do_quiet
, "ERROR: cannot scrub, fork failed: "
1296 "%s\n", strerror(errno
));
1303 scrub_handle_sigint_parent();
1305 printf("scrub %s on %s, fsid %s (pid=%d)\n",
1306 n_start
? "started" : "resumed",
1314 ERR(!do_quiet
, "ERROR: wait failed: (ret=%d) "
1315 "%s\n", ret
, strerror(errno
));
1319 if (!WIFEXITED(stat
) || WEXITSTATUS(stat
)) {
1320 ERR(!do_quiet
, "ERROR: scrub process failed\n");
1321 err
= WIFEXITED(stat
) ? WEXITSTATUS(stat
) : -1;
1329 scrub_handle_sigint_child(fdmnt
);
1331 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1333 sp
[i
].scrub_args
.progress
= sp
[i
].resumed
->p
;
1334 sp
[i
].stats
= sp
[i
].resumed
->stats
;
1336 sp
[i
].stats
.finished
= 1;
1339 devid
= di_args
[i
].devid
;
1340 gettimeofday(&tv
, NULL
);
1341 sp
[i
].stats
.t_start
= tv
.tv_sec
;
1342 ret
= pthread_create(&t_devs
[i
], &t_attr
,
1343 scrub_one_dev
, &sp
[i
]);
1346 fprintf(stderr
, "ERROR: creating "
1347 "scrub_one_dev[%llu] thread failed: "
1348 "%s\n", devid
, strerror(ret
));
1355 spc
.prg_fd
= prg_fd
;
1356 spc
.do_record
= do_record
;
1357 spc
.write_mutex
= &spc_write_mutex
;
1358 spc
.shared_progress
= sp
;
1360 ret
= pthread_create(&t_prog
, &t_attr
, scrub_progress_cycle
, &spc
);
1363 fprintf(stderr
, "ERROR: creating progress thread "
1364 "failed: %s\n", strerror(ret
));
1370 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1373 devid
= di_args
[i
].devid
;
1374 ret
= pthread_join(t_devs
[i
], NULL
);
1377 fprintf(stderr
, "ERROR: pthread_join failed "
1378 "for scrub_one_dev[%llu]: %s\n", devid
,
1383 if (sp
[i
].ret
&& sp
[i
].ioctl_errno
== ENODEV
) {
1385 fprintf(stderr
, "WARNING: device %lld not "
1386 "present\n", devid
);
1389 if (sp
[i
].ret
&& sp
[i
].ioctl_errno
== ECANCELED
) {
1391 } else if (sp
[i
].ret
) {
1393 fprintf(stderr
, "ERROR: scrubbing %s failed "
1394 "for device id %lld (%s)\n", path
,
1395 devid
, strerror(sp
[i
].ioctl_errno
));
1399 if (sp
[i
].scrub_args
.progress
.uncorrectable_errors
> 0)
1401 if (sp
[i
].scrub_args
.progress
.corrected_errors
> 0
1402 || sp
[i
].scrub_args
.progress
.unverified_errors
> 0)
1407 const char *append
= "done";
1408 if (!do_stats_per_dev
)
1409 init_fs_stat(&fs_stat
);
1410 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1411 if (do_stats_per_dev
) {
1412 print_scrub_dev(&di_args
[i
],
1413 &sp
[i
].scrub_args
.progress
,
1415 sp
[i
].ret
? "canceled" : "done",
1419 append
= "canceled";
1420 add_to_fs_stat(&sp
[i
].scrub_args
.progress
,
1421 &sp
[i
].stats
, &fs_stat
);
1424 if (!do_stats_per_dev
) {
1425 printf("scrub %s for %s\n", append
, fsid
);
1426 print_fs_stat(&fs_stat
, print_raw
);
1430 ret
= pthread_cancel(t_prog
);
1432 ret
= pthread_join(t_prog
, &terr
);
1433 if (do_print
&& ret
) {
1434 fprintf(stderr
, "ERROR: progress thead handling failed: %s\n",
1438 if (do_print
&& terr
&& terr
!= PTHREAD_CANCELED
) {
1439 fprintf(stderr
, "ERROR: recording progress "
1440 "failed: %s\n", strerror(-PTR_ERR(terr
)));
1444 ret
= scrub_write_progress(&spc_write_mutex
, fsid
, sp
,
1445 fi_args
.num_devices
);
1446 if (ret
&& do_print
) {
1447 fprintf(stderr
, "ERROR: failed to record the result: "
1448 "%s\n", strerror(-ret
));
1452 scrub_handle_sigint_child(-1);
1455 free_history(past_scrubs
);
1471 if (e_uncorrectable
)
1476 int do_scrub_start(int argc
, char **argv
)
1478 return scrub_start(argc
, argv
, 0);
1481 int do_scrub_resume(int argc
, char **argv
)
1483 return scrub_start(argc
, argv
, 1);
1486 int do_scrub_cancel(int argc
, char **argv
)
1488 char *path
= argv
[1];
1492 char mp
[BTRFS_PATH_NAME_MAX
+ 1];
1493 struct btrfs_fs_devices
*fs_devices_mnt
= NULL
;
1495 fdmnt
= open_file_or_dir(path
);
1497 fprintf(stderr
, "ERROR: scrub cancel failed\n");
1502 ret
= ioctl(fdmnt
, BTRFS_IOC_SCRUB_CANCEL
, NULL
);
1506 if (ret
&& err
== EINVAL
) {
1507 /* path is no mounted btrfs. try if it's a device */
1508 ret
= check_mounted_where(fdmnt
, path
, mp
, sizeof(mp
),
1512 fdmnt
= open_file_or_dir(mp
);
1521 fprintf(stderr
, "ERROR: scrub cancel failed on %s: %s\n", path
,
1522 err
== ENOTCONN
? "not running" : strerror(errno
));
1526 printf("scrub cancelled\n");
1531 int do_scrub_status(int argc
, char **argv
)
1535 struct btrfs_ioctl_fs_info_args fi_args
;
1536 struct btrfs_ioctl_dev_info_args
*di_args
= NULL
;
1537 struct scrub_file_record
**past_scrubs
= NULL
;
1538 struct scrub_file_record
*last_scrub
;
1539 struct scrub_fs_stat fs_stat
;
1540 struct sockaddr_un addr
= {
1541 .sun_family
= AF_UNIX
,
1548 int do_stats_per_dev
= 0;
1554 while ((c
= getopt(argc
, argv
, "dR")) != -1) {
1557 do_stats_per_dev
= 1;
1564 fprintf(stderr
, "ERROR: scrub status args invalid.\n"
1565 " -d stats per device\n");
1570 if (optind
+ 1 != argc
) {
1571 fprintf(stderr
, "ERROR: scrub status needs path as last "
1576 path
= argv
[optind
];
1578 fdmnt
= open_file_or_dir(path
);
1580 fprintf(stderr
, "ERROR: can't access to '%s'\n", path
);
1584 ret
= scrub_fs_info(fdmnt
, path
, &fi_args
, &di_args
);
1586 fprintf(stderr
, "ERROR: getting dev info for scrub failed: "
1587 "%s\n", strerror(-ret
));
1591 if (!fi_args
.num_devices
) {
1592 fprintf(stderr
, "ERROR: no devices found\n");
1597 uuid_unparse(fi_args
.fsid
, fsid
);
1599 fdres
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1601 fprintf(stderr
, "ERROR: failed to create socket to "
1602 "receive progress information: %s\n",
1607 scrub_datafile(SCRUB_PROGRESS_SOCKET_PATH
, fsid
,
1608 NULL
, addr
.sun_path
, sizeof(addr
.sun_path
));
1609 /* ignore EOVERFLOW, just use shorter name and hope for the best */
1610 addr
.sun_path
[sizeof(addr
.sun_path
) - 1] = '\0';
1611 ret
= connect(fdres
, (struct sockaddr
*)&addr
, sizeof(addr
));
1613 fdres
= scrub_open_file_r(SCRUB_DATA_FILE
, fsid
);
1614 if (fdres
< 0 && fdres
!= -ENOENT
) {
1615 fprintf(stderr
, "WARNING: failed to open status file: "
1616 "%s\n", strerror(-fdres
));
1623 past_scrubs
= scrub_read_file(fdres
, 1);
1624 if (IS_ERR(past_scrubs
))
1625 fprintf(stderr
, "WARNING: failed to read status: %s\n",
1626 strerror(-PTR_ERR(past_scrubs
)));
1629 printf("scrub status for %s\n", fsid
);
1631 if (do_stats_per_dev
) {
1632 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1633 last_scrub
= last_dev_scrub(past_scrubs
,
1636 print_scrub_dev(&di_args
[i
], NULL
, print_raw
,
1640 print_scrub_dev(&di_args
[i
], &last_scrub
->p
, print_raw
,
1641 last_scrub
->stats
.finished
?
1642 "history" : "status",
1643 &last_scrub
->stats
);
1646 init_fs_stat(&fs_stat
);
1647 for (i
= 0; i
< fi_args
.num_devices
; ++i
) {
1648 last_scrub
= last_dev_scrub(past_scrubs
,
1652 add_to_fs_stat(&last_scrub
->p
, &last_scrub
->stats
,
1655 print_fs_stat(&fs_stat
, print_raw
);
1659 free_history(past_scrubs
);