Merge branch 'for-4.13-part1' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...

[mirror_ubuntu-artful-kernel.git] / fs / btrfs / volumes.c

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 84a495967e0a8bb76afcaad47897b7565000c1d5..5eb7217738edbba5a49237736c3263b9b044d46f 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -242,6 +242,17 @@ static struct btrfs_device *__alloc_device(void)
        if (!dev)
                return ERR_PTR(-ENOMEM);
 
+       /*
+        * Preallocate a bio that's always going to be used for flushing device
+        * barriers and matches the device lifespan
+        */
+       dev->flush_bio = bio_alloc_bioset(GFP_KERNEL, 0, NULL);
+       if (!dev->flush_bio) {
+               kfree(dev);
+               return ERR_PTR(-ENOMEM);
+       }
+       bio_get(dev->flush_bio);
+
        INIT_LIST_HEAD(&dev->dev_list);
        INIT_LIST_HEAD(&dev->dev_alloc_list);
        INIT_LIST_HEAD(&dev->resized_list);
@@ -838,6 +849,7 @@ static void __free_device(struct work_struct *work)
 
        device = container_of(work, struct btrfs_device, rcu_work);
        rcu_string_free(device->name);
+       bio_put(device->flush_bio);
        kfree(device);
 }
 
@@ -1353,15 +1365,13 @@ int find_free_dev_extent_start(struct btrfs_transaction *transaction,
        int ret;
        int slot;
        struct extent_buffer *l;
-       u64 min_search_start;
 
        /*
         * We don't want to overwrite the superblock on the drive nor any area
         * used by the boot loader (grub for example), so we make sure to start
         * at an offset of at least 1MB.
         */
-       min_search_start = max(fs_info->alloc_start, 1024ull * 1024);
-       search_start = max(search_start, min_search_start);
+       search_start = max_t(u64, search_start, SZ_1M);
 
        path = btrfs_alloc_path();
        if (!path)
@@ -2387,7 +2397,8 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        device->io_width = fs_info->sectorsize;
        device->io_align = fs_info->sectorsize;
        device->sector_size = fs_info->sectorsize;
-       device->total_bytes = i_size_read(bdev->bd_inode);
+       device->total_bytes = round_down(i_size_read(bdev->bd_inode),
+                                        fs_info->sectorsize);
        device->disk_total_bytes = device->total_bytes;
        device->commit_total_bytes = device->total_bytes;
        device->fs_info = fs_info;
@@ -2417,16 +2428,14 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_path
        fs_info->fs_devices->total_devices++;
        fs_info->fs_devices->total_rw_bytes += device->total_bytes;
 
-       spin_lock(&fs_info->free_chunk_lock);
-       fs_info->free_chunk_space += device->total_bytes;
-       spin_unlock(&fs_info->free_chunk_lock);
+       atomic64_add(device->total_bytes, &fs_info->free_chunk_space);
 
        if (!blk_queue_nonrot(q))
                fs_info->fs_devices->rotating = 1;
 
        tmp = btrfs_super_total_bytes(fs_info->super_copy);
        btrfs_set_super_total_bytes(fs_info->super_copy,
-                                   tmp + device->total_bytes);
+               round_down(tmp + device->total_bytes, fs_info->sectorsize));
 
        tmp = btrfs_super_num_devices(fs_info->super_copy);
        btrfs_set_super_num_devices(fs_info->super_copy, tmp + 1);
@@ -2574,7 +2583,7 @@ int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
                goto error;
        }
 
-       name = rcu_string_strdup(device_path, GFP_NOFS);
+       name = rcu_string_strdup(device_path, GFP_KERNEL);
        if (!name) {
                kfree(device);
                ret = -ENOMEM;
@@ -2689,6 +2698,8 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,
        if (!device->writeable)
                return -EACCES;
 
+       new_size = round_down(new_size, fs_info->sectorsize);
+
        mutex_lock(&fs_info->chunk_mutex);
        old_total = btrfs_super_total_bytes(super_copy);
        diff = new_size - device->total_bytes;
@@ -2701,7 +2712,8 @@ int btrfs_grow_device(struct btrfs_trans_handle *trans,
 
        fs_devices = fs_info->fs_devices;
 
-       btrfs_set_super_total_bytes(super_copy, old_total + diff);
+       btrfs_set_super_total_bytes(super_copy,
+                       round_down(old_total + diff, fs_info->sectorsize));
        device->fs_devices->total_rw_bytes += diff;
 
        btrfs_device_set_total_bytes(device, new_size);
@@ -2874,9 +2886,7 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
                        mutex_lock(&fs_info->chunk_mutex);
                        btrfs_device_set_bytes_used(device,
                                        device->bytes_used - dev_extent_len);
-                       spin_lock(&fs_info->free_chunk_lock);
-                       fs_info->free_chunk_space += dev_extent_len;
-                       spin_unlock(&fs_info->free_chunk_lock);
+                       atomic64_add(dev_extent_len, &fs_info->free_chunk_space);
                        btrfs_clear_space_info_full(fs_info);
                        mutex_unlock(&fs_info->chunk_mutex);
                }
@@ -4393,7 +4403,10 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
        struct btrfs_super_block *super_copy = fs_info->super_copy;
        u64 old_total = btrfs_super_total_bytes(super_copy);
        u64 old_size = btrfs_device_get_total_bytes(device);
-       u64 diff = old_size - new_size;
+       u64 diff;
+
+       new_size = round_down(new_size, fs_info->sectorsize);
+       diff = old_size - new_size;
 
        if (device->is_tgtdev_for_dev_replace)
                return -EINVAL;
@@ -4409,9 +4422,7 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
        btrfs_device_set_total_bytes(device, new_size);
        if (device->writeable) {
                device->fs_devices->total_rw_bytes -= diff;
-               spin_lock(&fs_info->free_chunk_lock);
-               fs_info->free_chunk_space -= diff;
-               spin_unlock(&fs_info->free_chunk_lock);
+               atomic64_sub(diff, &fs_info->free_chunk_space);
        }
        mutex_unlock(&fs_info->chunk_mutex);
 
@@ -4522,7 +4533,8 @@ again:
                              &fs_info->fs_devices->resized_devices);
 
        WARN_ON(diff > old_total);
-       btrfs_set_super_total_bytes(super_copy, old_total - diff);
+       btrfs_set_super_total_bytes(super_copy,
+                       round_down(old_total - diff, fs_info->sectorsize));
        mutex_unlock(&fs_info->chunk_mutex);
 
        /* Now btrfs_update_device() will change the on-disk size. */
@@ -4535,9 +4547,7 @@ done:
                btrfs_device_set_total_bytes(device, old_size);
                if (device->writeable)
                        device->fs_devices->total_rw_bytes += diff;
-               spin_lock(&fs_info->free_chunk_lock);
-               fs_info->free_chunk_space += diff;
-               spin_unlock(&fs_info->free_chunk_lock);
+               atomic64_add(diff, &fs_info->free_chunk_space);
                mutex_unlock(&fs_info->chunk_mutex);
        }
        return ret;
@@ -4882,9 +4892,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                btrfs_device_set_bytes_used(map->stripes[i].dev, num_bytes);
        }
 
-       spin_lock(&info->free_chunk_lock);
-       info->free_chunk_space -= (stripe_size * map->num_stripes);
-       spin_unlock(&info->free_chunk_lock);
+       atomic64_sub(stripe_size * map->num_stripes, &info->free_chunk_space);
 
        free_extent_map(em);
        check_raid56_incompat_flag(info, type);
@@ -5029,20 +5037,19 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
                                         struct btrfs_fs_info *fs_info)
 {
-       struct btrfs_root *extent_root = fs_info->extent_root;
        u64 chunk_offset;
        u64 sys_chunk_offset;
        u64 alloc_profile;
        int ret;
 
        chunk_offset = find_next_chunk(fs_info);
-       alloc_profile = btrfs_get_alloc_profile(extent_root, 0);
+       alloc_profile = btrfs_metadata_alloc_profile(fs_info);
        ret = __btrfs_alloc_chunk(trans, chunk_offset, alloc_profile);
        if (ret)
                return ret;
 
        sys_chunk_offset = find_next_chunk(fs_info);
-       alloc_profile = btrfs_get_alloc_profile(fs_info->chunk_root, 0);
+       alloc_profile = btrfs_system_alloc_profile(fs_info);
        ret = __btrfs_alloc_chunk(trans, sys_chunk_offset, alloc_profile);
        return ret;
 }
@@ -6267,10 +6274,9 @@ int btrfs_map_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
                        continue;
                }
 
-               if (dev_nr < total_devs - 1) {
-                       bio = btrfs_bio_clone(first_bio, GFP_NOFS);
-                       BUG_ON(!bio); /* -ENOMEM */
-               } else
+               if (dev_nr < total_devs - 1)
+                       bio = btrfs_bio_clone(first_bio);
+               else
                        bio = first_bio;
 
                submit_stripe_bio(bbio, bio, bbio->stripes[dev_nr].physical,
@@ -6685,10 +6691,8 @@ static int read_one_dev(struct btrfs_fs_info *fs_info,
        device->in_fs_metadata = 1;
        if (device->writeable && !device->is_tgtdev_for_dev_replace) {
                device->fs_devices->total_rw_bytes += device->total_bytes;
-               spin_lock(&fs_info->free_chunk_lock);
-               fs_info->free_chunk_space += device->total_bytes -
-                       device->bytes_used;
-               spin_unlock(&fs_info->free_chunk_lock);
+               atomic64_add(device->total_bytes - device->bytes_used,
+                               &fs_info->free_chunk_space);
        }
        ret = 0;
        return ret;