/fs/btrfs/volumes.c
https://bitbucket.org/slukk/jb-tsm-kernel-4.2 · C · 3718 lines · 2949 code · 513 blank · 256 comment · 540 complexity · 58b4fc98f53631a2fc9f626b94464381 MD5 · raw file
Large files are truncated click here to view the full file
- /*
- * Copyright (C) 2007 Oracle. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
- #include <linux/sched.h>
- #include <linux/bio.h>
- #include <linux/slab.h>
- #include <linux/buffer_head.h>
- #include <linux/blkdev.h>
- #include <linux/random.h>
- #include <linux/iocontext.h>
- #include <linux/capability.h>
- #include <asm/div64.h>
- #include "compat.h"
- #include "ctree.h"
- #include "extent_map.h"
- #include "disk-io.h"
- #include "transaction.h"
- #include "print-tree.h"
- #include "volumes.h"
- #include "async-thread.h"
- static int init_first_rw_device(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_device *device);
- static int btrfs_relocate_sys_chunks(struct btrfs_root *root);
- static DEFINE_MUTEX(uuid_mutex);
- static LIST_HEAD(fs_uuids);
- static void lock_chunks(struct btrfs_root *root)
- {
- mutex_lock(&root->fs_info->chunk_mutex);
- }
- static void unlock_chunks(struct btrfs_root *root)
- {
- mutex_unlock(&root->fs_info->chunk_mutex);
- }
- static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
- {
- struct btrfs_device *device;
- WARN_ON(fs_devices->opened);
- while (!list_empty(&fs_devices->devices)) {
- device = list_entry(fs_devices->devices.next,
- struct btrfs_device, dev_list);
- list_del(&device->dev_list);
- kfree(device->name);
- kfree(device);
- }
- kfree(fs_devices);
- }
- int btrfs_cleanup_fs_uuids(void)
- {
- struct btrfs_fs_devices *fs_devices;
- while (!list_empty(&fs_uuids)) {
- fs_devices = list_entry(fs_uuids.next,
- struct btrfs_fs_devices, list);
- list_del(&fs_devices->list);
- free_fs_devices(fs_devices);
- }
- return 0;
- }
- static noinline struct btrfs_device *__find_device(struct list_head *head,
- u64 devid, u8 *uuid)
- {
- struct btrfs_device *dev;
- list_for_each_entry(dev, head, dev_list) {
- if (dev->devid == devid &&
- (!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
- return dev;
- }
- }
- return NULL;
- }
- static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
- {
- struct btrfs_fs_devices *fs_devices;
- list_for_each_entry(fs_devices, &fs_uuids, list) {
- if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
- return fs_devices;
- }
- return NULL;
- }
- static void requeue_list(struct btrfs_pending_bios *pending_bios,
- struct bio *head, struct bio *tail)
- {
- struct bio *old_head;
- old_head = pending_bios->head;
- pending_bios->head = head;
- if (pending_bios->tail)
- tail->bi_next = old_head;
- else
- pending_bios->tail = tail;
- }
- /*
- * we try to collect pending bios for a device so we don't get a large
- * number of procs sending bios down to the same device. This greatly
- * improves the schedulers ability to collect and merge the bios.
- *
- * But, it also turns into a long list of bios to process and that is sure
- * to eventually make the worker thread block. The solution here is to
- * make some progress and then put this work struct back at the end of
- * the list if the block device is congested. This way, multiple devices
- * can make progress from a single worker thread.
- */
- static noinline int run_scheduled_bios(struct btrfs_device *device)
- {
- struct bio *pending;
- struct backing_dev_info *bdi;
- struct btrfs_fs_info *fs_info;
- struct btrfs_pending_bios *pending_bios;
- struct bio *tail;
- struct bio *cur;
- int again = 0;
- unsigned long num_run;
- unsigned long batch_run = 0;
- unsigned long limit;
- unsigned long last_waited = 0;
- int force_reg = 0;
- struct blk_plug plug;
- /*
- * this function runs all the bios we've collected for
- * a particular device. We don't want to wander off to
- * another device without first sending all of these down.
- * So, setup a plug here and finish it off before we return
- */
- blk_start_plug(&plug);
- bdi = blk_get_backing_dev_info(device->bdev);
- fs_info = device->dev_root->fs_info;
- limit = btrfs_async_submit_limit(fs_info);
- limit = limit * 2 / 3;
- loop:
- spin_lock(&device->io_lock);
- loop_lock:
- num_run = 0;
- /* take all the bios off the list at once and process them
- * later on (without the lock held). But, remember the
- * tail and other pointers so the bios can be properly reinserted
- * into the list if we hit congestion
- */
- if (!force_reg && device->pending_sync_bios.head) {
- pending_bios = &device->pending_sync_bios;
- force_reg = 1;
- } else {
- pending_bios = &device->pending_bios;
- force_reg = 0;
- }
- pending = pending_bios->head;
- tail = pending_bios->tail;
- WARN_ON(pending && !tail);
- /*
- * if pending was null this time around, no bios need processing
- * at all and we can stop. Otherwise it'll loop back up again
- * and do an additional check so no bios are missed.
- *
- * device->running_pending is used to synchronize with the
- * schedule_bio code.
- */
- if (device->pending_sync_bios.head == NULL &&
- device->pending_bios.head == NULL) {
- again = 0;
- device->running_pending = 0;
- } else {
- again = 1;
- device->running_pending = 1;
- }
- pending_bios->head = NULL;
- pending_bios->tail = NULL;
- spin_unlock(&device->io_lock);
- while (pending) {
- rmb();
- /* we want to work on both lists, but do more bios on the
- * sync list than the regular list
- */
- if ((num_run > 32 &&
- pending_bios != &device->pending_sync_bios &&
- device->pending_sync_bios.head) ||
- (num_run > 64 && pending_bios == &device->pending_sync_bios &&
- device->pending_bios.head)) {
- spin_lock(&device->io_lock);
- requeue_list(pending_bios, pending, tail);
- goto loop_lock;
- }
- cur = pending;
- pending = pending->bi_next;
- cur->bi_next = NULL;
- atomic_dec(&fs_info->nr_async_bios);
- if (atomic_read(&fs_info->nr_async_bios) < limit &&
- waitqueue_active(&fs_info->async_submit_wait))
- wake_up(&fs_info->async_submit_wait);
- BUG_ON(atomic_read(&cur->bi_cnt) == 0);
- submit_bio(cur->bi_rw, cur);
- num_run++;
- batch_run++;
- if (need_resched())
- cond_resched();
- /*
- * we made progress, there is more work to do and the bdi
- * is now congested. Back off and let other work structs
- * run instead
- */
- if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
- fs_info->fs_devices->open_devices > 1) {
- struct io_context *ioc;
- ioc = current->io_context;
- /*
- * the main goal here is that we don't want to
- * block if we're going to be able to submit
- * more requests without blocking.
- *
- * This code does two great things, it pokes into
- * the elevator code from a filesystem _and_
- * it makes assumptions about how batching works.
- */
- if (ioc && ioc->nr_batch_requests > 0 &&
- time_before(jiffies, ioc->last_waited + HZ/50UL) &&
- (last_waited == 0 ||
- ioc->last_waited == last_waited)) {
- /*
- * we want to go through our batch of
- * requests and stop. So, we copy out
- * the ioc->last_waited time and test
- * against it before looping
- */
- last_waited = ioc->last_waited;
- if (need_resched())
- cond_resched();
- continue;
- }
- spin_lock(&device->io_lock);
- requeue_list(pending_bios, pending, tail);
- device->running_pending = 1;
- spin_unlock(&device->io_lock);
- btrfs_requeue_work(&device->work);
- goto done;
- }
- }
- cond_resched();
- if (again)
- goto loop;
- spin_lock(&device->io_lock);
- if (device->pending_bios.head || device->pending_sync_bios.head)
- goto loop_lock;
- spin_unlock(&device->io_lock);
- done:
- blk_finish_plug(&plug);
- return 0;
- }
- static void pending_bios_fn(struct btrfs_work *work)
- {
- struct btrfs_device *device;
- device = container_of(work, struct btrfs_device, work);
- run_scheduled_bios(device);
- }
- static noinline int device_list_add(const char *path,
- struct btrfs_super_block *disk_super,
- u64 devid, struct btrfs_fs_devices **fs_devices_ret)
- {
- struct btrfs_device *device;
- struct btrfs_fs_devices *fs_devices;
- u64 found_transid = btrfs_super_generation(disk_super);
- char *name;
- fs_devices = find_fsid(disk_super->fsid);
- if (!fs_devices) {
- fs_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
- if (!fs_devices)
- return -ENOMEM;
- INIT_LIST_HEAD(&fs_devices->devices);
- INIT_LIST_HEAD(&fs_devices->alloc_list);
- list_add(&fs_devices->list, &fs_uuids);
- memcpy(fs_devices->fsid, disk_super->fsid, BTRFS_FSID_SIZE);
- fs_devices->latest_devid = devid;
- fs_devices->latest_trans = found_transid;
- mutex_init(&fs_devices->device_list_mutex);
- device = NULL;
- } else {
- device = __find_device(&fs_devices->devices, devid,
- disk_super->dev_item.uuid);
- }
- if (!device) {
- if (fs_devices->opened)
- return -EBUSY;
- device = kzalloc(sizeof(*device), GFP_NOFS);
- if (!device) {
- /* we can safely leave the fs_devices entry around */
- return -ENOMEM;
- }
- device->devid = devid;
- device->work.func = pending_bios_fn;
- memcpy(device->uuid, disk_super->dev_item.uuid,
- BTRFS_UUID_SIZE);
- spin_lock_init(&device->io_lock);
- device->name = kstrdup(path, GFP_NOFS);
- if (!device->name) {
- kfree(device);
- return -ENOMEM;
- }
- INIT_LIST_HEAD(&device->dev_alloc_list);
- mutex_lock(&fs_devices->device_list_mutex);
- list_add_rcu(&device->dev_list, &fs_devices->devices);
- mutex_unlock(&fs_devices->device_list_mutex);
- device->fs_devices = fs_devices;
- fs_devices->num_devices++;
- } else if (!device->name || strcmp(device->name, path)) {
- name = kstrdup(path, GFP_NOFS);
- if (!name)
- return -ENOMEM;
- kfree(device->name);
- device->name = name;
- if (device->missing) {
- fs_devices->missing_devices--;
- device->missing = 0;
- }
- }
- if (found_transid > fs_devices->latest_trans) {
- fs_devices->latest_devid = devid;
- fs_devices->latest_trans = found_transid;
- }
- *fs_devices_ret = fs_devices;
- return 0;
- }
- static struct btrfs_fs_devices *clone_fs_devices(struct btrfs_fs_devices *orig)
- {
- struct btrfs_fs_devices *fs_devices;
- struct btrfs_device *device;
- struct btrfs_device *orig_dev;
- fs_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
- if (!fs_devices)
- return ERR_PTR(-ENOMEM);
- INIT_LIST_HEAD(&fs_devices->devices);
- INIT_LIST_HEAD(&fs_devices->alloc_list);
- INIT_LIST_HEAD(&fs_devices->list);
- mutex_init(&fs_devices->device_list_mutex);
- fs_devices->latest_devid = orig->latest_devid;
- fs_devices->latest_trans = orig->latest_trans;
- memcpy(fs_devices->fsid, orig->fsid, sizeof(fs_devices->fsid));
- /* We have held the volume lock, it is safe to get the devices. */
- list_for_each_entry(orig_dev, &orig->devices, dev_list) {
- device = kzalloc(sizeof(*device), GFP_NOFS);
- if (!device)
- goto error;
- device->name = kstrdup(orig_dev->name, GFP_NOFS);
- if (!device->name) {
- kfree(device);
- goto error;
- }
- device->devid = orig_dev->devid;
- device->work.func = pending_bios_fn;
- memcpy(device->uuid, orig_dev->uuid, sizeof(device->uuid));
- spin_lock_init(&device->io_lock);
- INIT_LIST_HEAD(&device->dev_list);
- INIT_LIST_HEAD(&device->dev_alloc_list);
- list_add(&device->dev_list, &fs_devices->devices);
- device->fs_devices = fs_devices;
- fs_devices->num_devices++;
- }
- return fs_devices;
- error:
- free_fs_devices(fs_devices);
- return ERR_PTR(-ENOMEM);
- }
- int btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices)
- {
- struct btrfs_device *device, *next;
- mutex_lock(&uuid_mutex);
- again:
- /* This is the initialized path, it is safe to release the devices. */
- list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
- if (device->in_fs_metadata)
- continue;
- if (device->bdev) {
- blkdev_put(device->bdev, device->mode);
- device->bdev = NULL;
- fs_devices->open_devices--;
- }
- if (device->writeable) {
- list_del_init(&device->dev_alloc_list);
- device->writeable = 0;
- fs_devices->rw_devices--;
- }
- list_del_init(&device->dev_list);
- fs_devices->num_devices--;
- kfree(device->name);
- kfree(device);
- }
- if (fs_devices->seed) {
- fs_devices = fs_devices->seed;
- goto again;
- }
- mutex_unlock(&uuid_mutex);
- return 0;
- }
- static void __free_device(struct work_struct *work)
- {
- struct btrfs_device *device;
- device = container_of(work, struct btrfs_device, rcu_work);
- if (device->bdev)
- blkdev_put(device->bdev, device->mode);
- kfree(device->name);
- kfree(device);
- }
- static void free_device(struct rcu_head *head)
- {
- struct btrfs_device *device;
- device = container_of(head, struct btrfs_device, rcu);
- INIT_WORK(&device->rcu_work, __free_device);
- schedule_work(&device->rcu_work);
- }
- static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
- {
- struct btrfs_device *device;
- if (--fs_devices->opened > 0)
- return 0;
- mutex_lock(&fs_devices->device_list_mutex);
- list_for_each_entry(device, &fs_devices->devices, dev_list) {
- struct btrfs_device *new_device;
- if (device->bdev)
- fs_devices->open_devices--;
- if (device->writeable) {
- list_del_init(&device->dev_alloc_list);
- fs_devices->rw_devices--;
- }
- if (device->can_discard)
- fs_devices->num_can_discard--;
- new_device = kmalloc(sizeof(*new_device), GFP_NOFS);
- BUG_ON(!new_device);
- memcpy(new_device, device, sizeof(*new_device));
- new_device->name = kstrdup(device->name, GFP_NOFS);
- BUG_ON(device->name && !new_device->name);
- new_device->bdev = NULL;
- new_device->writeable = 0;
- new_device->in_fs_metadata = 0;
- new_device->can_discard = 0;
- list_replace_rcu(&device->dev_list, &new_device->dev_list);
- call_rcu(&device->rcu, free_device);
- }
- mutex_unlock(&fs_devices->device_list_mutex);
- WARN_ON(fs_devices->open_devices);
- WARN_ON(fs_devices->rw_devices);
- fs_devices->opened = 0;
- fs_devices->seeding = 0;
- return 0;
- }
- int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
- {
- struct btrfs_fs_devices *seed_devices = NULL;
- int ret;
- mutex_lock(&uuid_mutex);
- ret = __btrfs_close_devices(fs_devices);
- if (!fs_devices->opened) {
- seed_devices = fs_devices->seed;
- fs_devices->seed = NULL;
- }
- mutex_unlock(&uuid_mutex);
- while (seed_devices) {
- fs_devices = seed_devices;
- seed_devices = fs_devices->seed;
- __btrfs_close_devices(fs_devices);
- free_fs_devices(fs_devices);
- }
- return ret;
- }
- static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
- fmode_t flags, void *holder)
- {
- struct request_queue *q;
- struct block_device *bdev;
- struct list_head *head = &fs_devices->devices;
- struct btrfs_device *device;
- struct block_device *latest_bdev = NULL;
- struct buffer_head *bh;
- struct btrfs_super_block *disk_super;
- u64 latest_devid = 0;
- u64 latest_transid = 0;
- u64 devid;
- int seeding = 1;
- int ret = 0;
- flags |= FMODE_EXCL;
- list_for_each_entry(device, head, dev_list) {
- if (device->bdev)
- continue;
- if (!device->name)
- continue;
- bdev = blkdev_get_by_path(device->name, flags, holder);
- if (IS_ERR(bdev)) {
- printk(KERN_INFO "open %s failed\n", device->name);
- goto error;
- }
- set_blocksize(bdev, 4096);
- bh = btrfs_read_dev_super(bdev);
- if (!bh) {
- ret = -EINVAL;
- goto error_close;
- }
- disk_super = (struct btrfs_super_block *)bh->b_data;
- devid = btrfs_stack_device_id(&disk_super->dev_item);
- if (devid != device->devid)
- goto error_brelse;
- if (memcmp(device->uuid, disk_super->dev_item.uuid,
- BTRFS_UUID_SIZE))
- goto error_brelse;
- device->generation = btrfs_super_generation(disk_super);
- if (!latest_transid || device->generation > latest_transid) {
- latest_devid = devid;
- latest_transid = device->generation;
- latest_bdev = bdev;
- }
- if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
- device->writeable = 0;
- } else {
- device->writeable = !bdev_read_only(bdev);
- seeding = 0;
- }
- q = bdev_get_queue(bdev);
- if (blk_queue_discard(q)) {
- device->can_discard = 1;
- fs_devices->num_can_discard++;
- }
- device->bdev = bdev;
- device->in_fs_metadata = 0;
- device->mode = flags;
- if (!blk_queue_nonrot(bdev_get_queue(bdev)))
- fs_devices->rotating = 1;
- fs_devices->open_devices++;
- if (device->writeable) {
- fs_devices->rw_devices++;
- list_add(&device->dev_alloc_list,
- &fs_devices->alloc_list);
- }
- brelse(bh);
- continue;
- error_brelse:
- brelse(bh);
- error_close:
- blkdev_put(bdev, flags);
- error:
- continue;
- }
- if (fs_devices->open_devices == 0) {
- ret = -EIO;
- goto out;
- }
- fs_devices->seeding = seeding;
- fs_devices->opened = 1;
- fs_devices->latest_bdev = latest_bdev;
- fs_devices->latest_devid = latest_devid;
- fs_devices->latest_trans = latest_transid;
- fs_devices->total_rw_bytes = 0;
- out:
- return ret;
- }
- int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
- fmode_t flags, void *holder)
- {
- int ret;
- mutex_lock(&uuid_mutex);
- if (fs_devices->opened) {
- fs_devices->opened++;
- ret = 0;
- } else {
- ret = __btrfs_open_devices(fs_devices, flags, holder);
- }
- mutex_unlock(&uuid_mutex);
- return ret;
- }
- int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
- struct btrfs_fs_devices **fs_devices_ret)
- {
- struct btrfs_super_block *disk_super;
- struct block_device *bdev;
- struct buffer_head *bh;
- int ret;
- u64 devid;
- u64 transid;
- mutex_lock(&uuid_mutex);
- flags |= FMODE_EXCL;
- bdev = blkdev_get_by_path(path, flags, holder);
- if (IS_ERR(bdev)) {
- ret = PTR_ERR(bdev);
- goto error;
- }
- ret = set_blocksize(bdev, 4096);
- if (ret)
- goto error_close;
- bh = btrfs_read_dev_super(bdev);
- if (!bh) {
- ret = -EINVAL;
- goto error_close;
- }
- disk_super = (struct btrfs_super_block *)bh->b_data;
- devid = btrfs_stack_device_id(&disk_super->dev_item);
- transid = btrfs_super_generation(disk_super);
- if (disk_super->label[0])
- printk(KERN_INFO "device label %s ", disk_super->label);
- else
- printk(KERN_INFO "device fsid %pU ", disk_super->fsid);
- printk(KERN_CONT "devid %llu transid %llu %s\n",
- (unsigned long long)devid, (unsigned long long)transid, path);
- ret = device_list_add(path, disk_super, devid, fs_devices_ret);
- brelse(bh);
- error_close:
- blkdev_put(bdev, flags);
- error:
- mutex_unlock(&uuid_mutex);
- return ret;
- }
- /* helper to account the used device space in the range */
- int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
- u64 end, u64 *length)
- {
- struct btrfs_key key;
- struct btrfs_root *root = device->dev_root;
- struct btrfs_dev_extent *dev_extent;
- struct btrfs_path *path;
- u64 extent_end;
- int ret;
- int slot;
- struct extent_buffer *l;
- *length = 0;
- if (start >= device->total_bytes)
- return 0;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- path->reada = 2;
- key.objectid = device->devid;
- key.offset = start;
- key.type = BTRFS_DEV_EXTENT_KEY;
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0)
- goto out;
- if (ret > 0) {
- ret = btrfs_previous_item(root, path, key.objectid, key.type);
- if (ret < 0)
- goto out;
- }
- while (1) {
- l = path->nodes[0];
- slot = path->slots[0];
- if (slot >= btrfs_header_nritems(l)) {
- ret = btrfs_next_leaf(root, path);
- if (ret == 0)
- continue;
- if (ret < 0)
- goto out;
- break;
- }
- btrfs_item_key_to_cpu(l, &key, slot);
- if (key.objectid < device->devid)
- goto next;
- if (key.objectid > device->devid)
- break;
- if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
- goto next;
- dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
- extent_end = key.offset + btrfs_dev_extent_length(l,
- dev_extent);
- if (key.offset <= start && extent_end > end) {
- *length = end - start + 1;
- break;
- } else if (key.offset <= start && extent_end > start)
- *length += extent_end - start;
- else if (key.offset > start && extent_end <= end)
- *length += extent_end - key.offset;
- else if (key.offset > start && key.offset <= end) {
- *length += end - key.offset + 1;
- break;
- } else if (key.offset > end)
- break;
- next:
- path->slots[0]++;
- }
- ret = 0;
- out:
- btrfs_free_path(path);
- return ret;
- }
- /*
- * find_free_dev_extent - find free space in the specified device
- * @trans: transaction handler
- * @device: the device which we search the free space in
- * @num_bytes: the size of the free space that we need
- * @start: store the start of the free space.
- * @len: the size of the free space. that we find, or the size of the max
- * free space if we don't find suitable free space
- *
- * this uses a pretty simple search, the expectation is that it is
- * called very infrequently and that a given device has a small number
- * of extents
- *
- * @start is used to store the start of the free space if we find. But if we
- * don't find suitable free space, it will be used to store the start position
- * of the max free space.
- *
- * @len is used to store the size of the free space that we find.
- * But if we don't find suitable free space, it is used to store the size of
- * the max free space.
- */
- int find_free_dev_extent(struct btrfs_trans_handle *trans,
- struct btrfs_device *device, u64 num_bytes,
- u64 *start, u64 *len)
- {
- struct btrfs_key key;
- struct btrfs_root *root = device->dev_root;
- struct btrfs_dev_extent *dev_extent;
- struct btrfs_path *path;
- u64 hole_size;
- u64 max_hole_start;
- u64 max_hole_size;
- u64 extent_end;
- u64 search_start;
- u64 search_end = device->total_bytes;
- int ret;
- int slot;
- struct extent_buffer *l;
- /* FIXME use last free of some kind */
- /* we don't want to overwrite the superblock on the drive,
- * so we make sure to start at an offset of at least 1MB
- */
- search_start = max(root->fs_info->alloc_start, 1024ull * 1024);
- max_hole_start = search_start;
- max_hole_size = 0;
- if (search_start >= search_end) {
- ret = -ENOSPC;
- goto error;
- }
- path = btrfs_alloc_path();
- if (!path) {
- ret = -ENOMEM;
- goto error;
- }
- path->reada = 2;
- key.objectid = device->devid;
- key.offset = search_start;
- key.type = BTRFS_DEV_EXTENT_KEY;
- ret = btrfs_search_slot(trans, root, &key, path, 0, 0);
- if (ret < 0)
- goto out;
- if (ret > 0) {
- ret = btrfs_previous_item(root, path, key.objectid, key.type);
- if (ret < 0)
- goto out;
- }
- while (1) {
- l = path->nodes[0];
- slot = path->slots[0];
- if (slot >= btrfs_header_nritems(l)) {
- ret = btrfs_next_leaf(root, path);
- if (ret == 0)
- continue;
- if (ret < 0)
- goto out;
- break;
- }
- btrfs_item_key_to_cpu(l, &key, slot);
- if (key.objectid < device->devid)
- goto next;
- if (key.objectid > device->devid)
- break;
- if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
- goto next;
- if (key.offset > search_start) {
- hole_size = key.offset - search_start;
- if (hole_size > max_hole_size) {
- max_hole_start = search_start;
- max_hole_size = hole_size;
- }
- /*
- * If this free space is greater than which we need,
- * it must be the max free space that we have found
- * until now, so max_hole_start must point to the start
- * of this free space and the length of this free space
- * is stored in max_hole_size. Thus, we return
- * max_hole_start and max_hole_size and go back to the
- * caller.
- */
- if (hole_size >= num_bytes) {
- ret = 0;
- goto out;
- }
- }
- dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
- extent_end = key.offset + btrfs_dev_extent_length(l,
- dev_extent);
- if (extent_end > search_start)
- search_start = extent_end;
- next:
- path->slots[0]++;
- cond_resched();
- }
- hole_size = search_end- search_start;
- if (hole_size > max_hole_size) {
- max_hole_start = search_start;
- max_hole_size = hole_size;
- }
- /* See above. */
- if (hole_size < num_bytes)
- ret = -ENOSPC;
- else
- ret = 0;
- out:
- btrfs_free_path(path);
- error:
- *start = max_hole_start;
- if (len)
- *len = max_hole_size;
- return ret;
- }
- static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
- struct btrfs_device *device,
- u64 start)
- {
- int ret;
- struct btrfs_path *path;
- struct btrfs_root *root = device->dev_root;
- struct btrfs_key key;
- struct btrfs_key found_key;
- struct extent_buffer *leaf = NULL;
- struct btrfs_dev_extent *extent = NULL;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = device->devid;
- key.offset = start;
- key.type = BTRFS_DEV_EXTENT_KEY;
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret > 0) {
- ret = btrfs_previous_item(root, path, key.objectid,
- BTRFS_DEV_EXTENT_KEY);
- if (ret)
- goto out;
- leaf = path->nodes[0];
- btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
- extent = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_dev_extent);
- BUG_ON(found_key.offset > start || found_key.offset +
- btrfs_dev_extent_length(leaf, extent) < start);
- } else if (ret == 0) {
- leaf = path->nodes[0];
- extent = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_dev_extent);
- }
- BUG_ON(ret);
- if (device->bytes_used > 0)
- device->bytes_used -= btrfs_dev_extent_length(leaf, extent);
- ret = btrfs_del_item(trans, root, path);
- out:
- btrfs_free_path(path);
- return ret;
- }
- int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
- struct btrfs_device *device,
- u64 chunk_tree, u64 chunk_objectid,
- u64 chunk_offset, u64 start, u64 num_bytes)
- {
- int ret;
- struct btrfs_path *path;
- struct btrfs_root *root = device->dev_root;
- struct btrfs_dev_extent *extent;
- struct extent_buffer *leaf;
- struct btrfs_key key;
- WARN_ON(!device->in_fs_metadata);
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = device->devid;
- key.offset = start;
- key.type = BTRFS_DEV_EXTENT_KEY;
- ret = btrfs_insert_empty_item(trans, root, path, &key,
- sizeof(*extent));
- BUG_ON(ret);
- leaf = path->nodes[0];
- extent = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_dev_extent);
- btrfs_set_dev_extent_chunk_tree(leaf, extent, chunk_tree);
- btrfs_set_dev_extent_chunk_objectid(leaf, extent, chunk_objectid);
- btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);
- write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
- (unsigned long)btrfs_dev_extent_chunk_tree_uuid(extent),
- BTRFS_UUID_SIZE);
- btrfs_set_dev_extent_length(leaf, extent, num_bytes);
- btrfs_mark_buffer_dirty(leaf);
- btrfs_free_path(path);
- return ret;
- }
- static noinline int find_next_chunk(struct btrfs_root *root,
- u64 objectid, u64 *offset)
- {
- struct btrfs_path *path;
- int ret;
- struct btrfs_key key;
- struct btrfs_chunk *chunk;
- struct btrfs_key found_key;
- path = btrfs_alloc_path();
- BUG_ON(!path);
- key.objectid = objectid;
- key.offset = (u64)-1;
- key.type = BTRFS_CHUNK_ITEM_KEY;
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0)
- goto error;
- BUG_ON(ret == 0);
- ret = btrfs_previous_item(root, path, 0, BTRFS_CHUNK_ITEM_KEY);
- if (ret) {
- *offset = 0;
- } else {
- btrfs_item_key_to_cpu(path->nodes[0], &found_key,
- path->slots[0]);
- if (found_key.objectid != objectid)
- *offset = 0;
- else {
- chunk = btrfs_item_ptr(path->nodes[0], path->slots[0],
- struct btrfs_chunk);
- *offset = found_key.offset +
- btrfs_chunk_length(path->nodes[0], chunk);
- }
- }
- ret = 0;
- error:
- btrfs_free_path(path);
- return ret;
- }
- static noinline int find_next_devid(struct btrfs_root *root, u64 *objectid)
- {
- int ret;
- struct btrfs_key key;
- struct btrfs_key found_key;
- struct btrfs_path *path;
- root = root->fs_info->chunk_root;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
- key.type = BTRFS_DEV_ITEM_KEY;
- key.offset = (u64)-1;
- ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
- if (ret < 0)
- goto error;
- BUG_ON(ret == 0);
- ret = btrfs_previous_item(root, path, BTRFS_DEV_ITEMS_OBJECTID,
- BTRFS_DEV_ITEM_KEY);
- if (ret) {
- *objectid = 1;
- } else {
- btrfs_item_key_to_cpu(path->nodes[0], &found_key,
- path->slots[0]);
- *objectid = found_key.offset + 1;
- }
- ret = 0;
- error:
- btrfs_free_path(path);
- return ret;
- }
- /*
- * the device information is stored in the chunk root
- * the btrfs_device struct should be fully filled in
- */
- int btrfs_add_device(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- struct btrfs_device *device)
- {
- int ret;
- struct btrfs_path *path;
- struct btrfs_dev_item *dev_item;
- struct extent_buffer *leaf;
- struct btrfs_key key;
- unsigned long ptr;
- root = root->fs_info->chunk_root;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
- key.type = BTRFS_DEV_ITEM_KEY;
- key.offset = device->devid;
- ret = btrfs_insert_empty_item(trans, root, path, &key,
- sizeof(*dev_item));
- if (ret)
- goto out;
- leaf = path->nodes[0];
- dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
- btrfs_set_device_id(leaf, dev_item, device->devid);
- btrfs_set_device_generation(leaf, dev_item, 0);
- btrfs_set_device_type(leaf, dev_item, device->type);
- btrfs_set_device_io_align(leaf, dev_item, device->io_align);
- btrfs_set_device_io_width(leaf, dev_item, device->io_width);
- btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
- btrfs_set_device_total_bytes(leaf, dev_item, device->total_bytes);
- btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
- btrfs_set_device_group(leaf, dev_item, 0);
- btrfs_set_device_seek_speed(leaf, dev_item, 0);
- btrfs_set_device_bandwidth(leaf, dev_item, 0);
- btrfs_set_device_start_offset(leaf, dev_item, 0);
- ptr = (unsigned long)btrfs_device_uuid(dev_item);
- write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
- ptr = (unsigned long)btrfs_device_fsid(dev_item);
- write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
- btrfs_mark_buffer_dirty(leaf);
- ret = 0;
- out:
- btrfs_free_path(path);
- return ret;
- }
- static int btrfs_rm_dev_item(struct btrfs_root *root,
- struct btrfs_device *device)
- {
- int ret;
- struct btrfs_path *path;
- struct btrfs_key key;
- struct btrfs_trans_handle *trans;
- root = root->fs_info->chunk_root;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- btrfs_free_path(path);
- return PTR_ERR(trans);
- }
- key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
- key.type = BTRFS_DEV_ITEM_KEY;
- key.offset = device->devid;
- lock_chunks(root);
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- if (ret < 0)
- goto out;
- if (ret > 0) {
- ret = -ENOENT;
- goto out;
- }
- ret = btrfs_del_item(trans, root, path);
- if (ret)
- goto out;
- out:
- btrfs_free_path(path);
- unlock_chunks(root);
- btrfs_commit_transaction(trans, root);
- return ret;
- }
- int btrfs_rm_device(struct btrfs_root *root, char *device_path)
- {
- struct btrfs_device *device;
- struct btrfs_device *next_device;
- struct block_device *bdev;
- struct buffer_head *bh = NULL;
- struct btrfs_super_block *disk_super;
- struct btrfs_fs_devices *cur_devices;
- u64 all_avail;
- u64 devid;
- u64 num_devices;
- u8 *dev_uuid;
- int ret = 0;
- bool clear_super = false;
- mutex_lock(&uuid_mutex);
- mutex_lock(&root->fs_info->volume_mutex);
- all_avail = root->fs_info->avail_data_alloc_bits |
- root->fs_info->avail_system_alloc_bits |
- root->fs_info->avail_metadata_alloc_bits;
- if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) &&
- root->fs_info->fs_devices->num_devices <= 4) {
- printk(KERN_ERR "btrfs: unable to go below four devices "
- "on raid10\n");
- ret = -EINVAL;
- goto out;
- }
- if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) &&
- root->fs_info->fs_devices->num_devices <= 2) {
- printk(KERN_ERR "btrfs: unable to go below two "
- "devices on raid1\n");
- ret = -EINVAL;
- goto out;
- }
- if (strcmp(device_path, "missing") == 0) {
- struct list_head *devices;
- struct btrfs_device *tmp;
- device = NULL;
- devices = &root->fs_info->fs_devices->devices;
- /*
- * It is safe to read the devices since the volume_mutex
- * is held.
- */
- list_for_each_entry(tmp, devices, dev_list) {
- if (tmp->in_fs_metadata && !tmp->bdev) {
- device = tmp;
- break;
- }
- }
- bdev = NULL;
- bh = NULL;
- disk_super = NULL;
- if (!device) {
- printk(KERN_ERR "btrfs: no missing devices found to "
- "remove\n");
- goto out;
- }
- } else {
- bdev = blkdev_get_by_path(device_path, FMODE_READ | FMODE_EXCL,
- root->fs_info->bdev_holder);
- if (IS_ERR(bdev)) {
- ret = PTR_ERR(bdev);
- goto out;
- }
- set_blocksize(bdev, 4096);
- bh = btrfs_read_dev_super(bdev);
- if (!bh) {
- ret = -EINVAL;
- goto error_close;
- }
- disk_super = (struct btrfs_super_block *)bh->b_data;
- devid = btrfs_stack_device_id(&disk_super->dev_item);
- dev_uuid = disk_super->dev_item.uuid;
- device = btrfs_find_device(root, devid, dev_uuid,
- disk_super->fsid);
- if (!device) {
- ret = -ENOENT;
- goto error_brelse;
- }
- }
- if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
- printk(KERN_ERR "btrfs: unable to remove the only writeable "
- "device\n");
- ret = -EINVAL;
- goto error_brelse;
- }
- if (device->writeable) {
- lock_chunks(root);
- list_del_init(&device->dev_alloc_list);
- unlock_chunks(root);
- root->fs_info->fs_devices->rw_devices--;
- clear_super = true;
- }
- ret = btrfs_shrink_device(device, 0);
- if (ret)
- goto error_undo;
- ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
- if (ret)
- goto error_undo;
- device->in_fs_metadata = 0;
- btrfs_scrub_cancel_dev(root, device);
- /*
- * the device list mutex makes sure that we don't change
- * the device list while someone else is writing out all
- * the device supers.
- */
- cur_devices = device->fs_devices;
- mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
- list_del_rcu(&device->dev_list);
- device->fs_devices->num_devices--;
- if (device->missing)
- root->fs_info->fs_devices->missing_devices--;
- next_device = list_entry(root->fs_info->fs_devices->devices.next,
- struct btrfs_device, dev_list);
- if (device->bdev == root->fs_info->sb->s_bdev)
- root->fs_info->sb->s_bdev = next_device->bdev;
- if (device->bdev == root->fs_info->fs_devices->latest_bdev)
- root->fs_info->fs_devices->latest_bdev = next_device->bdev;
- if (device->bdev)
- device->fs_devices->open_devices--;
- call_rcu(&device->rcu, free_device);
- mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
- num_devices = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
- btrfs_set_super_num_devices(&root->fs_info->super_copy, num_devices);
- if (cur_devices->open_devices == 0) {
- struct btrfs_fs_devices *fs_devices;
- fs_devices = root->fs_info->fs_devices;
- while (fs_devices) {
- if (fs_devices->seed == cur_devices)
- break;
- fs_devices = fs_devices->seed;
- }
- fs_devices->seed = cur_devices->seed;
- cur_devices->seed = NULL;
- lock_chunks(root);
- __btrfs_close_devices(cur_devices);
- unlock_chunks(root);
- free_fs_devices(cur_devices);
- }
- /*
- * at this point, the device is zero sized. We want to
- * remove it from the devices list and zero out the old super
- */
- if (clear_super) {
- /* make sure this device isn't detected as part of
- * the FS anymore
- */
- memset(&disk_super->magic, 0, sizeof(disk_super->magic));
- set_buffer_dirty(bh);
- sync_dirty_buffer(bh);
- }
- ret = 0;
- error_brelse:
- brelse(bh);
- error_close:
- if (bdev)
- blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
- out:
- mutex_unlock(&root->fs_info->volume_mutex);
- mutex_unlock(&uuid_mutex);
- return ret;
- error_undo:
- if (device->writeable) {
- lock_chunks(root);
- list_add(&device->dev_alloc_list,
- &root->fs_info->fs_devices->alloc_list);
- unlock_chunks(root);
- root->fs_info->fs_devices->rw_devices++;
- }
- goto error_brelse;
- }
- /*
- * does all the dirty work required for changing file system's UUID.
- */
- static int btrfs_prepare_sprout(struct btrfs_trans_handle *trans,
- struct btrfs_root *root)
- {
- struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
- struct btrfs_fs_devices *old_devices;
- struct btrfs_fs_devices *seed_devices;
- struct btrfs_super_block *disk_super = &root->fs_info->super_copy;
- struct btrfs_device *device;
- u64 super_flags;
- BUG_ON(!mutex_is_locked(&uuid_mutex));
- if (!fs_devices->seeding)
- return -EINVAL;
- seed_devices = kzalloc(sizeof(*fs_devices), GFP_NOFS);
- if (!seed_devices)
- return -ENOMEM;
- old_devices = clone_fs_devices(fs_devices);
- if (IS_ERR(old_devices)) {
- kfree(seed_devices);
- return PTR_ERR(old_devices);
- }
- list_add(&old_devices->list, &fs_uuids);
- memcpy(seed_devices, fs_devices, sizeof(*seed_devices));
- seed_devices->opened = 1;
- INIT_LIST_HEAD(&seed_devices->devices);
- INIT_LIST_HEAD(&seed_devices->alloc_list);
- mutex_init(&seed_devices->device_list_mutex);
- mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
- list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
- synchronize_rcu);
- mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
- list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
- list_for_each_entry(device, &seed_devices->devices, dev_list) {
- device->fs_devices = seed_devices;
- }
- fs_devices->seeding = 0;
- fs_devices->num_devices = 0;
- fs_devices->open_devices = 0;
- fs_devices->seed = seed_devices;
- generate_random_uuid(fs_devices->fsid);
- memcpy(root->fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
- memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
- super_flags = btrfs_super_flags(disk_super) &
- ~BTRFS_SUPER_FLAG_SEEDING;
- btrfs_set_super_flags(disk_super, super_flags);
- return 0;
- }
- /*
- * strore the expected generation for seed devices in device items.
- */
- static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
- struct btrfs_root *root)
- {
- struct btrfs_path *path;
- struct extent_buffer *leaf;
- struct btrfs_dev_item *dev_item;
- struct btrfs_device *device;
- struct btrfs_key key;
- u8 fs_uuid[BTRFS_UUID_SIZE];
- u8 dev_uuid[BTRFS_UUID_SIZE];
- u64 devid;
- int ret;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- root = root->fs_info->chunk_root;
- key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
- key.offset = 0;
- key.type = BTRFS_DEV_ITEM_KEY;
- while (1) {
- ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
- if (ret < 0)
- goto error;
- leaf = path->nodes[0];
- next_slot:
- if (path->slots[0] >= btrfs_header_nritems(leaf)) {
- ret = btrfs_next_leaf(root, path);
- if (ret > 0)
- break;
- if (ret < 0)
- goto error;
- leaf = path->nodes[0];
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- btrfs_release_path(path);
- continue;
- }
- btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
- if (key.objectid != BTRFS_DEV_ITEMS_OBJECTID ||
- key.type != BTRFS_DEV_ITEM_KEY)
- break;
- dev_item = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_dev_item);
- devid = btrfs_device_id(leaf, dev_item);
- read_extent_buffer(leaf, dev_uuid,
- (unsigned long)btrfs_device_uuid(dev_item),
- BTRFS_UUID_SIZE);
- read_extent_buffer(leaf, fs_uuid,
- (unsigned long)btrfs_device_fsid(dev_item),
- BTRFS_UUID_SIZE);
- device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
- BUG_ON(!device);
- if (device->fs_devices->seeding) {
- btrfs_set_device_generation(leaf, dev_item,
- device->generation);
- btrfs_mark_buffer_dirty(leaf);
- }
- path->slots[0]++;
- goto next_slot;
- }
- ret = 0;
- error:
- btrfs_free_path(path);
- return ret;
- }
- int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
- {
- struct request_queue *q;
- struct btrfs_trans_handle *trans;
- struct btrfs_device *device;
- struct block_device *bdev;
- struct list_head *devices;
- struct super_block *sb = root->fs_info->sb;
- u64 total_bytes;
- int seeding_dev = 0;
- int ret = 0;
- if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
- return -EINVAL;
- bdev = blkdev_get_by_path(device_path, FMODE_EXCL,
- root->fs_info->bdev_holder);
- if (IS_ERR(bdev))
- return PTR_ERR(bdev);
- if (root->fs_info->fs_devices->seeding) {
- seeding_dev = 1;
- down_write(&sb->s_umount);
- mutex_lock(&uuid_mutex);
- }
- filemap_write_and_wait(bdev->bd_inode->i_mapping);
- mutex_lock(&root->fs_info->volume_mutex);
- devices = &root->fs_info->fs_devices->devices;
- /*
- * we have the volume lock, so we don't need the extra
- * device list mutex while reading the list here.
- */
- list_for_each_entry(device, devices, dev_list) {
- if (device->bdev == bdev) {
- ret = -EEXIST;
- goto error;
- }
- }
- device = kzalloc(sizeof(*device), GFP_NOFS);
- if (!device) {
- /* we can safely leave the fs_devices entry around */
- ret = -ENOMEM;
- goto error;
- }
- device->name = kstrdup(device_path, GFP_NOFS);
- if (!device->name) {
- kfree(device);
- ret = -ENOMEM;
- goto error;
- }
- ret = find_next_devid(root, &device->devid);
- if (ret) {
- kfree(device->name);
- kfree(device);
- goto error;
- }
- trans = btrfs_start_transaction(root, 0);
- if (IS_ERR(trans)) {
- kfree(device->name);
- kfree(device);
- ret = PTR_ERR(trans);
- goto error;
- }
- lock_chunks(root);
- q = bdev_get_queue(bdev);
- if (blk_queue_discard(q))
- device->can_discard = 1;
- device->writeable = 1;
- device->work.func = pending_bios_fn;
- generate_random_uuid(device->uuid);
- spin_lock_init(&device->io_lock);
- device->generation = trans->transid;
- device->io_width = root->sectorsize;
- device->io_align = root->sectorsize;
- device->sector_size = root->sectorsize;
- device->total_bytes = i_size_read(bdev->bd_inode);
- device->disk_total_bytes = device->total_bytes;
- device->dev_root = root->fs_info->dev_root;
- device->bdev = bdev;
- device->in_fs_metadata = 1;
- device->mode = FMODE_EXCL;
- set_blocksize(device->bdev, 4096);
- if (seeding_dev) {
- sb->s_flags &= ~MS_RDONLY;
- ret = btrfs_prepare_sprout(trans, root);
- BUG_ON(ret);
- }
- device->fs_devices = root->fs_info->fs_devices;
- /*
- * we don't want write_supers to jump in here with our device
- * half setup
- */
- mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
- 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);
- root->fs_info->fs_devices->num_devices++;
- root->fs_info->fs_devices->open_devices++;
- root->fs_info->fs_devices->rw_devices++;
- if (device->can_discard)
- root->fs_info->fs_devices->num_can_discard++;
- root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
- if (!blk_queue_nonrot(bdev_get_queue(bdev)))
- root->fs_info->fs_devices->rotating = 1;
- total_bytes = btrfs_super_total_bytes(&root->fs_info->super_copy);
- btrfs_set_super_total_bytes(&root->fs_info->super_copy,
- total_bytes + device->total_bytes);
- total_bytes = btrfs_super_num_devices(&root->fs_info->super_copy);
- btrfs_set_super_num_devices(&root->fs_info->super_copy,
- total_bytes + 1);
- mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
- if (seeding_dev) {
- ret = init_first_rw_device(trans, root, device);
- BUG_ON(ret);
- ret = btrfs_finish_sprout(trans, root);
- BUG_ON(ret);
- } else {
- ret = btrfs_add_device(trans, root, device);
- }
- /*
- * we've got more storage, clear any full flags on the space
- * infos
- */
- btrfs_clear_space_info_full(root->fs_info);
- unlock_chunks(root);
- btrfs_commit_transaction(trans, root);
- if (seeding_dev) {
- mutex_unlock(&uuid_mutex);
- up_write(&sb->s_umount);
- ret = btrfs_relocate_sys_chunks(root);
- BUG_ON(ret);
- }
- out:
- mutex_unlock(&root->fs_info->volume_mutex);
- return ret;
- error:
- blkdev_put(bdev, FMODE_EXCL);
- if (seeding_dev) {
- mutex_unlock(&uuid_mutex);
- up_write(&sb->s_umount);
- }
- goto out;
- }
- static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
- struct btrfs_device *device)
- {
- int ret;
- struct btrfs_path *path;
- struct btrfs_root *root;
- struct btrfs_dev_item *dev_item;
- struct extent_buffer *leaf;
- struct btrfs_key key;
- root = device->dev_root->fs_info->chunk_root;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
- key.type = BTRFS_DEV_ITEM_KEY;
- key.offset = device->devid;
- ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
- if (ret < 0)
- goto out;
- if (ret > 0) {
- ret = -ENOENT;
- goto out;
- }
- leaf = path->nodes[0];
- dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
- btrfs_set_device_id(leaf, dev_item, device->devid);
- btrfs_set_device_type(leaf, dev_item, device->type);
- btrfs_set_device_io_align(leaf, dev_item, device->io_align);
- btrfs_set_device_io_width(leaf, dev_item, device->io_width);
- btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
- btrfs_set_device_total_bytes(leaf, dev_item, device->disk_total_bytes);
- btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
- btrfs_mark_buffer_dirty(leaf);
- out:
- btrfs_free_path(path);
- return ret;
- }
- static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
- struct btrfs_device *device, u64 new_size)
- {
- struct btrfs_super_block *super_copy =
- &device->dev_root->fs_info->super_copy;
- u64 old_total = btrfs_super_total_bytes(super_copy);
- u64 diff = new_size - device->total_bytes;
- if (!device->writeable)
- return -EACCES;
- if (new_size <= device->total_bytes)
- return -EINVAL;
- btrfs_set_super_total_bytes(super_copy, old_total + diff);
- device->fs_devices->total_rw_bytes += diff;
- device->total_bytes = new_size;
- device->disk_total_bytes = new_size;
- btrfs_clear_space_info_full(device->dev_root->fs_info);
- return btrfs_update_device(trans, device);
- }
- int btrfs_grow_device(struct btrfs_trans_handle *trans,
- struct btrfs_device *device, u64 new_size)
- {
- int ret;
- lock_chunks(device->dev_root);
- ret = __btrfs_grow_device(trans, device, new_size);
- unlock_chunks(device->dev_root);
- return ret;
- }
- static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
- struct btrfs_root *root,
- u64 chunk_tree, u64 chunk_objectid,
- u64 chunk_offset)
- {
- int ret;
- struct btrfs_path *path;
- struct btrfs_key key;
- root = root->fs_info->chunk_root;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- key.objectid = chunk_objectid;
- key.offset = chunk_offset;
- key.type = BTRFS_CHUNK_ITEM_KEY;
- ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
- BUG_ON(ret);
- ret = btrfs_del_item(trans, root, path);
- btrfs_free_path(path);
- return ret;
- }
- static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
- chunk_offset)
- {
- struct btrfs_super_block *super_copy = &root->fs_info->super_copy;
- struct btrfs_disk_key *disk_key;
- struct btrfs_chunk *chunk;
- u8 *ptr;
- int ret = 0;
- u32 num_stripes;
- u32 array_size;
- u32 len = 0;
- u32 cur;
- struct btrfs_key key;
- array_size = btrfs_super_sys_array_size(super_copy);
- ptr = super_copy->sys_chunk_array;
- cur = 0;
- while (cur < array_size) {
- disk_key = (struct btrfs_disk_key *)ptr;
- btrfs_disk_key_to_cpu(&key, disk_key);
- len = sizeof(*disk_key);
- if (key.type == BTRFS_CHUNK_ITEM_KEY) {
- chunk = (struct btrfs_chunk *)(ptr + len);
- num_stripes = btrfs_stack_chunk_num_stripes(chunk);
- len += btrfs_chunk_item_size(num_stripes);
- } else {
- ret = -EIO;
- break;
- }
- if (key.objectid == chunk_objectid &&
- key.offset == chunk_offset) {
- memmove(ptr, ptr + len, array_size - (cur + len));
- array_size -= len;
- btrfs_set_super_sys_array_size(super_copy, array_size);
- } else {
- ptr += len;
- cur += len;
- }
- }
- return ret;
- }
- static int btrfs_relocate_chunk(struct btrfs_root *root,
- u64 chunk_tree, u64 chunk_objectid,
- u64 chunk_offset)
- {
- struct extent_map_tree *em_tree;
- struct btrfs_root *extent_root;
- struct btrfs_trans_handle *trans;
- struct extent_map *em;
- struct map_lookup *map;
- int ret;
- int i;
- root = root->fs_info->chunk_root;
- extent_root = root->fs_info->extent_root;
- em_tree = &root->fs_info->mapping_tree.map_tree;
- ret = btrfs_can_relocate(extent_root, chunk_offset);
- if (ret)
- return -ENOSPC;
- /* step one, relocate all the extents inside this chunk */
- ret = btrfs_relocate_block_group(extent_root, chunk_offset);
- if (ret)
- return ret;
- trans = btrfs_start_transaction(root, 0);
- BUG_ON(IS_ERR(trans));
- lock_chunks(root);
- /*
- * step two, delete the device extents and the
- * chunk tree entries
- */
- read_lock(&em_tree->lock);
- em = lookup_extent_mapping(em_tree, chunk_offset, 1);
- read_unlock(&em_tree->lock);
- BUG_ON(em->start > chunk_offset ||
- em->start + em->len < chunk_offset);
- map = (struct map_lookup *)em->bdev;
- for (i = 0; i < map->num_stripes; i++) {
- ret = btrfs_free_dev_extent(trans, map->stripes[i].dev,
- map->stripes[i].physical);
- BUG_ON(ret);
- if (map->stripes[i].dev) {
- ret = btrfs_update_device(trans, map->stripes[i].dev);
- BUG_ON(ret);
- }
- }
- ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid,
- chunk_offset);
- BUG_ON(ret);
- trace_btrfs_chunk_free(root, map, chunk_offset, em->len);
- if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
- ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
- BUG_ON(ret);
- }
- ret = btrfs_remove_block_group(trans, extent_root, chunk_offset);
- BUG_ON(ret);
- write_lock(&em_tree->lock);
- remove_extent_mapping(em_tree, em);
- write_unlock(&em_tree->lock);
- kfree(map);
- em->bdev = NULL;
- /* once for the tree */
- free_extent_map(em);
- /* once for us */
- free_extent_map(em);
- unlock_chunks(root);
- btrfs_end_transaction(trans, root);
- return 0;
- }
- static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
- {
- struct btrfs_root *chunk_root = root->fs_info->chunk_root;
- struct btrfs_path *path;
- struct extent_buffer *leaf;
- struct btrfs_chunk *chunk;
- struct btrfs_key key;
- struct btrfs_key found_key;
- u64 chunk_tree = chunk_root->root_key.objectid;
- u64 chunk_type;
- bool retried = false;
- int failed = 0;
- int ret;
- path = btrfs_alloc_path();
- if (!path)
- return -ENOMEM;
- again:
- key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
- key.offset = (u64)-1;
- key.type = BTRFS_CHUNK_ITEM_KEY;
- while (1) {
- ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
- if (ret < 0)
- goto error;
- BUG_ON(ret == 0);
- ret = btrfs_previous_item(chunk_root, path, key.objectid,
- key.type);
- if (ret…