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 sync_blockdev(bdev);
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 set_bit(BTRFS_DEV_STATE_WRITEABLE, &device->dev_state);
241 device->generation = 0;
242 device->io_width = fs_info->sectorsize;
243 device->io_align = fs_info->sectorsize;
244 device->sector_size = fs_info->sectorsize;
245 device->total_bytes = btrfs_device_get_total_bytes(srcdev);
246 device->disk_total_bytes = btrfs_device_get_disk_total_bytes(srcdev);
247 device->bytes_used = btrfs_device_get_bytes_used(srcdev);
248 device->commit_total_bytes = srcdev->commit_total_bytes;
249 device->commit_bytes_used = device->bytes_used;
250 device->fs_info = fs_info;
251 device->bdev = bdev;
252 set_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &device->dev_state);
253 set_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state);
254 device->mode = FMODE_EXCL;
255 device->dev_stats_valid = 1;
256 set_blocksize(device->bdev, BTRFS_BDEV_BLOCKSIZE);
257 device->fs_devices = fs_info->fs_devices;
258
259 mutex_lock(&fs_info->fs_devices->device_list_mutex);
260 list_add(&device->dev_list, &fs_info->fs_devices->devices);
261 fs_info->fs_devices->num_devices++;
262 fs_info->fs_devices->open_devices++;
263 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
264
265 *device_out = device;
266 return 0;
267
268error:
269 blkdev_put(bdev, FMODE_EXCL);
270 return ret;
271}
272
273
274
275
276
277int btrfs_run_dev_replace(struct btrfs_trans_handle *trans)
278{
279 struct btrfs_fs_info *fs_info = trans->fs_info;
280 int ret;
281 struct btrfs_root *dev_root = fs_info->dev_root;
282 struct btrfs_path *path;
283 struct btrfs_key key;
284 struct extent_buffer *eb;
285 struct btrfs_dev_replace_item *ptr;
286 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
287
288 down_read(&dev_replace->rwsem);
289 if (!dev_replace->is_valid ||
290 !dev_replace->item_needs_writeback) {
291 up_read(&dev_replace->rwsem);
292 return 0;
293 }
294 up_read(&dev_replace->rwsem);
295
296 key.objectid = 0;
297 key.type = BTRFS_DEV_REPLACE_KEY;
298 key.offset = 0;
299
300 path = btrfs_alloc_path();
301 if (!path) {
302 ret = -ENOMEM;
303 goto out;
304 }
305 ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
306 if (ret < 0) {
307 btrfs_warn(fs_info,
308 "error %d while searching for dev_replace item!",
309 ret);
310 goto out;
311 }
312
313 if (ret == 0 &&
314 btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
315
316
317
318
319
320
321
322
323
324
325
326 ret = btrfs_del_item(trans, dev_root, path);
327 if (ret != 0) {
328 btrfs_warn(fs_info,
329 "delete too small dev_replace item failed %d!",
330 ret);
331 goto out;
332 }
333 ret = 1;
334 }
335
336 if (ret == 1) {
337
338 btrfs_release_path(path);
339 ret = btrfs_insert_empty_item(trans, dev_root, path,
340 &key, sizeof(*ptr));
341 if (ret < 0) {
342 btrfs_warn(fs_info,
343 "insert dev_replace item failed %d!", ret);
344 goto out;
345 }
346 }
347
348 eb = path->nodes[0];
349 ptr = btrfs_item_ptr(eb, path->slots[0],
350 struct btrfs_dev_replace_item);
351
352 down_write(&dev_replace->rwsem);
353 if (dev_replace->srcdev)
354 btrfs_set_dev_replace_src_devid(eb, ptr,
355 dev_replace->srcdev->devid);
356 else
357 btrfs_set_dev_replace_src_devid(eb, ptr, (u64)-1);
358 btrfs_set_dev_replace_cont_reading_from_srcdev_mode(eb, ptr,
359 dev_replace->cont_reading_from_srcdev_mode);
360 btrfs_set_dev_replace_replace_state(eb, ptr,
361 dev_replace->replace_state);
362 btrfs_set_dev_replace_time_started(eb, ptr, dev_replace->time_started);
363 btrfs_set_dev_replace_time_stopped(eb, ptr, dev_replace->time_stopped);
364 btrfs_set_dev_replace_num_write_errors(eb, ptr,
365 atomic64_read(&dev_replace->num_write_errors));
366 btrfs_set_dev_replace_num_uncorrectable_read_errors(eb, ptr,
367 atomic64_read(&dev_replace->num_uncorrectable_read_errors));
368 dev_replace->cursor_left_last_write_of_item =
369 dev_replace->cursor_left;
370 btrfs_set_dev_replace_cursor_left(eb, ptr,
371 dev_replace->cursor_left_last_write_of_item);
372 btrfs_set_dev_replace_cursor_right(eb, ptr,
373 dev_replace->cursor_right);
374 dev_replace->item_needs_writeback = 0;
375 up_write(&dev_replace->rwsem);
376
377 btrfs_mark_buffer_dirty(eb);
378
379out:
380 btrfs_free_path(path);
381
382 return ret;
383}
384
385static char* btrfs_dev_name(struct btrfs_device *device)
386{
387 if (!device || test_bit(BTRFS_DEV_STATE_MISSING, &device->dev_state))
388 return "<missing disk>";
389 else
390 return rcu_str_deref(device->name);
391}
392
393static int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,
394 const char *tgtdev_name, u64 srcdevid, const char *srcdev_name,
395 int read_src)
396{
397 struct btrfs_root *root = fs_info->dev_root;
398 struct btrfs_trans_handle *trans;
399 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
400 int ret;
401 struct btrfs_device *tgt_device = NULL;
402 struct btrfs_device *src_device = NULL;
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
417
418
419
420 trans = btrfs_attach_transaction(root);
421 if (!IS_ERR(trans)) {
422 ret = btrfs_commit_transaction(trans);
423 if (ret)
424 return ret;
425 } else if (PTR_ERR(trans) != -ENOENT) {
426 return PTR_ERR(trans);
427 }
428
429 ret = btrfs_init_dev_replace_tgtdev(fs_info, tgtdev_name,
430 src_device, &tgt_device);
431 if (ret)
432 return ret;
433
434 down_write(&dev_replace->rwsem);
435 switch (dev_replace->replace_state) {
436 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
437 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
438 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
439 break;
440 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
441 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
442 ASSERT(0);
443 ret = BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED;
444 up_write(&dev_replace->rwsem);
445 goto leave;
446 }
447
448 dev_replace->cont_reading_from_srcdev_mode = read_src;
449 dev_replace->srcdev = src_device;
450 dev_replace->tgtdev = tgt_device;
451
452 btrfs_info_in_rcu(fs_info,
453 "dev_replace from %s (devid %llu) to %s started",
454 btrfs_dev_name(src_device),
455 src_device->devid,
456 rcu_str_deref(tgt_device->name));
457
458
459
460
461
462 dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
463 dev_replace->time_started = ktime_get_real_seconds();
464 dev_replace->cursor_left = 0;
465 dev_replace->committed_cursor_left = 0;
466 dev_replace->cursor_left_last_write_of_item = 0;
467 dev_replace->cursor_right = 0;
468 dev_replace->is_valid = 1;
469 dev_replace->item_needs_writeback = 1;
470 atomic64_set(&dev_replace->num_write_errors, 0);
471 atomic64_set(&dev_replace->num_uncorrectable_read_errors, 0);
472 up_write(&dev_replace->rwsem);
473
474 ret = btrfs_sysfs_add_device_link(tgt_device->fs_devices, tgt_device);
475 if (ret)
476 btrfs_err(fs_info, "kobj add dev failed %d", ret);
477
478 btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
479
480
481 trans = btrfs_start_transaction(root, 1);
482 if (IS_ERR(trans)) {
483 ret = PTR_ERR(trans);
484 down_write(&dev_replace->rwsem);
485 dev_replace->replace_state =
486 BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED;
487 dev_replace->srcdev = NULL;
488 dev_replace->tgtdev = NULL;
489 up_write(&dev_replace->rwsem);
490 goto leave;
491 }
492
493 ret = btrfs_commit_transaction(trans);
494 WARN_ON(ret);
495
496
497 ret = btrfs_scrub_dev(fs_info, src_device->devid, 0,
498 btrfs_device_get_total_bytes(src_device),
499 &dev_replace->scrub_progress, 0, 1);
500
501 ret = btrfs_dev_replace_finishing(fs_info, ret);
502 if (ret == -EINPROGRESS) {
503 ret = BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS;
504 } else if (ret != -ECANCELED) {
505 WARN_ON(ret);
506 }
507
508 return ret;
509
510leave:
511 btrfs_destroy_dev_replace_tgtdev(tgt_device);
512 return ret;
513}
514
515int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info,
516 struct btrfs_ioctl_dev_replace_args *args)
517{
518 int ret;
519
520 switch (args->start.cont_reading_from_srcdev_mode) {
521 case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS:
522 case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID:
523 break;
524 default:
525 return -EINVAL;
526 }
527
528 if ((args->start.srcdevid == 0 && args->start.srcdev_name[0] == '\0') ||
529 args->start.tgtdev_name[0] == '\0')
530 return -EINVAL;
531
532 ret = btrfs_dev_replace_start(fs_info, args->start.tgtdev_name,
533 args->start.srcdevid,
534 args->start.srcdev_name,
535 args->start.cont_reading_from_srcdev_mode);
536 args->result = ret;
537
538 if (ret == BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS ||
539 ret == BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR)
540 return 0;
541
542 return ret;
543}
544
545
546
547
548static void btrfs_rm_dev_replace_blocked(struct btrfs_fs_info *fs_info)
549{
550 set_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);
551 wait_event(fs_info->dev_replace.replace_wait, !percpu_counter_sum(
552 &fs_info->dev_replace.bio_counter));
553}
554
555
556
557
558static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info *fs_info)
559{
560 clear_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);
561 wake_up(&fs_info->dev_replace.replace_wait);
562}
563
564static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
565 int scrub_ret)
566{
567 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
568 struct btrfs_device *tgt_device;
569 struct btrfs_device *src_device;
570 struct btrfs_root *root = fs_info->tree_root;
571 u8 uuid_tmp[BTRFS_UUID_SIZE];
572 struct btrfs_trans_handle *trans;
573 int ret = 0;
574
575
576 mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
577
578 down_read(&dev_replace->rwsem);
579
580 if (dev_replace->replace_state !=
581 BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED) {
582 up_read(&dev_replace->rwsem);
583 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
584 return 0;
585 }
586
587 tgt_device = dev_replace->tgtdev;
588 src_device = dev_replace->srcdev;
589 up_read(&dev_replace->rwsem);
590
591
592
593
594
595 ret = btrfs_start_delalloc_roots(fs_info, -1);
596 if (ret) {
597 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
598 return ret;
599 }
600 btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
601
602
603
604
605
606
607 while (1) {
608 trans = btrfs_start_transaction(root, 0);
609 if (IS_ERR(trans)) {
610 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
611 return PTR_ERR(trans);
612 }
613 ret = btrfs_commit_transaction(trans);
614 WARN_ON(ret);
615
616
617 mutex_lock(&fs_info->fs_devices->device_list_mutex);
618
619 mutex_lock(&fs_info->chunk_mutex);
620
621 if (!list_empty(&src_device->post_commit_list)) {
622 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
623 mutex_unlock(&fs_info->chunk_mutex);
624 } else {
625 break;
626 }
627 }
628
629 down_write(&dev_replace->rwsem);
630 dev_replace->replace_state =
631 scrub_ret ? BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
632 : BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED;
633 dev_replace->tgtdev = NULL;
634 dev_replace->srcdev = NULL;
635 dev_replace->time_stopped = ktime_get_real_seconds();
636 dev_replace->item_needs_writeback = 1;
637
638
639 if (!scrub_ret) {
640 btrfs_dev_replace_update_device_in_mapping_tree(fs_info,
641 src_device,
642 tgt_device);
643 } else {
644 if (scrub_ret != -ECANCELED)
645 btrfs_err_in_rcu(fs_info,
646 "btrfs_scrub_dev(%s, %llu, %s) failed %d",
647 btrfs_dev_name(src_device),
648 src_device->devid,
649 rcu_str_deref(tgt_device->name), scrub_ret);
650 up_write(&dev_replace->rwsem);
651 mutex_unlock(&fs_info->chunk_mutex);
652 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
653 btrfs_rm_dev_replace_blocked(fs_info);
654 if (tgt_device)
655 btrfs_destroy_dev_replace_tgtdev(tgt_device);
656 btrfs_rm_dev_replace_unblocked(fs_info);
657 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
658
659 return scrub_ret;
660 }
661
662 btrfs_info_in_rcu(fs_info,
663 "dev_replace from %s (devid %llu) to %s finished",
664 btrfs_dev_name(src_device),
665 src_device->devid,
666 rcu_str_deref(tgt_device->name));
667 clear_bit(BTRFS_DEV_STATE_REPLACE_TGT, &tgt_device->dev_state);
668 tgt_device->devid = src_device->devid;
669 src_device->devid = BTRFS_DEV_REPLACE_DEVID;
670 memcpy(uuid_tmp, tgt_device->uuid, sizeof(uuid_tmp));
671 memcpy(tgt_device->uuid, src_device->uuid, sizeof(tgt_device->uuid));
672 memcpy(src_device->uuid, uuid_tmp, sizeof(src_device->uuid));
673 btrfs_device_set_total_bytes(tgt_device, src_device->total_bytes);
674 btrfs_device_set_disk_total_bytes(tgt_device,
675 src_device->disk_total_bytes);
676 btrfs_device_set_bytes_used(tgt_device, src_device->bytes_used);
677 tgt_device->commit_bytes_used = src_device->bytes_used;
678
679 btrfs_assign_next_active_device(src_device, tgt_device);
680
681 list_add(&tgt_device->dev_alloc_list, &fs_info->fs_devices->alloc_list);
682 fs_info->fs_devices->rw_devices++;
683
684 up_write(&dev_replace->rwsem);
685 btrfs_rm_dev_replace_blocked(fs_info);
686
687 btrfs_rm_dev_replace_remove_srcdev(src_device);
688
689 btrfs_rm_dev_replace_unblocked(fs_info);
690
691
692
693
694
695 atomic_inc(&tgt_device->dev_stats_ccnt);
696
697
698
699
700
701
702
703
704 mutex_unlock(&fs_info->chunk_mutex);
705 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
706
707
708 btrfs_sysfs_rm_device_link(fs_info->fs_devices, src_device);
709 btrfs_rm_dev_replace_free_srcdev(src_device);
710
711
712 trans = btrfs_start_transaction(root, 0);
713 if (!IS_ERR(trans))
714 btrfs_commit_transaction(trans);
715
716 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
717
718 return 0;
719}
720
721static void btrfs_dev_replace_update_device_in_mapping_tree(
722 struct btrfs_fs_info *fs_info,
723 struct btrfs_device *srcdev,
724 struct btrfs_device *tgtdev)
725{
726 struct extent_map_tree *em_tree = &fs_info->mapping_tree;
727 struct extent_map *em;
728 struct map_lookup *map;
729 u64 start = 0;
730 int i;
731
732 write_lock(&em_tree->lock);
733 do {
734 em = lookup_extent_mapping(em_tree, start, (u64)-1);
735 if (!em)
736 break;
737 map = em->map_lookup;
738 for (i = 0; i < map->num_stripes; i++)
739 if (srcdev == map->stripes[i].dev)
740 map->stripes[i].dev = tgtdev;
741 start = em->start + em->len;
742 free_extent_map(em);
743 } while (start);
744 write_unlock(&em_tree->lock);
745}
746
747
748
749
750
751
752static u64 btrfs_dev_replace_progress(struct btrfs_fs_info *fs_info)
753{
754 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
755 u64 ret = 0;
756
757 switch (dev_replace->replace_state) {
758 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
759 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
760 ret = 0;
761 break;
762 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
763 ret = 1000;
764 break;
765 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
766 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
767 ret = div64_u64(dev_replace->cursor_left,
768 div_u64(btrfs_device_get_total_bytes(
769 dev_replace->srcdev), 1000));
770 break;
771 }
772
773 return ret;
774}
775
776void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
777 struct btrfs_ioctl_dev_replace_args *args)
778{
779 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
780
781 down_read(&dev_replace->rwsem);
782
783
784 args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
785 args->status.replace_state = dev_replace->replace_state;
786 args->status.time_started = dev_replace->time_started;
787 args->status.time_stopped = dev_replace->time_stopped;
788 args->status.num_write_errors =
789 atomic64_read(&dev_replace->num_write_errors);
790 args->status.num_uncorrectable_read_errors =
791 atomic64_read(&dev_replace->num_uncorrectable_read_errors);
792 args->status.progress_1000 = btrfs_dev_replace_progress(fs_info);
793 up_read(&dev_replace->rwsem);
794}
795
796int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
797{
798 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
799 struct btrfs_device *tgt_device = NULL;
800 struct btrfs_device *src_device = NULL;
801 struct btrfs_trans_handle *trans;
802 struct btrfs_root *root = fs_info->tree_root;
803 int result;
804 int ret;
805
806 if (sb_rdonly(fs_info->sb))
807 return -EROFS;
808
809 mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
810 down_write(&dev_replace->rwsem);
811 switch (dev_replace->replace_state) {
812 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
813 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
814 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
815 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED;
816 up_write(&dev_replace->rwsem);
817 break;
818 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
819 tgt_device = dev_replace->tgtdev;
820 src_device = dev_replace->srcdev;
821 up_write(&dev_replace->rwsem);
822 ret = btrfs_scrub_cancel(fs_info);
823 if (ret < 0) {
824 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED;
825 } else {
826 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
827
828
829
830
831 btrfs_info_in_rcu(fs_info,
832 "dev_replace from %s (devid %llu) to %s canceled",
833 btrfs_dev_name(src_device), src_device->devid,
834 btrfs_dev_name(tgt_device));
835 }
836 break;
837 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
838
839
840
841
842 result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
843 tgt_device = dev_replace->tgtdev;
844 src_device = dev_replace->srcdev;
845 dev_replace->tgtdev = NULL;
846 dev_replace->srcdev = NULL;
847 dev_replace->replace_state =
848 BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED;
849 dev_replace->time_stopped = ktime_get_real_seconds();
850 dev_replace->item_needs_writeback = 1;
851
852 up_write(&dev_replace->rwsem);
853
854
855 ret = btrfs_scrub_cancel(fs_info);
856 ASSERT(ret != -ENOTCONN);
857
858 trans = btrfs_start_transaction(root, 0);
859 if (IS_ERR(trans)) {
860 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
861 return PTR_ERR(trans);
862 }
863 ret = btrfs_commit_transaction(trans);
864 WARN_ON(ret);
865
866 btrfs_info_in_rcu(fs_info,
867 "suspended dev_replace from %s (devid %llu) to %s canceled",
868 btrfs_dev_name(src_device), src_device->devid,
869 btrfs_dev_name(tgt_device));
870
871 if (tgt_device)
872 btrfs_destroy_dev_replace_tgtdev(tgt_device);
873 break;
874 default:
875 up_write(&dev_replace->rwsem);
876 result = -EINVAL;
877 }
878
879 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
880 return result;
881}
882
883void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)
884{
885 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
886
887 mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
888 down_write(&dev_replace->rwsem);
889
890 switch (dev_replace->replace_state) {
891 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
892 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
893 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
894 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
895 break;
896 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
897 dev_replace->replace_state =
898 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
899 dev_replace->time_stopped = ktime_get_real_seconds();
900 dev_replace->item_needs_writeback = 1;
901 btrfs_info(fs_info, "suspending dev_replace for unmount");
902 break;
903 }
904
905 up_write(&dev_replace->rwsem);
906 mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
907}
908
909
910int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info)
911{
912 struct task_struct *task;
913 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
914
915 down_write(&dev_replace->rwsem);
916
917 switch (dev_replace->replace_state) {
918 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
919 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
920 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
921 up_write(&dev_replace->rwsem);
922 return 0;
923 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
924 break;
925 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
926 dev_replace->replace_state =
927 BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
928 break;
929 }
930 if (!dev_replace->tgtdev || !dev_replace->tgtdev->bdev) {
931 btrfs_info(fs_info,
932 "cannot continue dev_replace, tgtdev is missing");
933 btrfs_info(fs_info,
934 "you may cancel the operation after 'mount -o degraded'");
935 dev_replace->replace_state =
936 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
937 up_write(&dev_replace->rwsem);
938 return 0;
939 }
940 up_write(&dev_replace->rwsem);
941
942
943
944
945
946
947 if (test_and_set_bit(BTRFS_FS_EXCL_OP, &fs_info->flags)) {
948 down_write(&dev_replace->rwsem);
949 dev_replace->replace_state =
950 BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
951 up_write(&dev_replace->rwsem);
952 btrfs_info(fs_info,
953 "cannot resume dev-replace, other exclusive operation running");
954 return 0;
955 }
956
957 task = kthread_run(btrfs_dev_replace_kthread, fs_info, "btrfs-devrepl");
958 return PTR_ERR_OR_ZERO(task);
959}
960
961static int btrfs_dev_replace_kthread(void *data)
962{
963 struct btrfs_fs_info *fs_info = data;
964 struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
965 u64 progress;
966 int ret;
967
968 progress = btrfs_dev_replace_progress(fs_info);
969 progress = div_u64(progress, 10);
970 btrfs_info_in_rcu(fs_info,
971 "continuing dev_replace from %s (devid %llu) to target %s @%u%%",
972 btrfs_dev_name(dev_replace->srcdev),
973 dev_replace->srcdev->devid,
974 btrfs_dev_name(dev_replace->tgtdev),
975 (unsigned int)progress);
976
977 ret = btrfs_scrub_dev(fs_info, dev_replace->srcdev->devid,
978 dev_replace->committed_cursor_left,
979 btrfs_device_get_total_bytes(dev_replace->srcdev),
980 &dev_replace->scrub_progress, 0, 1);
981 ret = btrfs_dev_replace_finishing(fs_info, ret);
982 WARN_ON(ret && ret != -ECANCELED);
983
984 clear_bit(BTRFS_FS_EXCL_OP, &fs_info->flags);
985 return 0;
986}
987
988int btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
989{
990 if (!dev_replace->is_valid)
991 return 0;
992
993 switch (dev_replace->replace_state) {
994 case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
995 case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
996 case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
997 return 0;
998 case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
999 case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010 break;
1011 }
1012 return 1;
1013}
1014
1015void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info)
1016{
1017 percpu_counter_inc(&fs_info->dev_replace.bio_counter);
1018}
1019
1020void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount)
1021{
1022 percpu_counter_sub(&fs_info->dev_replace.bio_counter, amount);
1023 cond_wake_up_nomb(&fs_info->dev_replace.replace_wait);
1024}
1025
1026void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info)
1027{
1028 while (1) {
1029 percpu_counter_inc(&fs_info->dev_replace.bio_counter);
1030 if (likely(!test_bit(BTRFS_FS_STATE_DEV_REPLACING,
1031 &fs_info->fs_state)))
1032 break;
1033
1034 btrfs_bio_counter_dec(fs_info);
1035 wait_event(fs_info->dev_replace.replace_wait,
1036 !test_bit(BTRFS_FS_STATE_DEV_REPLACING,
1037 &fs_info->fs_state));
1038 }
1039}
1040