/* * Copyright (C) STRATO AG 2012.  All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License v2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 021110-1307, USA. */#include <linux/sched.h>#include <linux/bio.h>#include <linux/slab.h>#include <linux/buffer_head.h>#include <linux/blkdev.h>#include <linux/random.h>#include <linux/iocontext.h>#include <linux/capability.h>#include <linux/kthread.h>#include <linux/math64.h>#include <asm/div64.h>#include "ctree.h"#include "extent_map.h"#include "disk-io.h"#include "transaction.h"#include "print-tree.h"#include "volumes.h"#include "async-thread.h"#include "check-integrity.h"#include "rcu-string.h"#include "dev-replace.h"#include "sysfs.h" static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,				       int scrub_ret);static void btrfs_dev_replace_update_device_in_mapping_tree(						struct btrfs_fs_info *fs_info,						struct btrfs_device *srcdev,						struct btrfs_device *tgtdev);static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info);static int btrfs_dev_replace_kthread(void *data);static int btrfs_dev_replace_continue_on_mount(struct btrfs_fs_info *fs_info);  int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info){	struct btrfs_key key;	struct btrfs_root *dev_root = fs_info->dev_root;	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;	struct extent_buffer *eb;	int slot;	int ret = 0;	struct btrfs_path *path = NULL;	int item_size;	struct btrfs_dev_replace_item *ptr;	u64 src_devid; 	path = btrfs_alloc_path();	if (!path) {		ret = -ENOMEM;		goto out;	} 	key.objectid = 0;	key.type = BTRFS_DEV_REPLACE_KEY;	key.offset = 0;	ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);	if (ret) {no_valid_dev_replace_entry_found:		ret = 0;		dev_replace->replace_state =			BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED;		dev_replace->cont_reading_from_srcdev_mode =		    BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS;		dev_replace->replace_state = 0;		dev_replace->time_started = 0;		dev_replace->time_stopped = 0;		atomic64_set(&dev_replace->num_write_errors, 0);		atomic64_set(&dev_replace->num_uncorrectable_read_errors, 0);		dev_replace->cursor_left = 0;		dev_replace->committed_cursor_left = 0;		dev_replace->cursor_left_last_write_of_item = 0;		dev_replace->cursor_right = 0;		dev_replace->srcdev = NULL;		dev_replace->tgtdev = NULL;		dev_replace->is_valid = 0;		dev_replace->item_needs_writeback = 0;		goto out;	}	slot = path->slots[0];	eb = path->nodes[0];	item_size = btrfs_item_size_nr(eb, slot);	ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_replace_item); 	if (item_size != sizeof(struct btrfs_dev_replace_item)) {		btrfs_warn(fs_info,			"dev_replace entry found has unexpected size, ignore entry");		goto no_valid_dev_replace_entry_found;	} 	src_devid = btrfs_dev_replace_src_devid(eb, ptr);	dev_replace->cont_reading_from_srcdev_mode =		btrfs_dev_replace_cont_reading_from_srcdev_mode(eb, ptr);	dev_replace->replace_state = btrfs_dev_replace_replace_state(eb, ptr);	dev_replace->time_started = btrfs_dev_replace_time_started(eb, ptr);	dev_replace->time_stopped =		btrfs_dev_replace_time_stopped(eb, ptr);	atomic64_set(&dev_replace->num_write_errors,		     btrfs_dev_replace_num_write_errors(eb, ptr));	atomic64_set(&dev_replace->num_uncorrectable_read_errors,		     btrfs_dev_replace_num_uncorrectable_read_errors(eb, ptr));	dev_replace->cursor_left = btrfs_dev_replace_cursor_left(eb, ptr);	dev_replace->committed_cursor_left = dev_replace->cursor_left;	dev_replace->cursor_left_last_write_of_item = dev_replace->cursor_left;	dev_replace->cursor_right = btrfs_dev_replace_cursor_right(eb, ptr);	dev_replace->is_valid = 1; 	dev_replace->item_needs_writeback = 0;	switch (dev_replace->replace_state) {	case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:	case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:	case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:		dev_replace->srcdev = NULL;		dev_replace->tgtdev = NULL;		break;	case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:	case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:		dev_replace->srcdev = btrfs_find_device(fs_info, src_devid,							NULL, NULL);		dev_replace->tgtdev = btrfs_find_device(fs_info,							BTRFS_DEV_REPLACE_DEVID,							NULL, NULL);		/*		 * allow 'btrfs dev replace_cancel' if src/tgt device is		 * missing		 */		if (!dev_replace->srcdev &&		    !btrfs_test_opt(fs_info, DEGRADED)) {			ret = -EIO;			btrfs_warn(fs_info,			   "cannot mount because device replace operation is ongoing and");			btrfs_warn(fs_info,			   "srcdev (devid %llu) is missing, need to run 'btrfs dev scan'?",			   src_devid);		}		if (!dev_replace->tgtdev &&		    !btrfs_test_opt(fs_info, DEGRADED)) {			ret = -EIO;			btrfs_warn(fs_info,			   "cannot mount because device replace operation is ongoing and");			btrfs_warn(fs_info,			   "tgtdev (devid %llu) is missing, need to run 'btrfs dev scan'?",				BTRFS_DEV_REPLACE_DEVID);		}		if (dev_replace->tgtdev) {			if (dev_replace->srcdev) {				dev_replace->tgtdev->total_bytes =					dev_replace->srcdev->total_bytes;				dev_replace->tgtdev->disk_total_bytes =					dev_replace->srcdev->disk_total_bytes;				dev_replace->tgtdev->commit_total_bytes =					dev_replace->srcdev->commit_total_bytes;				dev_replace->tgtdev->bytes_used =					dev_replace->srcdev->bytes_used;				dev_replace->tgtdev->commit_bytes_used =					dev_replace->srcdev->commit_bytes_used;			}			dev_replace->tgtdev->is_tgtdev_for_dev_replace = 1;			btrfs_init_dev_replace_tgtdev_for_resume(fs_info,				dev_replace->tgtdev);		}		break;	} out:	btrfs_free_path(path);	return ret;} /* * called from commit_transaction. Writes changed device replace state to * disk. */int btrfs_run_dev_replace(struct btrfs_trans_handle *trans,			  struct btrfs_fs_info *fs_info){	int ret;	struct btrfs_root *dev_root = fs_info->dev_root;	struct btrfs_path *path;	struct btrfs_key key;	struct extent_buffer *eb;	struct btrfs_dev_replace_item *ptr;	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; 	btrfs_dev_replace_lock(dev_replace, 0);	if (!dev_replace->is_valid ||	    !dev_replace->item_needs_writeback) {		btrfs_dev_replace_unlock(dev_replace, 0);		return 0;	}	btrfs_dev_replace_unlock(dev_replace, 0); 	key.objectid = 0;	key.type = BTRFS_DEV_REPLACE_KEY;	key.offset = 0; 	path = btrfs_alloc_path();	if (!path) {		ret = -ENOMEM;		goto out;	}	ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);	if (ret < 0) {		btrfs_warn(fs_info,			   "error %d while searching for dev_replace item!",			   ret);		goto out;	} 	if (ret == 0 &&	    btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {		/*		 * need to delete old one and insert a new one.		 * Since no attempt is made to recover any old state, if the		 * dev_replace state is 'running', the data on the target		 * drive is lost.		 * It would be possible to recover the state: just make sure		 * that the beginning of the item is never changed and always		 * contains all the essential information. Then read this		 * minimal set of information and use it as a base for the		 * new state.		 */		ret = btrfs_del_item(trans, dev_root, path);		if (ret != 0) {			btrfs_warn(fs_info,				   "delete too small dev_replace item failed %d!",				   ret);			goto out;		}		ret = 1;	} 	if (ret == 1) {		/* need to insert a new item */		btrfs_release_path(path);		ret = btrfs_insert_empty_item(trans, dev_root, path,					      &key, sizeof(*ptr));		if (ret < 0) {			btrfs_warn(fs_info,				   "insert dev_replace item failed %d!", ret);			goto out;		}	} 	eb = path->nodes[0];	ptr = btrfs_item_ptr(eb, path->slots[0],			     struct btrfs_dev_replace_item); 	btrfs_dev_replace_lock(dev_replace, 1);	if (dev_replace->srcdev)		btrfs_set_dev_replace_src_devid(eb, ptr,			dev_replace->srcdev->devid);	else		btrfs_set_dev_replace_src_devid(eb, ptr, (u64)-1);	btrfs_set_dev_replace_cont_reading_from_srcdev_mode(eb, ptr,		dev_replace->cont_reading_from_srcdev_mode);	btrfs_set_dev_replace_replace_state(eb, ptr,		dev_replace->replace_state);	btrfs_set_dev_replace_time_started(eb, ptr, dev_replace->time_started);	btrfs_set_dev_replace_time_stopped(eb, ptr, dev_replace->time_stopped);	btrfs_set_dev_replace_num_write_errors(eb, ptr,		atomic64_read(&dev_replace->num_write_errors));	btrfs_set_dev_replace_num_uncorrectable_read_errors(eb, ptr,		atomic64_read(&dev_replace->num_uncorrectable_read_errors));	dev_replace->cursor_left_last_write_of_item =		dev_replace->cursor_left;	btrfs_set_dev_replace_cursor_left(eb, ptr,		dev_replace->cursor_left_last_write_of_item);	btrfs_set_dev_replace_cursor_right(eb, ptr,		dev_replace->cursor_right);	dev_replace->item_needs_writeback = 0;	btrfs_dev_replace_unlock(dev_replace, 1); 	btrfs_mark_buffer_dirty(eb); out:	btrfs_free_path(path); 	return ret;} void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info){	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace; 	dev_replace->committed_cursor_left =		dev_replace->cursor_left_last_write_of_item;} int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info,		const char *tgtdev_name, u64 srcdevid, const char *srcdev_name,		int read_src){	struct btrfs_root *root = fs_info->dev_root;	struct btrfs_trans_handle *trans;	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;	int ret;	struct btrfs_device *tgt_device = NULL;	struct btrfs_device *src_device = NULL; 	/* the disk copy procedure reuses the scrub code */	mutex_lock(&fs_info->volume_mutex);	ret = btrfs_find_device_by_devspec(fs_info, srcdevid,					    srcdev_name, &src_device);	if (ret) {		mutex_unlock(&fs_info->volume_mutex);		return ret;	} 	ret = btrfs_init_dev_replace_tgtdev(fs_info, tgtdev_name,					    src_device, &tgt_device);	mutex_unlock(&fs_info->volume_mutex);	if (ret)		return ret; 	/*	 * Here we commit the transaction to make sure commit_total_bytes	 * of all the devices are updated.	 */	trans = btrfs_attach_transaction(root);	if (!IS_ERR(trans)) {		ret = btrfs_commit_transaction(trans);		if (ret)			return ret;	} else if (PTR_ERR(trans) != -ENOENT) {		return PTR_ERR(trans);	} 	btrfs_dev_replace_lock(dev_replace, 1);	switch (dev_replace->replace_state) {	case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:	case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:	case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:		break;	case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:	case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:		ret = BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED;		goto leave;	} 	dev_replace->cont_reading_from_srcdev_mode = read_src;	WARN_ON(!src_device);	dev_replace->srcdev = src_device;	WARN_ON(!tgt_device);	dev_replace->tgtdev = tgt_device; 	btrfs_info_in_rcu(fs_info,		      "dev_replace from %s (devid %llu) to %s started",		      src_device->missing ? "<missing disk>" :		        rcu_str_deref(src_device->name),		      src_device->devid,		      rcu_str_deref(tgt_device->name)); 	/*	 * from now on, the writes to the srcdev are all duplicated to	 * go to the tgtdev as well (refer to btrfs_map_block()).	 */	dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;	dev_replace->time_started = get_seconds();	dev_replace->cursor_left = 0;	dev_replace->committed_cursor_left = 0;	dev_replace->cursor_left_last_write_of_item = 0;	dev_replace->cursor_right = 0;	dev_replace->is_valid = 1;	dev_replace->item_needs_writeback = 1;	atomic64_set(&dev_replace->num_write_errors, 0);	atomic64_set(&dev_replace->num_uncorrectable_read_errors, 0);	btrfs_dev_replace_unlock(dev_replace, 1); 	ret = btrfs_sysfs_add_device_link(tgt_device->fs_devices, tgt_device);	if (ret)		btrfs_err(fs_info, "kobj add dev failed %d", ret); 	btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 	/* force writing the updated state information to disk */	trans = btrfs_start_transaction(root, 0);	if (IS_ERR(trans)) {		ret = PTR_ERR(trans);		btrfs_dev_replace_lock(dev_replace, 1);		goto leave;	} 	ret = btrfs_commit_transaction(trans);	WARN_ON(ret); 	/* the disk copy procedure reuses the scrub code */	ret = btrfs_scrub_dev(fs_info, src_device->devid, 0,			      btrfs_device_get_total_bytes(src_device),			      &dev_replace->scrub_progress, 0, 1); 	ret = btrfs_dev_replace_finishing(fs_info, ret);	if (ret == -EINPROGRESS) {		ret = BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS;	} else {		WARN_ON(ret);	} 	return ret; leave:	dev_replace->srcdev = NULL;	dev_replace->tgtdev = NULL;	btrfs_dev_replace_unlock(dev_replace, 1);	btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);	return ret;} int btrfs_dev_replace_by_ioctl(struct btrfs_fs_info *fs_info,			    struct btrfs_ioctl_dev_replace_args *args){	int ret; 	switch (args->start.cont_reading_from_srcdev_mode) {	case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS:	case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID:		break;	default:		return -EINVAL;	} 	if ((args->start.srcdevid == 0 && args->start.srcdev_name[0] == '\0') ||	    args->start.tgtdev_name[0] == '\0')		return -EINVAL; 	ret = btrfs_dev_replace_start(fs_info, args->start.tgtdev_name,					args->start.srcdevid,					args->start.srcdev_name,					args->start.cont_reading_from_srcdev_mode);	args->result = ret;	/* don't warn if EINPROGRESS, someone else might be running scrub */	if (ret == BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS)		ret = 0; 	return ret;} /* * blocked until all in-flight bios operations are finished. */static void btrfs_rm_dev_replace_blocked(struct btrfs_fs_info *fs_info){	set_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);	wait_event(fs_info->replace_wait, !percpu_counter_sum(		   &fs_info->bio_counter));} /* * we have removed target device, it is safe to allow new bios request. */static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info *fs_info){	clear_bit(BTRFS_FS_STATE_DEV_REPLACING, &fs_info->fs_state);	wake_up(&fs_info->replace_wait);} static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,				       int scrub_ret){	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;	struct btrfs_device *tgt_device;	struct btrfs_device *src_device;	struct btrfs_root *root = fs_info->tree_root;	u8 uuid_tmp[BTRFS_UUID_SIZE];	struct btrfs_trans_handle *trans;	int ret = 0; 	/* don't allow cancel or unmount to disturb the finishing procedure */	mutex_lock(&dev_replace->lock_finishing_cancel_unmount); 	btrfs_dev_replace_lock(dev_replace, 0);	/* was the operation canceled, or is it finished? */	if (dev_replace->replace_state !=	    BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED) {		btrfs_dev_replace_unlock(dev_replace, 0);		mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);		return 0;	} 	tgt_device = dev_replace->tgtdev;	src_device = dev_replace->srcdev;	btrfs_dev_replace_unlock(dev_replace, 0); 

Lines 1–500 of 944. Load more