Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-18 00:53:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Btrfs: disallow some operations on the device replace target device

Browse Source 
This patch adds some code to disallow operations on the device that
is used as the target for the device replace operation.

Signed-off-by: Stefan Behrens <sbehrens@giantdisaster.de>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
This commit is contained in:
Stefan Behrens 2012-11-05 18:29:28 +01:00 committed by Josef Bacik
parent 5ac00addc7
commit 63a212abc2
7 changed files with 54 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/btrfs/ctree.h
View File

@ -3649,7 +3649,7 @@ int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
/* scrub.c */ /* scrub.c */
int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start, int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
u64 end, struct btrfs_scrub_progress *progress, u64 end, struct btrfs_scrub_progress *progress,
int readonly); int readonly, int is_dev_replace);
void btrfs_scrub_pause(struct btrfs_root *root); void btrfs_scrub_pause(struct btrfs_root *root);
void btrfs_scrub_pause_super(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(struct btrfs_root *root);

3
fs/btrfs/extent-tree.c
View File

@ -7468,7 +7468,8 @@ int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
* check to make sure we can actually find a chunk with enough * check to make sure we can actually find a chunk with enough
* space to fit our block group in. * space to fit our block group in.
*/ */
if (device->total_bytes > device->bytes_used + min_free) { if (device->total_bytes > device->bytes_used + min_free &&
!device->is_tgtdev_for_dev_replace) {
ret = find_free_dev_extent(device, min_free, ret = find_free_dev_extent(device, min_free,
&dev_offset, NULL); &dev_offset, NULL);
if (!ret) if (!ret)

8
fs/btrfs/ioctl.c
View File

@ -1375,6 +1375,11 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
} }
} }
if (device->is_tgtdev_for_dev_replace) {
ret = -EINVAL;
goto out_free;
}
old_size = device->total_bytes; old_size = device->total_bytes;
if (mod < 0) { if (mod < 0) {
@ -3102,7 +3107,8 @@ static long btrfs_ioctl_scrub(struct btrfs_root *root, void __user *arg)
return PTR_ERR(sa); return PTR_ERR(sa);
ret = btrfs_scrub_dev(root->fs_info, 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); &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
0);
if (copy_to_user(arg, sa, sizeof(*sa))) if (copy_to_user(arg, sa, sizeof(*sa)))
ret = -EFAULT; ret = -EFAULT;

14
fs/btrfs/scrub.c
View File

@ -116,6 +116,9 @@ struct scrub_ctx {
u32 sectorsize; u32 sectorsize;
u32 nodesize; u32 nodesize;
u32 leafsize; u32 leafsize;
int is_dev_replace;
/* /*
* statistics * statistics
*/ */
@ -284,7 +287,7 @@ static noinline_for_stack void scrub_free_ctx(struct scrub_ctx *sctx)
} }
static noinline_for_stack static noinline_for_stack
struct scrub_ctx *scrub_setup_ctx(struct btrfs_device *dev) struct scrub_ctx *scrub_setup_ctx(struct btrfs_device *dev, int is_dev_replace)
{ {
struct scrub_ctx *sctx; struct scrub_ctx *sctx;
int i; int i;
@ -296,6 +299,7 @@ struct scrub_ctx *scrub_setup_ctx(struct btrfs_device *dev)
sctx = kzalloc(sizeof(*sctx), GFP_NOFS); sctx = kzalloc(sizeof(*sctx), GFP_NOFS);
if (!sctx) if (!sctx)
goto nomem; goto nomem;
sctx->is_dev_replace = is_dev_replace;
sctx->pages_per_bio = pages_per_bio; sctx->pages_per_bio = pages_per_bio;
sctx->curr = -1; sctx->curr = -1;
sctx->dev_root = dev->dev_root; sctx->dev_root = dev->dev_root;
@ -2293,7 +2297,7 @@ static noinline_for_stack void scrub_workers_put(struct btrfs_fs_info *fs_info)
int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start, int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
u64 end, struct btrfs_scrub_progress *progress, u64 end, struct btrfs_scrub_progress *progress,
int readonly) int readonly, int is_dev_replace)
{ {
struct scrub_ctx *sctx; struct scrub_ctx *sctx;
int ret; int ret;
@ -2356,14 +2360,14 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
mutex_lock(&fs_info->fs_devices->device_list_mutex); mutex_lock(&fs_info->fs_devices->device_list_mutex);
dev = btrfs_find_device(fs_info, devid, NULL, NULL); dev = btrfs_find_device(fs_info, devid, NULL, NULL);
if (!dev || dev->missing) { if (!dev || (dev->missing && !is_dev_replace)) {
mutex_unlock(&fs_info->fs_devices->device_list_mutex); mutex_unlock(&fs_info->fs_devices->device_list_mutex);
scrub_workers_put(fs_info); scrub_workers_put(fs_info);
return -ENODEV; return -ENODEV;
} }
mutex_lock(&fs_info->scrub_lock); mutex_lock(&fs_info->scrub_lock);
if (!dev->in_fs_metadata) { if (!dev->in_fs_metadata || dev->is_tgtdev_for_dev_replace) {
mutex_unlock(&fs_info->scrub_lock); mutex_unlock(&fs_info->scrub_lock);
mutex_unlock(&fs_info->fs_devices->device_list_mutex); mutex_unlock(&fs_info->fs_devices->device_list_mutex);
scrub_workers_put(fs_info); scrub_workers_put(fs_info);
@ -2376,7 +2380,7 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
scrub_workers_put(fs_info); scrub_workers_put(fs_info);
return -EINPROGRESS; return -EINPROGRESS;
} }
sctx = scrub_setup_ctx(dev); sctx = scrub_setup_ctx(dev, is_dev_replace);
if (IS_ERR(sctx)) { if (IS_ERR(sctx)) {
mutex_unlock(&fs_info->scrub_lock); mutex_unlock(&fs_info->scrub_lock);
mutex_unlock(&fs_info->fs_devices->device_list_mutex); mutex_unlock(&fs_info->fs_devices->device_list_mutex);

3
fs/btrfs/super.c
View File

@ -1354,7 +1354,8 @@ static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
min_stripe_size = BTRFS_STRIPE_LEN; min_stripe_size = BTRFS_STRIPE_LEN;
list_for_each_entry(device, &fs_devices->devices, dev_list) { list_for_each_entry(device, &fs_devices->devices, dev_list) {
if (!device->in_fs_metadata || !device->bdev) if (!device->in_fs_metadata || !device->bdev ||
device->is_tgtdev_for_dev_replace)
continue; continue;
avail_space = device->total_bytes - device->bytes_used; avail_space = device->total_bytes - device->bytes_used;

41
fs/btrfs/volumes.c
View File

@ -518,8 +518,9 @@ again:
/* This is the initialized path, it is safe to release the devices. */ /* This is the initialized path, it is safe to release the devices. */
list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
if (device->in_fs_metadata) { if (device->in_fs_metadata) {
if (!latest_transid || if (!device->is_tgtdev_for_dev_replace &&
device->generation > latest_transid) { (!latest_transid ||
device->generation > latest_transid)) {
latest_devid = device->devid; latest_devid = device->devid;
latest_transid = device->generation; latest_transid = device->generation;
latest_bdev = device->bdev; latest_bdev = device->bdev;
@ -814,7 +815,7 @@ int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
*length = 0; *length = 0;
if (start >= device->total_bytes) if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
return 0; return 0;
path = btrfs_alloc_path(); path = btrfs_alloc_path();
@ -931,7 +932,7 @@ int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes,
max_hole_size = 0; max_hole_size = 0;
hole_size = 0; hole_size = 0;
if (search_start >= search_end) { if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
ret = -ENOSPC; ret = -ENOSPC;
goto error; goto error;
} }
@ -1114,6 +1115,7 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
struct btrfs_key key; struct btrfs_key key;
WARN_ON(!device->in_fs_metadata); WARN_ON(!device->in_fs_metadata);
WARN_ON(device->is_tgtdev_for_dev_replace);
path = btrfs_alloc_path(); path = btrfs_alloc_path();
if (!path) if (!path)
return -ENOMEM; return -ENOMEM;
@ -1375,7 +1377,9 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
* is held. * is held.
*/ */
list_for_each_entry(tmp, devices, dev_list) { list_for_each_entry(tmp, devices, dev_list) {
if (tmp->in_fs_metadata && !tmp->bdev) { if (tmp->in_fs_metadata &&
!tmp->is_tgtdev_for_dev_replace &&
!tmp->bdev) {
device = tmp; device = tmp;
break; break;
} }
@ -1406,6 +1410,12 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
} }
} }
if (device->is_tgtdev_for_dev_replace) {
pr_err("btrfs: unable to remove the dev_replace target dev\n");
ret = -EINVAL;
goto error_brelse;
}
if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) { if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
printk(KERN_ERR "btrfs: unable to remove the only writeable " printk(KERN_ERR "btrfs: unable to remove the only writeable "
"device\n"); "device\n");
@ -1425,6 +1435,11 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
if (ret) if (ret)
goto error_undo; goto error_undo;
/*
* TODO: the superblock still includes this device in its num_devices
* counter although write_all_supers() is not locked out. This
* could give a filesystem state which requires a degraded mount.
*/
ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device); ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
if (ret) if (ret)
goto error_undo; goto error_undo;
@ -1808,6 +1823,7 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
device->dev_root = root->fs_info->dev_root; device->dev_root = root->fs_info->dev_root;
device->bdev = bdev; device->bdev = bdev;
device->in_fs_metadata = 1; device->in_fs_metadata = 1;
device->is_tgtdev_for_dev_replace = 0;
device->mode = FMODE_EXCL; device->mode = FMODE_EXCL;
set_blocksize(device->bdev, 4096); set_blocksize(device->bdev, 4096);
@ -1971,7 +1987,8 @@ static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
if (!device->writeable) if (!device->writeable)
return -EACCES; return -EACCES;
if (new_size <= device->total_bytes) if (new_size <= device->total_bytes ||
device->is_tgtdev_for_dev_replace)
return -EINVAL; return -EINVAL;
btrfs_set_super_total_bytes(super_copy, old_total + diff); btrfs_set_super_total_bytes(super_copy, old_total + diff);
@ -2600,7 +2617,8 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)
size_to_free = div_factor(old_size, 1); size_to_free = div_factor(old_size, 1);
size_to_free = min(size_to_free, (u64)1 * 1024 * 1024); size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
if (!device->writeable || if (!device->writeable ||
device->total_bytes - device->bytes_used > size_to_free) device->total_bytes - device->bytes_used > size_to_free ||
device->is_tgtdev_for_dev_replace)
continue; continue;
ret = btrfs_shrink_device(device, old_size - size_to_free); ret = btrfs_shrink_device(device, old_size - size_to_free);
@ -3132,6 +3150,9 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
u64 old_size = device->total_bytes; u64 old_size = device->total_bytes;
u64 diff = device->total_bytes - new_size; u64 diff = device->total_bytes - new_size;
if (device->is_tgtdev_for_dev_replace)
return -EINVAL;
path = btrfs_alloc_path(); path = btrfs_alloc_path();
if (!path) if (!path)
return -ENOMEM; return -ENOMEM;
@ -3401,7 +3422,8 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
continue; continue;
} }
if (!device->in_fs_metadata) if (!device->in_fs_metadata ||
device->is_tgtdev_for_dev_replace)
continue; continue;
if (device->total_bytes > device->bytes_used) if (device->total_bytes > device->bytes_used)
@ -4612,6 +4634,7 @@ static void fill_device_from_item(struct extent_buffer *leaf,
device->io_align = btrfs_device_io_align(leaf, dev_item); device->io_align = btrfs_device_io_align(leaf, dev_item);
device->io_width = btrfs_device_io_width(leaf, dev_item); device->io_width = btrfs_device_io_width(leaf, dev_item);
device->sector_size = btrfs_device_sector_size(leaf, dev_item); device->sector_size = btrfs_device_sector_size(leaf, dev_item);
device->is_tgtdev_for_dev_replace = 0;
ptr = (unsigned long)btrfs_device_uuid(dev_item); ptr = (unsigned long)btrfs_device_uuid(dev_item);
read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
@ -4722,7 +4745,7 @@ static int read_one_dev(struct btrfs_root *root,
fill_device_from_item(leaf, dev_item, device); fill_device_from_item(leaf, dev_item, device);
device->dev_root = root->fs_info->dev_root; device->dev_root = root->fs_info->dev_root;
device->in_fs_metadata = 1; device->in_fs_metadata = 1;
if (device->writeable) { if (device->writeable && !device->is_tgtdev_for_dev_replace) {
device->fs_devices->total_rw_bytes += device->total_bytes; device->fs_devices->total_rw_bytes += device->total_bytes;
spin_lock(&root->fs_info->free_chunk_lock); spin_lock(&root->fs_info->free_chunk_lock);
root->fs_info->free_chunk_space += device->total_bytes - root->fs_info->free_chunk_space += device->total_bytes -

1
fs/btrfs/volumes.h
View File

@ -50,6 +50,7 @@ struct btrfs_device {
int in_fs_metadata; int in_fs_metadata;
int missing; int missing;
int can_discard; int can_discard;
int is_tgtdev_for_dev_replace;
spinlock_t io_lock; spinlock_t io_lock;