btrfs: use a temporary variable for fs_devices in btrfs_init_new_device

[sfrench/cifs-2.6.git] / fs / btrfs / volumes.c

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 1da162928d1a9b305ab36c2d99386afb2f060326..adce1c2e9b7b1c98daca44eeb530daea26d36ba0 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2410,12 +2410,13 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        struct list_head *devices;
        struct super_block *sb = fs_info->sb;
        struct rcu_string *name;
+       struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
        u64 tmp;
        int seeding_dev = 0;
        int ret = 0;
        bool unlocked = false;
 
-       if (sb_rdonly(sb) && !fs_info->fs_devices->seeding)
+       if (sb_rdonly(sb) && !fs_devices->seeding)
                return -EROFS;
 
        bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
@@ -2423,7 +2424,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        if (IS_ERR(bdev))
                return PTR_ERR(bdev);
 
-       if (fs_info->fs_devices->seeding) {
+       if (fs_devices->seeding) {
                seeding_dev = 1;
                down_write(&sb->s_umount);
                mutex_lock(&uuid_mutex);
@@ -2431,18 +2432,18 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
 
        filemap_write_and_wait(bdev->bd_inode->i_mapping);
 
-       devices = &fs_info->fs_devices->devices;
+       devices = &fs_devices->devices;
 
-       mutex_lock(&fs_info->fs_devices->device_list_mutex);
+       mutex_lock(&fs_devices->device_list_mutex);
        list_for_each_entry(device, devices, dev_list) {
                if (device->bdev == bdev) {
                        ret = -EEXIST;
                        mutex_unlock(
-                               &fs_info->fs_devices->device_list_mutex);
+                               &fs_devices->device_list_mutex);
                        goto error;
                }
        }
-       mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+       mutex_unlock(&fs_devices->device_list_mutex);
 
        device = btrfs_alloc_device(fs_info, NULL, NULL);
        if (IS_ERR(device)) {
@@ -2491,23 +2492,22 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
                }
        }
 
-       device->fs_devices = fs_info->fs_devices;
+       device->fs_devices = fs_devices;
 
-       mutex_lock(&fs_info->fs_devices->device_list_mutex);
+       mutex_lock(&fs_devices->device_list_mutex);
        mutex_lock(&fs_info->chunk_mutex);
-       list_add_rcu(&device->dev_list, &fs_info->fs_devices->devices);
-       list_add(&device->dev_alloc_list,
-                &fs_info->fs_devices->alloc_list);
-       fs_info->fs_devices->num_devices++;
-       fs_info->fs_devices->open_devices++;
-       fs_info->fs_devices->rw_devices++;
-       fs_info->fs_devices->total_devices++;
-       fs_info->fs_devices->total_rw_bytes += device->total_bytes;
+       list_add_rcu(&device->dev_list, &fs_devices->devices);
+       list_add(&device->dev_alloc_list, &fs_devices->alloc_list);
+       fs_devices->num_devices++;
+       fs_devices->open_devices++;
+       fs_devices->rw_devices++;
+       fs_devices->total_devices++;
+       fs_devices->total_rw_bytes += device->total_bytes;
 
        atomic64_add(device->total_bytes, &fs_info->free_chunk_space);
 
        if (!blk_queue_nonrot(q))
-               fs_info->fs_devices->rotating = 1;
+               fs_devices->rotating = 1;
 
        tmp = btrfs_super_total_bytes(fs_info->super_copy);
        btrfs_set_super_total_bytes(fs_info->super_copy,
@@ -2517,7 +2517,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        btrfs_set_super_num_devices(fs_info->super_copy, tmp + 1);
 
        /* add sysfs device entry */
-       btrfs_sysfs_add_device_link(fs_info->fs_devices, device);
+       btrfs_sysfs_add_device_link(fs_devices, device);
 
        /*
         * we've got more storage, clear any full flags on the space
@@ -2526,7 +2526,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        btrfs_clear_space_info_full(fs_info);
 
        mutex_unlock(&fs_info->chunk_mutex);
-       mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+       mutex_unlock(&fs_devices->device_list_mutex);
 
        if (seeding_dev) {
                mutex_lock(&fs_info->chunk_mutex);
@@ -2558,7 +2558,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
                 */
                snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU",
                                                fs_info->fsid);
-               if (kobject_rename(&fs_info->fs_devices->fsid_kobj, fsid_buf))
+               if (kobject_rename(&fs_devices->fsid_kobj, fsid_buf))
                        btrfs_warn(fs_info,
                                   "sysfs: failed to create fsid for sprout");
        }
@@ -2593,7 +2593,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        return ret;
 
 error_sysfs:
-       btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
+       btrfs_sysfs_rm_device_link(fs_devices, device);
 error_trans:
        if (seeding_dev)
                sb->s_flags |= SB_RDONLY;
@@ -2829,7 +2829,7 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
        }
        map = em->map_lookup;
        mutex_lock(&fs_info->chunk_mutex);
-       check_system_chunk(trans, fs_info, map->type);
+       check_system_chunk(trans, map->type);
        mutex_unlock(&fs_info->chunk_mutex);
 
        /*
@@ -2885,7 +2885,7 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
                }
        }
 
-       ret = btrfs_remove_block_group(trans, fs_info, chunk_offset, em);
+       ret = btrfs_remove_block_group(trans, chunk_offset, em);
        if (ret) {
                btrfs_abort_transaction(trans, ret);
                goto out;
@@ -3059,7 +3059,7 @@ static int btrfs_may_alloc_data_chunk(struct btrfs_fs_info *fs_info,
                        if (IS_ERR(trans))
                                return PTR_ERR(trans);
 
-                       ret = btrfs_force_chunk_alloc(trans, fs_info,
+                       ret = btrfs_force_chunk_alloc(trans,
                                                      BTRFS_BLOCK_GROUP_DATA);
                        btrfs_end_transaction(trans);
                        if (ret < 0)
@@ -4692,7 +4692,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 
        if (type & BTRFS_BLOCK_GROUP_DATA) {
                max_stripe_size = SZ_1G;
-               max_chunk_size = 10 * max_stripe_size;
+               max_chunk_size = BTRFS_MAX_DATA_CHUNK_SIZE;
                if (!devs_max)
                        devs_max = BTRFS_MAX_DEVS(info);
        } else if (type & BTRFS_BLOCK_GROUP_METADATA) {
@@ -4900,7 +4900,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
        refcount_inc(&em->refs);
        write_unlock(&em_tree->lock);
 
-       ret = btrfs_make_block_group(trans, info, 0, type, start, num_bytes);
+       ret = btrfs_make_block_group(trans, 0, type, start, num_bytes);
        if (ret)
                goto error_del_extent;
 
@@ -5038,13 +5038,12 @@ out:
  * require modifying the chunk tree. This division is important for the
  * bootstrap process of adding storage to a seed btrfs.
  */
-int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
-                     struct btrfs_fs_info *fs_info, u64 type)
+int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, u64 type)
 {
        u64 chunk_offset;
 
-       lockdep_assert_held(&fs_info->chunk_mutex);
-       chunk_offset = find_next_chunk(fs_info);
+       lockdep_assert_held(&trans->fs_info->chunk_mutex);
+       chunk_offset = find_next_chunk(trans->fs_info);
        return __btrfs_alloc_chunk(trans, chunk_offset, type);
 }
 
@@ -5175,7 +5174,7 @@ int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
                /*
                 * There could be two corrupted data stripes, we need
                 * to loop retry in order to rebuild the correct data.
-                * 
+                *
                 * Fail a stripe at a time on every retry except the
                 * stripe under reconstruction.
                 */