btrfs: root->fs_info cleanup, lock/unlock_chunks

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 3d4fb99d9e4f47018e21f98d7ce189fc7c1e4914..5abf3afa6ea5bb1555ba2444363e239b173b3a6e 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -3998,7 +3998,7 @@ void close_ctree(struct btrfs_fs_info *fs_info)
        __btrfs_free_block_rsv(root->orphan_block_rsv);
        root->orphan_block_rsv = NULL;
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        while (!list_empty(&fs_info->pinned_chunks)) {
                struct extent_map *em;
 
@@ -4007,7 +4007,7 @@ void close_ctree(struct btrfs_fs_info *fs_info)
                list_del_init(&em->list);
                free_extent_map(em);
        }
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 }
 
 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index b8ad81c69eb993f0e2d9518b289f3eb51d0d6560..cc9ae54036be3e3e64df8cbb78bd1929ee83ecb6 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -9436,9 +9436,9 @@ again:
 out:
        if (cache->flags & BTRFS_BLOCK_GROUP_SYSTEM) {
                alloc_flags = update_block_group_flags(root, cache->flags);
-               lock_chunks(root->fs_info->chunk_root);
+               lock_chunks(root->fs_info);
                check_system_chunk(trans, root, alloc_flags);
-               unlock_chunks(root->fs_info->chunk_root);
+               unlock_chunks(root->fs_info);
        }
        mutex_unlock(&root->fs_info->ro_block_group_mutex);
 
@@ -10482,7 +10482,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
 
        memcpy(&key, &block_group->key, sizeof(key));
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        if (!list_empty(&em->list)) {
                /* We're in the transaction->pending_chunks list. */
                free_extent_map(em);
@@ -10550,7 +10550,7 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
                free_extent_map(em);
        }
 
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 
        ret = remove_block_group_free_space(trans, root->fs_info, block_group);
        if (ret)

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index aee1255214ccde983264c05507cb19955202181c..842461792d4e56c7ef9cf30c99c42a2d7b3c82f7 100644 (file)
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -3328,7 +3328,7 @@ void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *block_group)
        spin_unlock(&block_group->lock);
 
        if (cleanup) {
-               lock_chunks(block_group->fs_info->chunk_root);
+               lock_chunks(block_group->fs_info);
                em_tree = &block_group->fs_info->mapping_tree.map_tree;
                write_lock(&em_tree->lock);
                em = lookup_extent_mapping(em_tree, block_group->key.objectid,
@@ -3340,7 +3340,7 @@ void btrfs_put_block_group_trimming(struct btrfs_block_group_cache *block_group)
                 */
                remove_extent_mapping(em_tree, em);
                write_unlock(&em_tree->lock);
-               unlock_chunks(block_group->fs_info->chunk_root);
+               unlock_chunks(block_group->fs_info);
 
                /* once for us and once for the tree */
                free_extent_map(em);

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 4d3e5c4234dd0433b6db3d7da13932dc23d108e9..9535828830346f2ed35730ae9a512df97e530232 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1889,10 +1889,10 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path, u64 devid)
        }
 
        if (device->writeable) {
-               lock_chunks(root);
+               lock_chunks(root->fs_info);
                list_del_init(&device->dev_alloc_list);
                device->fs_devices->rw_devices--;
-               unlock_chunks(root);
+               unlock_chunks(root->fs_info);
                clear_super = true;
        }
 
@@ -1981,11 +1981,11 @@ out:
 
 error_undo:
        if (device->writeable) {
-               lock_chunks(root);
+               lock_chunks(root->fs_info);
                list_add(&device->dev_alloc_list,
                         &root->fs_info->fs_devices->alloc_list);
                device->fs_devices->rw_devices++;
-               unlock_chunks(root);
+               unlock_chunks(root->fs_info);
        }
        goto out;
 }
@@ -2212,9 +2212,9 @@ static int btrfs_prepare_sprout(struct btrfs_root *root)
        list_for_each_entry(device, &seed_devices->devices, dev_list)
                device->fs_devices = seed_devices;
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 
        fs_devices->seeding = 0;
        fs_devices->num_devices = 0;
@@ -2404,7 +2404,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *device_path)
        device->fs_devices = root->fs_info->fs_devices;
 
        mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
        list_add(&device->dev_alloc_list,
                 &root->fs_info->fs_devices->alloc_list);
@@ -2438,13 +2438,13 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *device_path)
         */
        btrfs_clear_space_info_full(root->fs_info);
 
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
        mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
 
        if (seeding_dev) {
-               lock_chunks(root);
+               lock_chunks(root->fs_info);
                ret = init_first_rw_device(trans, root, device);
-               unlock_chunks(root);
+               unlock_chunks(root->fs_info);
                if (ret) {
                        btrfs_abort_transaction(trans, ret);
                        goto error_trans;
@@ -2689,13 +2689,13 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,
        if (!device->writeable)
                return -EACCES;
 
-       lock_chunks(device->fs_info->dev_root);
+       lock_chunks(device->fs_info);
        old_total = btrfs_super_total_bytes(super_copy);
        diff = new_size - device->total_bytes;
 
        if (new_size <= device->total_bytes ||
            device->is_tgtdev_for_dev_replace) {
-               unlock_chunks(device->fs_info->dev_root);
+               unlock_chunks(device->fs_info);
                return -EINVAL;
        }
 
@@ -2710,7 +2710,7 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,
        if (list_empty(&device->resized_list))
                list_add_tail(&device->resized_list,
                              &fs_devices->resized_devices);
-       unlock_chunks(device->fs_info->dev_root);
+       unlock_chunks(device->fs_info);
 
        return btrfs_update_device(trans, device);
 }
@@ -2766,7 +2766,7 @@ static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info,
        u32 cur;
        struct btrfs_key key;
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        array_size = btrfs_super_sys_array_size(super_copy);
 
        ptr = super_copy->sys_chunk_array;
@@ -2796,7 +2796,7 @@ static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info,
                        cur += len;
                }
        }
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
        return ret;
 }
 
@@ -2832,9 +2832,9 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
                return -EINVAL;
        }
        map = em->map_lookup;
-       lock_chunks(root->fs_info->chunk_root);
+       lock_chunks(fs_info);
        check_system_chunk(trans, extent_root, map->type);
-       unlock_chunks(root->fs_info->chunk_root);
+       unlock_chunks(fs_info);
 
        /*
         * Take the device list mutex to prevent races with the final phase of
@@ -2854,14 +2854,14 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
                }
 
                if (device->bytes_used > 0) {
-                       lock_chunks(root);
+                       lock_chunks(root->fs_info);
                        btrfs_device_set_bytes_used(device,
                                        device->bytes_used - dev_extent_len);
                        spin_lock(&root->fs_info->free_chunk_lock);
                        root->fs_info->free_chunk_space += dev_extent_len;
                        spin_unlock(&root->fs_info->free_chunk_lock);
                        btrfs_clear_space_info_full(root->fs_info);
-                       unlock_chunks(root);
+                       unlock_chunks(root->fs_info);
                }
 
                if (map->stripes[i].dev) {
@@ -4383,7 +4383,7 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
 
        path->reada = READA_FORWARD;
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
 
        btrfs_device_set_total_bytes(device, new_size);
        if (device->writeable) {
@@ -4392,7 +4392,7 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
                root->fs_info->free_chunk_space -= diff;
                spin_unlock(&root->fs_info->free_chunk_lock);
        }
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 
 again:
        key.objectid = device->devid;
@@ -4464,7 +4464,7 @@ again:
                goto done;
        }
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
 
        /*
         * We checked in the above loop all device extents that were already in
@@ -4484,7 +4484,7 @@ again:
 
                if (contains_pending_extent(trans->transaction, device,
                                            &start, len)) {
-                       unlock_chunks(root);
+                       unlock_chunks(root->fs_info);
                        checked_pending_chunks = true;
                        failed = 0;
                        retried = false;
@@ -4502,7 +4502,7 @@ again:
 
        WARN_ON(diff > old_total);
        btrfs_set_super_total_bytes(super_copy, old_total - diff);
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 
        /* Now btrfs_update_device() will change the on-disk size. */
        ret = btrfs_update_device(trans, device);
@@ -4510,14 +4510,14 @@ again:
 done:
        btrfs_free_path(path);
        if (ret) {
-               lock_chunks(root);
+               lock_chunks(root->fs_info);
                btrfs_device_set_total_bytes(device, old_size);
                if (device->writeable)
                        device->fs_devices->total_rw_bytes += diff;
                spin_lock(&root->fs_info->free_chunk_lock);
                root->fs_info->free_chunk_space += diff;
                spin_unlock(&root->fs_info->free_chunk_lock);
-               unlock_chunks(root);
+               unlock_chunks(root->fs_info);
        }
        return ret;
 }
@@ -4531,11 +4531,11 @@ static int btrfs_add_system_chunk(struct btrfs_root *root,
        u32 array_size;
        u8 *ptr;
 
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        array_size = btrfs_super_sys_array_size(super_copy);
        if (array_size + item_size + sizeof(disk_key)
                        > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
-               unlock_chunks(root);
+               unlock_chunks(root->fs_info);
                return -EFBIG;
        }
 
@@ -4546,7 +4546,7 @@ static int btrfs_add_system_chunk(struct btrfs_root *root,
        memcpy(ptr, chunk, item_size);
        item_size += sizeof(disk_key);
        btrfs_set_super_sys_array_size(super_copy, array_size + item_size);
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 
        return 0;
 }
@@ -6804,7 +6804,7 @@ int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info)
                return -ENOMEM;
 
        mutex_lock(&uuid_mutex);
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
 
        /*
         * Read all device items, and then all the chunk items. All
@@ -6871,7 +6871,7 @@ int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info)
        }
        ret = 0;
 error:
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
        mutex_unlock(&uuid_mutex);
 
        btrfs_free_path(path);
@@ -7172,13 +7172,13 @@ void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info)
                return;
 
        mutex_lock(&fs_devices->device_list_mutex);
-       lock_chunks(fs_info->dev_root);
+       lock_chunks(fs_info);
        list_for_each_entry_safe(curr, next, &fs_devices->resized_devices,
                                 resized_list) {
                list_del_init(&curr->resized_list);
                curr->commit_total_bytes = curr->disk_total_bytes;
        }
-       unlock_chunks(fs_info->dev_root);
+       unlock_chunks(fs_info);
        mutex_unlock(&fs_devices->device_list_mutex);
 }
 
@@ -7195,7 +7195,7 @@ void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
                return;
 
        /* In order to kick the device replace finish process */
-       lock_chunks(root);
+       lock_chunks(root->fs_info);
        list_for_each_entry(em, &transaction->pending_chunks, list) {
                map = em->map_lookup;
 
@@ -7204,7 +7204,7 @@ void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
                        dev->commit_bytes_used = dev->bytes_used;
                }
        }
-       unlock_chunks(root);
+       unlock_chunks(root->fs_info);
 }
 
 void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info)

diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 8592217696969b0471f4e1460fd06969b250a8b0..724d18ca7ff070a2278acd5a1af208650360a78f 100644 (file)
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -532,14 +532,14 @@ void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info);
 void btrfs_update_commit_device_bytes_used(struct btrfs_root *root,
                                        struct btrfs_transaction *transaction);
 
-static inline void lock_chunks(struct btrfs_root *root)
+static inline void lock_chunks(struct btrfs_fs_info *fs_info)
 {
-       mutex_lock(&root->fs_info->chunk_mutex);
+       mutex_lock(&fs_info->chunk_mutex);
 }
 
-static inline void unlock_chunks(struct btrfs_root *root)
+static inline void unlock_chunks(struct btrfs_fs_info *fs_info)
 {
-       mutex_unlock(&root->fs_info->chunk_mutex);
+       mutex_unlock(&fs_info->chunk_mutex);
 }
 
 struct list_head *btrfs_get_fs_uuids(void);