Commit aa1b8cd4 authored by Stefan Behrens's avatar Stefan Behrens Committed by Josef Bacik
Browse files

Btrfs: pass fs_info instead of root 



A small number of functions that are used in a device replace
procedure when the operation is resumed at mount time are unable
to pass the same root pointer that would be used in the regular
(ioctl) context. And since the root pointer is not required, only
the fs_info is, the root pointer argument is replaced with the
fs_info pointer argument.

Signed-off-by: default avatarStefan Behrens <sbehrens@giantdisaster.de>
Signed-off-by: default avatarChris Mason <chris.mason@fusionio.com>
parent a8a6dab7

fs/btrfs/ctree.h

+6 −5
Original line number Diff line number Diff line
@@ -3540,15 +3540,16 @@ int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, 
			      struct btrfs_pending_snapshot *pending);



/* scrub.c */

int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,

		    struct btrfs_scrub_progress *progress, int readonly);

int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,

		    u64 end, struct btrfs_scrub_progress *progress,

		    int readonly);

void btrfs_scrub_pause(struct btrfs_root *root);

void btrfs_scrub_pause_super(struct btrfs_root *root);

void btrfs_scrub_continue(struct btrfs_root *root);

void btrfs_scrub_continue_super(struct btrfs_root *root);

int __btrfs_scrub_cancel(struct btrfs_fs_info *info);

int btrfs_scrub_cancel(struct btrfs_root *root);

int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev);

int btrfs_scrub_cancel(struct btrfs_fs_info *info);

int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,

			   struct btrfs_device *dev);

int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid);

int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,

			 struct btrfs_scrub_progress *progress);

fs/btrfs/disk-io.c

+2 −2
Original line number Diff line number Diff line
@@ -3283,9 +3283,9 @@ int close_ctree(struct btrfs_root *root) 
	smp_mb();



	/* pause restriper - we want to resume on mount */

	btrfs_pause_balance(root->fs_info);

	btrfs_pause_balance(fs_info);



	btrfs_scrub_cancel(root);

	btrfs_scrub_cancel(fs_info);



	/* wait for any defraggers to finish */

	wait_event(fs_info->transaction_wait,

fs/btrfs/ioctl.c

+4 −4
Original line number Diff line number Diff line
@@ -1343,7 +1343,7 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root, 
		printk(KERN_INFO "btrfs: resizing devid %llu\n",

		       (unsigned long long)devid);

	}

	device = btrfs_find_device(root, devid, NULL, NULL);

	device = btrfs_find_device(root->fs_info, devid, NULL, NULL);

	if (!device) {

		printk(KERN_INFO "btrfs: resizer unable to find device %llu\n",

		       (unsigned long long)devid);
@@ -2332,7 +2332,7 @@ static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg) 
		s_uuid = di_args->uuid;



	mutex_lock(&fs_devices->device_list_mutex);

	dev = btrfs_find_device(root, di_args->devid, s_uuid, NULL);

	dev = btrfs_find_device(root->fs_info, di_args->devid, s_uuid, NULL);

	mutex_unlock(&fs_devices->device_list_mutex);



	if (!dev) {
@@ -3089,7 +3089,7 @@ static long btrfs_ioctl_scrub(struct btrfs_root *root, void __user *arg) 
	if (IS_ERR(sa))

		return PTR_ERR(sa);



	ret = btrfs_scrub_dev(root, sa->devid, sa->start, sa->end,

	ret = btrfs_scrub_dev(root->fs_info, sa->devid, sa->start, sa->end,

			      &sa->progress, sa->flags & BTRFS_SCRUB_READONLY);



	if (copy_to_user(arg, sa, sizeof(*sa)))
@@ -3104,7 +3104,7 @@ static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg) 
	if (!capable(CAP_SYS_ADMIN))

		return -EPERM;



	return btrfs_scrub_cancel(root);

	return btrfs_scrub_cancel(root->fs_info);

}



static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,

fs/btrfs/scrub.c

+34 −42
Original line number Diff line number Diff line
@@ -2262,9 +2262,8 @@ static noinline_for_stack int scrub_supers(struct scrub_ctx *sctx, 
/*

 * get a reference count on fs_info->scrub_workers. start worker if necessary

 */

static noinline_for_stack int scrub_workers_get(struct btrfs_root *root)

static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	int ret = 0;



	mutex_lock(&fs_info->scrub_lock);
@@ -2283,10 +2282,8 @@ out: 
	return ret;

}



static noinline_for_stack void scrub_workers_put(struct btrfs_root *root)

static noinline_for_stack void scrub_workers_put(struct btrfs_fs_info *fs_info)

{

	struct btrfs_fs_info *fs_info = root->fs_info;



	mutex_lock(&fs_info->scrub_lock);

	if (--fs_info->scrub_workers_refcnt == 0)

		btrfs_stop_workers(&fs_info->scrub_workers);
@@ -2294,29 +2291,29 @@ static noinline_for_stack void scrub_workers_put(struct btrfs_root *root) 
	mutex_unlock(&fs_info->scrub_lock);

}





int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,

		    struct btrfs_scrub_progress *progress, int readonly)

int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,

		    u64 end, struct btrfs_scrub_progress *progress,

		    int readonly)

{

	struct scrub_ctx *sctx;

	struct btrfs_fs_info *fs_info = root->fs_info;

	int ret;

	struct btrfs_device *dev;



	if (btrfs_fs_closing(root->fs_info))

	if (btrfs_fs_closing(fs_info))

		return -EINVAL;



	/*

	 * check some assumptions

	 */

	if (root->nodesize != root->leafsize) {

	if (fs_info->chunk_root->nodesize != fs_info->chunk_root->leafsize) {

		printk(KERN_ERR

		       "btrfs_scrub: size assumption nodesize == leafsize (%d == %d) fails\n",

		       root->nodesize, root->leafsize);

		       fs_info->chunk_root->nodesize,

		       fs_info->chunk_root->leafsize);

		return -EINVAL;

	}



	if (root->nodesize > BTRFS_STRIPE_LEN) {

	if (fs_info->chunk_root->nodesize > BTRFS_STRIPE_LEN) {

		/*

		 * in this case scrub is unable to calculate the checksum

		 * the way scrub is implemented. Do not handle this
@@ -2324,15 +2321,16 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, 
		 */

		printk(KERN_ERR

		       "btrfs_scrub: size assumption nodesize <= BTRFS_STRIPE_LEN (%d <= %d) fails\n",

		       root->nodesize, BTRFS_STRIPE_LEN);

		       fs_info->chunk_root->nodesize, BTRFS_STRIPE_LEN);

		return -EINVAL;

	}



	if (root->sectorsize != PAGE_SIZE) {

	if (fs_info->chunk_root->sectorsize != PAGE_SIZE) {

		/* not supported for data w/o checksums */

		printk(KERN_ERR

		       "btrfs_scrub: size assumption sectorsize != PAGE_SIZE (%d != %lld) fails\n",

		       root->sectorsize, (unsigned long long)PAGE_SIZE);

		       fs_info->chunk_root->sectorsize,

		       (unsigned long long)PAGE_SIZE);

		return -EINVAL;

	}
@@ -2352,37 +2350,37 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, 
		return -EINVAL;

	}



	ret = scrub_workers_get(root);

	ret = scrub_workers_get(fs_info);

	if (ret)

		return ret;



	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);

	dev = btrfs_find_device(root, devid, NULL, NULL);

	mutex_lock(&fs_info->fs_devices->device_list_mutex);

	dev = btrfs_find_device(fs_info, devid, NULL, NULL);

	if (!dev || dev->missing) {

		mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(root);

		mutex_unlock(&fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(fs_info);

		return -ENODEV;

	}

	mutex_lock(&fs_info->scrub_lock);



	if (!dev->in_fs_metadata) {

		mutex_unlock(&fs_info->scrub_lock);

		mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(root);

		return -ENODEV;

		mutex_unlock(&fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(fs_info);

		return -EIO;

	}



	if (dev->scrub_device) {

		mutex_unlock(&fs_info->scrub_lock);

		mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(root);

		mutex_unlock(&fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(fs_info);

		return -EINPROGRESS;

	}

	sctx = scrub_setup_ctx(dev);

	if (IS_ERR(sctx)) {

		mutex_unlock(&fs_info->scrub_lock);

		mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(root);

		mutex_unlock(&fs_info->fs_devices->device_list_mutex);

		scrub_workers_put(fs_info);

		return PTR_ERR(sctx);

	}

	sctx->readonly = readonly;
@@ -2390,7 +2388,7 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, 


	atomic_inc(&fs_info->scrubs_running);

	mutex_unlock(&fs_info->scrub_lock);

	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);

	mutex_unlock(&fs_info->fs_devices->device_list_mutex);



	down_read(&fs_info->scrub_super_lock);

	ret = scrub_supers(sctx, dev);
@@ -2413,7 +2411,7 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, 
	mutex_unlock(&fs_info->scrub_lock);



	scrub_free_ctx(sctx);

	scrub_workers_put(root);

	scrub_workers_put(fs_info);



	return ret;

}
@@ -2453,9 +2451,8 @@ void btrfs_scrub_continue_super(struct btrfs_root *root) 
	up_write(&root->fs_info->scrub_super_lock);

}



int __btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)

int btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)

{



	mutex_lock(&fs_info->scrub_lock);

	if (!atomic_read(&fs_info->scrubs_running)) {

		mutex_unlock(&fs_info->scrub_lock);
@@ -2475,14 +2472,9 @@ int __btrfs_scrub_cancel(struct btrfs_fs_info *fs_info) 
	return 0;

}



int btrfs_scrub_cancel(struct btrfs_root *root)

{

	return __btrfs_scrub_cancel(root->fs_info);

}



int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev)

int btrfs_scrub_cancel_dev(struct btrfs_fs_info *fs_info,

			   struct btrfs_device *dev)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct scrub_ctx *sctx;



	mutex_lock(&fs_info->scrub_lock);
@@ -2514,12 +2506,12 @@ int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid) 
	 * does not go away in cancel_dev. FIXME: find a better solution

	 */

	mutex_lock(&fs_info->fs_devices->device_list_mutex);

	dev = btrfs_find_device(root, devid, NULL, NULL);

	dev = btrfs_find_device(fs_info, devid, NULL, NULL);

	if (!dev) {

		mutex_unlock(&fs_info->fs_devices->device_list_mutex);

		return -ENODEV;

	}

	ret = btrfs_scrub_cancel_dev(root, dev);

	ret = btrfs_scrub_cancel_dev(fs_info, dev);

	mutex_unlock(&fs_info->fs_devices->device_list_mutex);



	return ret;
@@ -2532,7 +2524,7 @@ int btrfs_scrub_progress(struct btrfs_root *root, u64 devid, 
	struct scrub_ctx *sctx = NULL;



	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);

	dev = btrfs_find_device(root, devid, NULL, NULL);

	dev = btrfs_find_device(root->fs_info, devid, NULL, NULL);

	if (dev)

		sctx = dev->scrub_device;

	if (sctx)

fs/btrfs/super.c

+1 −1
Original line number Diff line number Diff line
@@ -116,7 +116,7 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info) 
	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {

		sb->s_flags |= MS_RDONLY;

		printk(KERN_INFO "btrfs is forced readonly\n");

		__btrfs_scrub_cancel(fs_info);

		btrfs_scrub_cancel(fs_info);

//		WARN_ON(1);

	}

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE