1
2
3
4
5
6#include <linux/sched.h>
7#include <linux/bio.h>
8#include <linux/slab.h>
9#include <linux/blkdev.h>
10#include <linux/kthread.h>
11#include <linux/math64.h>
12#include "ctree.h"
13#include "extent_map.h"
14#include "disk-io.h"
15#include "transaction.h"
16#include "print-tree.h"
17#include "volumes.h"
18#include "async-thread.h"
19#include "check-integrity.h"
20#include "rcu-string.h"
21#include "dev-replace.h"
22#include "sysfs.h"
23
24static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
25 int scrub_ret);
26static 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);
30static int btrfs_dev_replace_kthread(void *data);
31
32int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info)
33{
34 struct btrfs_key key;
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;
38 int slot;
39 int ret = 0;
40 struct btrfs_path *path = NULL;
41 int item_size;
42 struct btrfs_dev_replace_item *ptr;
43 u64 src_devid;
44
45 path = btrfs_alloc_path();
46 if (!path) {
47 ret = -ENOMEM;
48 goto out;
49 }
50
51 key.objectid = 0;
52 key.type = BTRFS_DEV_REPLACE_KEY;
53 key.offset = 0;
54 ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
55 if (ret) {
56no_valid_dev_replace_entry_found:
57 ret = 0;
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;
74 goto out;
75 }
76 slot = path->slots[0];
77 eb = path->nodes[0];
78 item_size = btrfs_item_size_nr(eb, slot);
79 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_replace_item);
80
81 if (item_size != sizeof(struct btrfs_dev_replace_item)) {
82 btrfs_warn(fs_info,
83 "dev_replace entry found has unexpected size, ignore entry");
84 goto no_valid_dev_replace_entry_found;
85 }
86
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;
103
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;
111 break;
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,
118 NULL, NULL, true);
119
120
121
122
123 if (!dev_replace->srcdev &&
124 !btrfs_test_opt(fs_info, DEGRADED)) {
125 ret = -EIO;
126 btrfs_warn(fs_info,
127 "cannot mount because device replace operation is ongoing and");
128 btrfs_warn(fs_info,
129 "srcdev (devid %llu) is missing, need to run 'btrfs dev scan'?",
130 src_devid);
131 }
132 if (!dev_replace->tgtdev &&
133 !btrfs_test_opt(fs_info, DEGRADED)) {
134 ret = -EIO;
135 btrfs_warn(fs_info,
136 "cannot mount because device replace operation is ongoing and");
137 btrfs_warn(fs_info,
138 "tgtdev (devid %llu) is missing, need to run 'btrfs dev scan'?",
139 BTRFS_DEV_REPLACE_DEVID);
140 }
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;
153 }
154 set_bit(BTRFS_DEV_STATE_REPLACE_TGT,
155 &dev_replace->tgtdev->dev_state);
156
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);
164 }
165 break;
166 }
167
168out:
169 btrfs_free_path(path);
170 return ret;
171}
172
173
174
175
176
177
178
179static 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)
183{
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;
189 int ret = 0;
190
191 *device_out = NULL;
192 if (fs_info->fs_devices->seeding) {
193 btrfs_err(fs_info, "the filesystem is a seed filesystem!");
194 return -EINVAL;
195 }
196
197 bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
198 fs_info->bdev_holder);
199 if (IS_ERR(bdev)) {
200 btrfs_err(fs_info, "target device %s is invalid!", device_path);
201 return PTR_ERR(bdev);
202 }
203
204 filemap_write_and_wait(bdev->bd_inode->i_mapping);
205
206 devices = &fs_info->fs_devices->devices;
207 list_for_each_entry(device, devices, dev_list) {
208 if (device->bdev == bdev) {
209 btrfs_err(fs_info,
210 "target device is in the filesystem!");
211 ret = -EEXIST;
212 goto error;
213 }
214 }
215
216
217 if (i_size_read(bdev->bd_inode) <
218 btrfs_device_get_total_bytes(srcdev)) {
219 btrfs_err(fs_info,
220 "target device is smaller than source device!");
221 ret = -EINVAL;
222 goto error;
223 }
224
225
226 device = btrfs_alloc_device(NULL, &devid, NULL);
227 if (IS_ERR(device)) {
228 ret = PTR_ERR(device);
229 goto error;
230 }
231
232 name = rcu_string_strdup(device_path, GFP_KERNEL);
233 if (!name) {
234 btrfs_free_device(device);
235 ret = -ENOMEM;
236 goto error;
237 }
238 rcu_assign_pointer(device->name, name);
239
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;
252 device->bdev = bdev;
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);
263
264 *device_out = device;
265 return 0;
266
267error:
268 blkdev_put(bdev, FMODE_EXCL);
269 return ret;
270}
271
272
273
274
275
276int btrfs_run_dev_replace(struct btrfs_trans_handle *trans)
277{
278 struct btrfs_fs_info *fs_info = trans->fs_info;
279 int ret;
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;
286
287 down_read(&dev_replace->rwsem);
288 if (!dev_replace->is_valid ||
289 !dev_replace->item_needs_writeback) {
290 up_read(&dev_replace->rwsem);
291 return 0;
292 }
293 up_read(&dev_replace->rwsem);
294
295 key.objectid = 0;
296 key.type = BTRFS_DEV_REPLACE_KEY;
297 key.offset = 0;
298
299 path = btrfs_alloc_path();
300 if (!path) {
301 ret = -ENOMEM;
302 goto out;
303 }
304 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
305 if (ret < 0) {
306 btrfs_warn(fs_info,
307 "error %d while searching for dev_replace item!",
308 ret);
309 goto out;
310 }
311
312 if (ret == 0 &&
313 btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
314
315
316
317
318
319
320
321
322
323
324
325 ret = btrfs_del_item(trans, dev_root, path);
326 if (ret != 0) {
327 btrfs_warn(fs_info,
328 "delete too small dev_replace item failed %d!",
329 ret);
330 goto out;
331 }
332 ret = 1;
333 }
334
335 if (ret == 1) {
336
337 btrfs_release_path(path);
338 ret = btrfs_insert_empty_item(trans, dev_root, path,
339 &key, sizeof(*ptr));
340 if (ret < 0) {
341 btrfs_warn(fs_info,
342 "insert dev_replace item failed %d!", ret);
343 goto out;
344 }
345 }
346
347 eb = path->nodes[0];
348 ptr = btrfs_item_ptr(eb, path->slots[0],
349 struct btrfs_dev_replace_item);
350
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);
355 else
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);
375
376 btrfs_mark_buffer_dirty(eb);
377
378out:
379 btrfs_free_path(path);
380
381 return ret;
382}
383
384static char* btrfs_dev_name(struct btrfs_device *device)
385{
386 if (!device || test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))
387 return "<missing disk>";
388 else
389 return rcu_str_deref(device->name);
390}
391
392static int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,
393 const char *tgtdev_name, u64 srcdevid, const char *srcdev_name,
394 int read_src)
395{
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;
399 int ret;
400 struct btrfs_device *tgt_device = NULL;
401 struct btrfs_device *src_device = NULL;
402 bool need_unlock;
403
404 src_device = btrfs_find_device_by_devspec(fs_info, srcdevid,
405 srcdev_name);
406 if (IS_ERR(src_device))
407 return PTR_ERR(src_device);
408
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);
413 return -ETXTBSY;
414 }
415
416 ret = btrfs_init_dev_replace_tgtdev(fs_info, tgtdev_name,
417 src_device, &tgt_device);
418 if (ret)
419 return ret;
420
421
422
423
424
425 trans = btrfs_attach_transaction(root);
426 if (!IS_ERR(trans)) {
427 ret = btrfs_commit_transaction(trans);
428 if (ret)
429 return ret;
430 } else if (PTR_ERR(trans) != -ENOENT) {
431 return PTR_ERR(trans);
432 }
433
434 need_unlock = true;
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:
440 break;
441 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
442 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
443 ASSERT(0);
444 ret = BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED;
445 goto leave;
446 }
447
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;
452
453 btrfs_info_in_rcu(fs_info,
454 "dev_replace from %s (devid %llu) to %s started",
455 btrfs_dev_name(src_device),
456 src_device->devid,
457 rcu_str_deref(tgt_device->name));
458
459
460
461
462
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);
474 need_unlock = false;
475
476 ret = btrfs_sysfs_add_device_link(tgt_device->fs_devices, tgt_device);
477 if (ret)
478 btrfs_err(fs_info, "kobj add dev failed %d", ret);
479
480 btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
481
482
483 trans = btrfs_start_transaction(root, 0);
484 if (IS_ERR(trans)) {
485 ret = PTR_ERR(trans);
486 need_unlock = true;
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;
492 goto leave;
493 }
494
495 ret = btrfs_commit_transaction(trans);
496 WARN_ON(ret);
497
498
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);
502
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) {
507 WARN_ON(ret);
508 }
509
510 return ret;
511
512leave:
513 if (need_unlock)
514 up_write(&dev_replace->rwsem);
515 btrfs_destroy_dev_replace_tgtdev(tgt_device);
516 return ret;
517}
518
519int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info,
520 struct btrfs_ioctl_dev_replace_args *args)
521{
522 int ret;
523
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:
527 break;
528 default:
529 return -EINVAL;
530 }
531
532 if ((args->start.srcdevid == 0 && args->start.srcdev_name[0] == '\0') ||
533 args->start.tgtdev_name[0] == '\0')
534 return -EINVAL;
535
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);
540 args->result = ret;
541
542 if (ret == BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS ||
543 ret == BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR)
544 return 0;
545
546 return ret;
547}
548
549
550
551
552static void btrfs_rm_dev_replace_blocked(struct btrfs_fs_info *fs_info)
553{
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));
557}
558
559
560
561
562static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info *fs_info)
563{
564 clear_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);
565 wake_up(&fs_info->dev_replace.replace_wait);
566}
567
568static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
569 int scrub_ret)
570{
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;
577 int ret = 0;
578
579
580 mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
581
582 down_read(&dev_replace->rwsem);
583
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);
588 return 0;
589 }
590
591 tgt_device = dev_replace->tgtdev;
592 src_device = dev_replace->srcdev;
593 up_read(&dev_replace->rwsem);
594
595
596
597
598
599 ret = btrfs_start_delalloc_roots(fs_info, -1);
600 if (ret) {
601 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
602 return ret;
603 }
604 btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
605
606
607
608
609
610
611 while (1) {
612 trans = btrfs_start_transaction(root, 0);
613 if (IS_ERR(trans)) {
614 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
615 return PTR_ERR(trans);
616 }
617 ret = btrfs_commit_transaction(trans);
618 WARN_ON(ret);
619
620
621 mutex_lock(&fs_info->fs_devices->device_list_mutex);
622
623 mutex_lock(&fs_info->chunk_mutex);
624
625 if (!list_empty(&src_device->post_commit_list)) {
626 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
627 mutex_unlock(&fs_info->chunk_mutex);
628 } else {
629 break;
630 }
631 }
632
633 down_write(&dev_replace->rwsem);
634 dev_replace->replace_state =
635 scrub_ret ? BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
636 : BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED;
637 dev_replace->tgtdev = NULL;
638 dev_replace->srcdev = NULL;
639 dev_replace->time_stopped = ktime_get_real_seconds();
640 dev_replace->item_needs_writeback = 1;
641
642
643 if (!scrub_ret) {
644 btrfs_dev_replace_update_device_in_mapping_tree(fs_info,
645 src_device,
646 tgt_device);
647 } else {
648 if (scrub_ret != -ECANCELED)
649 btrfs_err_in_rcu(fs_info,
650 "btrfs_scrub_dev(%s, %llu, %s) failed %d",
651 btrfs_dev_name(src_device),
652 src_device->devid,
653 rcu_str_deref(tgt_device->name), scrub_ret);
654 up_write(&dev_replace->rwsem);
655 mutex_unlock(&fs_info->chunk_mutex);
656 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
657 btrfs_rm_dev_replace_blocked(fs_info);
658 if (tgt_device)
659 btrfs_destroy_dev_replace_tgtdev(tgt_device);
660 btrfs_rm_dev_replace_unblocked(fs_info);
661 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
662
663 return scrub_ret;
664 }
665
666 btrfs_info_in_rcu(fs_info,
667 "dev_replace from %s (devid %llu) to %s finished",
668 btrfs_dev_name(src_device),
669 src_device->devid,
670 rcu_str_deref(tgt_device->name));
671 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &tgt_device->dev_state);
672 tgt_device->devid = src_device->devid;
673 src_device->devid = BTRFS_DEV_REPLACE_DEVID;
674 memcpy(uuid_tmp, tgt_device->uuid, sizeof(uuid_tmp));
675 memcpy(tgt_device->uuid, src_device->uuid, sizeof(tgt_device->uuid));
676 memcpy(src_device->uuid, uuid_tmp, sizeof(src_device->uuid));
677 btrfs_device_set_total_bytes(tgt_device, src_device->total_bytes);
678 btrfs_device_set_disk_total_bytes(tgt_device,
679 src_device->disk_total_bytes);
680 btrfs_device_set_bytes_used(tgt_device, src_device->bytes_used);
681 tgt_device->commit_total_bytes = src_device->commit_total_bytes;
682 tgt_device->commit_bytes_used = src_device->bytes_used;
683
684 btrfs_assign_next_active_device(src_device, tgt_device);
685
686 list_add(&tgt_device->dev_alloc_list, &fs_info->fs_devices->alloc_list);
687 fs_info->fs_devices->rw_devices++;
688
689 up_write(&dev_replace->rwsem);
690 btrfs_rm_dev_replace_blocked(fs_info);
691
692 btrfs_rm_dev_replace_remove_srcdev(src_device);
693
694 btrfs_rm_dev_replace_unblocked(fs_info);
695
696
697
698
699
700 atomic_inc(&tgt_device->dev_stats_ccnt);
701
702
703
704
705
706
707
708
709 mutex_unlock(&fs_info->chunk_mutex);
710 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
711
712
713 btrfs_sysfs_rm_device_link(fs_info->fs_devices, src_device);
714 btrfs_rm_dev_replace_free_srcdev(src_device);
715
716
717 trans = btrfs_start_transaction(root, 0);
718 if (!IS_ERR(trans))
719 btrfs_commit_transaction(trans);
720
721 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
722
723 return 0;
724}
725
726static void btrfs_dev_replace_update_device_in_mapping_tree(
727 struct btrfs_fs_info *fs_info,
728 struct btrfs_device *srcdev,
729 struct btrfs_device *tgtdev)
730{
731 struct extent_map_tree *em_tree = &fs_info->mapping_tree.map_tree;
732 struct extent_map *em;
733 struct map_lookup *map;
734 u64 start = 0;
735 int i;
736
737 write_lock(&em_tree->lock);
738 do {
739 em = lookup_extent_mapping(em_tree, start, (u64)-1);
740 if (!em)
741 break;
742 map = em->map_lookup;
743 for (i = 0; i < map->num_stripes; i++)
744 if (srcdev == map->stripes[i].dev)
745 map->stripes[i].dev = tgtdev;
746 start = em->start + em->len;
747 free_extent_map(em);
748 } while (start);
749 write_unlock(&em_tree->lock);
750}
751
752
753
754
755
756
757static u64 btrfs_dev_replace_progress(struct btrfs_fs_info *fs_info)
758{
759 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
760 u64 ret = 0;
761
762 switch (dev_replace->replace_state) {
763 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
764 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
765 ret = 0;
766 break;
767 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
768 ret = 1000;
769 break;
770 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
771 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
772 ret = div64_u64(dev_replace->cursor_left,
773 div_u64(btrfs_device_get_total_bytes(
774 dev_replace->srcdev), 1000));
775 break;
776 }
777
778 return ret;
779}
780
781void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
782 struct btrfs_ioctl_dev_replace_args *args)
783{
784 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
785
786 down_read(&dev_replace->rwsem);
787
788
789 args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
790 args->status.replace_state = dev_replace->replace_state;
791 args->status.time_started = dev_replace->time_started;
792 args->status.time_stopped = dev_replace->time_stopped;
793 args->status.num_write_errors =
794 atomic64_read(&dev_replace->num_write_errors);
795 args->status.num_uncorrectable_read_errors =
796 atomic64_read(&dev_replace->num_uncorrectable_read_errors);
797 args->status.progress_1000 = btrfs_dev_replace_progress(fs_info);
798 up_read(&dev_replace->rwsem);
799}
800
801int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
802{
803 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
804 struct btrfs_device *tgt_device = NULL;
805 struct btrfs_device *src_device = NULL;
806 struct btrfs_trans_handle *trans;
807 struct btrfs_root *root = fs_info->tree_root;
808 int result;
809 int ret;
810
811 if (sb_rdonly(fs_info->sb))
812 return -EROFS;
813
814 mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
815 down_write(&dev_replace->rwsem);
816 switch (dev_replace->replace_state) {
817 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
818 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
819 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
820 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED;
821 up_write(&dev_replace->rwsem);
822 break;
823 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
824 tgt_device = dev_replace->tgtdev;
825 src_device = dev_replace->srcdev;
826 up_write(&dev_replace->rwsem);
827 ret = btrfs_scrub_cancel(fs_info);
828 if (ret < 0) {
829 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED;
830 } else {
831 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
832
833
834
835
836 btrfs_info_in_rcu(fs_info,
837 "dev_replace from %s (devid %llu) to %s canceled",
838 btrfs_dev_name(src_device), src_device->devid,
839 btrfs_dev_name(tgt_device));
840 }
841 break;
842 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
843
844
845
846
847 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
848 tgt_device = dev_replace->tgtdev;
849 src_device = dev_replace->srcdev;
850 dev_replace->tgtdev = NULL;
851 dev_replace->srcdev = NULL;
852 dev_replace->replace_state =
853 BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED;
854 dev_replace->time_stopped = ktime_get_real_seconds();
855 dev_replace->item_needs_writeback = 1;
856
857 up_write(&dev_replace->rwsem);
858
859
860 ret = btrfs_scrub_cancel(fs_info);
861 ASSERT(ret != -ENOTCONN);
862
863 trans = btrfs_start_transaction(root, 0);
864 if (IS_ERR(trans)) {
865 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
866 return PTR_ERR(trans);
867 }
868 ret = btrfs_commit_transaction(trans);
869 WARN_ON(ret);
870
871 btrfs_info_in_rcu(fs_info,
872 "suspended dev_replace from %s (devid %llu) to %s canceled",
873 btrfs_dev_name(src_device), src_device->devid,
874 btrfs_dev_name(tgt_device));
875
876 if (tgt_device)
877 btrfs_destroy_dev_replace_tgtdev(tgt_device);
878 break;
879 default:
880 up_write(&dev_replace->rwsem);
881 result = -EINVAL;
882 }
883
884 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
885 return result;
886}
887
888void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)
889{
890 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
891
892 mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
893 down_write(&dev_replace->rwsem);
894
895 switch (dev_replace->replace_state) {
896 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
897 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
898 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
899 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
900 break;
901 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
902 dev_replace->replace_state =
903 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
904 dev_replace->time_stopped = ktime_get_real_seconds();
905 dev_replace->item_needs_writeback = 1;
906 btrfs_info(fs_info, "suspending dev_replace for unmount");
907 break;
908 }
909
910 up_write(&dev_replace->rwsem);
911 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
912}
913
914
915int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info)
916{
917 struct task_struct *task;
918 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
919
920 down_write(&dev_replace->rwsem);
921
922 switch (dev_replace->replace_state) {
923 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
924 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
925 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
926 up_write(&dev_replace->rwsem);
927 return 0;
928 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
929 break;
930 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
931 dev_replace->replace_state =
932 BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
933 break;
934 }
935 if (!dev_replace->tgtdev || !dev_replace->tgtdev->bdev) {
936 btrfs_info(fs_info,
937 "cannot continue dev_replace, tgtdev is missing");
938 btrfs_info(fs_info,
939 "you may cancel the operation after 'mount -o degraded'");
940 dev_replace->replace_state =
941 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
942 up_write(&dev_replace->rwsem);
943 return 0;
944 }
945 up_write(&dev_replace->rwsem);
946
947
948
949
950
951
952 if (test_and_set_bit(BTRFS_FS_EXCL_OP, &fs_info->flags)) {
953 down_write(&dev_replace->rwsem);
954 dev_replace->replace_state =
955 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
956 up_write(&dev_replace->rwsem);
957 btrfs_info(fs_info,
958 "cannot resume dev-replace, other exclusive operation running");
959 return 0;
960 }
961
962 task = kthread_run(btrfs_dev_replace_kthread, fs_info, "btrfs-devrepl");
963 return PTR_ERR_OR_ZERO(task);
964}
965
966static int btrfs_dev_replace_kthread(void *data)
967{
968 struct btrfs_fs_info *fs_info = data;
969 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
970 u64 progress;
971 int ret;
972
973 progress = btrfs_dev_replace_progress(fs_info);
974 progress = div_u64(progress, 10);
975 btrfs_info_in_rcu(fs_info,
976 "continuing dev_replace from %s (devid %llu) to target %s @%u%%",
977 btrfs_dev_name(dev_replace->srcdev),
978 dev_replace->srcdev->devid,
979 btrfs_dev_name(dev_replace->tgtdev),
980 (unsigned int)progress);
981
982 ret = btrfs_scrub_dev(fs_info, dev_replace->srcdev->devid,
983 dev_replace->committed_cursor_left,
984 btrfs_device_get_total_bytes(dev_replace->srcdev),
985 &dev_replace->scrub_progress, 0, 1);
986 ret = btrfs_dev_replace_finishing(fs_info, ret);
987 WARN_ON(ret && ret != -ECANCELED);
988
989 clear_bit(BTRFS_FS_EXCL_OP, &fs_info->flags);
990 return 0;
991}
992
993int btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
994{
995 if (!dev_replace->is_valid)
996 return 0;
997
998 switch (dev_replace->replace_state) {
999 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
1000 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
1001 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
1002 return 0;
1003 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
1004 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015 break;
1016 }
1017 return 1;
1018}
1019
1020void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info)
1021{
1022 percpu_counter_inc(&fs_info->dev_replace.bio_counter);
1023}
1024
1025void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount)
1026{
1027 percpu_counter_sub(&fs_info->dev_replace.bio_counter, amount);
1028 cond_wake_up_nomb(&fs_info->dev_replace.replace_wait);
1029}
1030
1031void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info)
1032{
1033 while (1) {
1034 percpu_counter_inc(&fs_info->dev_replace.bio_counter);
1035 if (likely(!test_bit(BTRFS_FS_STATE_DEV_REPLACING,
1036 &fs_info->fs_state)))
1037 break;
1038
1039 btrfs_bio_counter_dec(fs_info);
1040 wait_event(fs_info->dev_replace.replace_wait,
1041 !test_bit(BTRFS_FS_STATE_DEV_REPLACING,
1042 &fs_info->fs_state));
1043 }
1044}
1045