1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) STRATO AG 2012. All rights reserved.
6 #include <linux/sched.h>
8 #include <linux/slab.h>
9 #include <linux/blkdev.h>
10 #include <linux/kthread.h>
11 #include <linux/math64.h>
13 #include "extent_map.h"
15 #include "transaction.h"
16 #include "print-tree.h"
18 #include "async-thread.h"
19 #include "check-integrity.h"
20 #include "rcu-string.h"
21 #include "dev-replace.h"
24 static int btrfs_dev_replace_finishing(struct btrfs_fs_info
*fs_info
,
26 static void btrfs_dev_replace_update_device_in_mapping_tree(
27 struct btrfs_fs_info
*fs_info
,
28 struct btrfs_device
*srcdev
,
29 struct btrfs_device
*tgtdev
);
30 static int btrfs_dev_replace_kthread(void *data
);
32 int btrfs_init_dev_replace(struct btrfs_fs_info
*fs_info
)
35 struct btrfs_root
*dev_root
= fs_info
->dev_root
;
36 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
37 struct extent_buffer
*eb
;
40 struct btrfs_path
*path
= NULL
;
42 struct btrfs_dev_replace_item
*ptr
;
45 path
= btrfs_alloc_path();
52 key
.type
= BTRFS_DEV_REPLACE_KEY
;
54 ret
= btrfs_search_slot(NULL
, dev_root
, &key
, path
, 0, 0);
56 no_valid_dev_replace_entry_found
:
58 dev_replace
->replace_state
=
59 BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED
;
60 dev_replace
->cont_reading_from_srcdev_mode
=
61 BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS
;
62 dev_replace
->time_started
= 0;
63 dev_replace
->time_stopped
= 0;
64 atomic64_set(&dev_replace
->num_write_errors
, 0);
65 atomic64_set(&dev_replace
->num_uncorrectable_read_errors
, 0);
66 dev_replace
->cursor_left
= 0;
67 dev_replace
->committed_cursor_left
= 0;
68 dev_replace
->cursor_left_last_write_of_item
= 0;
69 dev_replace
->cursor_right
= 0;
70 dev_replace
->srcdev
= NULL
;
71 dev_replace
->tgtdev
= NULL
;
72 dev_replace
->is_valid
= 0;
73 dev_replace
->item_needs_writeback
= 0;
76 slot
= path
->slots
[0];
78 item_size
= btrfs_item_size_nr(eb
, slot
);
79 ptr
= btrfs_item_ptr(eb
, slot
, struct btrfs_dev_replace_item
);
81 if (item_size
!= sizeof(struct btrfs_dev_replace_item
)) {
83 "dev_replace entry found has unexpected size, ignore entry");
84 goto no_valid_dev_replace_entry_found
;
87 src_devid
= btrfs_dev_replace_src_devid(eb
, ptr
);
88 dev_replace
->cont_reading_from_srcdev_mode
=
89 btrfs_dev_replace_cont_reading_from_srcdev_mode(eb
, ptr
);
90 dev_replace
->replace_state
= btrfs_dev_replace_replace_state(eb
, ptr
);
91 dev_replace
->time_started
= btrfs_dev_replace_time_started(eb
, ptr
);
92 dev_replace
->time_stopped
=
93 btrfs_dev_replace_time_stopped(eb
, ptr
);
94 atomic64_set(&dev_replace
->num_write_errors
,
95 btrfs_dev_replace_num_write_errors(eb
, ptr
));
96 atomic64_set(&dev_replace
->num_uncorrectable_read_errors
,
97 btrfs_dev_replace_num_uncorrectable_read_errors(eb
, ptr
));
98 dev_replace
->cursor_left
= btrfs_dev_replace_cursor_left(eb
, ptr
);
99 dev_replace
->committed_cursor_left
= dev_replace
->cursor_left
;
100 dev_replace
->cursor_left_last_write_of_item
= dev_replace
->cursor_left
;
101 dev_replace
->cursor_right
= btrfs_dev_replace_cursor_right(eb
, ptr
);
102 dev_replace
->is_valid
= 1;
104 dev_replace
->item_needs_writeback
= 0;
105 switch (dev_replace
->replace_state
) {
106 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
107 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
108 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
109 dev_replace
->srcdev
= NULL
;
110 dev_replace
->tgtdev
= NULL
;
112 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
113 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
114 dev_replace
->srcdev
= btrfs_find_device(fs_info
->fs_devices
,
115 src_devid
, NULL
, NULL
, true);
116 dev_replace
->tgtdev
= btrfs_find_device(fs_info
->fs_devices
,
117 BTRFS_DEV_REPLACE_DEVID
,
120 * allow 'btrfs dev replace_cancel' if src/tgt device is
123 if (!dev_replace
->srcdev
&&
124 !btrfs_test_opt(fs_info
, DEGRADED
)) {
127 "cannot mount because device replace operation is ongoing and");
129 "srcdev (devid %llu) is missing, need to run 'btrfs dev scan'?",
132 if (!dev_replace
->tgtdev
&&
133 !btrfs_test_opt(fs_info
, DEGRADED
)) {
136 "cannot mount because device replace operation is ongoing and");
138 "tgtdev (devid %llu) is missing, need to run 'btrfs dev scan'?",
139 BTRFS_DEV_REPLACE_DEVID
);
141 if (dev_replace
->tgtdev
) {
142 if (dev_replace
->srcdev
) {
143 dev_replace
->tgtdev
->total_bytes
=
144 dev_replace
->srcdev
->total_bytes
;
145 dev_replace
->tgtdev
->disk_total_bytes
=
146 dev_replace
->srcdev
->disk_total_bytes
;
147 dev_replace
->tgtdev
->commit_total_bytes
=
148 dev_replace
->srcdev
->commit_total_bytes
;
149 dev_replace
->tgtdev
->bytes_used
=
150 dev_replace
->srcdev
->bytes_used
;
151 dev_replace
->tgtdev
->commit_bytes_used
=
152 dev_replace
->srcdev
->commit_bytes_used
;
154 set_bit(BTRFS_DEV_STATE_REPLACE_TGT
,
155 &dev_replace
->tgtdev
->dev_state
);
157 WARN_ON(fs_info
->fs_devices
->rw_devices
== 0);
158 dev_replace
->tgtdev
->io_width
= fs_info
->sectorsize
;
159 dev_replace
->tgtdev
->io_align
= fs_info
->sectorsize
;
160 dev_replace
->tgtdev
->sector_size
= fs_info
->sectorsize
;
161 dev_replace
->tgtdev
->fs_info
= fs_info
;
162 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA
,
163 &dev_replace
->tgtdev
->dev_state
);
169 btrfs_free_path(path
);
174 * Initialize a new device for device replace target from a given source dev
177 * Return 0 and new device in @device_out, otherwise return < 0
179 static int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info
*fs_info
,
180 const char *device_path
,
181 struct btrfs_device
*srcdev
,
182 struct btrfs_device
**device_out
)
184 struct btrfs_device
*device
;
185 struct block_device
*bdev
;
186 struct list_head
*devices
;
187 struct rcu_string
*name
;
188 u64 devid
= BTRFS_DEV_REPLACE_DEVID
;
192 if (fs_info
->fs_devices
->seeding
) {
193 btrfs_err(fs_info
, "the filesystem is a seed filesystem!");
197 bdev
= blkdev_get_by_path(device_path
, FMODE_WRITE
| FMODE_EXCL
,
198 fs_info
->bdev_holder
);
200 btrfs_err(fs_info
, "target device %s is invalid!", device_path
);
201 return PTR_ERR(bdev
);
204 filemap_write_and_wait(bdev
->bd_inode
->i_mapping
);
206 devices
= &fs_info
->fs_devices
->devices
;
207 list_for_each_entry(device
, devices
, dev_list
) {
208 if (device
->bdev
== bdev
) {
210 "target device is in the filesystem!");
217 if (i_size_read(bdev
->bd_inode
) <
218 btrfs_device_get_total_bytes(srcdev
)) {
220 "target device is smaller than source device!");
226 device
= btrfs_alloc_device(NULL
, &devid
, NULL
);
227 if (IS_ERR(device
)) {
228 ret
= PTR_ERR(device
);
232 name
= rcu_string_strdup(device_path
, GFP_KERNEL
);
234 btrfs_free_device(device
);
238 rcu_assign_pointer(device
->name
, name
);
240 mutex_lock(&fs_info
->fs_devices
->device_list_mutex
);
241 set_bit(BTRFS_DEV_STATE_WRITEABLE
, &device
->dev_state
);
242 device
->generation
= 0;
243 device
->io_width
= fs_info
->sectorsize
;
244 device
->io_align
= fs_info
->sectorsize
;
245 device
->sector_size
= fs_info
->sectorsize
;
246 device
->total_bytes
= btrfs_device_get_total_bytes(srcdev
);
247 device
->disk_total_bytes
= btrfs_device_get_disk_total_bytes(srcdev
);
248 device
->bytes_used
= btrfs_device_get_bytes_used(srcdev
);
249 device
->commit_total_bytes
= srcdev
->commit_total_bytes
;
250 device
->commit_bytes_used
= device
->bytes_used
;
251 device
->fs_info
= fs_info
;
253 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA
, &device
->dev_state
);
254 set_bit(BTRFS_DEV_STATE_REPLACE_TGT
, &device
->dev_state
);
255 device
->mode
= FMODE_EXCL
;
256 device
->dev_stats_valid
= 1;
257 set_blocksize(device
->bdev
, BTRFS_BDEV_BLOCKSIZE
);
258 device
->fs_devices
= fs_info
->fs_devices
;
259 list_add(&device
->dev_list
, &fs_info
->fs_devices
->devices
);
260 fs_info
->fs_devices
->num_devices
++;
261 fs_info
->fs_devices
->open_devices
++;
262 mutex_unlock(&fs_info
->fs_devices
->device_list_mutex
);
264 *device_out
= device
;
268 blkdev_put(bdev
, FMODE_EXCL
);
273 * called from commit_transaction. Writes changed device replace state to
276 int btrfs_run_dev_replace(struct btrfs_trans_handle
*trans
,
277 struct btrfs_fs_info
*fs_info
)
280 struct btrfs_root
*dev_root
= fs_info
->dev_root
;
281 struct btrfs_path
*path
;
282 struct btrfs_key key
;
283 struct extent_buffer
*eb
;
284 struct btrfs_dev_replace_item
*ptr
;
285 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
287 down_read(&dev_replace
->rwsem
);
288 if (!dev_replace
->is_valid
||
289 !dev_replace
->item_needs_writeback
) {
290 up_read(&dev_replace
->rwsem
);
293 up_read(&dev_replace
->rwsem
);
296 key
.type
= BTRFS_DEV_REPLACE_KEY
;
299 path
= btrfs_alloc_path();
304 ret
= btrfs_search_slot(trans
, dev_root
, &key
, path
, -1, 1);
307 "error %d while searching for dev_replace item!",
313 btrfs_item_size_nr(path
->nodes
[0], path
->slots
[0]) < sizeof(*ptr
)) {
315 * need to delete old one and insert a new one.
316 * Since no attempt is made to recover any old state, if the
317 * dev_replace state is 'running', the data on the target
319 * It would be possible to recover the state: just make sure
320 * that the beginning of the item is never changed and always
321 * contains all the essential information. Then read this
322 * minimal set of information and use it as a base for the
325 ret
= btrfs_del_item(trans
, dev_root
, path
);
328 "delete too small dev_replace item failed %d!",
336 /* need to insert a new item */
337 btrfs_release_path(path
);
338 ret
= btrfs_insert_empty_item(trans
, dev_root
, path
,
342 "insert dev_replace item failed %d!", ret
);
348 ptr
= btrfs_item_ptr(eb
, path
->slots
[0],
349 struct btrfs_dev_replace_item
);
351 down_write(&dev_replace
->rwsem
);
352 if (dev_replace
->srcdev
)
353 btrfs_set_dev_replace_src_devid(eb
, ptr
,
354 dev_replace
->srcdev
->devid
);
356 btrfs_set_dev_replace_src_devid(eb
, ptr
, (u64
)-1);
357 btrfs_set_dev_replace_cont_reading_from_srcdev_mode(eb
, ptr
,
358 dev_replace
->cont_reading_from_srcdev_mode
);
359 btrfs_set_dev_replace_replace_state(eb
, ptr
,
360 dev_replace
->replace_state
);
361 btrfs_set_dev_replace_time_started(eb
, ptr
, dev_replace
->time_started
);
362 btrfs_set_dev_replace_time_stopped(eb
, ptr
, dev_replace
->time_stopped
);
363 btrfs_set_dev_replace_num_write_errors(eb
, ptr
,
364 atomic64_read(&dev_replace
->num_write_errors
));
365 btrfs_set_dev_replace_num_uncorrectable_read_errors(eb
, ptr
,
366 atomic64_read(&dev_replace
->num_uncorrectable_read_errors
));
367 dev_replace
->cursor_left_last_write_of_item
=
368 dev_replace
->cursor_left
;
369 btrfs_set_dev_replace_cursor_left(eb
, ptr
,
370 dev_replace
->cursor_left_last_write_of_item
);
371 btrfs_set_dev_replace_cursor_right(eb
, ptr
,
372 dev_replace
->cursor_right
);
373 dev_replace
->item_needs_writeback
= 0;
374 up_write(&dev_replace
->rwsem
);
376 btrfs_mark_buffer_dirty(eb
);
379 btrfs_free_path(path
);
384 static char* btrfs_dev_name(struct btrfs_device
*device
)
386 if (!device
|| test_bit(BTRFS_DEV_STATE_MISSING
, &device
->dev_state
))
387 return "<missing disk>";
389 return rcu_str_deref(device
->name
);
392 static int btrfs_dev_replace_start(struct btrfs_fs_info
*fs_info
,
393 const char *tgtdev_name
, u64 srcdevid
, const char *srcdev_name
,
396 struct btrfs_root
*root
= fs_info
->dev_root
;
397 struct btrfs_trans_handle
*trans
;
398 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
400 struct btrfs_device
*tgt_device
= NULL
;
401 struct btrfs_device
*src_device
= NULL
;
404 src_device
= btrfs_find_device_by_devspec(fs_info
, srcdevid
,
406 if (IS_ERR(src_device
))
407 return PTR_ERR(src_device
);
409 if (btrfs_pinned_by_swapfile(fs_info
, src_device
)) {
410 btrfs_warn_in_rcu(fs_info
,
411 "cannot replace device %s (devid %llu) due to active swapfile",
412 btrfs_dev_name(src_device
), src_device
->devid
);
416 ret
= btrfs_init_dev_replace_tgtdev(fs_info
, tgtdev_name
,
417 src_device
, &tgt_device
);
422 * Here we commit the transaction to make sure commit_total_bytes
423 * of all the devices are updated.
425 trans
= btrfs_attach_transaction(root
);
426 if (!IS_ERR(trans
)) {
427 ret
= btrfs_commit_transaction(trans
);
430 } else if (PTR_ERR(trans
) != -ENOENT
) {
431 return PTR_ERR(trans
);
435 down_write(&dev_replace
->rwsem
);
436 switch (dev_replace
->replace_state
) {
437 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
438 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
439 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
441 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
442 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
444 ret
= BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED
;
448 dev_replace
->cont_reading_from_srcdev_mode
= read_src
;
449 WARN_ON(!src_device
);
450 dev_replace
->srcdev
= src_device
;
451 dev_replace
->tgtdev
= tgt_device
;
453 btrfs_info_in_rcu(fs_info
,
454 "dev_replace from %s (devid %llu) to %s started",
455 btrfs_dev_name(src_device
),
457 rcu_str_deref(tgt_device
->name
));
460 * from now on, the writes to the srcdev are all duplicated to
461 * go to the tgtdev as well (refer to btrfs_map_block()).
463 dev_replace
->replace_state
= BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
;
464 dev_replace
->time_started
= ktime_get_real_seconds();
465 dev_replace
->cursor_left
= 0;
466 dev_replace
->committed_cursor_left
= 0;
467 dev_replace
->cursor_left_last_write_of_item
= 0;
468 dev_replace
->cursor_right
= 0;
469 dev_replace
->is_valid
= 1;
470 dev_replace
->item_needs_writeback
= 1;
471 atomic64_set(&dev_replace
->num_write_errors
, 0);
472 atomic64_set(&dev_replace
->num_uncorrectable_read_errors
, 0);
473 up_write(&dev_replace
->rwsem
);
476 ret
= btrfs_sysfs_add_device_link(tgt_device
->fs_devices
, tgt_device
);
478 btrfs_err(fs_info
, "kobj add dev failed %d", ret
);
480 btrfs_wait_ordered_roots(fs_info
, U64_MAX
, 0, (u64
)-1);
482 /* force writing the updated state information to disk */
483 trans
= btrfs_start_transaction(root
, 0);
485 ret
= PTR_ERR(trans
);
487 down_write(&dev_replace
->rwsem
);
488 dev_replace
->replace_state
=
489 BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
;
490 dev_replace
->srcdev
= NULL
;
491 dev_replace
->tgtdev
= NULL
;
495 ret
= btrfs_commit_transaction(trans
);
498 /* the disk copy procedure reuses the scrub code */
499 ret
= btrfs_scrub_dev(fs_info
, src_device
->devid
, 0,
500 btrfs_device_get_total_bytes(src_device
),
501 &dev_replace
->scrub_progress
, 0, 1);
503 ret
= btrfs_dev_replace_finishing(fs_info
, ret
);
504 if (ret
== -EINPROGRESS
) {
505 ret
= BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS
;
506 } else if (ret
!= -ECANCELED
) {
514 up_write(&dev_replace
->rwsem
);
515 btrfs_destroy_dev_replace_tgtdev(tgt_device
);
519 int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info
*fs_info
,
520 struct btrfs_ioctl_dev_replace_args
*args
)
524 switch (args
->start
.cont_reading_from_srcdev_mode
) {
525 case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS
:
526 case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID
:
532 if ((args
->start
.srcdevid
== 0 && args
->start
.srcdev_name
[0] == '\0') ||
533 args
->start
.tgtdev_name
[0] == '\0')
536 ret
= btrfs_dev_replace_start(fs_info
, args
->start
.tgtdev_name
,
537 args
->start
.srcdevid
,
538 args
->start
.srcdev_name
,
539 args
->start
.cont_reading_from_srcdev_mode
);
541 /* don't warn if EINPROGRESS, someone else might be running scrub */
542 if (ret
== BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS
||
543 ret
== BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
)
550 * blocked until all in-flight bios operations are finished.
552 static void btrfs_rm_dev_replace_blocked(struct btrfs_fs_info
*fs_info
)
554 set_bit(BTRFS_FS_STATE_DEV_REPLACING
, &fs_info
->fs_state
);
555 wait_event(fs_info
->dev_replace
.replace_wait
, !percpu_counter_sum(
556 &fs_info
->dev_replace
.bio_counter
));
560 * we have removed target device, it is safe to allow new bios request.
562 static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info
*fs_info
)
564 clear_bit(BTRFS_FS_STATE_DEV_REPLACING
, &fs_info
->fs_state
);
565 wake_up(&fs_info
->dev_replace
.replace_wait
);
568 static int btrfs_dev_replace_finishing(struct btrfs_fs_info
*fs_info
,
571 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
572 struct btrfs_device
*tgt_device
;
573 struct btrfs_device
*src_device
;
574 struct btrfs_root
*root
= fs_info
->tree_root
;
575 u8 uuid_tmp
[BTRFS_UUID_SIZE
];
576 struct btrfs_trans_handle
*trans
;
579 /* don't allow cancel or unmount to disturb the finishing procedure */
580 mutex_lock(&dev_replace
->lock_finishing_cancel_unmount
);
582 down_read(&dev_replace
->rwsem
);
583 /* was the operation canceled, or is it finished? */
584 if (dev_replace
->replace_state
!=
585 BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
) {
586 up_read(&dev_replace
->rwsem
);
587 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
591 tgt_device
= dev_replace
->tgtdev
;
592 src_device
= dev_replace
->srcdev
;
593 up_read(&dev_replace
->rwsem
);
596 * flush all outstanding I/O and inode extent mappings before the
597 * copy operation is declared as being finished
599 ret
= btrfs_start_delalloc_roots(fs_info
, -1);
601 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
604 btrfs_wait_ordered_roots(fs_info
, U64_MAX
, 0, (u64
)-1);
606 trans
= btrfs_start_transaction(root
, 0);
608 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
609 return PTR_ERR(trans
);
611 ret
= btrfs_commit_transaction(trans
);
614 /* keep away write_all_supers() during the finishing procedure */
615 mutex_lock(&fs_info
->fs_devices
->device_list_mutex
);
616 mutex_lock(&fs_info
->chunk_mutex
);
617 down_write(&dev_replace
->rwsem
);
618 dev_replace
->replace_state
=
619 scrub_ret
? BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
620 : BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
;
621 dev_replace
->tgtdev
= NULL
;
622 dev_replace
->srcdev
= NULL
;
623 dev_replace
->time_stopped
= ktime_get_real_seconds();
624 dev_replace
->item_needs_writeback
= 1;
626 /* replace old device with new one in mapping tree */
628 btrfs_dev_replace_update_device_in_mapping_tree(fs_info
,
632 if (scrub_ret
!= -ECANCELED
)
633 btrfs_err_in_rcu(fs_info
,
634 "btrfs_scrub_dev(%s, %llu, %s) failed %d",
635 btrfs_dev_name(src_device
),
637 rcu_str_deref(tgt_device
->name
), scrub_ret
);
638 up_write(&dev_replace
->rwsem
);
639 mutex_unlock(&fs_info
->chunk_mutex
);
640 mutex_unlock(&fs_info
->fs_devices
->device_list_mutex
);
641 btrfs_rm_dev_replace_blocked(fs_info
);
643 btrfs_destroy_dev_replace_tgtdev(tgt_device
);
644 btrfs_rm_dev_replace_unblocked(fs_info
);
645 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
650 btrfs_info_in_rcu(fs_info
,
651 "dev_replace from %s (devid %llu) to %s finished",
652 btrfs_dev_name(src_device
),
654 rcu_str_deref(tgt_device
->name
));
655 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT
, &tgt_device
->dev_state
);
656 tgt_device
->devid
= src_device
->devid
;
657 src_device
->devid
= BTRFS_DEV_REPLACE_DEVID
;
658 memcpy(uuid_tmp
, tgt_device
->uuid
, sizeof(uuid_tmp
));
659 memcpy(tgt_device
->uuid
, src_device
->uuid
, sizeof(tgt_device
->uuid
));
660 memcpy(src_device
->uuid
, uuid_tmp
, sizeof(src_device
->uuid
));
661 btrfs_device_set_total_bytes(tgt_device
, src_device
->total_bytes
);
662 btrfs_device_set_disk_total_bytes(tgt_device
,
663 src_device
->disk_total_bytes
);
664 btrfs_device_set_bytes_used(tgt_device
, src_device
->bytes_used
);
665 ASSERT(list_empty(&src_device
->resized_list
));
666 tgt_device
->commit_total_bytes
= src_device
->commit_total_bytes
;
667 tgt_device
->commit_bytes_used
= src_device
->bytes_used
;
669 btrfs_assign_next_active_device(src_device
, tgt_device
);
671 list_add(&tgt_device
->dev_alloc_list
, &fs_info
->fs_devices
->alloc_list
);
672 fs_info
->fs_devices
->rw_devices
++;
674 up_write(&dev_replace
->rwsem
);
675 btrfs_rm_dev_replace_blocked(fs_info
);
677 btrfs_rm_dev_replace_remove_srcdev(src_device
);
679 btrfs_rm_dev_replace_unblocked(fs_info
);
682 * Increment dev_stats_ccnt so that btrfs_run_dev_stats() will
683 * update on-disk dev stats value during commit transaction
685 atomic_inc(&tgt_device
->dev_stats_ccnt
);
688 * this is again a consistent state where no dev_replace procedure
689 * is running, the target device is part of the filesystem, the
690 * source device is not part of the filesystem anymore and its 1st
691 * superblock is scratched out so that it is no longer marked to
692 * belong to this filesystem.
694 mutex_unlock(&fs_info
->chunk_mutex
);
695 mutex_unlock(&fs_info
->fs_devices
->device_list_mutex
);
697 /* replace the sysfs entry */
698 btrfs_sysfs_rm_device_link(fs_info
->fs_devices
, src_device
);
699 btrfs_rm_dev_replace_free_srcdev(fs_info
, src_device
);
701 /* write back the superblocks */
702 trans
= btrfs_start_transaction(root
, 0);
704 btrfs_commit_transaction(trans
);
706 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
711 static void btrfs_dev_replace_update_device_in_mapping_tree(
712 struct btrfs_fs_info
*fs_info
,
713 struct btrfs_device
*srcdev
,
714 struct btrfs_device
*tgtdev
)
716 struct extent_map_tree
*em_tree
= &fs_info
->mapping_tree
.map_tree
;
717 struct extent_map
*em
;
718 struct map_lookup
*map
;
722 write_lock(&em_tree
->lock
);
724 em
= lookup_extent_mapping(em_tree
, start
, (u64
)-1);
727 map
= em
->map_lookup
;
728 for (i
= 0; i
< map
->num_stripes
; i
++)
729 if (srcdev
== map
->stripes
[i
].dev
)
730 map
->stripes
[i
].dev
= tgtdev
;
731 start
= em
->start
+ em
->len
;
734 write_unlock(&em_tree
->lock
);
738 * Read progress of device replace status according to the state and last
739 * stored position. The value format is the same as for
740 * btrfs_dev_replace::progress_1000
742 static u64
btrfs_dev_replace_progress(struct btrfs_fs_info
*fs_info
)
744 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
747 switch (dev_replace
->replace_state
) {
748 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
749 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
752 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
755 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
756 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
757 ret
= div64_u64(dev_replace
->cursor_left
,
758 div_u64(btrfs_device_get_total_bytes(
759 dev_replace
->srcdev
), 1000));
766 void btrfs_dev_replace_status(struct btrfs_fs_info
*fs_info
,
767 struct btrfs_ioctl_dev_replace_args
*args
)
769 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
771 down_read(&dev_replace
->rwsem
);
772 /* even if !dev_replace_is_valid, the values are good enough for
773 * the replace_status ioctl */
774 args
->result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
;
775 args
->status
.replace_state
= dev_replace
->replace_state
;
776 args
->status
.time_started
= dev_replace
->time_started
;
777 args
->status
.time_stopped
= dev_replace
->time_stopped
;
778 args
->status
.num_write_errors
=
779 atomic64_read(&dev_replace
->num_write_errors
);
780 args
->status
.num_uncorrectable_read_errors
=
781 atomic64_read(&dev_replace
->num_uncorrectable_read_errors
);
782 args
->status
.progress_1000
= btrfs_dev_replace_progress(fs_info
);
783 up_read(&dev_replace
->rwsem
);
786 int btrfs_dev_replace_cancel(struct btrfs_fs_info
*fs_info
)
788 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
789 struct btrfs_device
*tgt_device
= NULL
;
790 struct btrfs_device
*src_device
= NULL
;
791 struct btrfs_trans_handle
*trans
;
792 struct btrfs_root
*root
= fs_info
->tree_root
;
796 if (sb_rdonly(fs_info
->sb
))
799 mutex_lock(&dev_replace
->lock_finishing_cancel_unmount
);
800 down_write(&dev_replace
->rwsem
);
801 switch (dev_replace
->replace_state
) {
802 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
803 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
804 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
805 result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED
;
806 up_write(&dev_replace
->rwsem
);
808 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
809 tgt_device
= dev_replace
->tgtdev
;
810 src_device
= dev_replace
->srcdev
;
811 up_write(&dev_replace
->rwsem
);
812 ret
= btrfs_scrub_cancel(fs_info
);
814 result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED
;
816 result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
;
818 * btrfs_dev_replace_finishing() will handle the
821 btrfs_info_in_rcu(fs_info
,
822 "dev_replace from %s (devid %llu) to %s canceled",
823 btrfs_dev_name(src_device
), src_device
->devid
,
824 btrfs_dev_name(tgt_device
));
827 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
829 * Scrub doing the replace isn't running so we need to do the
830 * cleanup step of btrfs_dev_replace_finishing() here
832 result
= BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR
;
833 tgt_device
= dev_replace
->tgtdev
;
834 src_device
= dev_replace
->srcdev
;
835 dev_replace
->tgtdev
= NULL
;
836 dev_replace
->srcdev
= NULL
;
837 dev_replace
->replace_state
=
838 BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
;
839 dev_replace
->time_stopped
= ktime_get_real_seconds();
840 dev_replace
->item_needs_writeback
= 1;
842 up_write(&dev_replace
->rwsem
);
844 /* Scrub for replace must not be running in suspended state */
845 ret
= btrfs_scrub_cancel(fs_info
);
846 ASSERT(ret
!= -ENOTCONN
);
848 trans
= btrfs_start_transaction(root
, 0);
850 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
851 return PTR_ERR(trans
);
853 ret
= btrfs_commit_transaction(trans
);
856 btrfs_info_in_rcu(fs_info
,
857 "suspended dev_replace from %s (devid %llu) to %s canceled",
858 btrfs_dev_name(src_device
), src_device
->devid
,
859 btrfs_dev_name(tgt_device
));
862 btrfs_destroy_dev_replace_tgtdev(tgt_device
);
865 up_write(&dev_replace
->rwsem
);
869 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
873 void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info
*fs_info
)
875 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
877 mutex_lock(&dev_replace
->lock_finishing_cancel_unmount
);
878 down_write(&dev_replace
->rwsem
);
880 switch (dev_replace
->replace_state
) {
881 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
882 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
883 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
884 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
886 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
887 dev_replace
->replace_state
=
888 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
;
889 dev_replace
->time_stopped
= ktime_get_real_seconds();
890 dev_replace
->item_needs_writeback
= 1;
891 btrfs_info(fs_info
, "suspending dev_replace for unmount");
895 up_write(&dev_replace
->rwsem
);
896 mutex_unlock(&dev_replace
->lock_finishing_cancel_unmount
);
899 /* resume dev_replace procedure that was interrupted by unmount */
900 int btrfs_resume_dev_replace_async(struct btrfs_fs_info
*fs_info
)
902 struct task_struct
*task
;
903 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
905 down_write(&dev_replace
->rwsem
);
907 switch (dev_replace
->replace_state
) {
908 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
909 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
910 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
911 up_write(&dev_replace
->rwsem
);
913 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
915 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
916 dev_replace
->replace_state
=
917 BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
;
920 if (!dev_replace
->tgtdev
|| !dev_replace
->tgtdev
->bdev
) {
922 "cannot continue dev_replace, tgtdev is missing");
924 "you may cancel the operation after 'mount -o degraded'");
925 dev_replace
->replace_state
=
926 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
;
927 up_write(&dev_replace
->rwsem
);
930 up_write(&dev_replace
->rwsem
);
933 * This could collide with a paused balance, but the exclusive op logic
934 * should never allow both to start and pause. We don't want to allow
935 * dev-replace to start anyway.
937 if (test_and_set_bit(BTRFS_FS_EXCL_OP
, &fs_info
->flags
)) {
938 down_write(&dev_replace
->rwsem
);
939 dev_replace
->replace_state
=
940 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
;
941 up_write(&dev_replace
->rwsem
);
943 "cannot resume dev-replace, other exclusive operation running");
947 task
= kthread_run(btrfs_dev_replace_kthread
, fs_info
, "btrfs-devrepl");
948 return PTR_ERR_OR_ZERO(task
);
951 static int btrfs_dev_replace_kthread(void *data
)
953 struct btrfs_fs_info
*fs_info
= data
;
954 struct btrfs_dev_replace
*dev_replace
= &fs_info
->dev_replace
;
958 progress
= btrfs_dev_replace_progress(fs_info
);
959 progress
= div_u64(progress
, 10);
960 btrfs_info_in_rcu(fs_info
,
961 "continuing dev_replace from %s (devid %llu) to target %s @%u%%",
962 btrfs_dev_name(dev_replace
->srcdev
),
963 dev_replace
->srcdev
->devid
,
964 btrfs_dev_name(dev_replace
->tgtdev
),
965 (unsigned int)progress
);
967 ret
= btrfs_scrub_dev(fs_info
, dev_replace
->srcdev
->devid
,
968 dev_replace
->committed_cursor_left
,
969 btrfs_device_get_total_bytes(dev_replace
->srcdev
),
970 &dev_replace
->scrub_progress
, 0, 1);
971 ret
= btrfs_dev_replace_finishing(fs_info
, ret
);
972 WARN_ON(ret
&& ret
!= -ECANCELED
);
974 clear_bit(BTRFS_FS_EXCL_OP
, &fs_info
->flags
);
978 int btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace
*dev_replace
)
980 if (!dev_replace
->is_valid
)
983 switch (dev_replace
->replace_state
) {
984 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED
:
985 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED
:
986 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
:
988 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED
:
989 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED
:
991 * return true even if tgtdev is missing (this is
992 * something that can happen if the dev_replace
993 * procedure is suspended by an umount and then
994 * the tgtdev is missing (or "btrfs dev scan") was
995 * not called and the filesystem is remounted
996 * in degraded state. This does not stop the
997 * dev_replace procedure. It needs to be canceled
998 * manually if the cancellation is wanted.
1005 void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info
*fs_info
)
1007 percpu_counter_inc(&fs_info
->dev_replace
.bio_counter
);
1010 void btrfs_bio_counter_sub(struct btrfs_fs_info
*fs_info
, s64 amount
)
1012 percpu_counter_sub(&fs_info
->dev_replace
.bio_counter
, amount
);
1013 cond_wake_up_nomb(&fs_info
->dev_replace
.replace_wait
);
1016 void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info
*fs_info
)
1019 percpu_counter_inc(&fs_info
->dev_replace
.bio_counter
);
1020 if (likely(!test_bit(BTRFS_FS_STATE_DEV_REPLACING
,
1021 &fs_info
->fs_state
)))
1024 btrfs_bio_counter_dec(fs_info
);
1025 wait_event(fs_info
->dev_replace
.replace_wait
,
1026 !test_bit(BTRFS_FS_STATE_DEV_REPLACING
,
1027 &fs_info
->fs_state
));