| 1 | |
| 2 | * Copyright (C) STRATO AG 2012. All rights reserved.
|
| 3 | *
|
| 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.
|
| 7 | *
|
| 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.
|
| 12 | *
|
| 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.
|
| 17 |
|
| 18 | #include <linux/sched.h>
|
| 19 | #include <linux/bio.h>
|
| 20 | #include <linux/slab.h>
|
| 21 | #include <linux/buffer_head.h>
|
| 22 | #include <linux/blkdev.h>
|
| 23 | #include <linux/random.h>
|
| 24 | #include <linux/iocontext.h>
|
| 25 | #include <linux/capability.h>
|
| 26 | #include <linux/kthread.h>
|
| 27 | #include <linux/math64.h>
|
| 28 | #include <asm/div64.h>
|
| 29 | #include "compat.h"
|
| 30 | #include "ctree.h"
|
| 31 | #include "extent_map.h"
|
| 32 | #include "disk-io.h"
|
| 33 | #include "transaction.h"
|
| 34 | #include "print-tree.h"
|
| 35 | #include "volumes.h"
|
| 36 | #include "async-thread.h"
|
| 37 | #include "check-integrity.h"
|
| 38 | #include "rcu-string.h"
|
| 39 | #include "dev-replace.h"
|
| 40 |
|
| 41 | static u64 btrfs_get_seconds_since_1970(void);
|
| 42 | static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
|
| 43 | int scrub_ret);
|
| 44 | static void btrfs_dev_replace_update_device_in_mapping_tree(
|
| 45 | struct btrfs_fs_info *fs_info,
|
| 46 | struct btrfs_device *srcdev,
|
| 47 | struct btrfs_device *tgtdev);
|
| 48 | static int btrfs_dev_replace_find_srcdev(struct btrfs_root *root, u64 srcdevid,
|
| 49 | char *srcdev_name,
|
| 50 | struct btrfs_device **device);
|
| 51 | static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info);
|
| 52 | static int btrfs_dev_replace_kthread(void *data);
|
| 53 | static int btrfs_dev_replace_continue_on_mount(struct btrfs_fs_info *fs_info);
|
| 54 |
|
| 55 |
|
| 56 | int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info)
|
| 57 | {
|
| 58 | struct btrfs_key key;
|
| 59 | struct btrfs_root *dev_root = fs_info->dev_root;
|
| 60 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 61 | struct extent_buffer *eb;
|
| 62 | int slot;
|
| 63 | int ret = 0;
|
| 64 | struct btrfs_path *path = NULL;
|
| 65 | int item_size;
|
| 66 | struct btrfs_dev_replace_item *ptr;
|
| 67 | u64 src_devid;
|
| 68 |
|
| 69 | path = btrfs_alloc_path();
|
| 70 | if (!path) {
|
| 71 | ret = -ENOMEM;
|
| 72 | goto out;
|
| 73 | }
|
| 74 |
|
| 75 | key.objectid = 0;
|
| 76 | key.type = BTRFS_DEV_REPLACE_KEY;
|
| 77 | key.offset = 0;
|
| 78 | ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
|
| 79 | if (ret) {
|
| 80 | no_valid_dev_replace_entry_found:
|
| 81 | ret = 0;
|
| 82 | dev_replace->replace_state =
|
| 83 | BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED;
|
| 84 | dev_replace->cont_reading_from_srcdev_mode =
|
| 85 | BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS;
|
| 86 | dev_replace->replace_state = 0;
|
| 87 | dev_replace->time_started = 0;
|
| 88 | dev_replace->time_stopped = 0;
|
| 89 | atomic64_set(&dev_replace->num_write_errors, 0);
|
| 90 | atomic64_set(&dev_replace->num_uncorrectable_read_errors, 0);
|
| 91 | dev_replace->cursor_left = 0;
|
| 92 | dev_replace->committed_cursor_left = 0;
|
| 93 | dev_replace->cursor_left_last_write_of_item = 0;
|
| 94 | dev_replace->cursor_right = 0;
|
| 95 | dev_replace->srcdev = NULL;
|
| 96 | dev_replace->tgtdev = NULL;
|
| 97 | dev_replace->is_valid = 0;
|
| 98 | dev_replace->item_needs_writeback = 0;
|
| 99 | goto out;
|
| 100 | }
|
| 101 | slot = path->slots[0];
|
| 102 | eb = path->nodes[0];
|
| 103 | item_size = btrfs_item_size_nr(eb, slot);
|
| 104 | ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_replace_item);
|
| 105 |
|
| 106 | if (item_size != sizeof(struct btrfs_dev_replace_item)) {
|
| 107 | pr_warn("btrfs: dev_replace entry found has unexpected size, ignore entry\n");
|
| 108 | goto no_valid_dev_replace_entry_found;
|
| 109 | }
|
| 110 |
|
| 111 | src_devid = btrfs_dev_replace_src_devid(eb, ptr);
|
| 112 | dev_replace->cont_reading_from_srcdev_mode =
|
| 113 | btrfs_dev_replace_cont_reading_from_srcdev_mode(eb, ptr);
|
| 114 | dev_replace->replace_state = btrfs_dev_replace_replace_state(eb, ptr);
|
| 115 | dev_replace->time_started = btrfs_dev_replace_time_started(eb, ptr);
|
| 116 | dev_replace->time_stopped =
|
| 117 | btrfs_dev_replace_time_stopped(eb, ptr);
|
| 118 | atomic64_set(&dev_replace->num_write_errors,
|
| 119 | btrfs_dev_replace_num_write_errors(eb, ptr));
|
| 120 | atomic64_set(&dev_replace->num_uncorrectable_read_errors,
|
| 121 | btrfs_dev_replace_num_uncorrectable_read_errors(eb, ptr));
|
| 122 | dev_replace->cursor_left = btrfs_dev_replace_cursor_left(eb, ptr);
|
| 123 | dev_replace->committed_cursor_left = dev_replace->cursor_left;
|
| 124 | dev_replace->cursor_left_last_write_of_item = dev_replace->cursor_left;
|
| 125 | dev_replace->cursor_right = btrfs_dev_replace_cursor_right(eb, ptr);
|
| 126 | dev_replace->is_valid = 1;
|
| 127 |
|
| 128 | dev_replace->item_needs_writeback = 0;
|
| 129 | switch (dev_replace->replace_state) {
|
| 130 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 131 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 132 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 133 | dev_replace->srcdev = NULL;
|
| 134 | dev_replace->tgtdev = NULL;
|
| 135 | break;
|
| 136 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 137 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 138 | dev_replace->srcdev = btrfs_find_device(fs_info, src_devid,
|
| 139 | NULL, NULL);
|
| 140 | dev_replace->tgtdev = btrfs_find_device(fs_info,
|
| 141 | BTRFS_DEV_REPLACE_DEVID,
|
| 142 | NULL, NULL);
|
| 143 | |
| 144 | * allow 'btrfs dev replace_cancel' if src/tgt device is
|
| 145 | * missing
|
| 146 |
|
| 147 | if (!dev_replace->srcdev &&
|
| 148 | !btrfs_test_opt(dev_root, DEGRADED)) {
|
| 149 | ret = -EIO;
|
| 150 | pr_warn("btrfs: cannot mount because device replace operation is ongoing and\n" "srcdev (devid %llu) is missing, need to run 'btrfs dev scan'?\n",
|
| 151 | (unsigned long long)src_devid);
|
| 152 | }
|
| 153 | if (!dev_replace->tgtdev &&
|
| 154 | !btrfs_test_opt(dev_root, DEGRADED)) {
|
| 155 | ret = -EIO;
|
| 156 | pr_warn("btrfs: cannot mount because device replace operation is ongoing and\n" "tgtdev (devid %llu) is missing, need to run btrfs dev scan?\n",
|
| 157 | (unsigned long long)BTRFS_DEV_REPLACE_DEVID);
|
| 158 | }
|
| 159 | if (dev_replace->tgtdev) {
|
| 160 | if (dev_replace->srcdev) {
|
| 161 | dev_replace->tgtdev->total_bytes =
|
| 162 | dev_replace->srcdev->total_bytes;
|
| 163 | dev_replace->tgtdev->disk_total_bytes =
|
| 164 | dev_replace->srcdev->disk_total_bytes;
|
| 165 | dev_replace->tgtdev->bytes_used =
|
| 166 | dev_replace->srcdev->bytes_used;
|
| 167 | }
|
| 168 | dev_replace->tgtdev->is_tgtdev_for_dev_replace = 1;
|
| 169 | btrfs_init_dev_replace_tgtdev_for_resume(fs_info,
|
| 170 | dev_replace->tgtdev);
|
| 171 | }
|
| 172 | break;
|
| 173 | }
|
| 174 |
|
| 175 | out:
|
| 176 | if (path)
|
| 177 | btrfs_free_path(path);
|
| 178 | return ret;
|
| 179 | }
|
| 180 |
|
| 181 | |
| 182 | * called from commit_transaction. Writes changed device replace state to
|
| 183 | * disk.
|
| 184 |
|
| 185 | int btrfs_run_dev_replace(struct btrfs_trans_handle *trans,
|
| 186 | struct btrfs_fs_info *fs_info)
|
| 187 | {
|
| 188 | int ret;
|
| 189 | struct btrfs_root *dev_root = fs_info->dev_root;
|
| 190 | struct btrfs_path *path;
|
| 191 | struct btrfs_key key;
|
| 192 | struct extent_buffer *eb;
|
| 193 | struct btrfs_dev_replace_item *ptr;
|
| 194 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 195 |
|
| 196 | btrfs_dev_replace_lock(dev_replace);
|
| 197 | if (!dev_replace->is_valid ||
|
| 198 | !dev_replace->item_needs_writeback) {
|
| 199 | btrfs_dev_replace_unlock(dev_replace);
|
| 200 | return 0;
|
| 201 | }
|
| 202 | btrfs_dev_replace_unlock(dev_replace);
|
| 203 |
|
| 204 | key.objectid = 0;
|
| 205 | key.type = BTRFS_DEV_REPLACE_KEY;
|
| 206 | key.offset = 0;
|
| 207 |
|
| 208 | path = btrfs_alloc_path();
|
| 209 | if (!path) {
|
| 210 | ret = -ENOMEM;
|
| 211 | goto out;
|
| 212 | }
|
| 213 | ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
|
| 214 | if (ret < 0) {
|
| 215 | pr_warn("btrfs: error %d while searching for dev_replace item!\n",
|
| 216 | ret);
|
| 217 | goto out;
|
| 218 | }
|
| 219 |
|
| 220 | if (ret == 0 &&
|
| 221 | btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
|
| 222 | |
| 223 | * need to delete old one and insert a new one.
|
| 224 | * Since no attempt is made to recover any old state, if the
|
| 225 | * dev_replace state is 'running', the data on the target
|
| 226 | * drive is lost.
|
| 227 | * It would be possible to recover the state: just make sure
|
| 228 | * that the beginning of the item is never changed and always
|
| 229 | * contains all the essential information. Then read this
|
| 230 | * minimal set of information and use it as a base for the
|
| 231 | * new state.
|
| 232 |
|
| 233 | ret = btrfs_del_item(trans, dev_root, path);
|
| 234 | if (ret != 0) {
|
| 235 | pr_warn("btrfs: delete too small dev_replace item failed %d!\n",
|
| 236 | ret);
|
| 237 | goto out;
|
| 238 | }
|
| 239 | ret = 1;
|
| 240 | }
|
| 241 |
|
| 242 | if (ret == 1) {
|
| 243 |
|
| 244 | btrfs_release_path(path);
|
| 245 | ret = btrfs_insert_empty_item(trans, dev_root, path,
|
| 246 | &key, sizeof(*ptr));
|
| 247 | if (ret < 0) {
|
| 248 | pr_warn("btrfs: insert dev_replace item failed %d!\n",
|
| 249 | ret);
|
| 250 | goto out;
|
| 251 | }
|
| 252 | }
|
| 253 |
|
| 254 | eb = path->nodes[0];
|
| 255 | ptr = btrfs_item_ptr(eb, path->slots[0],
|
| 256 | struct btrfs_dev_replace_item);
|
| 257 |
|
| 258 | btrfs_dev_replace_lock(dev_replace);
|
| 259 | if (dev_replace->srcdev)
|
| 260 | btrfs_set_dev_replace_src_devid(eb, ptr,
|
| 261 | dev_replace->srcdev->devid);
|
| 262 | else
|
| 263 | btrfs_set_dev_replace_src_devid(eb, ptr, (u64)-1);
|
| 264 | btrfs_set_dev_replace_cont_reading_from_srcdev_mode(eb, ptr,
|
| 265 | dev_replace->cont_reading_from_srcdev_mode);
|
| 266 | btrfs_set_dev_replace_replace_state(eb, ptr,
|
| 267 | dev_replace->replace_state);
|
| 268 | btrfs_set_dev_replace_time_started(eb, ptr, dev_replace->time_started);
|
| 269 | btrfs_set_dev_replace_time_stopped(eb, ptr, dev_replace->time_stopped);
|
| 270 | btrfs_set_dev_replace_num_write_errors(eb, ptr,
|
| 271 | atomic64_read(&dev_replace->num_write_errors));
|
| 272 | btrfs_set_dev_replace_num_uncorrectable_read_errors(eb, ptr,
|
| 273 | atomic64_read(&dev_replace->num_uncorrectable_read_errors));
|
| 274 | dev_replace->cursor_left_last_write_of_item =
|
| 275 | dev_replace->cursor_left;
|
| 276 | btrfs_set_dev_replace_cursor_left(eb, ptr,
|
| 277 | dev_replace->cursor_left_last_write_of_item);
|
| 278 | btrfs_set_dev_replace_cursor_right(eb, ptr,
|
| 279 | dev_replace->cursor_right);
|
| 280 | dev_replace->item_needs_writeback = 0;
|
| 281 | btrfs_dev_replace_unlock(dev_replace);
|
| 282 |
|
| 283 | btrfs_mark_buffer_dirty(eb);
|
| 284 |
|
| 285 | out:
|
| 286 | btrfs_free_path(path);
|
| 287 |
|
| 288 | return ret;
|
| 289 | }
|
| 290 |
|
| 291 | void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info)
|
| 292 | {
|
| 293 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 294 |
|
| 295 | dev_replace->committed_cursor_left =
|
| 296 | dev_replace->cursor_left_last_write_of_item;
|
| 297 | }
|
| 298 |
|
| 299 | static u64 btrfs_get_seconds_since_1970(void)
|
| 300 | {
|
| 301 | struct timespec t = CURRENT_TIME_SEC;
|
| 302 |
|
| 303 | return t.tv_sec;
|
| 304 | }
|
| 305 |
|
| 306 | int btrfs_dev_replace_start(struct btrfs_root *root,
|
| 307 | struct btrfs_ioctl_dev_replace_args *args)
|
| 308 | {
|
| 309 | struct btrfs_trans_handle *trans;
|
| 310 | struct btrfs_fs_info *fs_info = root->fs_info;
|
| 311 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 312 | int ret;
|
| 313 | struct btrfs_device *tgt_device = NULL;
|
| 314 | struct btrfs_device *src_device = NULL;
|
| 315 |
|
| 316 | switch (args->start.cont_reading_from_srcdev_mode) {
|
| 317 | case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS:
|
| 318 | case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID:
|
| 319 | break;
|
| 320 | default:
|
| 321 | return -EINVAL;
|
| 322 | }
|
| 323 |
|
| 324 | if ((args->start.srcdevid == 0 && args->start.srcdev_name[0] == '\0') ||
|
| 325 | args->start.tgtdev_name[0] == '\0')
|
| 326 | return -EINVAL;
|
| 327 |
|
| 328 | mutex_lock(&fs_info->volume_mutex);
|
| 329 | ret = btrfs_init_dev_replace_tgtdev(root, args->start.tgtdev_name,
|
| 330 | &tgt_device);
|
| 331 | if (ret) {
|
| 332 | pr_err("btrfs: target device %s is invalid!\n",
|
| 333 | args->start.tgtdev_name);
|
| 334 | mutex_unlock(&fs_info->volume_mutex);
|
| 335 | return -EINVAL;
|
| 336 | }
|
| 337 |
|
| 338 | ret = btrfs_dev_replace_find_srcdev(root, args->start.srcdevid,
|
| 339 | args->start.srcdev_name,
|
| 340 | &src_device);
|
| 341 | mutex_unlock(&fs_info->volume_mutex);
|
| 342 | if (ret) {
|
| 343 | ret = -EINVAL;
|
| 344 | goto leave_no_lock;
|
| 345 | }
|
| 346 |
|
| 347 | if (tgt_device->total_bytes < src_device->total_bytes) {
|
| 348 | pr_err("btrfs: target device is smaller than source device!\n");
|
| 349 | ret = -EINVAL;
|
| 350 | goto leave_no_lock;
|
| 351 | }
|
| 352 |
|
| 353 | btrfs_dev_replace_lock(dev_replace);
|
| 354 | switch (dev_replace->replace_state) {
|
| 355 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 356 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 357 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 358 | break;
|
| 359 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 360 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 361 | args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED;
|
| 362 | goto leave;
|
| 363 | }
|
| 364 |
|
| 365 | dev_replace->cont_reading_from_srcdev_mode =
|
| 366 | args->start.cont_reading_from_srcdev_mode;
|
| 367 | WARN_ON(!src_device);
|
| 368 | dev_replace->srcdev = src_device;
|
| 369 | WARN_ON(!tgt_device);
|
| 370 | dev_replace->tgtdev = tgt_device;
|
| 371 |
|
| 372 | printk_in_rcu(KERN_INFO
|
| 373 | "btrfs: dev_replace from %s (devid %llu) to %s) started\n",
|
| 374 | src_device->missing ? "<missing disk>" :
|
| 375 | rcu_str_deref(src_device->name),
|
| 376 | src_device->devid,
|
| 377 | rcu_str_deref(tgt_device->name));
|
| 378 |
|
| 379 | tgt_device->total_bytes = src_device->total_bytes;
|
| 380 | tgt_device->disk_total_bytes = src_device->disk_total_bytes;
|
| 381 | tgt_device->bytes_used = src_device->bytes_used;
|
| 382 |
|
| 383 | |
| 384 | * from now on, the writes to the srcdev are all duplicated to
|
| 385 | * go to the tgtdev as well (refer to btrfs_map_block()).
|
| 386 |
|
| 387 | dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
|
| 388 | dev_replace->time_started = btrfs_get_seconds_since_1970();
|
| 389 | dev_replace->cursor_left = 0;
|
| 390 | dev_replace->committed_cursor_left = 0;
|
| 391 | dev_replace->cursor_left_last_write_of_item = 0;
|
| 392 | dev_replace->cursor_right = 0;
|
| 393 | dev_replace->is_valid = 1;
|
| 394 | dev_replace->item_needs_writeback = 1;
|
| 395 | args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
|
| 396 | btrfs_dev_replace_unlock(dev_replace);
|
| 397 |
|
| 398 | btrfs_wait_ordered_extents(root, 0);
|
| 399 |
|
| 400 |
|
| 401 | trans = btrfs_start_transaction(root, 0);
|
| 402 | if (IS_ERR(trans)) {
|
| 403 | ret = PTR_ERR(trans);
|
| 404 | btrfs_dev_replace_lock(dev_replace);
|
| 405 | goto leave;
|
| 406 | }
|
| 407 |
|
| 408 | ret = btrfs_commit_transaction(trans, root);
|
| 409 | WARN_ON(ret);
|
| 410 |
|
| 411 |
|
| 412 | ret = btrfs_scrub_dev(fs_info, src_device->devid, 0,
|
| 413 | src_device->total_bytes,
|
| 414 | &dev_replace->scrub_progress, 0, 1);
|
| 415 |
|
| 416 | ret = btrfs_dev_replace_finishing(root->fs_info, ret);
|
| 417 | WARN_ON(ret);
|
| 418 |
|
| 419 | return 0;
|
| 420 |
|
| 421 | leave:
|
| 422 | dev_replace->srcdev = NULL;
|
| 423 | dev_replace->tgtdev = NULL;
|
| 424 | btrfs_dev_replace_unlock(dev_replace);
|
| 425 | leave_no_lock:
|
| 426 | if (tgt_device)
|
| 427 | btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);
|
| 428 | return ret;
|
| 429 | }
|
| 430 |
|
| 431 | static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
|
| 432 | int scrub_ret)
|
| 433 | {
|
| 434 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 435 | struct btrfs_device *tgt_device;
|
| 436 | struct btrfs_device *src_device;
|
| 437 | struct btrfs_root *root = fs_info->tree_root;
|
| 438 | u8 uuid_tmp[BTRFS_UUID_SIZE];
|
| 439 | struct btrfs_trans_handle *trans;
|
| 440 | int ret = 0;
|
| 441 |
|
| 442 |
|
| 443 | mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
|
| 444 |
|
| 445 | btrfs_dev_replace_lock(dev_replace);
|
| 446 |
|
| 447 | if (dev_replace->replace_state !=
|
| 448 | BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED) {
|
| 449 | btrfs_dev_replace_unlock(dev_replace);
|
| 450 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 451 | return 0;
|
| 452 | }
|
| 453 |
|
| 454 | tgt_device = dev_replace->tgtdev;
|
| 455 | src_device = dev_replace->srcdev;
|
| 456 | btrfs_dev_replace_unlock(dev_replace);
|
| 457 |
|
| 458 |
|
| 459 | if (!scrub_ret)
|
| 460 | btrfs_dev_replace_update_device_in_mapping_tree(fs_info,
|
| 461 | src_device,
|
| 462 | tgt_device);
|
| 463 |
|
| 464 | |
| 465 | * flush all outstanding I/O and inode extent mappings before the
|
| 466 | * copy operation is declared as being finished
|
| 467 |
|
| 468 | ret = btrfs_start_delalloc_inodes(root, 0);
|
| 469 | if (ret) {
|
| 470 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 471 | return ret;
|
| 472 | }
|
| 473 | btrfs_wait_ordered_extents(root, 0);
|
| 474 |
|
| 475 | trans = btrfs_start_transaction(root, 0);
|
| 476 | if (IS_ERR(trans)) {
|
| 477 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 478 | return PTR_ERR(trans);
|
| 479 | }
|
| 480 | ret = btrfs_commit_transaction(trans, root);
|
| 481 | WARN_ON(ret);
|
| 482 |
|
| 483 |
|
| 484 | mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
| 485 | btrfs_dev_replace_lock(dev_replace);
|
| 486 | dev_replace->replace_state =
|
| 487 | scrub_ret ? BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
|
| 488 | : BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED;
|
| 489 | dev_replace->tgtdev = NULL;
|
| 490 | dev_replace->srcdev = NULL;
|
| 491 | dev_replace->time_stopped = btrfs_get_seconds_since_1970();
|
| 492 | dev_replace->item_needs_writeback = 1;
|
| 493 |
|
| 494 | if (scrub_ret) {
|
| 495 | printk_in_rcu(KERN_ERR
|
| 496 | "btrfs: btrfs_scrub_dev(%s, %llu, %s) failed %d\n",
|
| 497 | src_device->missing ? "<missing disk>" :
|
| 498 | rcu_str_deref(src_device->name),
|
| 499 | src_device->devid,
|
| 500 | rcu_str_deref(tgt_device->name), scrub_ret);
|
| 501 | btrfs_dev_replace_unlock(dev_replace);
|
| 502 | mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
| 503 | if (tgt_device)
|
| 504 | btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);
|
| 505 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 506 |
|
| 507 | return 0;
|
| 508 | }
|
| 509 |
|
| 510 | printk_in_rcu(KERN_INFO
|
| 511 | "btrfs: dev_replace from %s (devid %llu) to %s) finished\n",
|
| 512 | src_device->missing ? "<missing disk>" :
|
| 513 | rcu_str_deref(src_device->name),
|
| 514 | src_device->devid,
|
| 515 | rcu_str_deref(tgt_device->name));
|
| 516 | tgt_device->is_tgtdev_for_dev_replace = 0;
|
| 517 | tgt_device->devid = src_device->devid;
|
| 518 | src_device->devid = BTRFS_DEV_REPLACE_DEVID;
|
| 519 | tgt_device->bytes_used = src_device->bytes_used;
|
| 520 | memcpy(uuid_tmp, tgt_device->uuid, sizeof(uuid_tmp));
|
| 521 | memcpy(tgt_device->uuid, src_device->uuid, sizeof(tgt_device->uuid));
|
| 522 | memcpy(src_device->uuid, uuid_tmp, sizeof(src_device->uuid));
|
| 523 | tgt_device->total_bytes = src_device->total_bytes;
|
| 524 | tgt_device->disk_total_bytes = src_device->disk_total_bytes;
|
| 525 | tgt_device->bytes_used = src_device->bytes_used;
|
| 526 | if (fs_info->sb->s_bdev == src_device->bdev)
|
| 527 | fs_info->sb->s_bdev = tgt_device->bdev;
|
| 528 | if (fs_info->fs_devices->latest_bdev == src_device->bdev)
|
| 529 | fs_info->fs_devices->latest_bdev = tgt_device->bdev;
|
| 530 | list_add(&tgt_device->dev_alloc_list, &fs_info->fs_devices->alloc_list);
|
| 531 |
|
| 532 | btrfs_rm_dev_replace_srcdev(fs_info, src_device);
|
| 533 | if (src_device->bdev) {
|
| 534 |
|
| 535 | btrfs_scratch_superblock(src_device);
|
| 536 | }
|
| 537 | |
| 538 | * this is again a consistent state where no dev_replace procedure
|
| 539 | * is running, the target device is part of the filesystem, the
|
| 540 | * source device is not part of the filesystem anymore and its 1st
|
| 541 | * superblock is scratched out so that it is no longer marked to
|
| 542 | * belong to this filesystem.
|
| 543 |
|
| 544 | btrfs_dev_replace_unlock(dev_replace);
|
| 545 | mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
| 546 |
|
| 547 |
|
| 548 | trans = btrfs_start_transaction(root, 0);
|
| 549 | if (!IS_ERR(trans))
|
| 550 | btrfs_commit_transaction(trans, root);
|
| 551 |
|
| 552 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 553 |
|
| 554 | return 0;
|
| 555 | }
|
| 556 |
|
| 557 | static void btrfs_dev_replace_update_device_in_mapping_tree(
|
| 558 | struct btrfs_fs_info *fs_info,
|
| 559 | struct btrfs_device *srcdev,
|
| 560 | struct btrfs_device *tgtdev)
|
| 561 | {
|
| 562 | struct extent_map_tree *em_tree = &fs_info->mapping_tree.map_tree;
|
| 563 | struct extent_map *em;
|
| 564 | struct map_lookup *map;
|
| 565 | u64 start = 0;
|
| 566 | int i;
|
| 567 |
|
| 568 | write_lock(&em_tree->lock);
|
| 569 | do {
|
| 570 | em = lookup_extent_mapping(em_tree, start, (u64)-1);
|
| 571 | if (!em)
|
| 572 | break;
|
| 573 | map = (struct map_lookup *)em->bdev;
|
| 574 | for (i = 0; i < map->num_stripes; i++)
|
| 575 | if (srcdev == map->stripes[i].dev)
|
| 576 | map->stripes[i].dev = tgtdev;
|
| 577 | start = em->start + em->len;
|
| 578 | free_extent_map(em);
|
| 579 | } while (start);
|
| 580 | write_unlock(&em_tree->lock);
|
| 581 | }
|
| 582 |
|
| 583 | static int btrfs_dev_replace_find_srcdev(struct btrfs_root *root, u64 srcdevid,
|
| 584 | char *srcdev_name,
|
| 585 | struct btrfs_device **device)
|
| 586 | {
|
| 587 | int ret;
|
| 588 |
|
| 589 | if (srcdevid) {
|
| 590 | ret = 0;
|
| 591 | *device = btrfs_find_device(root->fs_info, srcdevid, NULL,
|
| 592 | NULL);
|
| 593 | if (!*device)
|
| 594 | ret = -ENOENT;
|
| 595 | } else {
|
| 596 | ret = btrfs_find_device_missing_or_by_path(root, srcdev_name,
|
| 597 | device);
|
| 598 | }
|
| 599 | return ret;
|
| 600 | }
|
| 601 |
|
| 602 | void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
|
| 603 | struct btrfs_ioctl_dev_replace_args *args)
|
| 604 | {
|
| 605 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 606 |
|
| 607 | btrfs_dev_replace_lock(dev_replace);
|
| 608 | |
| 609 | * the replace_status ioctl
|
| 610 | args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
|
| 611 | args->status.replace_state = dev_replace->replace_state;
|
| 612 | args->status.time_started = dev_replace->time_started;
|
| 613 | args->status.time_stopped = dev_replace->time_stopped;
|
| 614 | args->status.num_write_errors =
|
| 615 | atomic64_read(&dev_replace->num_write_errors);
|
| 616 | args->status.num_uncorrectable_read_errors =
|
| 617 | atomic64_read(&dev_replace->num_uncorrectable_read_errors);
|
| 618 | switch (dev_replace->replace_state) {
|
| 619 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 620 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 621 | args->status.progress_1000 = 0;
|
| 622 | break;
|
| 623 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 624 | args->status.progress_1000 = 1000;
|
| 625 | break;
|
| 626 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 627 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 628 | args->status.progress_1000 = div64_u64(dev_replace->cursor_left,
|
| 629 | div64_u64(dev_replace->srcdev->total_bytes, 1000));
|
| 630 | break;
|
| 631 | }
|
| 632 | btrfs_dev_replace_unlock(dev_replace);
|
| 633 | }
|
| 634 |
|
| 635 | int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info,
|
| 636 | struct btrfs_ioctl_dev_replace_args *args)
|
| 637 | {
|
| 638 | args->result = __btrfs_dev_replace_cancel(fs_info);
|
| 639 | return 0;
|
| 640 | }
|
| 641 |
|
| 642 | static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
|
| 643 | {
|
| 644 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 645 | struct btrfs_device *tgt_device = NULL;
|
| 646 | struct btrfs_trans_handle *trans;
|
| 647 | struct btrfs_root *root = fs_info->tree_root;
|
| 648 | u64 result;
|
| 649 | int ret;
|
| 650 |
|
| 651 | mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
|
| 652 | btrfs_dev_replace_lock(dev_replace);
|
| 653 | switch (dev_replace->replace_state) {
|
| 654 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 655 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 656 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 657 | result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED;
|
| 658 | btrfs_dev_replace_unlock(dev_replace);
|
| 659 | goto leave;
|
| 660 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 661 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 662 | result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
|
| 663 | tgt_device = dev_replace->tgtdev;
|
| 664 | dev_replace->tgtdev = NULL;
|
| 665 | dev_replace->srcdev = NULL;
|
| 666 | break;
|
| 667 | }
|
| 668 | dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED;
|
| 669 | dev_replace->time_stopped = btrfs_get_seconds_since_1970();
|
| 670 | dev_replace->item_needs_writeback = 1;
|
| 671 | btrfs_dev_replace_unlock(dev_replace);
|
| 672 | btrfs_scrub_cancel(fs_info);
|
| 673 |
|
| 674 | trans = btrfs_start_transaction(root, 0);
|
| 675 | if (IS_ERR(trans)) {
|
| 676 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 677 | return PTR_ERR(trans);
|
| 678 | }
|
| 679 | ret = btrfs_commit_transaction(trans, root);
|
| 680 | WARN_ON(ret);
|
| 681 | if (tgt_device)
|
| 682 | btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);
|
| 683 |
|
| 684 | leave:
|
| 685 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 686 | return result;
|
| 687 | }
|
| 688 |
|
| 689 | void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)
|
| 690 | {
|
| 691 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 692 |
|
| 693 | mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
|
| 694 | btrfs_dev_replace_lock(dev_replace);
|
| 695 | switch (dev_replace->replace_state) {
|
| 696 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 697 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 698 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 699 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 700 | break;
|
| 701 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 702 | dev_replace->replace_state =
|
| 703 | BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
|
| 704 | dev_replace->time_stopped = btrfs_get_seconds_since_1970();
|
| 705 | dev_replace->item_needs_writeback = 1;
|
| 706 | pr_info("btrfs: suspending dev_replace for unmount\n");
|
| 707 | break;
|
| 708 | }
|
| 709 |
|
| 710 | btrfs_dev_replace_unlock(dev_replace);
|
| 711 | mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
|
| 712 | }
|
| 713 |
|
| 714 |
|
| 715 | int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info)
|
| 716 | {
|
| 717 | struct task_struct *task;
|
| 718 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 719 |
|
| 720 | btrfs_dev_replace_lock(dev_replace);
|
| 721 | switch (dev_replace->replace_state) {
|
| 722 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 723 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 724 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 725 | btrfs_dev_replace_unlock(dev_replace);
|
| 726 | return 0;
|
| 727 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 728 | break;
|
| 729 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 730 | dev_replace->replace_state =
|
| 731 | BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
|
| 732 | break;
|
| 733 | }
|
| 734 | if (!dev_replace->tgtdev || !dev_replace->tgtdev->bdev) {
|
| 735 | pr_info("btrfs: cannot continue dev_replace, tgtdev is missing\n"
|
| 736 | "btrfs: you may cancel the operation after 'mount -o degraded'\n");
|
| 737 | btrfs_dev_replace_unlock(dev_replace);
|
| 738 | return 0;
|
| 739 | }
|
| 740 | btrfs_dev_replace_unlock(dev_replace);
|
| 741 |
|
| 742 | WARN_ON(atomic_xchg(
|
| 743 | &fs_info->mutually_exclusive_operation_running, 1));
|
| 744 | task = kthread_run(btrfs_dev_replace_kthread, fs_info, "btrfs-devrepl");
|
| 745 | return PTR_RET(task);
|
| 746 | }
|
| 747 |
|
| 748 | static int btrfs_dev_replace_kthread(void *data)
|
| 749 | {
|
| 750 | struct btrfs_fs_info *fs_info = data;
|
| 751 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 752 | struct btrfs_ioctl_dev_replace_args *status_args;
|
| 753 | u64 progress;
|
| 754 |
|
| 755 | status_args = kzalloc(sizeof(*status_args), GFP_NOFS);
|
| 756 | if (status_args) {
|
| 757 | btrfs_dev_replace_status(fs_info, status_args);
|
| 758 | progress = status_args->status.progress_1000;
|
| 759 | kfree(status_args);
|
| 760 | do_div(progress, 10);
|
| 761 | printk_in_rcu(KERN_INFO
|
| 762 | "btrfs: continuing dev_replace from %s (devid %llu) to %s @%u%%\n",
|
| 763 | dev_replace->srcdev->missing ? "<missing disk>" :
|
| 764 | rcu_str_deref(dev_replace->srcdev->name),
|
| 765 | dev_replace->srcdev->devid,
|
| 766 | dev_replace->tgtdev ?
|
| 767 | rcu_str_deref(dev_replace->tgtdev->name) :
|
| 768 | "<missing target disk>",
|
| 769 | (unsigned int)progress);
|
| 770 | }
|
| 771 | btrfs_dev_replace_continue_on_mount(fs_info);
|
| 772 | atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
|
| 773 |
|
| 774 | return 0;
|
| 775 | }
|
| 776 |
|
| 777 | static int btrfs_dev_replace_continue_on_mount(struct btrfs_fs_info *fs_info)
|
| 778 | {
|
| 779 | struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
| 780 | int ret;
|
| 781 |
|
| 782 | ret = btrfs_scrub_dev(fs_info, dev_replace->srcdev->devid,
|
| 783 | dev_replace->committed_cursor_left,
|
| 784 | dev_replace->srcdev->total_bytes,
|
| 785 | &dev_replace->scrub_progress, 0, 1);
|
| 786 | ret = btrfs_dev_replace_finishing(fs_info, ret);
|
| 787 | WARN_ON(ret);
|
| 788 | return 0;
|
| 789 | }
|
| 790 |
|
| 791 | int btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
|
| 792 | {
|
| 793 | if (!dev_replace->is_valid)
|
| 794 | return 0;
|
| 795 |
|
| 796 | switch (dev_replace->replace_state) {
|
| 797 | case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
|
| 798 | case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
|
| 799 | case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
|
| 800 | return 0;
|
| 801 | case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
|
| 802 | case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
|
| 803 | |
| 804 | * return true even if tgtdev is missing (this is
|
| 805 | * something that can happen if the dev_replace
|
| 806 | * procedure is suspended by an umount and then
|
| 807 | * the tgtdev is missing (or "btrfs dev scan") was
|
| 808 | * not called and the the filesystem is remounted
|
| 809 | * in degraded state. This does not stop the
|
| 810 | * dev_replace procedure. It needs to be canceled
|
| 811 | * manually if the cancelation is wanted.
|
| 812 |
|
| 813 | break;
|
| 814 | }
|
| 815 | return 1;
|
| 816 | }
|
| 817 |
|
| 818 | void btrfs_dev_replace_lock(struct btrfs_dev_replace *dev_replace)
|
| 819 | {
|
| 820 |
|
| 821 | if (atomic_read(&dev_replace->nesting_level) == 0) {
|
| 822 | acquire_lock:
|
| 823 | |
| 824 | * is trying to acqurire the same lock twice
|
| 825 | mutex_lock(&dev_replace->lock);
|
| 826 | mutex_lock(&dev_replace->lock_management_lock);
|
| 827 | dev_replace->lock_owner = current->pid;
|
| 828 | atomic_inc(&dev_replace->nesting_level);
|
| 829 | mutex_unlock(&dev_replace->lock_management_lock);
|
| 830 | return;
|
| 831 | }
|
| 832 |
|
| 833 | mutex_lock(&dev_replace->lock_management_lock);
|
| 834 | if (atomic_read(&dev_replace->nesting_level) > 0 &&
|
| 835 | dev_replace->lock_owner == current->pid) {
|
| 836 | WARN_ON(!mutex_is_locked(&dev_replace->lock));
|
| 837 | atomic_inc(&dev_replace->nesting_level);
|
| 838 | mutex_unlock(&dev_replace->lock_management_lock);
|
| 839 | return;
|
| 840 | }
|
| 841 |
|
| 842 | mutex_unlock(&dev_replace->lock_management_lock);
|
| 843 | goto acquire_lock;
|
| 844 | }
|
| 845 |
|
| 846 | void btrfs_dev_replace_unlock(struct btrfs_dev_replace *dev_replace)
|
| 847 | {
|
| 848 | WARN_ON(!mutex_is_locked(&dev_replace->lock));
|
| 849 | mutex_lock(&dev_replace->lock_management_lock);
|
| 850 | WARN_ON(atomic_read(&dev_replace->nesting_level) < 1);
|
| 851 | WARN_ON(dev_replace->lock_owner != current->pid);
|
| 852 | atomic_dec(&dev_replace->nesting_level);
|
| 853 | if (atomic_read(&dev_replace->nesting_level) == 0) {
|
| 854 | dev_replace->lock_owner = 0;
|
| 855 | mutex_unlock(&dev_replace->lock_management_lock);
|
| 856 | mutex_unlock(&dev_replace->lock);
|
| 857 | } else {
|
| 858 | mutex_unlock(&dev_replace->lock_management_lock);
|
| 859 | }
|
| 860 | }
|