![Chris Mason](/assets/img/avatar_default.png)
Commitscc8385b59e
and7ef70b4d99
added preallocation for the reada radix trees and also switched them over to GFP_KERNEL for the default gfp mask. Since we're doing radix tree insertions under spinlocks, we need to make sure the mask doesn't allow sleeping. This fix keeps the radix preallocation but switches back to the original gfp_mask. Reported-by: Filipe Manana <fdmanana@suse.com> Signed-off-by: Chris Mason <clm@fb.com>
7251 lines
187 KiB
C
7251 lines
187 KiB
C
/*
|
|
* 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/iocontext.h>
|
|
#include <linux/capability.h>
|
|
#include <linux/ratelimit.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/raid/pq.h>
|
|
#include <linux/semaphore.h>
|
|
#include <linux/uuid.h>
|
|
#include <asm/div64.h>
|
|
#include "ctree.h"
|
|
#include "extent_map.h"
|
|
#include "disk-io.h"
|
|
#include "transaction.h"
|
|
#include "print-tree.h"
|
|
#include "volumes.h"
|
|
#include "raid56.h"
|
|
#include "async-thread.h"
|
|
#include "check-integrity.h"
|
|
#include "rcu-string.h"
|
|
#include "math.h"
|
|
#include "dev-replace.h"
|
|
#include "sysfs.h"
|
|
|
|
const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
|
|
[BTRFS_RAID_RAID10] = {
|
|
.sub_stripes = 2,
|
|
.dev_stripes = 1,
|
|
.devs_max = 0, /* 0 == as many as possible */
|
|
.devs_min = 4,
|
|
.tolerated_failures = 1,
|
|
.devs_increment = 2,
|
|
.ncopies = 2,
|
|
},
|
|
[BTRFS_RAID_RAID1] = {
|
|
.sub_stripes = 1,
|
|
.dev_stripes = 1,
|
|
.devs_max = 2,
|
|
.devs_min = 2,
|
|
.tolerated_failures = 1,
|
|
.devs_increment = 2,
|
|
.ncopies = 2,
|
|
},
|
|
[BTRFS_RAID_DUP] = {
|
|
.sub_stripes = 1,
|
|
.dev_stripes = 2,
|
|
.devs_max = 1,
|
|
.devs_min = 1,
|
|
.tolerated_failures = 0,
|
|
.devs_increment = 1,
|
|
.ncopies = 2,
|
|
},
|
|
[BTRFS_RAID_RAID0] = {
|
|
.sub_stripes = 1,
|
|
.dev_stripes = 1,
|
|
.devs_max = 0,
|
|
.devs_min = 2,
|
|
.tolerated_failures = 0,
|
|
.devs_increment = 1,
|
|
.ncopies = 1,
|
|
},
|
|
[BTRFS_RAID_SINGLE] = {
|
|
.sub_stripes = 1,
|
|
.dev_stripes = 1,
|
|
.devs_max = 1,
|
|
.devs_min = 1,
|
|
.tolerated_failures = 0,
|
|
.devs_increment = 1,
|
|
.ncopies = 1,
|
|
},
|
|
[BTRFS_RAID_RAID5] = {
|
|
.sub_stripes = 1,
|
|
.dev_stripes = 1,
|
|
.devs_max = 0,
|
|
.devs_min = 2,
|
|
.tolerated_failures = 1,
|
|
.devs_increment = 1,
|
|
.ncopies = 2,
|
|
},
|
|
[BTRFS_RAID_RAID6] = {
|
|
.sub_stripes = 1,
|
|
.dev_stripes = 1,
|
|
.devs_max = 0,
|
|
.devs_min = 3,
|
|
.tolerated_failures = 2,
|
|
.devs_increment = 1,
|
|
.ncopies = 3,
|
|
},
|
|
};
|
|
|
|
const u64 btrfs_raid_group[BTRFS_NR_RAID_TYPES] = {
|
|
[BTRFS_RAID_RAID10] = BTRFS_BLOCK_GROUP_RAID10,
|
|
[BTRFS_RAID_RAID1] = BTRFS_BLOCK_GROUP_RAID1,
|
|
[BTRFS_RAID_DUP] = BTRFS_BLOCK_GROUP_DUP,
|
|
[BTRFS_RAID_RAID0] = BTRFS_BLOCK_GROUP_RAID0,
|
|
[BTRFS_RAID_SINGLE] = 0,
|
|
[BTRFS_RAID_RAID5] = BTRFS_BLOCK_GROUP_RAID5,
|
|
[BTRFS_RAID_RAID6] = BTRFS_BLOCK_GROUP_RAID6,
|
|
};
|
|
|
|
/*
|
|
* Table to convert BTRFS_RAID_* to the error code if minimum number of devices
|
|
* condition is not met. Zero means there's no corresponding
|
|
* BTRFS_ERROR_DEV_*_NOT_MET value.
|
|
*/
|
|
const int btrfs_raid_mindev_error[BTRFS_NR_RAID_TYPES] = {
|
|
[BTRFS_RAID_RAID10] = BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET,
|
|
[BTRFS_RAID_RAID1] = BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET,
|
|
[BTRFS_RAID_DUP] = 0,
|
|
[BTRFS_RAID_RAID0] = 0,
|
|
[BTRFS_RAID_SINGLE] = 0,
|
|
[BTRFS_RAID_RAID5] = BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET,
|
|
[BTRFS_RAID_RAID6] = BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET,
|
|
};
|
|
|
|
static int init_first_rw_device(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info);
|
|
static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info);
|
|
static void __btrfs_reset_dev_stats(struct btrfs_device *dev);
|
|
static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev);
|
|
static void btrfs_dev_stat_print_on_load(struct btrfs_device *device);
|
|
static int __btrfs_map_block(struct btrfs_fs_info *fs_info,
|
|
enum btrfs_map_op op,
|
|
u64 logical, u64 *length,
|
|
struct btrfs_bio **bbio_ret,
|
|
int mirror_num, int need_raid_map);
|
|
|
|
DEFINE_MUTEX(uuid_mutex);
|
|
static LIST_HEAD(fs_uuids);
|
|
struct list_head *btrfs_get_fs_uuids(void)
|
|
{
|
|
return &fs_uuids;
|
|
}
|
|
|
|
static struct btrfs_fs_devices *__alloc_fs_devices(void)
|
|
{
|
|
struct btrfs_fs_devices *fs_devs;
|
|
|
|
fs_devs = kzalloc(sizeof(*fs_devs), GFP_KERNEL);
|
|
if (!fs_devs)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
mutex_init(&fs_devs->device_list_mutex);
|
|
|
|
INIT_LIST_HEAD(&fs_devs->devices);
|
|
INIT_LIST_HEAD(&fs_devs->resized_devices);
|
|
INIT_LIST_HEAD(&fs_devs->alloc_list);
|
|
INIT_LIST_HEAD(&fs_devs->list);
|
|
|
|
return fs_devs;
|
|
}
|
|
|
|
/**
|
|
* alloc_fs_devices - allocate struct btrfs_fs_devices
|
|
* @fsid: a pointer to UUID for this FS. If NULL a new UUID is
|
|
* generated.
|
|
*
|
|
* Return: a pointer to a new &struct btrfs_fs_devices on success;
|
|
* ERR_PTR() on error. Returned struct is not linked onto any lists and
|
|
* can be destroyed with kfree() right away.
|
|
*/
|
|
static struct btrfs_fs_devices *alloc_fs_devices(const u8 *fsid)
|
|
{
|
|
struct btrfs_fs_devices *fs_devs;
|
|
|
|
fs_devs = __alloc_fs_devices();
|
|
if (IS_ERR(fs_devs))
|
|
return fs_devs;
|
|
|
|
if (fsid)
|
|
memcpy(fs_devs->fsid, fsid, BTRFS_FSID_SIZE);
|
|
else
|
|
generate_random_uuid(fs_devs->fsid);
|
|
|
|
return fs_devs;
|
|
}
|
|
|
|
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);
|
|
rcu_string_free(device->name);
|
|
kfree(device);
|
|
}
|
|
kfree(fs_devices);
|
|
}
|
|
|
|
static void btrfs_kobject_uevent(struct block_device *bdev,
|
|
enum kobject_action action)
|
|
{
|
|
int ret;
|
|
|
|
ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
|
|
if (ret)
|
|
pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
|
|
action,
|
|
kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
|
|
&disk_to_dev(bdev->bd_disk)->kobj);
|
|
}
|
|
|
|
void 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);
|
|
}
|
|
}
|
|
|
|
static struct btrfs_device *__alloc_device(void)
|
|
{
|
|
struct btrfs_device *dev;
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
if (!dev)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
INIT_LIST_HEAD(&dev->dev_list);
|
|
INIT_LIST_HEAD(&dev->dev_alloc_list);
|
|
INIT_LIST_HEAD(&dev->resized_list);
|
|
|
|
spin_lock_init(&dev->io_lock);
|
|
|
|
spin_lock_init(&dev->reada_lock);
|
|
atomic_set(&dev->reada_in_flight, 0);
|
|
atomic_set(&dev->dev_stats_ccnt, 0);
|
|
btrfs_device_data_ordered_init(dev);
|
|
INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
|
|
INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
|
|
|
|
return dev;
|
|
}
|
|
|
|
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 int
|
|
btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
|
|
int flush, struct block_device **bdev,
|
|
struct buffer_head **bh)
|
|
{
|
|
int ret;
|
|
|
|
*bdev = blkdev_get_by_path(device_path, flags, holder);
|
|
|
|
if (IS_ERR(*bdev)) {
|
|
ret = PTR_ERR(*bdev);
|
|
goto error;
|
|
}
|
|
|
|
if (flush)
|
|
filemap_write_and_wait((*bdev)->bd_inode->i_mapping);
|
|
ret = set_blocksize(*bdev, 4096);
|
|
if (ret) {
|
|
blkdev_put(*bdev, flags);
|
|
goto error;
|
|
}
|
|
invalidate_bdev(*bdev);
|
|
*bh = btrfs_read_dev_super(*bdev);
|
|
if (IS_ERR(*bh)) {
|
|
ret = PTR_ERR(*bh);
|
|
blkdev_put(*bdev, flags);
|
|
goto error;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error:
|
|
*bdev = NULL;
|
|
*bh = NULL;
|
|
return ret;
|
|
}
|
|
|
|
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 void run_scheduled_bios(struct btrfs_device *device)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
struct bio *pending;
|
|
struct backing_dev_info *bdi;
|
|
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;
|
|
int sync_pending = 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 = device->bdev->bd_bdi;
|
|
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_return implies a barrier for waitqueue_active
|
|
*/
|
|
if (atomic_dec_return(&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);
|
|
|
|
/*
|
|
* if we're doing the sync list, record that our
|
|
* plug has some sync requests on it
|
|
*
|
|
* If we're doing the regular list and there are
|
|
* sync requests sitting around, unplug before
|
|
* we add more
|
|
*/
|
|
if (pending_bios == &device->pending_sync_bios) {
|
|
sync_pending = 1;
|
|
} else if (sync_pending) {
|
|
blk_finish_plug(&plug);
|
|
blk_start_plug(&plug);
|
|
sync_pending = 0;
|
|
}
|
|
|
|
btrfsic_submit_bio(cur);
|
|
num_run++;
|
|
batch_run++;
|
|
|
|
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;
|
|
cond_resched();
|
|
continue;
|
|
}
|
|
spin_lock(&device->io_lock);
|
|
requeue_list(pending_bios, pending, tail);
|
|
device->running_pending = 1;
|
|
|
|
spin_unlock(&device->io_lock);
|
|
btrfs_queue_work(fs_info->submit_workers,
|
|
&device->work);
|
|
goto done;
|
|
}
|
|
/* unplug every 64 requests just for good measure */
|
|
if (batch_run % 64 == 0) {
|
|
blk_finish_plug(&plug);
|
|
blk_start_plug(&plug);
|
|
sync_pending = 0;
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
void btrfs_free_stale_device(struct btrfs_device *cur_dev)
|
|
{
|
|
struct btrfs_fs_devices *fs_devs;
|
|
struct btrfs_device *dev;
|
|
|
|
if (!cur_dev->name)
|
|
return;
|
|
|
|
list_for_each_entry(fs_devs, &fs_uuids, list) {
|
|
int del = 1;
|
|
|
|
if (fs_devs->opened)
|
|
continue;
|
|
if (fs_devs->seeding)
|
|
continue;
|
|
|
|
list_for_each_entry(dev, &fs_devs->devices, dev_list) {
|
|
|
|
if (dev == cur_dev)
|
|
continue;
|
|
if (!dev->name)
|
|
continue;
|
|
|
|
/*
|
|
* Todo: This won't be enough. What if the same device
|
|
* comes back (with new uuid and) with its mapper path?
|
|
* But for now, this does help as mostly an admin will
|
|
* either use mapper or non mapper path throughout.
|
|
*/
|
|
rcu_read_lock();
|
|
del = strcmp(rcu_str_deref(dev->name),
|
|
rcu_str_deref(cur_dev->name));
|
|
rcu_read_unlock();
|
|
if (!del)
|
|
break;
|
|
}
|
|
|
|
if (!del) {
|
|
/* delete the stale device */
|
|
if (fs_devs->num_devices == 1) {
|
|
btrfs_sysfs_remove_fsid(fs_devs);
|
|
list_del(&fs_devs->list);
|
|
free_fs_devices(fs_devs);
|
|
} else {
|
|
fs_devs->num_devices--;
|
|
list_del(&dev->dev_list);
|
|
rcu_string_free(dev->name);
|
|
kfree(dev);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add new device to list of registered devices
|
|
*
|
|
* Returns:
|
|
* 1 - first time device is seen
|
|
* 0 - device already known
|
|
* < 0 - error
|
|
*/
|
|
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;
|
|
struct rcu_string *name;
|
|
int ret = 0;
|
|
u64 found_transid = btrfs_super_generation(disk_super);
|
|
|
|
fs_devices = find_fsid(disk_super->fsid);
|
|
if (!fs_devices) {
|
|
fs_devices = alloc_fs_devices(disk_super->fsid);
|
|
if (IS_ERR(fs_devices))
|
|
return PTR_ERR(fs_devices);
|
|
|
|
list_add(&fs_devices->list, &fs_uuids);
|
|
|
|
device = NULL;
|
|
} else {
|
|
device = __find_device(&fs_devices->devices, devid,
|
|
disk_super->dev_item.uuid);
|
|
}
|
|
|
|
if (!device) {
|
|
if (fs_devices->opened)
|
|
return -EBUSY;
|
|
|
|
device = btrfs_alloc_device(NULL, &devid,
|
|
disk_super->dev_item.uuid);
|
|
if (IS_ERR(device)) {
|
|
/* we can safely leave the fs_devices entry around */
|
|
return PTR_ERR(device);
|
|
}
|
|
|
|
name = rcu_string_strdup(path, GFP_NOFS);
|
|
if (!name) {
|
|
kfree(device);
|
|
return -ENOMEM;
|
|
}
|
|
rcu_assign_pointer(device->name, name);
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
list_add_rcu(&device->dev_list, &fs_devices->devices);
|
|
fs_devices->num_devices++;
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
ret = 1;
|
|
device->fs_devices = fs_devices;
|
|
} else if (!device->name || strcmp(device->name->str, path)) {
|
|
/*
|
|
* When FS is already mounted.
|
|
* 1. If you are here and if the device->name is NULL that
|
|
* means this device was missing at time of FS mount.
|
|
* 2. If you are here and if the device->name is different
|
|
* from 'path' that means either
|
|
* a. The same device disappeared and reappeared with
|
|
* different name. or
|
|
* b. The missing-disk-which-was-replaced, has
|
|
* reappeared now.
|
|
*
|
|
* We must allow 1 and 2a above. But 2b would be a spurious
|
|
* and unintentional.
|
|
*
|
|
* Further in case of 1 and 2a above, the disk at 'path'
|
|
* would have missed some transaction when it was away and
|
|
* in case of 2a the stale bdev has to be updated as well.
|
|
* 2b must not be allowed at all time.
|
|
*/
|
|
|
|
/*
|
|
* For now, we do allow update to btrfs_fs_device through the
|
|
* btrfs dev scan cli after FS has been mounted. We're still
|
|
* tracking a problem where systems fail mount by subvolume id
|
|
* when we reject replacement on a mounted FS.
|
|
*/
|
|
if (!fs_devices->opened && found_transid < device->generation) {
|
|
/*
|
|
* That is if the FS is _not_ mounted and if you
|
|
* are here, that means there is more than one
|
|
* disk with same uuid and devid.We keep the one
|
|
* with larger generation number or the last-in if
|
|
* generation are equal.
|
|
*/
|
|
return -EEXIST;
|
|
}
|
|
|
|
name = rcu_string_strdup(path, GFP_NOFS);
|
|
if (!name)
|
|
return -ENOMEM;
|
|
rcu_string_free(device->name);
|
|
rcu_assign_pointer(device->name, name);
|
|
if (device->missing) {
|
|
fs_devices->missing_devices--;
|
|
device->missing = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Unmount does not free the btrfs_device struct but would zero
|
|
* generation along with most of the other members. So just update
|
|
* it back. We need it to pick the disk with largest generation
|
|
* (as above).
|
|
*/
|
|
if (!fs_devices->opened)
|
|
device->generation = found_transid;
|
|
|
|
/*
|
|
* if there is new btrfs on an already registered device,
|
|
* then remove the stale device entry.
|
|
*/
|
|
if (ret > 0)
|
|
btrfs_free_stale_device(device);
|
|
|
|
*fs_devices_ret = fs_devices;
|
|
|
|
return ret;
|
|
}
|
|
|
|
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 = alloc_fs_devices(orig->fsid);
|
|
if (IS_ERR(fs_devices))
|
|
return fs_devices;
|
|
|
|
mutex_lock(&orig->device_list_mutex);
|
|
fs_devices->total_devices = orig->total_devices;
|
|
|
|
/* We have held the volume lock, it is safe to get the devices. */
|
|
list_for_each_entry(orig_dev, &orig->devices, dev_list) {
|
|
struct rcu_string *name;
|
|
|
|
device = btrfs_alloc_device(NULL, &orig_dev->devid,
|
|
orig_dev->uuid);
|
|
if (IS_ERR(device))
|
|
goto error;
|
|
|
|
/*
|
|
* This is ok to do without rcu read locked because we hold the
|
|
* uuid mutex so nothing we touch in here is going to disappear.
|
|
*/
|
|
if (orig_dev->name) {
|
|
name = rcu_string_strdup(orig_dev->name->str,
|
|
GFP_KERNEL);
|
|
if (!name) {
|
|
kfree(device);
|
|
goto error;
|
|
}
|
|
rcu_assign_pointer(device->name, name);
|
|
}
|
|
|
|
list_add(&device->dev_list, &fs_devices->devices);
|
|
device->fs_devices = fs_devices;
|
|
fs_devices->num_devices++;
|
|
}
|
|
mutex_unlock(&orig->device_list_mutex);
|
|
return fs_devices;
|
|
error:
|
|
mutex_unlock(&orig->device_list_mutex);
|
|
free_fs_devices(fs_devices);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices, int step)
|
|
{
|
|
struct btrfs_device *device, *next;
|
|
struct btrfs_device *latest_dev = NULL;
|
|
|
|
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) {
|
|
if (!device->is_tgtdev_for_dev_replace &&
|
|
(!latest_dev ||
|
|
device->generation > latest_dev->generation)) {
|
|
latest_dev = device;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (device->devid == BTRFS_DEV_REPLACE_DEVID) {
|
|
/*
|
|
* In the first step, keep the device which has
|
|
* the correct fsid and the devid that is used
|
|
* for the dev_replace procedure.
|
|
* In the second step, the dev_replace state is
|
|
* read from the device tree and it is known
|
|
* whether the procedure is really active or
|
|
* not, which means whether this device is
|
|
* used or whether it should be removed.
|
|
*/
|
|
if (step == 0 || device->is_tgtdev_for_dev_replace) {
|
|
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;
|
|
if (!device->is_tgtdev_for_dev_replace)
|
|
fs_devices->rw_devices--;
|
|
}
|
|
list_del_init(&device->dev_list);
|
|
fs_devices->num_devices--;
|
|
rcu_string_free(device->name);
|
|
kfree(device);
|
|
}
|
|
|
|
if (fs_devices->seed) {
|
|
fs_devices = fs_devices->seed;
|
|
goto again;
|
|
}
|
|
|
|
fs_devices->latest_bdev = latest_dev->bdev;
|
|
|
|
mutex_unlock(&uuid_mutex);
|
|
}
|
|
|
|
static void __free_device(struct work_struct *work)
|
|
{
|
|
struct btrfs_device *device;
|
|
|
|
device = container_of(work, struct btrfs_device, rcu_work);
|
|
rcu_string_free(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 void btrfs_close_bdev(struct btrfs_device *device)
|
|
{
|
|
if (device->bdev && device->writeable) {
|
|
sync_blockdev(device->bdev);
|
|
invalidate_bdev(device->bdev);
|
|
}
|
|
|
|
if (device->bdev)
|
|
blkdev_put(device->bdev, device->mode);
|
|
}
|
|
|
|
static void btrfs_prepare_close_one_device(struct btrfs_device *device)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = device->fs_devices;
|
|
struct btrfs_device *new_device;
|
|
struct rcu_string *name;
|
|
|
|
if (device->bdev)
|
|
fs_devices->open_devices--;
|
|
|
|
if (device->writeable &&
|
|
device->devid != BTRFS_DEV_REPLACE_DEVID) {
|
|
list_del_init(&device->dev_alloc_list);
|
|
fs_devices->rw_devices--;
|
|
}
|
|
|
|
if (device->missing)
|
|
fs_devices->missing_devices--;
|
|
|
|
new_device = btrfs_alloc_device(NULL, &device->devid,
|
|
device->uuid);
|
|
BUG_ON(IS_ERR(new_device)); /* -ENOMEM */
|
|
|
|
/* Safe because we are under uuid_mutex */
|
|
if (device->name) {
|
|
name = rcu_string_strdup(device->name->str, GFP_NOFS);
|
|
BUG_ON(!name); /* -ENOMEM */
|
|
rcu_assign_pointer(new_device->name, name);
|
|
}
|
|
|
|
list_replace_rcu(&device->dev_list, &new_device->dev_list);
|
|
new_device->fs_devices = device->fs_devices;
|
|
}
|
|
|
|
static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
|
|
{
|
|
struct btrfs_device *device, *tmp;
|
|
struct list_head pending_put;
|
|
|
|
INIT_LIST_HEAD(&pending_put);
|
|
|
|
if (--fs_devices->opened > 0)
|
|
return 0;
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
list_for_each_entry_safe(device, tmp, &fs_devices->devices, dev_list) {
|
|
btrfs_prepare_close_one_device(device);
|
|
list_add(&device->dev_list, &pending_put);
|
|
}
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
/*
|
|
* btrfs_show_devname() is using the device_list_mutex,
|
|
* sometimes call to blkdev_put() leads vfs calling
|
|
* into this func. So do put outside of device_list_mutex,
|
|
* as of now.
|
|
*/
|
|
while (!list_empty(&pending_put)) {
|
|
device = list_first_entry(&pending_put,
|
|
struct btrfs_device, dev_list);
|
|
list_del(&device->dev_list);
|
|
btrfs_close_bdev(device);
|
|
call_rcu(&device->rcu, free_device);
|
|
}
|
|
|
|
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);
|
|
}
|
|
/*
|
|
* Wait for rcu kworkers under __btrfs_close_devices
|
|
* to finish all blkdev_puts so device is really
|
|
* free when umount is done.
|
|
*/
|
|
rcu_barrier();
|
|
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 btrfs_device *latest_dev = NULL;
|
|
struct buffer_head *bh;
|
|
struct btrfs_super_block *disk_super;
|
|
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;
|
|
|
|
/* Just open everything we can; ignore failures here */
|
|
if (btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
|
|
&bdev, &bh))
|
|
continue;
|
|
|
|
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_dev ||
|
|
device->generation > latest_dev->generation)
|
|
latest_dev = device;
|
|
|
|
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;
|
|
if (!blk_queue_nonrot(q))
|
|
fs_devices->rotating = 1;
|
|
|
|
device->bdev = bdev;
|
|
device->in_fs_metadata = 0;
|
|
device->mode = flags;
|
|
|
|
fs_devices->open_devices++;
|
|
if (device->writeable &&
|
|
device->devid != BTRFS_DEV_REPLACE_DEVID) {
|
|
fs_devices->rw_devices++;
|
|
list_add(&device->dev_alloc_list,
|
|
&fs_devices->alloc_list);
|
|
}
|
|
brelse(bh);
|
|
continue;
|
|
|
|
error_brelse:
|
|
brelse(bh);
|
|
blkdev_put(bdev, flags);
|
|
continue;
|
|
}
|
|
if (fs_devices->open_devices == 0) {
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
fs_devices->seeding = seeding;
|
|
fs_devices->opened = 1;
|
|
fs_devices->latest_bdev = latest_dev->bdev;
|
|
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;
|
|
}
|
|
|
|
void btrfs_release_disk_super(struct page *page)
|
|
{
|
|
kunmap(page);
|
|
put_page(page);
|
|
}
|
|
|
|
int btrfs_read_disk_super(struct block_device *bdev, u64 bytenr,
|
|
struct page **page, struct btrfs_super_block **disk_super)
|
|
{
|
|
void *p;
|
|
pgoff_t index;
|
|
|
|
/* make sure our super fits in the device */
|
|
if (bytenr + PAGE_SIZE >= i_size_read(bdev->bd_inode))
|
|
return 1;
|
|
|
|
/* make sure our super fits in the page */
|
|
if (sizeof(**disk_super) > PAGE_SIZE)
|
|
return 1;
|
|
|
|
/* make sure our super doesn't straddle pages on disk */
|
|
index = bytenr >> PAGE_SHIFT;
|
|
if ((bytenr + sizeof(**disk_super) - 1) >> PAGE_SHIFT != index)
|
|
return 1;
|
|
|
|
/* pull in the page with our super */
|
|
*page = read_cache_page_gfp(bdev->bd_inode->i_mapping,
|
|
index, GFP_KERNEL);
|
|
|
|
if (IS_ERR_OR_NULL(*page))
|
|
return 1;
|
|
|
|
p = kmap(*page);
|
|
|
|
/* align our pointer to the offset of the super block */
|
|
*disk_super = p + (bytenr & ~PAGE_MASK);
|
|
|
|
if (btrfs_super_bytenr(*disk_super) != bytenr ||
|
|
btrfs_super_magic(*disk_super) != BTRFS_MAGIC) {
|
|
btrfs_release_disk_super(*page);
|
|
return 1;
|
|
}
|
|
|
|
if ((*disk_super)->label[0] &&
|
|
(*disk_super)->label[BTRFS_LABEL_SIZE - 1])
|
|
(*disk_super)->label[BTRFS_LABEL_SIZE - 1] = '\0';
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Look for a btrfs signature on a device. This may be called out of the mount path
|
|
* and we are not allowed to call set_blocksize during the scan. The superblock
|
|
* is read via pagecache
|
|
*/
|
|
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 page *page;
|
|
int ret = -EINVAL;
|
|
u64 devid;
|
|
u64 transid;
|
|
u64 total_devices;
|
|
u64 bytenr;
|
|
|
|
/*
|
|
* we would like to check all the supers, but that would make
|
|
* a btrfs mount succeed after a mkfs from a different FS.
|
|
* So, we need to add a special mount option to scan for
|
|
* later supers, using BTRFS_SUPER_MIRROR_MAX instead
|
|
*/
|
|
bytenr = btrfs_sb_offset(0);
|
|
flags |= FMODE_EXCL;
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
bdev = blkdev_get_by_path(path, flags, holder);
|
|
if (IS_ERR(bdev)) {
|
|
ret = PTR_ERR(bdev);
|
|
goto error;
|
|
}
|
|
|
|
if (btrfs_read_disk_super(bdev, bytenr, &page, &disk_super))
|
|
goto error_bdev_put;
|
|
|
|
devid = btrfs_stack_device_id(&disk_super->dev_item);
|
|
transid = btrfs_super_generation(disk_super);
|
|
total_devices = btrfs_super_num_devices(disk_super);
|
|
|
|
ret = device_list_add(path, disk_super, devid, fs_devices_ret);
|
|
if (ret > 0) {
|
|
if (disk_super->label[0]) {
|
|
pr_info("BTRFS: device label %s ", disk_super->label);
|
|
} else {
|
|
pr_info("BTRFS: device fsid %pU ", disk_super->fsid);
|
|
}
|
|
|
|
pr_cont("devid %llu transid %llu %s\n", devid, transid, path);
|
|
ret = 0;
|
|
}
|
|
if (!ret && fs_devices_ret)
|
|
(*fs_devices_ret)->total_devices = total_devices;
|
|
|
|
btrfs_release_disk_super(page);
|
|
|
|
error_bdev_put:
|
|
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->fs_info->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 || device->is_tgtdev_for_dev_replace)
|
|
return 0;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
path->reada = READA_FORWARD;
|
|
|
|
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 (key.type != 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;
|
|
}
|
|
|
|
static int contains_pending_extent(struct btrfs_transaction *transaction,
|
|
struct btrfs_device *device,
|
|
u64 *start, u64 len)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
struct extent_map *em;
|
|
struct list_head *search_list = &fs_info->pinned_chunks;
|
|
int ret = 0;
|
|
u64 physical_start = *start;
|
|
|
|
if (transaction)
|
|
search_list = &transaction->pending_chunks;
|
|
again:
|
|
list_for_each_entry(em, search_list, list) {
|
|
struct map_lookup *map;
|
|
int i;
|
|
|
|
map = em->map_lookup;
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
u64 end;
|
|
|
|
if (map->stripes[i].dev != device)
|
|
continue;
|
|
if (map->stripes[i].physical >= physical_start + len ||
|
|
map->stripes[i].physical + em->orig_block_len <=
|
|
physical_start)
|
|
continue;
|
|
/*
|
|
* Make sure that while processing the pinned list we do
|
|
* not override our *start with a lower value, because
|
|
* we can have pinned chunks that fall within this
|
|
* device hole and that have lower physical addresses
|
|
* than the pending chunks we processed before. If we
|
|
* do not take this special care we can end up getting
|
|
* 2 pending chunks that start at the same physical
|
|
* device offsets because the end offset of a pinned
|
|
* chunk can be equal to the start offset of some
|
|
* pending chunk.
|
|
*/
|
|
end = map->stripes[i].physical + em->orig_block_len;
|
|
if (end > *start) {
|
|
*start = end;
|
|
ret = 1;
|
|
}
|
|
}
|
|
}
|
|
if (search_list != &fs_info->pinned_chunks) {
|
|
search_list = &fs_info->pinned_chunks;
|
|
goto again;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*
|
|
* find_free_dev_extent_start - find free space in the specified device
|
|
* @device: the device which we search the free space in
|
|
* @num_bytes: the size of the free space that we need
|
|
* @search_start: the position from which to begin the search
|
|
* @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_start(struct btrfs_transaction *transaction,
|
|
struct btrfs_device *device, u64 num_bytes,
|
|
u64 search_start, u64 *start, u64 *len)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
struct btrfs_root *root = fs_info->dev_root;
|
|
struct btrfs_key key;
|
|
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_end = device->total_bytes;
|
|
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);
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
|
|
max_hole_start = search_start;
|
|
max_hole_size = 0;
|
|
|
|
again:
|
|
if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
|
|
ret = -ENOSPC;
|
|
goto out;
|
|
}
|
|
|
|
path->reada = READA_FORWARD;
|
|
path->search_commit_root = 1;
|
|
path->skip_locking = 1;
|
|
|
|
key.objectid = device->devid;
|
|
key.offset = search_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 (key.type != BTRFS_DEV_EXTENT_KEY)
|
|
goto next;
|
|
|
|
if (key.offset > search_start) {
|
|
hole_size = key.offset - search_start;
|
|
|
|
/*
|
|
* Have to check before we set max_hole_start, otherwise
|
|
* we could end up sending back this offset anyway.
|
|
*/
|
|
if (contains_pending_extent(transaction, device,
|
|
&search_start,
|
|
hole_size)) {
|
|
if (key.offset >= search_start) {
|
|
hole_size = key.offset - search_start;
|
|
} else {
|
|
WARN_ON_ONCE(1);
|
|
hole_size = 0;
|
|
}
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
/*
|
|
* At this point, search_start should be the end of
|
|
* allocated dev extents, and when shrinking the device,
|
|
* search_end may be smaller than search_start.
|
|
*/
|
|
if (search_end > search_start) {
|
|
hole_size = search_end - search_start;
|
|
|
|
if (contains_pending_extent(transaction, device, &search_start,
|
|
hole_size)) {
|
|
btrfs_release_path(path);
|
|
goto again;
|
|
}
|
|
|
|
if (hole_size > max_hole_size) {
|
|
max_hole_start = search_start;
|
|
max_hole_size = hole_size;
|
|
}
|
|
}
|
|
|
|
/* See above. */
|
|
if (max_hole_size < num_bytes)
|
|
ret = -ENOSPC;
|
|
else
|
|
ret = 0;
|
|
|
|
out:
|
|
btrfs_free_path(path);
|
|
*start = max_hole_start;
|
|
if (len)
|
|
*len = max_hole_size;
|
|
return ret;
|
|
}
|
|
|
|
int find_free_dev_extent(struct btrfs_trans_handle *trans,
|
|
struct btrfs_device *device, u64 num_bytes,
|
|
u64 *start, u64 *len)
|
|
{
|
|
/* FIXME use last free of some kind */
|
|
return find_free_dev_extent_start(trans->transaction, device,
|
|
num_bytes, 0, start, len);
|
|
}
|
|
|
|
static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
|
|
struct btrfs_device *device,
|
|
u64 start, u64 *dev_extent_len)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
struct btrfs_root *root = fs_info->dev_root;
|
|
int ret;
|
|
struct btrfs_path *path;
|
|
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;
|
|
again:
|
|
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);
|
|
key = found_key;
|
|
btrfs_release_path(path);
|
|
goto again;
|
|
} else if (ret == 0) {
|
|
leaf = path->nodes[0];
|
|
extent = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_dev_extent);
|
|
} else {
|
|
btrfs_handle_fs_error(fs_info, ret, "Slot search failed");
|
|
goto out;
|
|
}
|
|
|
|
*dev_extent_len = btrfs_dev_extent_length(leaf, extent);
|
|
|
|
ret = btrfs_del_item(trans, root, path);
|
|
if (ret) {
|
|
btrfs_handle_fs_error(fs_info, ret,
|
|
"Failed to remove dev extent item");
|
|
} else {
|
|
set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags);
|
|
}
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
static 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_fs_info *fs_info = device->fs_info;
|
|
struct btrfs_root *root = fs_info->dev_root;
|
|
struct btrfs_dev_extent *extent;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
|
|
WARN_ON(!device->in_fs_metadata);
|
|
WARN_ON(device->is_tgtdev_for_dev_replace);
|
|
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));
|
|
if (ret)
|
|
goto out;
|
|
|
|
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_chunk_tree_uuid(leaf, fs_info->chunk_tree_uuid);
|
|
|
|
btrfs_set_dev_extent_length(leaf, extent, num_bytes);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
static u64 find_next_chunk(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct extent_map_tree *em_tree;
|
|
struct extent_map *em;
|
|
struct rb_node *n;
|
|
u64 ret = 0;
|
|
|
|
em_tree = &fs_info->mapping_tree.map_tree;
|
|
read_lock(&em_tree->lock);
|
|
n = rb_last(&em_tree->map);
|
|
if (n) {
|
|
em = rb_entry(n, struct extent_map, rb_node);
|
|
ret = em->start + em->len;
|
|
}
|
|
read_unlock(&em_tree->lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static noinline int find_next_devid(struct btrfs_fs_info *fs_info,
|
|
u64 *devid_ret)
|
|
{
|
|
int ret;
|
|
struct btrfs_key key;
|
|
struct btrfs_key found_key;
|
|
struct btrfs_path *path;
|
|
|
|
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, fs_info->chunk_root, &key, path, 0, 0);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
BUG_ON(ret == 0); /* Corruption */
|
|
|
|
ret = btrfs_previous_item(fs_info->chunk_root, path,
|
|
BTRFS_DEV_ITEMS_OBJECTID,
|
|
BTRFS_DEV_ITEM_KEY);
|
|
if (ret) {
|
|
*devid_ret = 1;
|
|
} else {
|
|
btrfs_item_key_to_cpu(path->nodes[0], &found_key,
|
|
path->slots[0]);
|
|
*devid_ret = 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
|
|
*/
|
|
static int btrfs_add_device(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *device)
|
|
{
|
|
struct btrfs_root *root = fs_info->chunk_root;
|
|
int ret;
|
|
struct btrfs_path *path;
|
|
struct btrfs_dev_item *dev_item;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
unsigned long ptr;
|
|
|
|
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,
|
|
btrfs_device_get_disk_total_bytes(device));
|
|
btrfs_set_device_bytes_used(leaf, dev_item,
|
|
btrfs_device_get_bytes_used(device));
|
|
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 = btrfs_device_uuid(dev_item);
|
|
write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
|
|
ptr = btrfs_device_fsid(dev_item);
|
|
write_extent_buffer(leaf, fs_info->fsid, ptr, BTRFS_UUID_SIZE);
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
ret = 0;
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Function to update ctime/mtime for a given device path.
|
|
* Mainly used for ctime/mtime based probe like libblkid.
|
|
*/
|
|
static void update_dev_time(const char *path_name)
|
|
{
|
|
struct file *filp;
|
|
|
|
filp = filp_open(path_name, O_RDWR, 0);
|
|
if (IS_ERR(filp))
|
|
return;
|
|
file_update_time(filp);
|
|
filp_close(filp, NULL);
|
|
}
|
|
|
|
static int btrfs_rm_dev_item(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *device)
|
|
{
|
|
struct btrfs_root *root = fs_info->chunk_root;
|
|
int ret;
|
|
struct btrfs_path *path;
|
|
struct btrfs_key key;
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
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;
|
|
|
|
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);
|
|
btrfs_commit_transaction(trans);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Verify that @num_devices satisfies the RAID profile constraints in the whole
|
|
* filesystem. It's up to the caller to adjust that number regarding eg. device
|
|
* replace.
|
|
*/
|
|
static int btrfs_check_raid_min_devices(struct btrfs_fs_info *fs_info,
|
|
u64 num_devices)
|
|
{
|
|
u64 all_avail;
|
|
unsigned seq;
|
|
int i;
|
|
|
|
do {
|
|
seq = read_seqbegin(&fs_info->profiles_lock);
|
|
|
|
all_avail = fs_info->avail_data_alloc_bits |
|
|
fs_info->avail_system_alloc_bits |
|
|
fs_info->avail_metadata_alloc_bits;
|
|
} while (read_seqretry(&fs_info->profiles_lock, seq));
|
|
|
|
for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
|
|
if (!(all_avail & btrfs_raid_group[i]))
|
|
continue;
|
|
|
|
if (num_devices < btrfs_raid_array[i].devs_min) {
|
|
int ret = btrfs_raid_mindev_error[i];
|
|
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct btrfs_device *btrfs_find_next_active_device(struct btrfs_fs_devices *fs_devs,
|
|
struct btrfs_device *device)
|
|
{
|
|
struct btrfs_device *next_device;
|
|
|
|
list_for_each_entry(next_device, &fs_devs->devices, dev_list) {
|
|
if (next_device != device &&
|
|
!next_device->missing && next_device->bdev)
|
|
return next_device;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Helper function to check if the given device is part of s_bdev / latest_bdev
|
|
* and replace it with the provided or the next active device, in the context
|
|
* where this function called, there should be always be another device (or
|
|
* this_dev) which is active.
|
|
*/
|
|
void btrfs_assign_next_active_device(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *device, struct btrfs_device *this_dev)
|
|
{
|
|
struct btrfs_device *next_device;
|
|
|
|
if (this_dev)
|
|
next_device = this_dev;
|
|
else
|
|
next_device = btrfs_find_next_active_device(fs_info->fs_devices,
|
|
device);
|
|
ASSERT(next_device);
|
|
|
|
if (fs_info->sb->s_bdev &&
|
|
(fs_info->sb->s_bdev == device->bdev))
|
|
fs_info->sb->s_bdev = next_device->bdev;
|
|
|
|
if (fs_info->fs_devices->latest_bdev == device->bdev)
|
|
fs_info->fs_devices->latest_bdev = next_device->bdev;
|
|
}
|
|
|
|
int btrfs_rm_device(struct btrfs_fs_info *fs_info, const char *device_path,
|
|
u64 devid)
|
|
{
|
|
struct btrfs_device *device;
|
|
struct btrfs_fs_devices *cur_devices;
|
|
u64 num_devices;
|
|
int ret = 0;
|
|
bool clear_super = false;
|
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
num_devices = fs_info->fs_devices->num_devices;
|
|
btrfs_dev_replace_lock(&fs_info->dev_replace, 0);
|
|
if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
|
|
WARN_ON(num_devices < 1);
|
|
num_devices--;
|
|
}
|
|
btrfs_dev_replace_unlock(&fs_info->dev_replace, 0);
|
|
|
|
ret = btrfs_check_raid_min_devices(fs_info, num_devices - 1);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = btrfs_find_device_by_devspec(fs_info, devid, device_path,
|
|
&device);
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (device->is_tgtdev_for_dev_replace) {
|
|
ret = BTRFS_ERROR_DEV_TGT_REPLACE;
|
|
goto out;
|
|
}
|
|
|
|
if (device->writeable && fs_info->fs_devices->rw_devices == 1) {
|
|
ret = BTRFS_ERROR_DEV_ONLY_WRITABLE;
|
|
goto out;
|
|
}
|
|
|
|
if (device->writeable) {
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
list_del_init(&device->dev_alloc_list);
|
|
device->fs_devices->rw_devices--;
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
clear_super = true;
|
|
}
|
|
|
|
mutex_unlock(&uuid_mutex);
|
|
ret = btrfs_shrink_device(device, 0);
|
|
mutex_lock(&uuid_mutex);
|
|
if (ret)
|
|
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(fs_info, device);
|
|
if (ret)
|
|
goto error_undo;
|
|
|
|
device->in_fs_metadata = 0;
|
|
btrfs_scrub_cancel_dev(fs_info, 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. Whoever is writing all supers, should
|
|
* lock the device list mutex before getting the number of
|
|
* devices in the super block (super_copy). Conversely,
|
|
* whoever updates the number of devices in the super block
|
|
* (super_copy) should hold the device list mutex.
|
|
*/
|
|
|
|
cur_devices = device->fs_devices;
|
|
mutex_lock(&fs_info->fs_devices->device_list_mutex);
|
|
list_del_rcu(&device->dev_list);
|
|
|
|
device->fs_devices->num_devices--;
|
|
device->fs_devices->total_devices--;
|
|
|
|
if (device->missing)
|
|
device->fs_devices->missing_devices--;
|
|
|
|
btrfs_assign_next_active_device(fs_info, device, NULL);
|
|
|
|
if (device->bdev) {
|
|
device->fs_devices->open_devices--;
|
|
/* remove sysfs entry */
|
|
btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
|
|
}
|
|
|
|
num_devices = btrfs_super_num_devices(fs_info->super_copy) - 1;
|
|
btrfs_set_super_num_devices(fs_info->super_copy, num_devices);
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
/*
|
|
* at this point, the device is zero sized and detached from
|
|
* the devices list. All that's left is to zero out the old
|
|
* supers and free the device.
|
|
*/
|
|
if (device->writeable)
|
|
btrfs_scratch_superblocks(device->bdev, device->name->str);
|
|
|
|
btrfs_close_bdev(device);
|
|
call_rcu(&device->rcu, free_device);
|
|
|
|
if (cur_devices->open_devices == 0) {
|
|
struct btrfs_fs_devices *fs_devices;
|
|
fs_devices = fs_info->fs_devices;
|
|
while (fs_devices) {
|
|
if (fs_devices->seed == cur_devices) {
|
|
fs_devices->seed = cur_devices->seed;
|
|
break;
|
|
}
|
|
fs_devices = fs_devices->seed;
|
|
}
|
|
cur_devices->seed = NULL;
|
|
__btrfs_close_devices(cur_devices);
|
|
free_fs_devices(cur_devices);
|
|
}
|
|
|
|
fs_info->num_tolerated_disk_barrier_failures =
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
|
|
|
|
out:
|
|
mutex_unlock(&uuid_mutex);
|
|
return ret;
|
|
|
|
error_undo:
|
|
if (device->writeable) {
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
list_add(&device->dev_alloc_list,
|
|
&fs_info->fs_devices->alloc_list);
|
|
device->fs_devices->rw_devices++;
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
void btrfs_rm_dev_replace_remove_srcdev(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *srcdev)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices;
|
|
|
|
WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
|
|
|
|
/*
|
|
* in case of fs with no seed, srcdev->fs_devices will point
|
|
* to fs_devices of fs_info. However when the dev being replaced is
|
|
* a seed dev it will point to the seed's local fs_devices. In short
|
|
* srcdev will have its correct fs_devices in both the cases.
|
|
*/
|
|
fs_devices = srcdev->fs_devices;
|
|
|
|
list_del_rcu(&srcdev->dev_list);
|
|
list_del_rcu(&srcdev->dev_alloc_list);
|
|
fs_devices->num_devices--;
|
|
if (srcdev->missing)
|
|
fs_devices->missing_devices--;
|
|
|
|
if (srcdev->writeable)
|
|
fs_devices->rw_devices--;
|
|
|
|
if (srcdev->bdev)
|
|
fs_devices->open_devices--;
|
|
}
|
|
|
|
void btrfs_rm_dev_replace_free_srcdev(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *srcdev)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = srcdev->fs_devices;
|
|
|
|
if (srcdev->writeable) {
|
|
/* zero out the old super if it is writable */
|
|
btrfs_scratch_superblocks(srcdev->bdev, srcdev->name->str);
|
|
}
|
|
|
|
btrfs_close_bdev(srcdev);
|
|
|
|
call_rcu(&srcdev->rcu, free_device);
|
|
|
|
/*
|
|
* unless fs_devices is seed fs, num_devices shouldn't go
|
|
* zero
|
|
*/
|
|
BUG_ON(!fs_devices->num_devices && !fs_devices->seeding);
|
|
|
|
/* if this is no devs we rather delete the fs_devices */
|
|
if (!fs_devices->num_devices) {
|
|
struct btrfs_fs_devices *tmp_fs_devices;
|
|
|
|
tmp_fs_devices = fs_info->fs_devices;
|
|
while (tmp_fs_devices) {
|
|
if (tmp_fs_devices->seed == fs_devices) {
|
|
tmp_fs_devices->seed = fs_devices->seed;
|
|
break;
|
|
}
|
|
tmp_fs_devices = tmp_fs_devices->seed;
|
|
}
|
|
fs_devices->seed = NULL;
|
|
__btrfs_close_devices(fs_devices);
|
|
free_fs_devices(fs_devices);
|
|
}
|
|
}
|
|
|
|
void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *tgtdev)
|
|
{
|
|
mutex_lock(&uuid_mutex);
|
|
WARN_ON(!tgtdev);
|
|
mutex_lock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
btrfs_sysfs_rm_device_link(fs_info->fs_devices, tgtdev);
|
|
|
|
if (tgtdev->bdev)
|
|
fs_info->fs_devices->open_devices--;
|
|
|
|
fs_info->fs_devices->num_devices--;
|
|
|
|
btrfs_assign_next_active_device(fs_info, tgtdev, NULL);
|
|
|
|
list_del_rcu(&tgtdev->dev_list);
|
|
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
/*
|
|
* The update_dev_time() with in btrfs_scratch_superblocks()
|
|
* may lead to a call to btrfs_show_devname() which will try
|
|
* to hold device_list_mutex. And here this device
|
|
* is already out of device list, so we don't have to hold
|
|
* the device_list_mutex lock.
|
|
*/
|
|
btrfs_scratch_superblocks(tgtdev->bdev, tgtdev->name->str);
|
|
|
|
btrfs_close_bdev(tgtdev);
|
|
call_rcu(&tgtdev->rcu, free_device);
|
|
}
|
|
|
|
static int btrfs_find_device_by_path(struct btrfs_fs_info *fs_info,
|
|
const char *device_path,
|
|
struct btrfs_device **device)
|
|
{
|
|
int ret = 0;
|
|
struct btrfs_super_block *disk_super;
|
|
u64 devid;
|
|
u8 *dev_uuid;
|
|
struct block_device *bdev;
|
|
struct buffer_head *bh;
|
|
|
|
*device = NULL;
|
|
ret = btrfs_get_bdev_and_sb(device_path, FMODE_READ,
|
|
fs_info->bdev_holder, 0, &bdev, &bh);
|
|
if (ret)
|
|
return ret;
|
|
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(fs_info, devid, dev_uuid, disk_super->fsid);
|
|
brelse(bh);
|
|
if (!*device)
|
|
ret = -ENOENT;
|
|
blkdev_put(bdev, FMODE_READ);
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_find_device_missing_or_by_path(struct btrfs_fs_info *fs_info,
|
|
const char *device_path,
|
|
struct btrfs_device **device)
|
|
{
|
|
*device = NULL;
|
|
if (strcmp(device_path, "missing") == 0) {
|
|
struct list_head *devices;
|
|
struct btrfs_device *tmp;
|
|
|
|
devices = &fs_info->fs_devices->devices;
|
|
/*
|
|
* It is safe to read the devices since the volume_mutex
|
|
* is held by the caller.
|
|
*/
|
|
list_for_each_entry(tmp, devices, dev_list) {
|
|
if (tmp->in_fs_metadata && !tmp->bdev) {
|
|
*device = tmp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!*device)
|
|
return BTRFS_ERROR_DEV_MISSING_NOT_FOUND;
|
|
|
|
return 0;
|
|
} else {
|
|
return btrfs_find_device_by_path(fs_info, device_path, device);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Lookup a device given by device id, or the path if the id is 0.
|
|
*/
|
|
int btrfs_find_device_by_devspec(struct btrfs_fs_info *fs_info, u64 devid,
|
|
const char *devpath,
|
|
struct btrfs_device **device)
|
|
{
|
|
int ret;
|
|
|
|
if (devid) {
|
|
ret = 0;
|
|
*device = btrfs_find_device(fs_info, devid, NULL, NULL);
|
|
if (!*device)
|
|
ret = -ENOENT;
|
|
} else {
|
|
if (!devpath || !devpath[0])
|
|
return -EINVAL;
|
|
|
|
ret = btrfs_find_device_missing_or_by_path(fs_info, devpath,
|
|
device);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* does all the dirty work required for changing file system's UUID.
|
|
*/
|
|
static int btrfs_prepare_sprout(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
struct btrfs_fs_devices *old_devices;
|
|
struct btrfs_fs_devices *seed_devices;
|
|
struct btrfs_super_block *disk_super = 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 = __alloc_fs_devices();
|
|
if (IS_ERR(seed_devices))
|
|
return PTR_ERR(seed_devices);
|
|
|
|
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(&fs_info->fs_devices->device_list_mutex);
|
|
list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
|
|
synchronize_rcu);
|
|
list_for_each_entry(device, &seed_devices->devices, dev_list)
|
|
device->fs_devices = seed_devices;
|
|
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
|
|
fs_devices->seeding = 0;
|
|
fs_devices->num_devices = 0;
|
|
fs_devices->open_devices = 0;
|
|
fs_devices->missing_devices = 0;
|
|
fs_devices->rotating = 0;
|
|
fs_devices->seed = seed_devices;
|
|
|
|
generate_random_uuid(fs_devices->fsid);
|
|
memcpy(fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
|
|
memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
super_flags = btrfs_super_flags(disk_super) &
|
|
~BTRFS_SUPER_FLAG_SEEDING;
|
|
btrfs_set_super_flags(disk_super, super_flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Store the expected generation for seed devices in device items.
|
|
*/
|
|
static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_root *root = fs_info->chunk_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;
|
|
|
|
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, btrfs_device_uuid(dev_item),
|
|
BTRFS_UUID_SIZE);
|
|
read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
|
|
BTRFS_UUID_SIZE);
|
|
device = btrfs_find_device(fs_info, devid, dev_uuid, fs_uuid);
|
|
BUG_ON(!device); /* Logic error */
|
|
|
|
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_fs_info *fs_info, const char *device_path)
|
|
{
|
|
struct btrfs_root *root = fs_info->dev_root;
|
|
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 = fs_info->sb;
|
|
struct rcu_string *name;
|
|
u64 tmp;
|
|
int seeding_dev = 0;
|
|
int ret = 0;
|
|
|
|
if ((sb->s_flags & MS_RDONLY) && !fs_info->fs_devices->seeding)
|
|
return -EROFS;
|
|
|
|
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
|
|
fs_info->bdev_holder);
|
|
if (IS_ERR(bdev))
|
|
return PTR_ERR(bdev);
|
|
|
|
if (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);
|
|
|
|
devices = &fs_info->fs_devices->devices;
|
|
|
|
mutex_lock(&fs_info->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);
|
|
goto error;
|
|
}
|
|
}
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
device = btrfs_alloc_device(fs_info, NULL, NULL);
|
|
if (IS_ERR(device)) {
|
|
/* we can safely leave the fs_devices entry around */
|
|
ret = PTR_ERR(device);
|
|
goto error;
|
|
}
|
|
|
|
name = rcu_string_strdup(device_path, GFP_KERNEL);
|
|
if (!name) {
|
|
kfree(device);
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
rcu_assign_pointer(device->name, name);
|
|
|
|
trans = btrfs_start_transaction(root, 0);
|
|
if (IS_ERR(trans)) {
|
|
rcu_string_free(device->name);
|
|
kfree(device);
|
|
ret = PTR_ERR(trans);
|
|
goto error;
|
|
}
|
|
|
|
q = bdev_get_queue(bdev);
|
|
if (blk_queue_discard(q))
|
|
device->can_discard = 1;
|
|
device->writeable = 1;
|
|
device->generation = trans->transid;
|
|
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->disk_total_bytes = device->total_bytes;
|
|
device->commit_total_bytes = device->total_bytes;
|
|
device->fs_info = fs_info;
|
|
device->bdev = bdev;
|
|
device->in_fs_metadata = 1;
|
|
device->is_tgtdev_for_dev_replace = 0;
|
|
device->mode = FMODE_EXCL;
|
|
device->dev_stats_valid = 1;
|
|
set_blocksize(device->bdev, 4096);
|
|
|
|
if (seeding_dev) {
|
|
sb->s_flags &= ~MS_RDONLY;
|
|
ret = btrfs_prepare_sprout(fs_info);
|
|
BUG_ON(ret); /* -ENOMEM */
|
|
}
|
|
|
|
device->fs_devices = fs_info->fs_devices;
|
|
|
|
mutex_lock(&fs_info->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;
|
|
|
|
spin_lock(&fs_info->free_chunk_lock);
|
|
fs_info->free_chunk_space += device->total_bytes;
|
|
spin_unlock(&fs_info->free_chunk_lock);
|
|
|
|
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);
|
|
|
|
tmp = btrfs_super_num_devices(fs_info->super_copy);
|
|
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);
|
|
|
|
/*
|
|
* we've got more storage, clear any full flags on the space
|
|
* infos
|
|
*/
|
|
btrfs_clear_space_info_full(fs_info);
|
|
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
if (seeding_dev) {
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
ret = init_first_rw_device(trans, fs_info);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto error_trans;
|
|
}
|
|
}
|
|
|
|
ret = btrfs_add_device(trans, fs_info, device);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto error_trans;
|
|
}
|
|
|
|
if (seeding_dev) {
|
|
char fsid_buf[BTRFS_UUID_UNPARSED_SIZE];
|
|
|
|
ret = btrfs_finish_sprout(trans, fs_info);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto error_trans;
|
|
}
|
|
|
|
/* Sprouting would change fsid of the mounted root,
|
|
* so rename the fsid on the sysfs
|
|
*/
|
|
snprintf(fsid_buf, BTRFS_UUID_UNPARSED_SIZE, "%pU",
|
|
fs_info->fsid);
|
|
if (kobject_rename(&fs_info->fs_devices->fsid_kobj, fsid_buf))
|
|
btrfs_warn(fs_info,
|
|
"sysfs: failed to create fsid for sprout");
|
|
}
|
|
|
|
fs_info->num_tolerated_disk_barrier_failures =
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
|
|
ret = btrfs_commit_transaction(trans);
|
|
|
|
if (seeding_dev) {
|
|
mutex_unlock(&uuid_mutex);
|
|
up_write(&sb->s_umount);
|
|
|
|
if (ret) /* transaction commit */
|
|
return ret;
|
|
|
|
ret = btrfs_relocate_sys_chunks(fs_info);
|
|
if (ret < 0)
|
|
btrfs_handle_fs_error(fs_info, ret,
|
|
"Failed to relocate sys chunks after device initialization. This can be fixed using the \"btrfs balance\" command.");
|
|
trans = btrfs_attach_transaction(root);
|
|
if (IS_ERR(trans)) {
|
|
if (PTR_ERR(trans) == -ENOENT)
|
|
return 0;
|
|
return PTR_ERR(trans);
|
|
}
|
|
ret = btrfs_commit_transaction(trans);
|
|
}
|
|
|
|
/* Update ctime/mtime for libblkid */
|
|
update_dev_time(device_path);
|
|
return ret;
|
|
|
|
error_trans:
|
|
btrfs_end_transaction(trans);
|
|
rcu_string_free(device->name);
|
|
btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
|
|
kfree(device);
|
|
error:
|
|
blkdev_put(bdev, FMODE_EXCL);
|
|
if (seeding_dev) {
|
|
mutex_unlock(&uuid_mutex);
|
|
up_write(&sb->s_umount);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_init_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
|
|
const char *device_path,
|
|
struct btrfs_device *srcdev,
|
|
struct btrfs_device **device_out)
|
|
{
|
|
struct request_queue *q;
|
|
struct btrfs_device *device;
|
|
struct block_device *bdev;
|
|
struct list_head *devices;
|
|
struct rcu_string *name;
|
|
u64 devid = BTRFS_DEV_REPLACE_DEVID;
|
|
int ret = 0;
|
|
|
|
*device_out = NULL;
|
|
if (fs_info->fs_devices->seeding) {
|
|
btrfs_err(fs_info, "the filesystem is a seed filesystem!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
|
|
fs_info->bdev_holder);
|
|
if (IS_ERR(bdev)) {
|
|
btrfs_err(fs_info, "target device %s is invalid!", device_path);
|
|
return PTR_ERR(bdev);
|
|
}
|
|
|
|
filemap_write_and_wait(bdev->bd_inode->i_mapping);
|
|
|
|
devices = &fs_info->fs_devices->devices;
|
|
list_for_each_entry(device, devices, dev_list) {
|
|
if (device->bdev == bdev) {
|
|
btrfs_err(fs_info,
|
|
"target device is in the filesystem!");
|
|
ret = -EEXIST;
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
|
|
if (i_size_read(bdev->bd_inode) <
|
|
btrfs_device_get_total_bytes(srcdev)) {
|
|
btrfs_err(fs_info,
|
|
"target device is smaller than source device!");
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
|
|
|
|
device = btrfs_alloc_device(NULL, &devid, NULL);
|
|
if (IS_ERR(device)) {
|
|
ret = PTR_ERR(device);
|
|
goto error;
|
|
}
|
|
|
|
name = rcu_string_strdup(device_path, GFP_NOFS);
|
|
if (!name) {
|
|
kfree(device);
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
rcu_assign_pointer(device->name, name);
|
|
|
|
q = bdev_get_queue(bdev);
|
|
if (blk_queue_discard(q))
|
|
device->can_discard = 1;
|
|
mutex_lock(&fs_info->fs_devices->device_list_mutex);
|
|
device->writeable = 1;
|
|
device->generation = 0;
|
|
device->io_width = fs_info->sectorsize;
|
|
device->io_align = fs_info->sectorsize;
|
|
device->sector_size = fs_info->sectorsize;
|
|
device->total_bytes = btrfs_device_get_total_bytes(srcdev);
|
|
device->disk_total_bytes = btrfs_device_get_disk_total_bytes(srcdev);
|
|
device->bytes_used = btrfs_device_get_bytes_used(srcdev);
|
|
ASSERT(list_empty(&srcdev->resized_list));
|
|
device->commit_total_bytes = srcdev->commit_total_bytes;
|
|
device->commit_bytes_used = device->bytes_used;
|
|
device->fs_info = fs_info;
|
|
device->bdev = bdev;
|
|
device->in_fs_metadata = 1;
|
|
device->is_tgtdev_for_dev_replace = 1;
|
|
device->mode = FMODE_EXCL;
|
|
device->dev_stats_valid = 1;
|
|
set_blocksize(device->bdev, 4096);
|
|
device->fs_devices = fs_info->fs_devices;
|
|
list_add(&device->dev_list, &fs_info->fs_devices->devices);
|
|
fs_info->fs_devices->num_devices++;
|
|
fs_info->fs_devices->open_devices++;
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
*device_out = device;
|
|
return ret;
|
|
|
|
error:
|
|
blkdev_put(bdev, FMODE_EXCL);
|
|
return ret;
|
|
}
|
|
|
|
void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *tgtdev)
|
|
{
|
|
u32 sectorsize = fs_info->sectorsize;
|
|
|
|
WARN_ON(fs_info->fs_devices->rw_devices == 0);
|
|
tgtdev->io_width = sectorsize;
|
|
tgtdev->io_align = sectorsize;
|
|
tgtdev->sector_size = sectorsize;
|
|
tgtdev->fs_info = fs_info;
|
|
tgtdev->in_fs_metadata = 1;
|
|
}
|
|
|
|
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 = device->fs_info->chunk_root;
|
|
struct btrfs_dev_item *dev_item;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
|
|
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,
|
|
btrfs_device_get_disk_total_bytes(device));
|
|
btrfs_set_device_bytes_used(leaf, dev_item,
|
|
btrfs_device_get_bytes_used(device));
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_grow_device(struct btrfs_trans_handle *trans,
|
|
struct btrfs_device *device, u64 new_size)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
struct btrfs_super_block *super_copy = fs_info->super_copy;
|
|
struct btrfs_fs_devices *fs_devices;
|
|
u64 old_total;
|
|
u64 diff;
|
|
|
|
if (!device->writeable)
|
|
return -EACCES;
|
|
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
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) {
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
return -EINVAL;
|
|
}
|
|
|
|
fs_devices = fs_info->fs_devices;
|
|
|
|
btrfs_set_super_total_bytes(super_copy, old_total + diff);
|
|
device->fs_devices->total_rw_bytes += diff;
|
|
|
|
btrfs_device_set_total_bytes(device, new_size);
|
|
btrfs_device_set_disk_total_bytes(device, new_size);
|
|
btrfs_clear_space_info_full(device->fs_info);
|
|
if (list_empty(&device->resized_list))
|
|
list_add_tail(&device->resized_list,
|
|
&fs_devices->resized_devices);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
|
|
return btrfs_update_device(trans, device);
|
|
}
|
|
|
|
static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info, u64 chunk_objectid,
|
|
u64 chunk_offset)
|
|
{
|
|
struct btrfs_root *root = fs_info->chunk_root;
|
|
int ret;
|
|
struct btrfs_path *path;
|
|
struct btrfs_key key;
|
|
|
|
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);
|
|
if (ret < 0)
|
|
goto out;
|
|
else if (ret > 0) { /* Logic error or corruption */
|
|
btrfs_handle_fs_error(fs_info, -ENOENT,
|
|
"Failed lookup while freeing chunk.");
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
ret = btrfs_del_item(trans, root, path);
|
|
if (ret < 0)
|
|
btrfs_handle_fs_error(fs_info, ret,
|
|
"Failed to delete chunk item.");
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info,
|
|
u64 chunk_objectid, u64 chunk_offset)
|
|
{
|
|
struct btrfs_super_block *super_copy = 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;
|
|
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
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;
|
|
}
|
|
}
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
return ret;
|
|
}
|
|
|
|
static struct extent_map *get_chunk_map(struct btrfs_fs_info *fs_info,
|
|
u64 logical, u64 length)
|
|
{
|
|
struct extent_map_tree *em_tree;
|
|
struct extent_map *em;
|
|
|
|
em_tree = &fs_info->mapping_tree.map_tree;
|
|
read_lock(&em_tree->lock);
|
|
em = lookup_extent_mapping(em_tree, logical, length);
|
|
read_unlock(&em_tree->lock);
|
|
|
|
if (!em) {
|
|
btrfs_crit(fs_info, "unable to find logical %llu length %llu",
|
|
logical, length);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
if (em->start > logical || em->start + em->len < logical) {
|
|
btrfs_crit(fs_info,
|
|
"found a bad mapping, wanted %llu-%llu, found %llu-%llu",
|
|
logical, length, em->start, em->start + em->len);
|
|
free_extent_map(em);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
/* callers are responsible for dropping em's ref. */
|
|
return em;
|
|
}
|
|
|
|
int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info, u64 chunk_offset)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
u64 dev_extent_len = 0;
|
|
u64 chunk_objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
|
|
int i, ret = 0;
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
|
|
em = get_chunk_map(fs_info, chunk_offset, 1);
|
|
if (IS_ERR(em)) {
|
|
/*
|
|
* This is a logic error, but we don't want to just rely on the
|
|
* user having built with ASSERT enabled, so if ASSERT doesn't
|
|
* do anything we still error out.
|
|
*/
|
|
ASSERT(0);
|
|
return PTR_ERR(em);
|
|
}
|
|
map = em->map_lookup;
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
check_system_chunk(trans, fs_info, map->type);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
|
|
/*
|
|
* Take the device list mutex to prevent races with the final phase of
|
|
* a device replace operation that replaces the device object associated
|
|
* with map stripes (dev-replace.c:btrfs_dev_replace_finishing()).
|
|
*/
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
struct btrfs_device *device = map->stripes[i].dev;
|
|
ret = btrfs_free_dev_extent(trans, device,
|
|
map->stripes[i].physical,
|
|
&dev_extent_len);
|
|
if (ret) {
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
|
|
if (device->bytes_used > 0) {
|
|
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);
|
|
btrfs_clear_space_info_full(fs_info);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
}
|
|
|
|
if (map->stripes[i].dev) {
|
|
ret = btrfs_update_device(trans, map->stripes[i].dev);
|
|
if (ret) {
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
}
|
|
}
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
ret = btrfs_free_chunk(trans, fs_info, chunk_objectid, chunk_offset);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
|
|
trace_btrfs_chunk_free(fs_info, map, chunk_offset, em->len);
|
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
ret = btrfs_del_sys_chunk(fs_info, chunk_objectid,
|
|
chunk_offset);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
ret = btrfs_remove_block_group(trans, fs_info, chunk_offset, em);
|
|
if (ret) {
|
|
btrfs_abort_transaction(trans, ret);
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
/* once for us */
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)
|
|
{
|
|
struct btrfs_root *root = fs_info->chunk_root;
|
|
struct btrfs_trans_handle *trans;
|
|
int ret;
|
|
|
|
/*
|
|
* Prevent races with automatic removal of unused block groups.
|
|
* After we relocate and before we remove the chunk with offset
|
|
* chunk_offset, automatic removal of the block group can kick in,
|
|
* resulting in a failure when calling btrfs_remove_chunk() below.
|
|
*
|
|
* Make sure to acquire this mutex before doing a tree search (dev
|
|
* or chunk trees) to find chunks. Otherwise the cleaner kthread might
|
|
* call btrfs_remove_chunk() (through btrfs_delete_unused_bgs()) after
|
|
* we release the path used to search the chunk/dev tree and before
|
|
* the current task acquires this mutex and calls us.
|
|
*/
|
|
ASSERT(mutex_is_locked(&fs_info->delete_unused_bgs_mutex));
|
|
|
|
ret = btrfs_can_relocate(fs_info, chunk_offset);
|
|
if (ret)
|
|
return -ENOSPC;
|
|
|
|
/* step one, relocate all the extents inside this chunk */
|
|
btrfs_scrub_pause(fs_info);
|
|
ret = btrfs_relocate_block_group(fs_info, chunk_offset);
|
|
btrfs_scrub_continue(fs_info);
|
|
if (ret)
|
|
return ret;
|
|
|
|
trans = btrfs_start_trans_remove_block_group(root->fs_info,
|
|
chunk_offset);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
btrfs_handle_fs_error(root->fs_info, ret, NULL);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* step two, delete the device extents and the
|
|
* chunk tree entries
|
|
*/
|
|
ret = btrfs_remove_chunk(trans, fs_info, chunk_offset);
|
|
btrfs_end_transaction(trans);
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_relocate_sys_chunks(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_root *chunk_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_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) {
|
|
mutex_lock(&fs_info->delete_unused_bgs_mutex);
|
|
ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
|
|
if (ret < 0) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
goto error;
|
|
}
|
|
BUG_ON(ret == 0); /* Corruption */
|
|
|
|
ret = btrfs_previous_item(chunk_root, path, key.objectid,
|
|
key.type);
|
|
if (ret)
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
if (ret < 0)
|
|
goto error;
|
|
if (ret > 0)
|
|
break;
|
|
|
|
leaf = path->nodes[0];
|
|
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
|
|
|
|
chunk = btrfs_item_ptr(leaf, path->slots[0],
|
|
struct btrfs_chunk);
|
|
chunk_type = btrfs_chunk_type(leaf, chunk);
|
|
btrfs_release_path(path);
|
|
|
|
if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
ret = btrfs_relocate_chunk(fs_info, found_key.offset);
|
|
if (ret == -ENOSPC)
|
|
failed++;
|
|
else
|
|
BUG_ON(ret);
|
|
}
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
|
|
if (found_key.offset == 0)
|
|
break;
|
|
key.offset = found_key.offset - 1;
|
|
}
|
|
ret = 0;
|
|
if (failed && !retried) {
|
|
failed = 0;
|
|
retried = true;
|
|
goto again;
|
|
} else if (WARN_ON(failed && retried)) {
|
|
ret = -ENOSPC;
|
|
}
|
|
error:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
static int insert_balance_item(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_balance_control *bctl)
|
|
{
|
|
struct btrfs_root *root = fs_info->tree_root;
|
|
struct btrfs_trans_handle *trans;
|
|
struct btrfs_balance_item *item;
|
|
struct btrfs_disk_balance_args disk_bargs;
|
|
struct btrfs_path *path;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
int ret, err;
|
|
|
|
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_BALANCE_OBJECTID;
|
|
key.type = BTRFS_TEMPORARY_ITEM_KEY;
|
|
key.offset = 0;
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, &key,
|
|
sizeof(*item));
|
|
if (ret)
|
|
goto out;
|
|
|
|
leaf = path->nodes[0];
|
|
item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
|
|
|
|
memzero_extent_buffer(leaf, (unsigned long)item, sizeof(*item));
|
|
|
|
btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->data);
|
|
btrfs_set_balance_data(leaf, item, &disk_bargs);
|
|
btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->meta);
|
|
btrfs_set_balance_meta(leaf, item, &disk_bargs);
|
|
btrfs_cpu_balance_args_to_disk(&disk_bargs, &bctl->sys);
|
|
btrfs_set_balance_sys(leaf, item, &disk_bargs);
|
|
|
|
btrfs_set_balance_flags(leaf, item, bctl->flags);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
out:
|
|
btrfs_free_path(path);
|
|
err = btrfs_commit_transaction(trans);
|
|
if (err && !ret)
|
|
ret = err;
|
|
return ret;
|
|
}
|
|
|
|
static int del_balance_item(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_root *root = fs_info->tree_root;
|
|
struct btrfs_trans_handle *trans;
|
|
struct btrfs_path *path;
|
|
struct btrfs_key key;
|
|
int ret, err;
|
|
|
|
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_BALANCE_OBJECTID;
|
|
key.type = BTRFS_TEMPORARY_ITEM_KEY;
|
|
key.offset = 0;
|
|
|
|
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);
|
|
out:
|
|
btrfs_free_path(path);
|
|
err = btrfs_commit_transaction(trans);
|
|
if (err && !ret)
|
|
ret = err;
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* This is a heuristic used to reduce the number of chunks balanced on
|
|
* resume after balance was interrupted.
|
|
*/
|
|
static void update_balance_args(struct btrfs_balance_control *bctl)
|
|
{
|
|
/*
|
|
* Turn on soft mode for chunk types that were being converted.
|
|
*/
|
|
if (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)
|
|
bctl->data.flags |= BTRFS_BALANCE_ARGS_SOFT;
|
|
if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)
|
|
bctl->sys.flags |= BTRFS_BALANCE_ARGS_SOFT;
|
|
if (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)
|
|
bctl->meta.flags |= BTRFS_BALANCE_ARGS_SOFT;
|
|
|
|
/*
|
|
* Turn on usage filter if is not already used. The idea is
|
|
* that chunks that we have already balanced should be
|
|
* reasonably full. Don't do it for chunks that are being
|
|
* converted - that will keep us from relocating unconverted
|
|
* (albeit full) chunks.
|
|
*/
|
|
if (!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE) &&
|
|
!(bctl->data.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
|
|
!(bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
|
|
bctl->data.flags |= BTRFS_BALANCE_ARGS_USAGE;
|
|
bctl->data.usage = 90;
|
|
}
|
|
if (!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE) &&
|
|
!(bctl->sys.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
|
|
!(bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
|
|
bctl->sys.flags |= BTRFS_BALANCE_ARGS_USAGE;
|
|
bctl->sys.usage = 90;
|
|
}
|
|
if (!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE) &&
|
|
!(bctl->meta.flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
|
|
!(bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT)) {
|
|
bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE;
|
|
bctl->meta.usage = 90;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Should be called with both balance and volume mutexes held to
|
|
* serialize other volume operations (add_dev/rm_dev/resize) with
|
|
* restriper. Same goes for unset_balance_control.
|
|
*/
|
|
static void set_balance_control(struct btrfs_balance_control *bctl)
|
|
{
|
|
struct btrfs_fs_info *fs_info = bctl->fs_info;
|
|
|
|
BUG_ON(fs_info->balance_ctl);
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
fs_info->balance_ctl = bctl;
|
|
spin_unlock(&fs_info->balance_lock);
|
|
}
|
|
|
|
static void unset_balance_control(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_balance_control *bctl = fs_info->balance_ctl;
|
|
|
|
BUG_ON(!fs_info->balance_ctl);
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
fs_info->balance_ctl = NULL;
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
kfree(bctl);
|
|
}
|
|
|
|
/*
|
|
* Balance filters. Return 1 if chunk should be filtered out
|
|
* (should not be balanced).
|
|
*/
|
|
static int chunk_profiles_filter(u64 chunk_type,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
chunk_type = chunk_to_extended(chunk_type) &
|
|
BTRFS_EXTENDED_PROFILE_MASK;
|
|
|
|
if (bargs->profiles & chunk_type)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int chunk_usage_range_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
struct btrfs_block_group_cache *cache;
|
|
u64 chunk_used;
|
|
u64 user_thresh_min;
|
|
u64 user_thresh_max;
|
|
int ret = 1;
|
|
|
|
cache = btrfs_lookup_block_group(fs_info, chunk_offset);
|
|
chunk_used = btrfs_block_group_used(&cache->item);
|
|
|
|
if (bargs->usage_min == 0)
|
|
user_thresh_min = 0;
|
|
else
|
|
user_thresh_min = div_factor_fine(cache->key.offset,
|
|
bargs->usage_min);
|
|
|
|
if (bargs->usage_max == 0)
|
|
user_thresh_max = 1;
|
|
else if (bargs->usage_max > 100)
|
|
user_thresh_max = cache->key.offset;
|
|
else
|
|
user_thresh_max = div_factor_fine(cache->key.offset,
|
|
bargs->usage_max);
|
|
|
|
if (user_thresh_min <= chunk_used && chunk_used < user_thresh_max)
|
|
ret = 0;
|
|
|
|
btrfs_put_block_group(cache);
|
|
return ret;
|
|
}
|
|
|
|
static int chunk_usage_filter(struct btrfs_fs_info *fs_info,
|
|
u64 chunk_offset, struct btrfs_balance_args *bargs)
|
|
{
|
|
struct btrfs_block_group_cache *cache;
|
|
u64 chunk_used, user_thresh;
|
|
int ret = 1;
|
|
|
|
cache = btrfs_lookup_block_group(fs_info, chunk_offset);
|
|
chunk_used = btrfs_block_group_used(&cache->item);
|
|
|
|
if (bargs->usage_min == 0)
|
|
user_thresh = 1;
|
|
else if (bargs->usage > 100)
|
|
user_thresh = cache->key.offset;
|
|
else
|
|
user_thresh = div_factor_fine(cache->key.offset,
|
|
bargs->usage);
|
|
|
|
if (chunk_used < user_thresh)
|
|
ret = 0;
|
|
|
|
btrfs_put_block_group(cache);
|
|
return ret;
|
|
}
|
|
|
|
static int chunk_devid_filter(struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
struct btrfs_stripe *stripe;
|
|
int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
|
|
int i;
|
|
|
|
for (i = 0; i < num_stripes; i++) {
|
|
stripe = btrfs_stripe_nr(chunk, i);
|
|
if (btrfs_stripe_devid(leaf, stripe) == bargs->devid)
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* [pstart, pend) */
|
|
static int chunk_drange_filter(struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk,
|
|
u64 chunk_offset,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
struct btrfs_stripe *stripe;
|
|
int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
|
|
u64 stripe_offset;
|
|
u64 stripe_length;
|
|
int factor;
|
|
int i;
|
|
|
|
if (!(bargs->flags & BTRFS_BALANCE_ARGS_DEVID))
|
|
return 0;
|
|
|
|
if (btrfs_chunk_type(leaf, chunk) & (BTRFS_BLOCK_GROUP_DUP |
|
|
BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)) {
|
|
factor = num_stripes / 2;
|
|
} else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID5) {
|
|
factor = num_stripes - 1;
|
|
} else if (btrfs_chunk_type(leaf, chunk) & BTRFS_BLOCK_GROUP_RAID6) {
|
|
factor = num_stripes - 2;
|
|
} else {
|
|
factor = num_stripes;
|
|
}
|
|
|
|
for (i = 0; i < num_stripes; i++) {
|
|
stripe = btrfs_stripe_nr(chunk, i);
|
|
if (btrfs_stripe_devid(leaf, stripe) != bargs->devid)
|
|
continue;
|
|
|
|
stripe_offset = btrfs_stripe_offset(leaf, stripe);
|
|
stripe_length = btrfs_chunk_length(leaf, chunk);
|
|
stripe_length = div_u64(stripe_length, factor);
|
|
|
|
if (stripe_offset < bargs->pend &&
|
|
stripe_offset + stripe_length > bargs->pstart)
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* [vstart, vend) */
|
|
static int chunk_vrange_filter(struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk,
|
|
u64 chunk_offset,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
if (chunk_offset < bargs->vend &&
|
|
chunk_offset + btrfs_chunk_length(leaf, chunk) > bargs->vstart)
|
|
/* at least part of the chunk is inside this vrange */
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int chunk_stripes_range_filter(struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
int num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
|
|
|
|
if (bargs->stripes_min <= num_stripes
|
|
&& num_stripes <= bargs->stripes_max)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int chunk_soft_convert_filter(u64 chunk_type,
|
|
struct btrfs_balance_args *bargs)
|
|
{
|
|
if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
|
|
return 0;
|
|
|
|
chunk_type = chunk_to_extended(chunk_type) &
|
|
BTRFS_EXTENDED_PROFILE_MASK;
|
|
|
|
if (bargs->target == chunk_type)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int should_balance_chunk(struct btrfs_fs_info *fs_info,
|
|
struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk, u64 chunk_offset)
|
|
{
|
|
struct btrfs_balance_control *bctl = fs_info->balance_ctl;
|
|
struct btrfs_balance_args *bargs = NULL;
|
|
u64 chunk_type = btrfs_chunk_type(leaf, chunk);
|
|
|
|
/* type filter */
|
|
if (!((chunk_type & BTRFS_BLOCK_GROUP_TYPE_MASK) &
|
|
(bctl->flags & BTRFS_BALANCE_TYPE_MASK))) {
|
|
return 0;
|
|
}
|
|
|
|
if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
|
|
bargs = &bctl->data;
|
|
else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
|
|
bargs = &bctl->sys;
|
|
else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
|
|
bargs = &bctl->meta;
|
|
|
|
/* profiles filter */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
|
|
chunk_profiles_filter(chunk_type, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/* usage filter */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
|
|
chunk_usage_filter(fs_info, chunk_offset, bargs)) {
|
|
return 0;
|
|
} else if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE_RANGE) &&
|
|
chunk_usage_range_filter(fs_info, chunk_offset, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/* devid filter */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
|
|
chunk_devid_filter(leaf, chunk, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/* drange filter, makes sense only with devid filter */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_DRANGE) &&
|
|
chunk_drange_filter(leaf, chunk, chunk_offset, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/* vrange filter */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) &&
|
|
chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/* stripes filter */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_STRIPES_RANGE) &&
|
|
chunk_stripes_range_filter(leaf, chunk, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/* soft profile changing mode */
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
|
|
chunk_soft_convert_filter(chunk_type, bargs)) {
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* limited by count, must be the last filter
|
|
*/
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT)) {
|
|
if (bargs->limit == 0)
|
|
return 0;
|
|
else
|
|
bargs->limit--;
|
|
} else if ((bargs->flags & BTRFS_BALANCE_ARGS_LIMIT_RANGE)) {
|
|
/*
|
|
* Same logic as the 'limit' filter; the minimum cannot be
|
|
* determined here because we do not have the global information
|
|
* about the count of all chunks that satisfy the filters.
|
|
*/
|
|
if (bargs->limit_max == 0)
|
|
return 0;
|
|
else
|
|
bargs->limit_max--;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int __btrfs_balance(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_balance_control *bctl = fs_info->balance_ctl;
|
|
struct btrfs_root *chunk_root = fs_info->chunk_root;
|
|
struct btrfs_root *dev_root = fs_info->dev_root;
|
|
struct list_head *devices;
|
|
struct btrfs_device *device;
|
|
u64 old_size;
|
|
u64 size_to_free;
|
|
u64 chunk_type;
|
|
struct btrfs_chunk *chunk;
|
|
struct btrfs_path *path = NULL;
|
|
struct btrfs_key key;
|
|
struct btrfs_key found_key;
|
|
struct btrfs_trans_handle *trans;
|
|
struct extent_buffer *leaf;
|
|
int slot;
|
|
int ret;
|
|
int enospc_errors = 0;
|
|
bool counting = true;
|
|
/* The single value limit and min/max limits use the same bytes in the */
|
|
u64 limit_data = bctl->data.limit;
|
|
u64 limit_meta = bctl->meta.limit;
|
|
u64 limit_sys = bctl->sys.limit;
|
|
u32 count_data = 0;
|
|
u32 count_meta = 0;
|
|
u32 count_sys = 0;
|
|
int chunk_reserved = 0;
|
|
u64 bytes_used = 0;
|
|
|
|
/* step one make some room on all the devices */
|
|
devices = &fs_info->fs_devices->devices;
|
|
list_for_each_entry(device, devices, dev_list) {
|
|
old_size = btrfs_device_get_total_bytes(device);
|
|
size_to_free = div_factor(old_size, 1);
|
|
size_to_free = min_t(u64, size_to_free, SZ_1M);
|
|
if (!device->writeable ||
|
|
btrfs_device_get_total_bytes(device) -
|
|
btrfs_device_get_bytes_used(device) > size_to_free ||
|
|
device->is_tgtdev_for_dev_replace)
|
|
continue;
|
|
|
|
ret = btrfs_shrink_device(device, old_size - size_to_free);
|
|
if (ret == -ENOSPC)
|
|
break;
|
|
if (ret) {
|
|
/* btrfs_shrink_device never returns ret > 0 */
|
|
WARN_ON(ret > 0);
|
|
goto error;
|
|
}
|
|
|
|
trans = btrfs_start_transaction(dev_root, 0);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
btrfs_info_in_rcu(fs_info,
|
|
"resize: unable to start transaction after shrinking device %s (error %d), old size %llu, new size %llu",
|
|
rcu_str_deref(device->name), ret,
|
|
old_size, old_size - size_to_free);
|
|
goto error;
|
|
}
|
|
|
|
ret = btrfs_grow_device(trans, device, old_size);
|
|
if (ret) {
|
|
btrfs_end_transaction(trans);
|
|
/* btrfs_grow_device never returns ret > 0 */
|
|
WARN_ON(ret > 0);
|
|
btrfs_info_in_rcu(fs_info,
|
|
"resize: unable to grow device after shrinking device %s (error %d), old size %llu, new size %llu",
|
|
rcu_str_deref(device->name), ret,
|
|
old_size, old_size - size_to_free);
|
|
goto error;
|
|
}
|
|
|
|
btrfs_end_transaction(trans);
|
|
}
|
|
|
|
/* step two, relocate all the chunks */
|
|
path = btrfs_alloc_path();
|
|
if (!path) {
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
|
|
/* zero out stat counters */
|
|
spin_lock(&fs_info->balance_lock);
|
|
memset(&bctl->stat, 0, sizeof(bctl->stat));
|
|
spin_unlock(&fs_info->balance_lock);
|
|
again:
|
|
if (!counting) {
|
|
/*
|
|
* The single value limit and min/max limits use the same bytes
|
|
* in the
|
|
*/
|
|
bctl->data.limit = limit_data;
|
|
bctl->meta.limit = limit_meta;
|
|
bctl->sys.limit = limit_sys;
|
|
}
|
|
key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
|
|
key.offset = (u64)-1;
|
|
key.type = BTRFS_CHUNK_ITEM_KEY;
|
|
|
|
while (1) {
|
|
if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||
|
|
atomic_read(&fs_info->balance_cancel_req)) {
|
|
ret = -ECANCELED;
|
|
goto error;
|
|
}
|
|
|
|
mutex_lock(&fs_info->delete_unused_bgs_mutex);
|
|
ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
|
|
if (ret < 0) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
goto error;
|
|
}
|
|
|
|
/*
|
|
* this shouldn't happen, it means the last relocate
|
|
* failed
|
|
*/
|
|
if (ret == 0)
|
|
BUG(); /* FIXME break ? */
|
|
|
|
ret = btrfs_previous_item(chunk_root, path, 0,
|
|
BTRFS_CHUNK_ITEM_KEY);
|
|
if (ret) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
ret = 0;
|
|
break;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
slot = path->slots[0];
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
|
|
|
if (found_key.objectid != key.objectid) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
break;
|
|
}
|
|
|
|
chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
|
|
chunk_type = btrfs_chunk_type(leaf, chunk);
|
|
|
|
if (!counting) {
|
|
spin_lock(&fs_info->balance_lock);
|
|
bctl->stat.considered++;
|
|
spin_unlock(&fs_info->balance_lock);
|
|
}
|
|
|
|
ret = should_balance_chunk(fs_info, leaf, chunk,
|
|
found_key.offset);
|
|
|
|
btrfs_release_path(path);
|
|
if (!ret) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
goto loop;
|
|
}
|
|
|
|
if (counting) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
spin_lock(&fs_info->balance_lock);
|
|
bctl->stat.expected++;
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
if (chunk_type & BTRFS_BLOCK_GROUP_DATA)
|
|
count_data++;
|
|
else if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM)
|
|
count_sys++;
|
|
else if (chunk_type & BTRFS_BLOCK_GROUP_METADATA)
|
|
count_meta++;
|
|
|
|
goto loop;
|
|
}
|
|
|
|
/*
|
|
* Apply limit_min filter, no need to check if the LIMITS
|
|
* filter is used, limit_min is 0 by default
|
|
*/
|
|
if (((chunk_type & BTRFS_BLOCK_GROUP_DATA) &&
|
|
count_data < bctl->data.limit_min)
|
|
|| ((chunk_type & BTRFS_BLOCK_GROUP_METADATA) &&
|
|
count_meta < bctl->meta.limit_min)
|
|
|| ((chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) &&
|
|
count_sys < bctl->sys.limit_min)) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
goto loop;
|
|
}
|
|
|
|
ASSERT(fs_info->data_sinfo);
|
|
spin_lock(&fs_info->data_sinfo->lock);
|
|
bytes_used = fs_info->data_sinfo->bytes_used;
|
|
spin_unlock(&fs_info->data_sinfo->lock);
|
|
|
|
if ((chunk_type & BTRFS_BLOCK_GROUP_DATA) &&
|
|
!chunk_reserved && !bytes_used) {
|
|
trans = btrfs_start_transaction(chunk_root, 0);
|
|
if (IS_ERR(trans)) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
ret = PTR_ERR(trans);
|
|
goto error;
|
|
}
|
|
|
|
ret = btrfs_force_chunk_alloc(trans, fs_info,
|
|
BTRFS_BLOCK_GROUP_DATA);
|
|
btrfs_end_transaction(trans);
|
|
if (ret < 0) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
goto error;
|
|
}
|
|
chunk_reserved = 1;
|
|
}
|
|
|
|
ret = btrfs_relocate_chunk(fs_info, found_key.offset);
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
if (ret && ret != -ENOSPC)
|
|
goto error;
|
|
if (ret == -ENOSPC) {
|
|
enospc_errors++;
|
|
} else {
|
|
spin_lock(&fs_info->balance_lock);
|
|
bctl->stat.completed++;
|
|
spin_unlock(&fs_info->balance_lock);
|
|
}
|
|
loop:
|
|
if (found_key.offset == 0)
|
|
break;
|
|
key.offset = found_key.offset - 1;
|
|
}
|
|
|
|
if (counting) {
|
|
btrfs_release_path(path);
|
|
counting = false;
|
|
goto again;
|
|
}
|
|
error:
|
|
btrfs_free_path(path);
|
|
if (enospc_errors) {
|
|
btrfs_info(fs_info, "%d enospc errors during balance",
|
|
enospc_errors);
|
|
if (!ret)
|
|
ret = -ENOSPC;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* alloc_profile_is_valid - see if a given profile is valid and reduced
|
|
* @flags: profile to validate
|
|
* @extended: if true @flags is treated as an extended profile
|
|
*/
|
|
static int alloc_profile_is_valid(u64 flags, int extended)
|
|
{
|
|
u64 mask = (extended ? BTRFS_EXTENDED_PROFILE_MASK :
|
|
BTRFS_BLOCK_GROUP_PROFILE_MASK);
|
|
|
|
flags &= ~BTRFS_BLOCK_GROUP_TYPE_MASK;
|
|
|
|
/* 1) check that all other bits are zeroed */
|
|
if (flags & ~mask)
|
|
return 0;
|
|
|
|
/* 2) see if profile is reduced */
|
|
if (flags == 0)
|
|
return !extended; /* "0" is valid for usual profiles */
|
|
|
|
/* true if exactly one bit set */
|
|
return (flags & (flags - 1)) == 0;
|
|
}
|
|
|
|
static inline int balance_need_close(struct btrfs_fs_info *fs_info)
|
|
{
|
|
/* cancel requested || normal exit path */
|
|
return atomic_read(&fs_info->balance_cancel_req) ||
|
|
(atomic_read(&fs_info->balance_pause_req) == 0 &&
|
|
atomic_read(&fs_info->balance_cancel_req) == 0);
|
|
}
|
|
|
|
static void __cancel_balance(struct btrfs_fs_info *fs_info)
|
|
{
|
|
int ret;
|
|
|
|
unset_balance_control(fs_info);
|
|
ret = del_balance_item(fs_info);
|
|
if (ret)
|
|
btrfs_handle_fs_error(fs_info, ret, NULL);
|
|
|
|
clear_bit(BTRFS_FS_EXCL_OP, &fs_info->flags);
|
|
}
|
|
|
|
/* Non-zero return value signifies invalidity */
|
|
static inline int validate_convert_profile(struct btrfs_balance_args *bctl_arg,
|
|
u64 allowed)
|
|
{
|
|
return ((bctl_arg->flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
|
(!alloc_profile_is_valid(bctl_arg->target, 1) ||
|
|
(bctl_arg->target & ~allowed)));
|
|
}
|
|
|
|
/*
|
|
* Should be called with both balance and volume mutexes held
|
|
*/
|
|
int btrfs_balance(struct btrfs_balance_control *bctl,
|
|
struct btrfs_ioctl_balance_args *bargs)
|
|
{
|
|
struct btrfs_fs_info *fs_info = bctl->fs_info;
|
|
u64 meta_target, data_target;
|
|
u64 allowed;
|
|
int mixed = 0;
|
|
int ret;
|
|
u64 num_devices;
|
|
unsigned seq;
|
|
|
|
if (btrfs_fs_closing(fs_info) ||
|
|
atomic_read(&fs_info->balance_pause_req) ||
|
|
atomic_read(&fs_info->balance_cancel_req)) {
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
allowed = btrfs_super_incompat_flags(fs_info->super_copy);
|
|
if (allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
|
|
mixed = 1;
|
|
|
|
/*
|
|
* In case of mixed groups both data and meta should be picked,
|
|
* and identical options should be given for both of them.
|
|
*/
|
|
allowed = BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA;
|
|
if (mixed && (bctl->flags & allowed)) {
|
|
if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
|
|
!(bctl->flags & BTRFS_BALANCE_METADATA) ||
|
|
memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
|
|
btrfs_err(fs_info,
|
|
"with mixed groups data and metadata balance options must be the same");
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
num_devices = fs_info->fs_devices->num_devices;
|
|
btrfs_dev_replace_lock(&fs_info->dev_replace, 0);
|
|
if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
|
|
BUG_ON(num_devices < 1);
|
|
num_devices--;
|
|
}
|
|
btrfs_dev_replace_unlock(&fs_info->dev_replace, 0);
|
|
allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE | BTRFS_BLOCK_GROUP_DUP;
|
|
if (num_devices > 1)
|
|
allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
|
|
if (num_devices > 2)
|
|
allowed |= BTRFS_BLOCK_GROUP_RAID5;
|
|
if (num_devices > 3)
|
|
allowed |= (BTRFS_BLOCK_GROUP_RAID10 |
|
|
BTRFS_BLOCK_GROUP_RAID6);
|
|
if (validate_convert_profile(&bctl->data, allowed)) {
|
|
btrfs_err(fs_info,
|
|
"unable to start balance with target data profile %llu",
|
|
bctl->data.target);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
if (validate_convert_profile(&bctl->meta, allowed)) {
|
|
btrfs_err(fs_info,
|
|
"unable to start balance with target metadata profile %llu",
|
|
bctl->meta.target);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
if (validate_convert_profile(&bctl->sys, allowed)) {
|
|
btrfs_err(fs_info,
|
|
"unable to start balance with target system profile %llu",
|
|
bctl->sys.target);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/* allow to reduce meta or sys integrity only if force set */
|
|
allowed = BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
|
|
BTRFS_BLOCK_GROUP_RAID10 |
|
|
BTRFS_BLOCK_GROUP_RAID5 |
|
|
BTRFS_BLOCK_GROUP_RAID6;
|
|
do {
|
|
seq = read_seqbegin(&fs_info->profiles_lock);
|
|
|
|
if (((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
|
(fs_info->avail_system_alloc_bits & allowed) &&
|
|
!(bctl->sys.target & allowed)) ||
|
|
((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
|
(fs_info->avail_metadata_alloc_bits & allowed) &&
|
|
!(bctl->meta.target & allowed))) {
|
|
if (bctl->flags & BTRFS_BALANCE_FORCE) {
|
|
btrfs_info(fs_info,
|
|
"force reducing metadata integrity");
|
|
} else {
|
|
btrfs_err(fs_info,
|
|
"balance will reduce metadata integrity, use force if you want this");
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
}
|
|
} while (read_seqretry(&fs_info->profiles_lock, seq));
|
|
|
|
/* if we're not converting, the target field is uninitialized */
|
|
meta_target = (bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) ?
|
|
bctl->meta.target : fs_info->avail_metadata_alloc_bits;
|
|
data_target = (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) ?
|
|
bctl->data.target : fs_info->avail_data_alloc_bits;
|
|
if (btrfs_get_num_tolerated_disk_barrier_failures(meta_target) <
|
|
btrfs_get_num_tolerated_disk_barrier_failures(data_target)) {
|
|
btrfs_warn(fs_info,
|
|
"metadata profile 0x%llx has lower redundancy than data profile 0x%llx",
|
|
meta_target, data_target);
|
|
}
|
|
|
|
if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
|
|
fs_info->num_tolerated_disk_barrier_failures = min(
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(fs_info),
|
|
btrfs_get_num_tolerated_disk_barrier_failures(
|
|
bctl->sys.target));
|
|
}
|
|
|
|
ret = insert_balance_item(fs_info, bctl);
|
|
if (ret && ret != -EEXIST)
|
|
goto out;
|
|
|
|
if (!(bctl->flags & BTRFS_BALANCE_RESUME)) {
|
|
BUG_ON(ret == -EEXIST);
|
|
set_balance_control(bctl);
|
|
} else {
|
|
BUG_ON(ret != -EEXIST);
|
|
spin_lock(&fs_info->balance_lock);
|
|
update_balance_args(bctl);
|
|
spin_unlock(&fs_info->balance_lock);
|
|
}
|
|
|
|
atomic_inc(&fs_info->balance_running);
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
ret = __btrfs_balance(fs_info);
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
atomic_dec(&fs_info->balance_running);
|
|
|
|
if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
|
|
fs_info->num_tolerated_disk_barrier_failures =
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
|
|
}
|
|
|
|
if (bargs) {
|
|
memset(bargs, 0, sizeof(*bargs));
|
|
update_ioctl_balance_args(fs_info, 0, bargs);
|
|
}
|
|
|
|
if ((ret && ret != -ECANCELED && ret != -ENOSPC) ||
|
|
balance_need_close(fs_info)) {
|
|
__cancel_balance(fs_info);
|
|
}
|
|
|
|
wake_up(&fs_info->balance_wait_q);
|
|
|
|
return ret;
|
|
out:
|
|
if (bctl->flags & BTRFS_BALANCE_RESUME)
|
|
__cancel_balance(fs_info);
|
|
else {
|
|
kfree(bctl);
|
|
clear_bit(BTRFS_FS_EXCL_OP, &fs_info->flags);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int balance_kthread(void *data)
|
|
{
|
|
struct btrfs_fs_info *fs_info = data;
|
|
int ret = 0;
|
|
|
|
mutex_lock(&fs_info->volume_mutex);
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
if (fs_info->balance_ctl) {
|
|
btrfs_info(fs_info, "continuing balance");
|
|
ret = btrfs_balance(fs_info->balance_ctl, NULL);
|
|
}
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
mutex_unlock(&fs_info->volume_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct task_struct *tsk;
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
if (!fs_info->balance_ctl) {
|
|
spin_unlock(&fs_info->balance_lock);
|
|
return 0;
|
|
}
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
if (btrfs_test_opt(fs_info, SKIP_BALANCE)) {
|
|
btrfs_info(fs_info, "force skipping balance");
|
|
return 0;
|
|
}
|
|
|
|
tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
|
|
return PTR_ERR_OR_ZERO(tsk);
|
|
}
|
|
|
|
int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_balance_control *bctl;
|
|
struct btrfs_balance_item *item;
|
|
struct btrfs_disk_balance_args disk_bargs;
|
|
struct btrfs_path *path;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
int ret;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
|
|
key.objectid = BTRFS_BALANCE_OBJECTID;
|
|
key.type = BTRFS_TEMPORARY_ITEM_KEY;
|
|
key.offset = 0;
|
|
|
|
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
|
|
if (ret < 0)
|
|
goto out;
|
|
if (ret > 0) { /* ret = -ENOENT; */
|
|
ret = 0;
|
|
goto out;
|
|
}
|
|
|
|
bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
|
|
if (!bctl) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
leaf = path->nodes[0];
|
|
item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
|
|
|
|
bctl->fs_info = fs_info;
|
|
bctl->flags = btrfs_balance_flags(leaf, item);
|
|
bctl->flags |= BTRFS_BALANCE_RESUME;
|
|
|
|
btrfs_balance_data(leaf, item, &disk_bargs);
|
|
btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs);
|
|
btrfs_balance_meta(leaf, item, &disk_bargs);
|
|
btrfs_disk_balance_args_to_cpu(&bctl->meta, &disk_bargs);
|
|
btrfs_balance_sys(leaf, item, &disk_bargs);
|
|
btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs);
|
|
|
|
WARN_ON(test_and_set_bit(BTRFS_FS_EXCL_OP, &fs_info->flags));
|
|
|
|
mutex_lock(&fs_info->volume_mutex);
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
set_balance_control(bctl);
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
mutex_unlock(&fs_info->volume_mutex);
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_pause_balance(struct btrfs_fs_info *fs_info)
|
|
{
|
|
int ret = 0;
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
if (!fs_info->balance_ctl) {
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
return -ENOTCONN;
|
|
}
|
|
|
|
if (atomic_read(&fs_info->balance_running)) {
|
|
atomic_inc(&fs_info->balance_pause_req);
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
wait_event(fs_info->balance_wait_q,
|
|
atomic_read(&fs_info->balance_running) == 0);
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
/* we are good with balance_ctl ripped off from under us */
|
|
BUG_ON(atomic_read(&fs_info->balance_running));
|
|
atomic_dec(&fs_info->balance_pause_req);
|
|
} else {
|
|
ret = -ENOTCONN;
|
|
}
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
|
|
{
|
|
if (fs_info->sb->s_flags & MS_RDONLY)
|
|
return -EROFS;
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
if (!fs_info->balance_ctl) {
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
return -ENOTCONN;
|
|
}
|
|
|
|
atomic_inc(&fs_info->balance_cancel_req);
|
|
/*
|
|
* if we are running just wait and return, balance item is
|
|
* deleted in btrfs_balance in this case
|
|
*/
|
|
if (atomic_read(&fs_info->balance_running)) {
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
wait_event(fs_info->balance_wait_q,
|
|
atomic_read(&fs_info->balance_running) == 0);
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
} else {
|
|
/* __cancel_balance needs volume_mutex */
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
mutex_lock(&fs_info->volume_mutex);
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
if (fs_info->balance_ctl)
|
|
__cancel_balance(fs_info);
|
|
|
|
mutex_unlock(&fs_info->volume_mutex);
|
|
}
|
|
|
|
BUG_ON(fs_info->balance_ctl || atomic_read(&fs_info->balance_running));
|
|
atomic_dec(&fs_info->balance_cancel_req);
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
return 0;
|
|
}
|
|
|
|
static int btrfs_uuid_scan_kthread(void *data)
|
|
{
|
|
struct btrfs_fs_info *fs_info = data;
|
|
struct btrfs_root *root = fs_info->tree_root;
|
|
struct btrfs_key key;
|
|
struct btrfs_key max_key;
|
|
struct btrfs_path *path = NULL;
|
|
int ret = 0;
|
|
struct extent_buffer *eb;
|
|
int slot;
|
|
struct btrfs_root_item root_item;
|
|
u32 item_size;
|
|
struct btrfs_trans_handle *trans = NULL;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
key.objectid = 0;
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
|
key.offset = 0;
|
|
|
|
max_key.objectid = (u64)-1;
|
|
max_key.type = BTRFS_ROOT_ITEM_KEY;
|
|
max_key.offset = (u64)-1;
|
|
|
|
while (1) {
|
|
ret = btrfs_search_forward(root, &key, path, 0);
|
|
if (ret) {
|
|
if (ret > 0)
|
|
ret = 0;
|
|
break;
|
|
}
|
|
|
|
if (key.type != BTRFS_ROOT_ITEM_KEY ||
|
|
(key.objectid < BTRFS_FIRST_FREE_OBJECTID &&
|
|
key.objectid != BTRFS_FS_TREE_OBJECTID) ||
|
|
key.objectid > BTRFS_LAST_FREE_OBJECTID)
|
|
goto skip;
|
|
|
|
eb = path->nodes[0];
|
|
slot = path->slots[0];
|
|
item_size = btrfs_item_size_nr(eb, slot);
|
|
if (item_size < sizeof(root_item))
|
|
goto skip;
|
|
|
|
read_extent_buffer(eb, &root_item,
|
|
btrfs_item_ptr_offset(eb, slot),
|
|
(int)sizeof(root_item));
|
|
if (btrfs_root_refs(&root_item) == 0)
|
|
goto skip;
|
|
|
|
if (!btrfs_is_empty_uuid(root_item.uuid) ||
|
|
!btrfs_is_empty_uuid(root_item.received_uuid)) {
|
|
if (trans)
|
|
goto update_tree;
|
|
|
|
btrfs_release_path(path);
|
|
/*
|
|
* 1 - subvol uuid item
|
|
* 1 - received_subvol uuid item
|
|
*/
|
|
trans = btrfs_start_transaction(fs_info->uuid_root, 2);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
break;
|
|
}
|
|
continue;
|
|
} else {
|
|
goto skip;
|
|
}
|
|
update_tree:
|
|
if (!btrfs_is_empty_uuid(root_item.uuid)) {
|
|
ret = btrfs_uuid_tree_add(trans, fs_info,
|
|
root_item.uuid,
|
|
BTRFS_UUID_KEY_SUBVOL,
|
|
key.objectid);
|
|
if (ret < 0) {
|
|
btrfs_warn(fs_info, "uuid_tree_add failed %d",
|
|
ret);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!btrfs_is_empty_uuid(root_item.received_uuid)) {
|
|
ret = btrfs_uuid_tree_add(trans, fs_info,
|
|
root_item.received_uuid,
|
|
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
|
|
key.objectid);
|
|
if (ret < 0) {
|
|
btrfs_warn(fs_info, "uuid_tree_add failed %d",
|
|
ret);
|
|
break;
|
|
}
|
|
}
|
|
|
|
skip:
|
|
if (trans) {
|
|
ret = btrfs_end_transaction(trans);
|
|
trans = NULL;
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
btrfs_release_path(path);
|
|
if (key.offset < (u64)-1) {
|
|
key.offset++;
|
|
} else if (key.type < BTRFS_ROOT_ITEM_KEY) {
|
|
key.offset = 0;
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
|
} else if (key.objectid < (u64)-1) {
|
|
key.offset = 0;
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
|
key.objectid++;
|
|
} else {
|
|
break;
|
|
}
|
|
cond_resched();
|
|
}
|
|
|
|
out:
|
|
btrfs_free_path(path);
|
|
if (trans && !IS_ERR(trans))
|
|
btrfs_end_transaction(trans);
|
|
if (ret)
|
|
btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
|
|
else
|
|
set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Callback for btrfs_uuid_tree_iterate().
|
|
* returns:
|
|
* 0 check succeeded, the entry is not outdated.
|
|
* < 0 if an error occurred.
|
|
* > 0 if the check failed, which means the caller shall remove the entry.
|
|
*/
|
|
static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
|
|
u8 *uuid, u8 type, u64 subid)
|
|
{
|
|
struct btrfs_key key;
|
|
int ret = 0;
|
|
struct btrfs_root *subvol_root;
|
|
|
|
if (type != BTRFS_UUID_KEY_SUBVOL &&
|
|
type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
|
|
goto out;
|
|
|
|
key.objectid = subid;
|
|
key.type = BTRFS_ROOT_ITEM_KEY;
|
|
key.offset = (u64)-1;
|
|
subvol_root = btrfs_read_fs_root_no_name(fs_info, &key);
|
|
if (IS_ERR(subvol_root)) {
|
|
ret = PTR_ERR(subvol_root);
|
|
if (ret == -ENOENT)
|
|
ret = 1;
|
|
goto out;
|
|
}
|
|
|
|
switch (type) {
|
|
case BTRFS_UUID_KEY_SUBVOL:
|
|
if (memcmp(uuid, subvol_root->root_item.uuid, BTRFS_UUID_SIZE))
|
|
ret = 1;
|
|
break;
|
|
case BTRFS_UUID_KEY_RECEIVED_SUBVOL:
|
|
if (memcmp(uuid, subvol_root->root_item.received_uuid,
|
|
BTRFS_UUID_SIZE))
|
|
ret = 1;
|
|
break;
|
|
}
|
|
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_uuid_rescan_kthread(void *data)
|
|
{
|
|
struct btrfs_fs_info *fs_info = (struct btrfs_fs_info *)data;
|
|
int ret;
|
|
|
|
/*
|
|
* 1st step is to iterate through the existing UUID tree and
|
|
* to delete all entries that contain outdated data.
|
|
* 2nd step is to add all missing entries to the UUID tree.
|
|
*/
|
|
ret = btrfs_uuid_tree_iterate(fs_info, btrfs_check_uuid_tree_entry);
|
|
if (ret < 0) {
|
|
btrfs_warn(fs_info, "iterating uuid_tree failed %d", ret);
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
return ret;
|
|
}
|
|
return btrfs_uuid_scan_kthread(data);
|
|
}
|
|
|
|
int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_trans_handle *trans;
|
|
struct btrfs_root *tree_root = fs_info->tree_root;
|
|
struct btrfs_root *uuid_root;
|
|
struct task_struct *task;
|
|
int ret;
|
|
|
|
/*
|
|
* 1 - root node
|
|
* 1 - root item
|
|
*/
|
|
trans = btrfs_start_transaction(tree_root, 2);
|
|
if (IS_ERR(trans))
|
|
return PTR_ERR(trans);
|
|
|
|
uuid_root = btrfs_create_tree(trans, fs_info,
|
|
BTRFS_UUID_TREE_OBJECTID);
|
|
if (IS_ERR(uuid_root)) {
|
|
ret = PTR_ERR(uuid_root);
|
|
btrfs_abort_transaction(trans, ret);
|
|
btrfs_end_transaction(trans);
|
|
return ret;
|
|
}
|
|
|
|
fs_info->uuid_root = uuid_root;
|
|
|
|
ret = btrfs_commit_transaction(trans);
|
|
if (ret)
|
|
return ret;
|
|
|
|
down(&fs_info->uuid_tree_rescan_sem);
|
|
task = kthread_run(btrfs_uuid_scan_kthread, fs_info, "btrfs-uuid");
|
|
if (IS_ERR(task)) {
|
|
/* fs_info->update_uuid_tree_gen remains 0 in all error case */
|
|
btrfs_warn(fs_info, "failed to start uuid_scan task");
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
return PTR_ERR(task);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int btrfs_check_uuid_tree(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct task_struct *task;
|
|
|
|
down(&fs_info->uuid_tree_rescan_sem);
|
|
task = kthread_run(btrfs_uuid_rescan_kthread, fs_info, "btrfs-uuid");
|
|
if (IS_ERR(task)) {
|
|
/* fs_info->update_uuid_tree_gen remains 0 in all error case */
|
|
btrfs_warn(fs_info, "failed to start uuid_rescan task");
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
return PTR_ERR(task);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* shrinking a device means finding all of the device extents past
|
|
* the new size, and then following the back refs to the chunks.
|
|
* The chunk relocation code actually frees the device extent
|
|
*/
|
|
int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
struct btrfs_root *root = fs_info->dev_root;
|
|
struct btrfs_trans_handle *trans;
|
|
struct btrfs_dev_extent *dev_extent = NULL;
|
|
struct btrfs_path *path;
|
|
u64 length;
|
|
u64 chunk_offset;
|
|
int ret;
|
|
int slot;
|
|
int failed = 0;
|
|
bool retried = false;
|
|
bool checked_pending_chunks = false;
|
|
struct extent_buffer *l;
|
|
struct btrfs_key key;
|
|
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;
|
|
|
|
if (device->is_tgtdev_for_dev_replace)
|
|
return -EINVAL;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
|
|
path->reada = READA_FORWARD;
|
|
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
|
|
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);
|
|
}
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
|
|
again:
|
|
key.objectid = device->devid;
|
|
key.offset = (u64)-1;
|
|
key.type = BTRFS_DEV_EXTENT_KEY;
|
|
|
|
do {
|
|
mutex_lock(&fs_info->delete_unused_bgs_mutex);
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
if (ret < 0) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
goto done;
|
|
}
|
|
|
|
ret = btrfs_previous_item(root, path, 0, key.type);
|
|
if (ret)
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
if (ret < 0)
|
|
goto done;
|
|
if (ret) {
|
|
ret = 0;
|
|
btrfs_release_path(path);
|
|
break;
|
|
}
|
|
|
|
l = path->nodes[0];
|
|
slot = path->slots[0];
|
|
btrfs_item_key_to_cpu(l, &key, path->slots[0]);
|
|
|
|
if (key.objectid != device->devid) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
btrfs_release_path(path);
|
|
break;
|
|
}
|
|
|
|
dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
|
|
length = btrfs_dev_extent_length(l, dev_extent);
|
|
|
|
if (key.offset + length <= new_size) {
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
btrfs_release_path(path);
|
|
break;
|
|
}
|
|
|
|
chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent);
|
|
btrfs_release_path(path);
|
|
|
|
ret = btrfs_relocate_chunk(fs_info, chunk_offset);
|
|
mutex_unlock(&fs_info->delete_unused_bgs_mutex);
|
|
if (ret && ret != -ENOSPC)
|
|
goto done;
|
|
if (ret == -ENOSPC)
|
|
failed++;
|
|
} while (key.offset-- > 0);
|
|
|
|
if (failed && !retried) {
|
|
failed = 0;
|
|
retried = true;
|
|
goto again;
|
|
} else if (failed && retried) {
|
|
ret = -ENOSPC;
|
|
goto done;
|
|
}
|
|
|
|
/* Shrinking succeeded, else we would be at "done". */
|
|
trans = btrfs_start_transaction(root, 0);
|
|
if (IS_ERR(trans)) {
|
|
ret = PTR_ERR(trans);
|
|
goto done;
|
|
}
|
|
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
|
|
/*
|
|
* We checked in the above loop all device extents that were already in
|
|
* the device tree. However before we have updated the device's
|
|
* total_bytes to the new size, we might have had chunk allocations that
|
|
* have not complete yet (new block groups attached to transaction
|
|
* handles), and therefore their device extents were not yet in the
|
|
* device tree and we missed them in the loop above. So if we have any
|
|
* pending chunk using a device extent that overlaps the device range
|
|
* that we can not use anymore, commit the current transaction and
|
|
* repeat the search on the device tree - this way we guarantee we will
|
|
* not have chunks using device extents that end beyond 'new_size'.
|
|
*/
|
|
if (!checked_pending_chunks) {
|
|
u64 start = new_size;
|
|
u64 len = old_size - new_size;
|
|
|
|
if (contains_pending_extent(trans->transaction, device,
|
|
&start, len)) {
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
checked_pending_chunks = true;
|
|
failed = 0;
|
|
retried = false;
|
|
ret = btrfs_commit_transaction(trans);
|
|
if (ret)
|
|
goto done;
|
|
goto again;
|
|
}
|
|
}
|
|
|
|
btrfs_device_set_disk_total_bytes(device, new_size);
|
|
if (list_empty(&device->resized_list))
|
|
list_add_tail(&device->resized_list,
|
|
&fs_info->fs_devices->resized_devices);
|
|
|
|
WARN_ON(diff > old_total);
|
|
btrfs_set_super_total_bytes(super_copy, old_total - diff);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
|
|
/* Now btrfs_update_device() will change the on-disk size. */
|
|
ret = btrfs_update_device(trans, device);
|
|
btrfs_end_transaction(trans);
|
|
done:
|
|
btrfs_free_path(path);
|
|
if (ret) {
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
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);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_key *key,
|
|
struct btrfs_chunk *chunk, int item_size)
|
|
{
|
|
struct btrfs_super_block *super_copy = fs_info->super_copy;
|
|
struct btrfs_disk_key disk_key;
|
|
u32 array_size;
|
|
u8 *ptr;
|
|
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
array_size = btrfs_super_sys_array_size(super_copy);
|
|
if (array_size + item_size + sizeof(disk_key)
|
|
> BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
return -EFBIG;
|
|
}
|
|
|
|
ptr = super_copy->sys_chunk_array + array_size;
|
|
btrfs_cpu_key_to_disk(&disk_key, key);
|
|
memcpy(ptr, &disk_key, sizeof(disk_key));
|
|
ptr += sizeof(disk_key);
|
|
memcpy(ptr, chunk, item_size);
|
|
item_size += sizeof(disk_key);
|
|
btrfs_set_super_sys_array_size(super_copy, array_size + item_size);
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* sort the devices in descending order by max_avail, total_avail
|
|
*/
|
|
static int btrfs_cmp_device_info(const void *a, const void *b)
|
|
{
|
|
const struct btrfs_device_info *di_a = a;
|
|
const struct btrfs_device_info *di_b = b;
|
|
|
|
if (di_a->max_avail > di_b->max_avail)
|
|
return -1;
|
|
if (di_a->max_avail < di_b->max_avail)
|
|
return 1;
|
|
if (di_a->total_avail > di_b->total_avail)
|
|
return -1;
|
|
if (di_a->total_avail < di_b->total_avail)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static u32 find_raid56_stripe_len(u32 data_devices, u32 dev_stripe_target)
|
|
{
|
|
/* TODO allow them to set a preferred stripe size */
|
|
return SZ_64K;
|
|
}
|
|
|
|
static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type)
|
|
{
|
|
if (!(type & BTRFS_BLOCK_GROUP_RAID56_MASK))
|
|
return;
|
|
|
|
btrfs_set_fs_incompat(info, RAID56);
|
|
}
|
|
|
|
#define BTRFS_MAX_DEVS(r) ((BTRFS_MAX_ITEM_SIZE(r->fs_info) \
|
|
- sizeof(struct btrfs_chunk)) \
|
|
/ sizeof(struct btrfs_stripe) + 1)
|
|
|
|
#define BTRFS_MAX_DEVS_SYS_CHUNK ((BTRFS_SYSTEM_CHUNK_ARRAY_SIZE \
|
|
- 2 * sizeof(struct btrfs_disk_key) \
|
|
- 2 * sizeof(struct btrfs_chunk)) \
|
|
/ sizeof(struct btrfs_stripe) + 1)
|
|
|
|
static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
|
|
u64 start, u64 type)
|
|
{
|
|
struct btrfs_fs_info *info = trans->fs_info;
|
|
struct btrfs_fs_devices *fs_devices = info->fs_devices;
|
|
struct list_head *cur;
|
|
struct map_lookup *map = NULL;
|
|
struct extent_map_tree *em_tree;
|
|
struct extent_map *em;
|
|
struct btrfs_device_info *devices_info = NULL;
|
|
u64 total_avail;
|
|
int num_stripes; /* total number of stripes to allocate */
|
|
int data_stripes; /* number of stripes that count for
|
|
block group size */
|
|
int sub_stripes; /* sub_stripes info for map */
|
|
int dev_stripes; /* stripes per dev */
|
|
int devs_max; /* max devs to use */
|
|
int devs_min; /* min devs needed */
|
|
int devs_increment; /* ndevs has to be a multiple of this */
|
|
int ncopies; /* how many copies to data has */
|
|
int ret;
|
|
u64 max_stripe_size;
|
|
u64 max_chunk_size;
|
|
u64 stripe_size;
|
|
u64 num_bytes;
|
|
u64 raid_stripe_len = BTRFS_STRIPE_LEN;
|
|
int ndevs;
|
|
int i;
|
|
int j;
|
|
int index;
|
|
|
|
BUG_ON(!alloc_profile_is_valid(type, 0));
|
|
|
|
if (list_empty(&fs_devices->alloc_list))
|
|
return -ENOSPC;
|
|
|
|
index = __get_raid_index(type);
|
|
|
|
sub_stripes = btrfs_raid_array[index].sub_stripes;
|
|
dev_stripes = btrfs_raid_array[index].dev_stripes;
|
|
devs_max = btrfs_raid_array[index].devs_max;
|
|
devs_min = btrfs_raid_array[index].devs_min;
|
|
devs_increment = btrfs_raid_array[index].devs_increment;
|
|
ncopies = btrfs_raid_array[index].ncopies;
|
|
|
|
if (type & BTRFS_BLOCK_GROUP_DATA) {
|
|
max_stripe_size = SZ_1G;
|
|
max_chunk_size = 10 * max_stripe_size;
|
|
if (!devs_max)
|
|
devs_max = BTRFS_MAX_DEVS(info->chunk_root);
|
|
} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
|
|
/* for larger filesystems, use larger metadata chunks */
|
|
if (fs_devices->total_rw_bytes > 50ULL * SZ_1G)
|
|
max_stripe_size = SZ_1G;
|
|
else
|
|
max_stripe_size = SZ_256M;
|
|
max_chunk_size = max_stripe_size;
|
|
if (!devs_max)
|
|
devs_max = BTRFS_MAX_DEVS(info->chunk_root);
|
|
} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
max_stripe_size = SZ_32M;
|
|
max_chunk_size = 2 * max_stripe_size;
|
|
if (!devs_max)
|
|
devs_max = BTRFS_MAX_DEVS_SYS_CHUNK;
|
|
} else {
|
|
btrfs_err(info, "invalid chunk type 0x%llx requested",
|
|
type);
|
|
BUG_ON(1);
|
|
}
|
|
|
|
/* we don't want a chunk larger than 10% of writeable space */
|
|
max_chunk_size = min(div_factor(fs_devices->total_rw_bytes, 1),
|
|
max_chunk_size);
|
|
|
|
devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info),
|
|
GFP_NOFS);
|
|
if (!devices_info)
|
|
return -ENOMEM;
|
|
|
|
cur = fs_devices->alloc_list.next;
|
|
|
|
/*
|
|
* in the first pass through the devices list, we gather information
|
|
* about the available holes on each device.
|
|
*/
|
|
ndevs = 0;
|
|
while (cur != &fs_devices->alloc_list) {
|
|
struct btrfs_device *device;
|
|
u64 max_avail;
|
|
u64 dev_offset;
|
|
|
|
device = list_entry(cur, struct btrfs_device, dev_alloc_list);
|
|
|
|
cur = cur->next;
|
|
|
|
if (!device->writeable) {
|
|
WARN(1, KERN_ERR
|
|
"BTRFS: read-only device in alloc_list\n");
|
|
continue;
|
|
}
|
|
|
|
if (!device->in_fs_metadata ||
|
|
device->is_tgtdev_for_dev_replace)
|
|
continue;
|
|
|
|
if (device->total_bytes > device->bytes_used)
|
|
total_avail = device->total_bytes - device->bytes_used;
|
|
else
|
|
total_avail = 0;
|
|
|
|
/* If there is no space on this device, skip it. */
|
|
if (total_avail == 0)
|
|
continue;
|
|
|
|
ret = find_free_dev_extent(trans, device,
|
|
max_stripe_size * dev_stripes,
|
|
&dev_offset, &max_avail);
|
|
if (ret && ret != -ENOSPC)
|
|
goto error;
|
|
|
|
if (ret == 0)
|
|
max_avail = max_stripe_size * dev_stripes;
|
|
|
|
if (max_avail < BTRFS_STRIPE_LEN * dev_stripes)
|
|
continue;
|
|
|
|
if (ndevs == fs_devices->rw_devices) {
|
|
WARN(1, "%s: found more than %llu devices\n",
|
|
__func__, fs_devices->rw_devices);
|
|
break;
|
|
}
|
|
devices_info[ndevs].dev_offset = dev_offset;
|
|
devices_info[ndevs].max_avail = max_avail;
|
|
devices_info[ndevs].total_avail = total_avail;
|
|
devices_info[ndevs].dev = device;
|
|
++ndevs;
|
|
}
|
|
|
|
/*
|
|
* now sort the devices by hole size / available space
|
|
*/
|
|
sort(devices_info, ndevs, sizeof(struct btrfs_device_info),
|
|
btrfs_cmp_device_info, NULL);
|
|
|
|
/* round down to number of usable stripes */
|
|
ndevs -= ndevs % devs_increment;
|
|
|
|
if (ndevs < devs_increment * sub_stripes || ndevs < devs_min) {
|
|
ret = -ENOSPC;
|
|
goto error;
|
|
}
|
|
|
|
if (devs_max && ndevs > devs_max)
|
|
ndevs = devs_max;
|
|
/*
|
|
* the primary goal is to maximize the number of stripes, so use as many
|
|
* devices as possible, even if the stripes are not maximum sized.
|
|
*/
|
|
stripe_size = devices_info[ndevs-1].max_avail;
|
|
num_stripes = ndevs * dev_stripes;
|
|
|
|
/*
|
|
* this will have to be fixed for RAID1 and RAID10 over
|
|
* more drives
|
|
*/
|
|
data_stripes = num_stripes / ncopies;
|
|
|
|
if (type & BTRFS_BLOCK_GROUP_RAID5) {
|
|
raid_stripe_len = find_raid56_stripe_len(ndevs - 1,
|
|
info->stripesize);
|
|
data_stripes = num_stripes - 1;
|
|
}
|
|
if (type & BTRFS_BLOCK_GROUP_RAID6) {
|
|
raid_stripe_len = find_raid56_stripe_len(ndevs - 2,
|
|
info->stripesize);
|
|
data_stripes = num_stripes - 2;
|
|
}
|
|
|
|
/*
|
|
* Use the number of data stripes to figure out how big this chunk
|
|
* is really going to be in terms of logical address space,
|
|
* and compare that answer with the max chunk size
|
|
*/
|
|
if (stripe_size * data_stripes > max_chunk_size) {
|
|
u64 mask = (1ULL << 24) - 1;
|
|
|
|
stripe_size = div_u64(max_chunk_size, data_stripes);
|
|
|
|
/* bump the answer up to a 16MB boundary */
|
|
stripe_size = (stripe_size + mask) & ~mask;
|
|
|
|
/* but don't go higher than the limits we found
|
|
* while searching for free extents
|
|
*/
|
|
if (stripe_size > devices_info[ndevs-1].max_avail)
|
|
stripe_size = devices_info[ndevs-1].max_avail;
|
|
}
|
|
|
|
stripe_size = div_u64(stripe_size, dev_stripes);
|
|
|
|
/* align to BTRFS_STRIPE_LEN */
|
|
stripe_size = div64_u64(stripe_size, raid_stripe_len);
|
|
stripe_size *= raid_stripe_len;
|
|
|
|
map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
|
|
if (!map) {
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
map->num_stripes = num_stripes;
|
|
|
|
for (i = 0; i < ndevs; ++i) {
|
|
for (j = 0; j < dev_stripes; ++j) {
|
|
int s = i * dev_stripes + j;
|
|
map->stripes[s].dev = devices_info[i].dev;
|
|
map->stripes[s].physical = devices_info[i].dev_offset +
|
|
j * stripe_size;
|
|
}
|
|
}
|
|
map->sector_size = info->sectorsize;
|
|
map->stripe_len = raid_stripe_len;
|
|
map->io_align = raid_stripe_len;
|
|
map->io_width = raid_stripe_len;
|
|
map->type = type;
|
|
map->sub_stripes = sub_stripes;
|
|
|
|
num_bytes = stripe_size * data_stripes;
|
|
|
|
trace_btrfs_chunk_alloc(info, map, start, num_bytes);
|
|
|
|
em = alloc_extent_map();
|
|
if (!em) {
|
|
kfree(map);
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags);
|
|
em->map_lookup = map;
|
|
em->start = start;
|
|
em->len = num_bytes;
|
|
em->block_start = 0;
|
|
em->block_len = em->len;
|
|
em->orig_block_len = stripe_size;
|
|
|
|
em_tree = &info->mapping_tree.map_tree;
|
|
write_lock(&em_tree->lock);
|
|
ret = add_extent_mapping(em_tree, em, 0);
|
|
if (!ret) {
|
|
list_add_tail(&em->list, &trans->transaction->pending_chunks);
|
|
refcount_inc(&em->refs);
|
|
}
|
|
write_unlock(&em_tree->lock);
|
|
if (ret) {
|
|
free_extent_map(em);
|
|
goto error;
|
|
}
|
|
|
|
ret = btrfs_make_block_group(trans, info, 0, type,
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
start, num_bytes);
|
|
if (ret)
|
|
goto error_del_extent;
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
num_bytes = map->stripes[i].dev->bytes_used + stripe_size;
|
|
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);
|
|
|
|
free_extent_map(em);
|
|
check_raid56_incompat_flag(info, type);
|
|
|
|
kfree(devices_info);
|
|
return 0;
|
|
|
|
error_del_extent:
|
|
write_lock(&em_tree->lock);
|
|
remove_extent_mapping(em_tree, em);
|
|
write_unlock(&em_tree->lock);
|
|
|
|
/* One for our allocation */
|
|
free_extent_map(em);
|
|
/* One for the tree reference */
|
|
free_extent_map(em);
|
|
/* One for the pending_chunks list reference */
|
|
free_extent_map(em);
|
|
error:
|
|
kfree(devices_info);
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info,
|
|
u64 chunk_offset, u64 chunk_size)
|
|
{
|
|
struct btrfs_root *extent_root = fs_info->extent_root;
|
|
struct btrfs_root *chunk_root = fs_info->chunk_root;
|
|
struct btrfs_key key;
|
|
struct btrfs_device *device;
|
|
struct btrfs_chunk *chunk;
|
|
struct btrfs_stripe *stripe;
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
size_t item_size;
|
|
u64 dev_offset;
|
|
u64 stripe_size;
|
|
int i = 0;
|
|
int ret = 0;
|
|
|
|
em = get_chunk_map(fs_info, chunk_offset, chunk_size);
|
|
if (IS_ERR(em))
|
|
return PTR_ERR(em);
|
|
|
|
map = em->map_lookup;
|
|
item_size = btrfs_chunk_item_size(map->num_stripes);
|
|
stripe_size = em->orig_block_len;
|
|
|
|
chunk = kzalloc(item_size, GFP_NOFS);
|
|
if (!chunk) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Take the device list mutex to prevent races with the final phase of
|
|
* a device replace operation that replaces the device object associated
|
|
* with the map's stripes, because the device object's id can change
|
|
* at any time during that final phase of the device replace operation
|
|
* (dev-replace.c:btrfs_dev_replace_finishing()).
|
|
*/
|
|
mutex_lock(&fs_info->fs_devices->device_list_mutex);
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
device = map->stripes[i].dev;
|
|
dev_offset = map->stripes[i].physical;
|
|
|
|
ret = btrfs_update_device(trans, device);
|
|
if (ret)
|
|
break;
|
|
ret = btrfs_alloc_dev_extent(trans, device,
|
|
chunk_root->root_key.objectid,
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
chunk_offset, dev_offset,
|
|
stripe_size);
|
|
if (ret)
|
|
break;
|
|
}
|
|
if (ret) {
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
goto out;
|
|
}
|
|
|
|
stripe = &chunk->stripe;
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
device = map->stripes[i].dev;
|
|
dev_offset = map->stripes[i].physical;
|
|
|
|
btrfs_set_stack_stripe_devid(stripe, device->devid);
|
|
btrfs_set_stack_stripe_offset(stripe, dev_offset);
|
|
memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE);
|
|
stripe++;
|
|
}
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
btrfs_set_stack_chunk_length(chunk, chunk_size);
|
|
btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
|
|
btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len);
|
|
btrfs_set_stack_chunk_type(chunk, map->type);
|
|
btrfs_set_stack_chunk_num_stripes(chunk, map->num_stripes);
|
|
btrfs_set_stack_chunk_io_align(chunk, map->stripe_len);
|
|
btrfs_set_stack_chunk_io_width(chunk, map->stripe_len);
|
|
btrfs_set_stack_chunk_sector_size(chunk, fs_info->sectorsize);
|
|
btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
|
|
|
|
key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
|
|
key.type = BTRFS_CHUNK_ITEM_KEY;
|
|
key.offset = chunk_offset;
|
|
|
|
ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
|
|
if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
/*
|
|
* TODO: Cleanup of inserted chunk root in case of
|
|
* failure.
|
|
*/
|
|
ret = btrfs_add_system_chunk(fs_info, &key, chunk, item_size);
|
|
}
|
|
|
|
out:
|
|
kfree(chunk);
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Chunk allocation falls into two parts. The first part does works
|
|
* that make the new allocated chunk useable, but not do any operation
|
|
* that modifies the chunk tree. The second part does the works that
|
|
* 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)
|
|
{
|
|
u64 chunk_offset;
|
|
|
|
ASSERT(mutex_is_locked(&fs_info->chunk_mutex));
|
|
chunk_offset = find_next_chunk(fs_info);
|
|
return __btrfs_alloc_chunk(trans, chunk_offset, type);
|
|
}
|
|
|
|
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);
|
|
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);
|
|
ret = __btrfs_alloc_chunk(trans, sys_chunk_offset, alloc_profile);
|
|
return ret;
|
|
}
|
|
|
|
static inline int btrfs_chunk_max_errors(struct map_lookup *map)
|
|
{
|
|
int max_errors;
|
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
|
|
BTRFS_BLOCK_GROUP_RAID10 |
|
|
BTRFS_BLOCK_GROUP_RAID5 |
|
|
BTRFS_BLOCK_GROUP_DUP)) {
|
|
max_errors = 1;
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID6) {
|
|
max_errors = 2;
|
|
} else {
|
|
max_errors = 0;
|
|
}
|
|
|
|
return max_errors;
|
|
}
|
|
|
|
int btrfs_chunk_readonly(struct btrfs_fs_info *fs_info, u64 chunk_offset)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
int readonly = 0;
|
|
int miss_ndevs = 0;
|
|
int i;
|
|
|
|
em = get_chunk_map(fs_info, chunk_offset, 1);
|
|
if (IS_ERR(em))
|
|
return 1;
|
|
|
|
map = em->map_lookup;
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
if (map->stripes[i].dev->missing) {
|
|
miss_ndevs++;
|
|
continue;
|
|
}
|
|
|
|
if (!map->stripes[i].dev->writeable) {
|
|
readonly = 1;
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the number of missing devices is larger than max errors,
|
|
* we can not write the data into that chunk successfully, so
|
|
* set it readonly.
|
|
*/
|
|
if (miss_ndevs > btrfs_chunk_max_errors(map))
|
|
readonly = 1;
|
|
end:
|
|
free_extent_map(em);
|
|
return readonly;
|
|
}
|
|
|
|
void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
|
|
{
|
|
extent_map_tree_init(&tree->map_tree);
|
|
}
|
|
|
|
void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
|
|
{
|
|
struct extent_map *em;
|
|
|
|
while (1) {
|
|
write_lock(&tree->map_tree.lock);
|
|
em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
|
|
if (em)
|
|
remove_extent_mapping(&tree->map_tree, em);
|
|
write_unlock(&tree->map_tree.lock);
|
|
if (!em)
|
|
break;
|
|
/* once for us */
|
|
free_extent_map(em);
|
|
/* once for the tree */
|
|
free_extent_map(em);
|
|
}
|
|
}
|
|
|
|
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
int ret;
|
|
|
|
em = get_chunk_map(fs_info, logical, len);
|
|
if (IS_ERR(em))
|
|
/*
|
|
* We could return errors for these cases, but that could get
|
|
* ugly and we'd probably do the same thing which is just not do
|
|
* anything else and exit, so return 1 so the callers don't try
|
|
* to use other copies.
|
|
*/
|
|
return 1;
|
|
|
|
map = em->map_lookup;
|
|
if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1))
|
|
ret = map->num_stripes;
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID10)
|
|
ret = map->sub_stripes;
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID5)
|
|
ret = 2;
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID6)
|
|
ret = 3;
|
|
else
|
|
ret = 1;
|
|
free_extent_map(em);
|
|
|
|
btrfs_dev_replace_lock(&fs_info->dev_replace, 0);
|
|
if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace) &&
|
|
fs_info->dev_replace.tgtdev)
|
|
ret++;
|
|
btrfs_dev_replace_unlock(&fs_info->dev_replace, 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_mapping_tree *map_tree,
|
|
u64 logical)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
unsigned long len = fs_info->sectorsize;
|
|
|
|
em = get_chunk_map(fs_info, logical, len);
|
|
WARN_ON(IS_ERR(em));
|
|
|
|
map = em->map_lookup;
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)
|
|
len = map->stripe_len * nr_data_stripes(map);
|
|
free_extent_map(em);
|
|
return len;
|
|
}
|
|
|
|
int btrfs_is_parity_mirror(struct btrfs_fs_info *fs_info,
|
|
u64 logical, u64 len, int mirror_num)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
int ret = 0;
|
|
|
|
em = get_chunk_map(fs_info, logical, len);
|
|
WARN_ON(IS_ERR(em));
|
|
|
|
map = em->map_lookup;
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK)
|
|
ret = 1;
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
static int find_live_mirror(struct btrfs_fs_info *fs_info,
|
|
struct map_lookup *map, int first, int num,
|
|
int optimal, int dev_replace_is_ongoing)
|
|
{
|
|
int i;
|
|
int tolerance;
|
|
struct btrfs_device *srcdev;
|
|
|
|
if (dev_replace_is_ongoing &&
|
|
fs_info->dev_replace.cont_reading_from_srcdev_mode ==
|
|
BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID)
|
|
srcdev = fs_info->dev_replace.srcdev;
|
|
else
|
|
srcdev = NULL;
|
|
|
|
/*
|
|
* try to avoid the drive that is the source drive for a
|
|
* dev-replace procedure, only choose it if no other non-missing
|
|
* mirror is available
|
|
*/
|
|
for (tolerance = 0; tolerance < 2; tolerance++) {
|
|
if (map->stripes[optimal].dev->bdev &&
|
|
(tolerance || map->stripes[optimal].dev != srcdev))
|
|
return optimal;
|
|
for (i = first; i < first + num; i++) {
|
|
if (map->stripes[i].dev->bdev &&
|
|
(tolerance || map->stripes[i].dev != srcdev))
|
|
return i;
|
|
}
|
|
}
|
|
|
|
/* we couldn't find one that doesn't fail. Just return something
|
|
* and the io error handling code will clean up eventually
|
|
*/
|
|
return optimal;
|
|
}
|
|
|
|
static inline int parity_smaller(u64 a, u64 b)
|
|
{
|
|
return a > b;
|
|
}
|
|
|
|
/* Bubble-sort the stripe set to put the parity/syndrome stripes last */
|
|
static void sort_parity_stripes(struct btrfs_bio *bbio, int num_stripes)
|
|
{
|
|
struct btrfs_bio_stripe s;
|
|
int i;
|
|
u64 l;
|
|
int again = 1;
|
|
|
|
while (again) {
|
|
again = 0;
|
|
for (i = 0; i < num_stripes - 1; i++) {
|
|
if (parity_smaller(bbio->raid_map[i],
|
|
bbio->raid_map[i+1])) {
|
|
s = bbio->stripes[i];
|
|
l = bbio->raid_map[i];
|
|
bbio->stripes[i] = bbio->stripes[i+1];
|
|
bbio->raid_map[i] = bbio->raid_map[i+1];
|
|
bbio->stripes[i+1] = s;
|
|
bbio->raid_map[i+1] = l;
|
|
|
|
again = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static struct btrfs_bio *alloc_btrfs_bio(int total_stripes, int real_stripes)
|
|
{
|
|
struct btrfs_bio *bbio = kzalloc(
|
|
/* the size of the btrfs_bio */
|
|
sizeof(struct btrfs_bio) +
|
|
/* plus the variable array for the stripes */
|
|
sizeof(struct btrfs_bio_stripe) * (total_stripes) +
|
|
/* plus the variable array for the tgt dev */
|
|
sizeof(int) * (real_stripes) +
|
|
/*
|
|
* plus the raid_map, which includes both the tgt dev
|
|
* and the stripes
|
|
*/
|
|
sizeof(u64) * (total_stripes),
|
|
GFP_NOFS|__GFP_NOFAIL);
|
|
|
|
atomic_set(&bbio->error, 0);
|
|
refcount_set(&bbio->refs, 1);
|
|
|
|
return bbio;
|
|
}
|
|
|
|
void btrfs_get_bbio(struct btrfs_bio *bbio)
|
|
{
|
|
WARN_ON(!refcount_read(&bbio->refs));
|
|
refcount_inc(&bbio->refs);
|
|
}
|
|
|
|
void btrfs_put_bbio(struct btrfs_bio *bbio)
|
|
{
|
|
if (!bbio)
|
|
return;
|
|
if (refcount_dec_and_test(&bbio->refs))
|
|
kfree(bbio);
|
|
}
|
|
|
|
/* can REQ_OP_DISCARD be sent with other REQ like REQ_OP_WRITE? */
|
|
/*
|
|
* Please note that, discard won't be sent to target device of device
|
|
* replace.
|
|
*/
|
|
static int __btrfs_map_block_for_discard(struct btrfs_fs_info *fs_info,
|
|
u64 logical, u64 length,
|
|
struct btrfs_bio **bbio_ret)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
struct btrfs_bio *bbio;
|
|
u64 offset;
|
|
u64 stripe_nr;
|
|
u64 stripe_nr_end;
|
|
u64 stripe_end_offset;
|
|
u64 stripe_cnt;
|
|
u64 stripe_len;
|
|
u64 stripe_offset;
|
|
u64 num_stripes;
|
|
u32 stripe_index;
|
|
u32 factor = 0;
|
|
u32 sub_stripes = 0;
|
|
u64 stripes_per_dev = 0;
|
|
u32 remaining_stripes = 0;
|
|
u32 last_stripe = 0;
|
|
int ret = 0;
|
|
int i;
|
|
|
|
/* discard always return a bbio */
|
|
ASSERT(bbio_ret);
|
|
|
|
em = get_chunk_map(fs_info, logical, length);
|
|
if (IS_ERR(em))
|
|
return PTR_ERR(em);
|
|
|
|
map = em->map_lookup;
|
|
/* we don't discard raid56 yet */
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
|
|
ret = -EOPNOTSUPP;
|
|
goto out;
|
|
}
|
|
|
|
offset = logical - em->start;
|
|
length = min_t(u64, em->len - offset, length);
|
|
|
|
stripe_len = map->stripe_len;
|
|
/*
|
|
* stripe_nr counts the total number of stripes we have to stride
|
|
* to get to this block
|
|
*/
|
|
stripe_nr = div64_u64(offset, stripe_len);
|
|
|
|
/* stripe_offset is the offset of this block in its stripe */
|
|
stripe_offset = offset - stripe_nr * stripe_len;
|
|
|
|
stripe_nr_end = round_up(offset + length, map->stripe_len);
|
|
stripe_nr_end = div64_u64(stripe_nr_end, map->stripe_len);
|
|
stripe_cnt = stripe_nr_end - stripe_nr;
|
|
stripe_end_offset = stripe_nr_end * map->stripe_len -
|
|
(offset + length);
|
|
/*
|
|
* after this, stripe_nr is the number of stripes on this
|
|
* device we have to walk to find the data, and stripe_index is
|
|
* the number of our device in the stripe array
|
|
*/
|
|
num_stripes = 1;
|
|
stripe_index = 0;
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
|
|
BTRFS_BLOCK_GROUP_RAID10)) {
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID0)
|
|
sub_stripes = 1;
|
|
else
|
|
sub_stripes = map->sub_stripes;
|
|
|
|
factor = map->num_stripes / sub_stripes;
|
|
num_stripes = min_t(u64, map->num_stripes,
|
|
sub_stripes * stripe_cnt);
|
|
stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index);
|
|
stripe_index *= sub_stripes;
|
|
stripes_per_dev = div_u64_rem(stripe_cnt, factor,
|
|
&remaining_stripes);
|
|
div_u64_rem(stripe_nr_end - 1, factor, &last_stripe);
|
|
last_stripe *= sub_stripes;
|
|
} else if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
|
|
BTRFS_BLOCK_GROUP_DUP)) {
|
|
num_stripes = map->num_stripes;
|
|
} else {
|
|
stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
|
|
&stripe_index);
|
|
}
|
|
|
|
bbio = alloc_btrfs_bio(num_stripes, 0);
|
|
if (!bbio) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
for (i = 0; i < num_stripes; i++) {
|
|
bbio->stripes[i].physical =
|
|
map->stripes[stripe_index].physical +
|
|
stripe_offset + stripe_nr * map->stripe_len;
|
|
bbio->stripes[i].dev = map->stripes[stripe_index].dev;
|
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
|
|
BTRFS_BLOCK_GROUP_RAID10)) {
|
|
bbio->stripes[i].length = stripes_per_dev *
|
|
map->stripe_len;
|
|
|
|
if (i / sub_stripes < remaining_stripes)
|
|
bbio->stripes[i].length +=
|
|
map->stripe_len;
|
|
|
|
/*
|
|
* Special for the first stripe and
|
|
* the last stripe:
|
|
*
|
|
* |-------|...|-------|
|
|
* |----------|
|
|
* off end_off
|
|
*/
|
|
if (i < sub_stripes)
|
|
bbio->stripes[i].length -=
|
|
stripe_offset;
|
|
|
|
if (stripe_index >= last_stripe &&
|
|
stripe_index <= (last_stripe +
|
|
sub_stripes - 1))
|
|
bbio->stripes[i].length -=
|
|
stripe_end_offset;
|
|
|
|
if (i == sub_stripes - 1)
|
|
stripe_offset = 0;
|
|
} else {
|
|
bbio->stripes[i].length = length;
|
|
}
|
|
|
|
stripe_index++;
|
|
if (stripe_index == map->num_stripes) {
|
|
stripe_index = 0;
|
|
stripe_nr++;
|
|
}
|
|
}
|
|
|
|
*bbio_ret = bbio;
|
|
bbio->map_type = map->type;
|
|
bbio->num_stripes = num_stripes;
|
|
out:
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* In dev-replace case, for repair case (that's the only case where the mirror
|
|
* is selected explicitly when calling btrfs_map_block), blocks left of the
|
|
* left cursor can also be read from the target drive.
|
|
*
|
|
* For REQ_GET_READ_MIRRORS, the target drive is added as the last one to the
|
|
* array of stripes.
|
|
* For READ, it also needs to be supported using the same mirror number.
|
|
*
|
|
* If the requested block is not left of the left cursor, EIO is returned. This
|
|
* can happen because btrfs_num_copies() returns one more in the dev-replace
|
|
* case.
|
|
*/
|
|
static int get_extra_mirror_from_replace(struct btrfs_fs_info *fs_info,
|
|
u64 logical, u64 length,
|
|
u64 srcdev_devid, int *mirror_num,
|
|
u64 *physical)
|
|
{
|
|
struct btrfs_bio *bbio = NULL;
|
|
int num_stripes;
|
|
int index_srcdev = 0;
|
|
int found = 0;
|
|
u64 physical_of_found = 0;
|
|
int i;
|
|
int ret = 0;
|
|
|
|
ret = __btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS,
|
|
logical, &length, &bbio, 0, 0);
|
|
if (ret) {
|
|
ASSERT(bbio == NULL);
|
|
return ret;
|
|
}
|
|
|
|
num_stripes = bbio->num_stripes;
|
|
if (*mirror_num > num_stripes) {
|
|
/*
|
|
* BTRFS_MAP_GET_READ_MIRRORS does not contain this mirror,
|
|
* that means that the requested area is not left of the left
|
|
* cursor
|
|
*/
|
|
btrfs_put_bbio(bbio);
|
|
return -EIO;
|
|
}
|
|
|
|
/*
|
|
* process the rest of the function using the mirror_num of the source
|
|
* drive. Therefore look it up first. At the end, patch the device
|
|
* pointer to the one of the target drive.
|
|
*/
|
|
for (i = 0; i < num_stripes; i++) {
|
|
if (bbio->stripes[i].dev->devid != srcdev_devid)
|
|
continue;
|
|
|
|
/*
|
|
* In case of DUP, in order to keep it simple, only add the
|
|
* mirror with the lowest physical address
|
|
*/
|
|
if (found &&
|
|
physical_of_found <= bbio->stripes[i].physical)
|
|
continue;
|
|
|
|
index_srcdev = i;
|
|
found = 1;
|
|
physical_of_found = bbio->stripes[i].physical;
|
|
}
|
|
|
|
btrfs_put_bbio(bbio);
|
|
|
|
ASSERT(found);
|
|
if (!found)
|
|
return -EIO;
|
|
|
|
*mirror_num = index_srcdev + 1;
|
|
*physical = physical_of_found;
|
|
return ret;
|
|
}
|
|
|
|
static void handle_ops_on_dev_replace(enum btrfs_map_op op,
|
|
struct btrfs_bio **bbio_ret,
|
|
struct btrfs_dev_replace *dev_replace,
|
|
int *num_stripes_ret, int *max_errors_ret)
|
|
{
|
|
struct btrfs_bio *bbio = *bbio_ret;
|
|
u64 srcdev_devid = dev_replace->srcdev->devid;
|
|
int tgtdev_indexes = 0;
|
|
int num_stripes = *num_stripes_ret;
|
|
int max_errors = *max_errors_ret;
|
|
int i;
|
|
|
|
if (op == BTRFS_MAP_WRITE) {
|
|
int index_where_to_add;
|
|
|
|
/*
|
|
* duplicate the write operations while the dev replace
|
|
* procedure is running. Since the copying of the old disk to
|
|
* the new disk takes place at run time while the filesystem is
|
|
* mounted writable, the regular write operations to the old
|
|
* disk have to be duplicated to go to the new disk as well.
|
|
*
|
|
* Note that device->missing is handled by the caller, and that
|
|
* the write to the old disk is already set up in the stripes
|
|
* array.
|
|
*/
|
|
index_where_to_add = num_stripes;
|
|
for (i = 0; i < num_stripes; i++) {
|
|
if (bbio->stripes[i].dev->devid == srcdev_devid) {
|
|
/* write to new disk, too */
|
|
struct btrfs_bio_stripe *new =
|
|
bbio->stripes + index_where_to_add;
|
|
struct btrfs_bio_stripe *old =
|
|
bbio->stripes + i;
|
|
|
|
new->physical = old->physical;
|
|
new->length = old->length;
|
|
new->dev = dev_replace->tgtdev;
|
|
bbio->tgtdev_map[i] = index_where_to_add;
|
|
index_where_to_add++;
|
|
max_errors++;
|
|
tgtdev_indexes++;
|
|
}
|
|
}
|
|
num_stripes = index_where_to_add;
|
|
} else if (op == BTRFS_MAP_GET_READ_MIRRORS) {
|
|
int index_srcdev = 0;
|
|
int found = 0;
|
|
u64 physical_of_found = 0;
|
|
|
|
/*
|
|
* During the dev-replace procedure, the target drive can also
|
|
* be used to read data in case it is needed to repair a corrupt
|
|
* block elsewhere. This is possible if the requested area is
|
|
* left of the left cursor. In this area, the target drive is a
|
|
* full copy of the source drive.
|
|
*/
|
|
for (i = 0; i < num_stripes; i++) {
|
|
if (bbio->stripes[i].dev->devid == srcdev_devid) {
|
|
/*
|
|
* In case of DUP, in order to keep it simple,
|
|
* only add the mirror with the lowest physical
|
|
* address
|
|
*/
|
|
if (found &&
|
|
physical_of_found <=
|
|
bbio->stripes[i].physical)
|
|
continue;
|
|
index_srcdev = i;
|
|
found = 1;
|
|
physical_of_found = bbio->stripes[i].physical;
|
|
}
|
|
}
|
|
if (found) {
|
|
struct btrfs_bio_stripe *tgtdev_stripe =
|
|
bbio->stripes + num_stripes;
|
|
|
|
tgtdev_stripe->physical = physical_of_found;
|
|
tgtdev_stripe->length =
|
|
bbio->stripes[index_srcdev].length;
|
|
tgtdev_stripe->dev = dev_replace->tgtdev;
|
|
bbio->tgtdev_map[index_srcdev] = num_stripes;
|
|
|
|
tgtdev_indexes++;
|
|
num_stripes++;
|
|
}
|
|
}
|
|
|
|
*num_stripes_ret = num_stripes;
|
|
*max_errors_ret = max_errors;
|
|
bbio->num_tgtdevs = tgtdev_indexes;
|
|
*bbio_ret = bbio;
|
|
}
|
|
|
|
static bool need_full_stripe(enum btrfs_map_op op)
|
|
{
|
|
return (op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS);
|
|
}
|
|
|
|
static int __btrfs_map_block(struct btrfs_fs_info *fs_info,
|
|
enum btrfs_map_op op,
|
|
u64 logical, u64 *length,
|
|
struct btrfs_bio **bbio_ret,
|
|
int mirror_num, int need_raid_map)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
u64 offset;
|
|
u64 stripe_offset;
|
|
u64 stripe_nr;
|
|
u64 stripe_len;
|
|
u32 stripe_index;
|
|
int i;
|
|
int ret = 0;
|
|
int num_stripes;
|
|
int max_errors = 0;
|
|
int tgtdev_indexes = 0;
|
|
struct btrfs_bio *bbio = NULL;
|
|
struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
|
int dev_replace_is_ongoing = 0;
|
|
int num_alloc_stripes;
|
|
int patch_the_first_stripe_for_dev_replace = 0;
|
|
u64 physical_to_patch_in_first_stripe = 0;
|
|
u64 raid56_full_stripe_start = (u64)-1;
|
|
|
|
if (op == BTRFS_MAP_DISCARD)
|
|
return __btrfs_map_block_for_discard(fs_info, logical,
|
|
*length, bbio_ret);
|
|
|
|
em = get_chunk_map(fs_info, logical, *length);
|
|
if (IS_ERR(em))
|
|
return PTR_ERR(em);
|
|
|
|
map = em->map_lookup;
|
|
offset = logical - em->start;
|
|
|
|
stripe_len = map->stripe_len;
|
|
stripe_nr = offset;
|
|
/*
|
|
* stripe_nr counts the total number of stripes we have to stride
|
|
* to get to this block
|
|
*/
|
|
stripe_nr = div64_u64(stripe_nr, stripe_len);
|
|
|
|
stripe_offset = stripe_nr * stripe_len;
|
|
if (offset < stripe_offset) {
|
|
btrfs_crit(fs_info,
|
|
"stripe math has gone wrong, stripe_offset=%llu, offset=%llu, start=%llu, logical=%llu, stripe_len=%llu",
|
|
stripe_offset, offset, em->start, logical,
|
|
stripe_len);
|
|
free_extent_map(em);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* stripe_offset is the offset of this block in its stripe*/
|
|
stripe_offset = offset - stripe_offset;
|
|
|
|
/* if we're here for raid56, we need to know the stripe aligned start */
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
|
|
unsigned long full_stripe_len = stripe_len * nr_data_stripes(map);
|
|
raid56_full_stripe_start = offset;
|
|
|
|
/* allow a write of a full stripe, but make sure we don't
|
|
* allow straddling of stripes
|
|
*/
|
|
raid56_full_stripe_start = div64_u64(raid56_full_stripe_start,
|
|
full_stripe_len);
|
|
raid56_full_stripe_start *= full_stripe_len;
|
|
}
|
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
|
|
u64 max_len;
|
|
/* For writes to RAID[56], allow a full stripeset across all disks.
|
|
For other RAID types and for RAID[56] reads, just allow a single
|
|
stripe (on a single disk). */
|
|
if ((map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) &&
|
|
(op == BTRFS_MAP_WRITE)) {
|
|
max_len = stripe_len * nr_data_stripes(map) -
|
|
(offset - raid56_full_stripe_start);
|
|
} else {
|
|
/* we limit the length of each bio to what fits in a stripe */
|
|
max_len = stripe_len - stripe_offset;
|
|
}
|
|
*length = min_t(u64, em->len - offset, max_len);
|
|
} else {
|
|
*length = em->len - offset;
|
|
}
|
|
|
|
/* This is for when we're called from btrfs_merge_bio_hook() and all
|
|
it cares about is the length */
|
|
if (!bbio_ret)
|
|
goto out;
|
|
|
|
btrfs_dev_replace_lock(dev_replace, 0);
|
|
dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
|
|
if (!dev_replace_is_ongoing)
|
|
btrfs_dev_replace_unlock(dev_replace, 0);
|
|
else
|
|
btrfs_dev_replace_set_lock_blocking(dev_replace);
|
|
|
|
if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 &&
|
|
!need_full_stripe(op) && dev_replace->tgtdev != NULL) {
|
|
ret = get_extra_mirror_from_replace(fs_info, logical, *length,
|
|
dev_replace->srcdev->devid,
|
|
&mirror_num,
|
|
&physical_to_patch_in_first_stripe);
|
|
if (ret)
|
|
goto out;
|
|
else
|
|
patch_the_first_stripe_for_dev_replace = 1;
|
|
} else if (mirror_num > map->num_stripes) {
|
|
mirror_num = 0;
|
|
}
|
|
|
|
num_stripes = 1;
|
|
stripe_index = 0;
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
|
|
stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
|
|
&stripe_index);
|
|
if (op != BTRFS_MAP_WRITE && op != BTRFS_MAP_GET_READ_MIRRORS)
|
|
mirror_num = 1;
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
|
|
if (op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS)
|
|
num_stripes = map->num_stripes;
|
|
else if (mirror_num)
|
|
stripe_index = mirror_num - 1;
|
|
else {
|
|
stripe_index = find_live_mirror(fs_info, map, 0,
|
|
map->num_stripes,
|
|
current->pid % map->num_stripes,
|
|
dev_replace_is_ongoing);
|
|
mirror_num = stripe_index + 1;
|
|
}
|
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
|
|
if (op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS) {
|
|
num_stripes = map->num_stripes;
|
|
} else if (mirror_num) {
|
|
stripe_index = mirror_num - 1;
|
|
} else {
|
|
mirror_num = 1;
|
|
}
|
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
|
|
u32 factor = map->num_stripes / map->sub_stripes;
|
|
|
|
stripe_nr = div_u64_rem(stripe_nr, factor, &stripe_index);
|
|
stripe_index *= map->sub_stripes;
|
|
|
|
if (op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS)
|
|
num_stripes = map->sub_stripes;
|
|
else if (mirror_num)
|
|
stripe_index += mirror_num - 1;
|
|
else {
|
|
int old_stripe_index = stripe_index;
|
|
stripe_index = find_live_mirror(fs_info, map,
|
|
stripe_index,
|
|
map->sub_stripes, stripe_index +
|
|
current->pid % map->sub_stripes,
|
|
dev_replace_is_ongoing);
|
|
mirror_num = stripe_index - old_stripe_index + 1;
|
|
}
|
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
|
|
if (need_raid_map &&
|
|
(op == BTRFS_MAP_WRITE || op == BTRFS_MAP_GET_READ_MIRRORS ||
|
|
mirror_num > 1)) {
|
|
/* push stripe_nr back to the start of the full stripe */
|
|
stripe_nr = div64_u64(raid56_full_stripe_start,
|
|
stripe_len * nr_data_stripes(map));
|
|
|
|
/* RAID[56] write or recovery. Return all stripes */
|
|
num_stripes = map->num_stripes;
|
|
max_errors = nr_parity_stripes(map);
|
|
|
|
*length = map->stripe_len;
|
|
stripe_index = 0;
|
|
stripe_offset = 0;
|
|
} else {
|
|
/*
|
|
* Mirror #0 or #1 means the original data block.
|
|
* Mirror #2 is RAID5 parity block.
|
|
* Mirror #3 is RAID6 Q block.
|
|
*/
|
|
stripe_nr = div_u64_rem(stripe_nr,
|
|
nr_data_stripes(map), &stripe_index);
|
|
if (mirror_num > 1)
|
|
stripe_index = nr_data_stripes(map) +
|
|
mirror_num - 2;
|
|
|
|
/* We distribute the parity blocks across stripes */
|
|
div_u64_rem(stripe_nr + stripe_index, map->num_stripes,
|
|
&stripe_index);
|
|
if ((op != BTRFS_MAP_WRITE &&
|
|
op != BTRFS_MAP_GET_READ_MIRRORS) &&
|
|
mirror_num <= 1)
|
|
mirror_num = 1;
|
|
}
|
|
} else {
|
|
/*
|
|
* after this, stripe_nr is the number of stripes on this
|
|
* device we have to walk to find the data, and stripe_index is
|
|
* the number of our device in the stripe array
|
|
*/
|
|
stripe_nr = div_u64_rem(stripe_nr, map->num_stripes,
|
|
&stripe_index);
|
|
mirror_num = stripe_index + 1;
|
|
}
|
|
if (stripe_index >= map->num_stripes) {
|
|
btrfs_crit(fs_info,
|
|
"stripe index math went horribly wrong, got stripe_index=%u, num_stripes=%u",
|
|
stripe_index, map->num_stripes);
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
num_alloc_stripes = num_stripes;
|
|
if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL) {
|
|
if (op == BTRFS_MAP_WRITE)
|
|
num_alloc_stripes <<= 1;
|
|
if (op == BTRFS_MAP_GET_READ_MIRRORS)
|
|
num_alloc_stripes++;
|
|
tgtdev_indexes = num_stripes;
|
|
}
|
|
|
|
bbio = alloc_btrfs_bio(num_alloc_stripes, tgtdev_indexes);
|
|
if (!bbio) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL)
|
|
bbio->tgtdev_map = (int *)(bbio->stripes + num_alloc_stripes);
|
|
|
|
/* build raid_map */
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK && need_raid_map &&
|
|
(need_full_stripe(op) || mirror_num > 1)) {
|
|
u64 tmp;
|
|
unsigned rot;
|
|
|
|
bbio->raid_map = (u64 *)((void *)bbio->stripes +
|
|
sizeof(struct btrfs_bio_stripe) *
|
|
num_alloc_stripes +
|
|
sizeof(int) * tgtdev_indexes);
|
|
|
|
/* Work out the disk rotation on this stripe-set */
|
|
div_u64_rem(stripe_nr, num_stripes, &rot);
|
|
|
|
/* Fill in the logical address of each stripe */
|
|
tmp = stripe_nr * nr_data_stripes(map);
|
|
for (i = 0; i < nr_data_stripes(map); i++)
|
|
bbio->raid_map[(i+rot) % num_stripes] =
|
|
em->start + (tmp + i) * map->stripe_len;
|
|
|
|
bbio->raid_map[(i+rot) % map->num_stripes] = RAID5_P_STRIPE;
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID6)
|
|
bbio->raid_map[(i+rot+1) % num_stripes] =
|
|
RAID6_Q_STRIPE;
|
|
}
|
|
|
|
|
|
for (i = 0; i < num_stripes; i++) {
|
|
bbio->stripes[i].physical =
|
|
map->stripes[stripe_index].physical +
|
|
stripe_offset +
|
|
stripe_nr * map->stripe_len;
|
|
bbio->stripes[i].dev =
|
|
map->stripes[stripe_index].dev;
|
|
stripe_index++;
|
|
}
|
|
|
|
if (need_full_stripe(op))
|
|
max_errors = btrfs_chunk_max_errors(map);
|
|
|
|
if (bbio->raid_map)
|
|
sort_parity_stripes(bbio, num_stripes);
|
|
|
|
if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL &&
|
|
need_full_stripe(op)) {
|
|
handle_ops_on_dev_replace(op, &bbio, dev_replace, &num_stripes,
|
|
&max_errors);
|
|
}
|
|
|
|
*bbio_ret = bbio;
|
|
bbio->map_type = map->type;
|
|
bbio->num_stripes = num_stripes;
|
|
bbio->max_errors = max_errors;
|
|
bbio->mirror_num = mirror_num;
|
|
|
|
/*
|
|
* this is the case that REQ_READ && dev_replace_is_ongoing &&
|
|
* mirror_num == num_stripes + 1 && dev_replace target drive is
|
|
* available as a mirror
|
|
*/
|
|
if (patch_the_first_stripe_for_dev_replace && num_stripes > 0) {
|
|
WARN_ON(num_stripes > 1);
|
|
bbio->stripes[0].dev = dev_replace->tgtdev;
|
|
bbio->stripes[0].physical = physical_to_patch_in_first_stripe;
|
|
bbio->mirror_num = map->num_stripes + 1;
|
|
}
|
|
out:
|
|
if (dev_replace_is_ongoing) {
|
|
btrfs_dev_replace_clear_lock_blocking(dev_replace);
|
|
btrfs_dev_replace_unlock(dev_replace, 0);
|
|
}
|
|
free_extent_map(em);
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_map_block(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
|
|
u64 logical, u64 *length,
|
|
struct btrfs_bio **bbio_ret, int mirror_num)
|
|
{
|
|
return __btrfs_map_block(fs_info, op, logical, length, bbio_ret,
|
|
mirror_num, 0);
|
|
}
|
|
|
|
/* For Scrub/replace */
|
|
int btrfs_map_sblock(struct btrfs_fs_info *fs_info, enum btrfs_map_op op,
|
|
u64 logical, u64 *length,
|
|
struct btrfs_bio **bbio_ret)
|
|
{
|
|
return __btrfs_map_block(fs_info, op, logical, length, bbio_ret, 0, 1);
|
|
}
|
|
|
|
int btrfs_rmap_block(struct btrfs_fs_info *fs_info,
|
|
u64 chunk_start, u64 physical, u64 devid,
|
|
u64 **logical, int *naddrs, int *stripe_len)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
u64 *buf;
|
|
u64 bytenr;
|
|
u64 length;
|
|
u64 stripe_nr;
|
|
u64 rmap_len;
|
|
int i, j, nr = 0;
|
|
|
|
em = get_chunk_map(fs_info, chunk_start, 1);
|
|
if (IS_ERR(em))
|
|
return -EIO;
|
|
|
|
map = em->map_lookup;
|
|
length = em->len;
|
|
rmap_len = map->stripe_len;
|
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID10)
|
|
length = div_u64(length, map->num_stripes / map->sub_stripes);
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID0)
|
|
length = div_u64(length, map->num_stripes);
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
|
|
length = div_u64(length, nr_data_stripes(map));
|
|
rmap_len = map->stripe_len * nr_data_stripes(map);
|
|
}
|
|
|
|
buf = kcalloc(map->num_stripes, sizeof(u64), GFP_NOFS);
|
|
BUG_ON(!buf); /* -ENOMEM */
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
if (devid && map->stripes[i].dev->devid != devid)
|
|
continue;
|
|
if (map->stripes[i].physical > physical ||
|
|
map->stripes[i].physical + length <= physical)
|
|
continue;
|
|
|
|
stripe_nr = physical - map->stripes[i].physical;
|
|
stripe_nr = div64_u64(stripe_nr, map->stripe_len);
|
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
|
|
stripe_nr = stripe_nr * map->num_stripes + i;
|
|
stripe_nr = div_u64(stripe_nr, map->sub_stripes);
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
|
|
stripe_nr = stripe_nr * map->num_stripes + i;
|
|
} /* else if RAID[56], multiply by nr_data_stripes().
|
|
* Alternatively, just use rmap_len below instead of
|
|
* map->stripe_len */
|
|
|
|
bytenr = chunk_start + stripe_nr * rmap_len;
|
|
WARN_ON(nr >= map->num_stripes);
|
|
for (j = 0; j < nr; j++) {
|
|
if (buf[j] == bytenr)
|
|
break;
|
|
}
|
|
if (j == nr) {
|
|
WARN_ON(nr >= map->num_stripes);
|
|
buf[nr++] = bytenr;
|
|
}
|
|
}
|
|
|
|
*logical = buf;
|
|
*naddrs = nr;
|
|
*stripe_len = rmap_len;
|
|
|
|
free_extent_map(em);
|
|
return 0;
|
|
}
|
|
|
|
static inline void btrfs_end_bbio(struct btrfs_bio *bbio, struct bio *bio)
|
|
{
|
|
bio->bi_private = bbio->private;
|
|
bio->bi_end_io = bbio->end_io;
|
|
bio_endio(bio);
|
|
|
|
btrfs_put_bbio(bbio);
|
|
}
|
|
|
|
static void btrfs_end_bio(struct bio *bio)
|
|
{
|
|
struct btrfs_bio *bbio = bio->bi_private;
|
|
int is_orig_bio = 0;
|
|
|
|
if (bio->bi_error) {
|
|
atomic_inc(&bbio->error);
|
|
if (bio->bi_error == -EIO || bio->bi_error == -EREMOTEIO) {
|
|
unsigned int stripe_index =
|
|
btrfs_io_bio(bio)->stripe_index;
|
|
struct btrfs_device *dev;
|
|
|
|
BUG_ON(stripe_index >= bbio->num_stripes);
|
|
dev = bbio->stripes[stripe_index].dev;
|
|
if (dev->bdev) {
|
|
if (bio_op(bio) == REQ_OP_WRITE)
|
|
btrfs_dev_stat_inc(dev,
|
|
BTRFS_DEV_STAT_WRITE_ERRS);
|
|
else
|
|
btrfs_dev_stat_inc(dev,
|
|
BTRFS_DEV_STAT_READ_ERRS);
|
|
if (bio->bi_opf & REQ_PREFLUSH)
|
|
btrfs_dev_stat_inc(dev,
|
|
BTRFS_DEV_STAT_FLUSH_ERRS);
|
|
btrfs_dev_stat_print_on_error(dev);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bio == bbio->orig_bio)
|
|
is_orig_bio = 1;
|
|
|
|
btrfs_bio_counter_dec(bbio->fs_info);
|
|
|
|
if (atomic_dec_and_test(&bbio->stripes_pending)) {
|
|
if (!is_orig_bio) {
|
|
bio_put(bio);
|
|
bio = bbio->orig_bio;
|
|
}
|
|
|
|
btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
|
|
/* only send an error to the higher layers if it is
|
|
* beyond the tolerance of the btrfs bio
|
|
*/
|
|
if (atomic_read(&bbio->error) > bbio->max_errors) {
|
|
bio->bi_error = -EIO;
|
|
} else {
|
|
/*
|
|
* this bio is actually up to date, we didn't
|
|
* go over the max number of errors
|
|
*/
|
|
bio->bi_error = 0;
|
|
}
|
|
|
|
btrfs_end_bbio(bbio, bio);
|
|
} else if (!is_orig_bio) {
|
|
bio_put(bio);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* see run_scheduled_bios for a description of why bios are collected for
|
|
* async submit.
|
|
*
|
|
* This will add one bio to the pending list for a device and make sure
|
|
* the work struct is scheduled.
|
|
*/
|
|
static noinline void btrfs_schedule_bio(struct btrfs_device *device,
|
|
struct bio *bio)
|
|
{
|
|
struct btrfs_fs_info *fs_info = device->fs_info;
|
|
int should_queue = 1;
|
|
struct btrfs_pending_bios *pending_bios;
|
|
|
|
if (device->missing || !device->bdev) {
|
|
bio_io_error(bio);
|
|
return;
|
|
}
|
|
|
|
/* don't bother with additional async steps for reads, right now */
|
|
if (bio_op(bio) == REQ_OP_READ) {
|
|
bio_get(bio);
|
|
btrfsic_submit_bio(bio);
|
|
bio_put(bio);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* nr_async_bios allows us to reliably return congestion to the
|
|
* higher layers. Otherwise, the async bio makes it appear we have
|
|
* made progress against dirty pages when we've really just put it
|
|
* on a queue for later
|
|
*/
|
|
atomic_inc(&fs_info->nr_async_bios);
|
|
WARN_ON(bio->bi_next);
|
|
bio->bi_next = NULL;
|
|
|
|
spin_lock(&device->io_lock);
|
|
if (op_is_sync(bio->bi_opf))
|
|
pending_bios = &device->pending_sync_bios;
|
|
else
|
|
pending_bios = &device->pending_bios;
|
|
|
|
if (pending_bios->tail)
|
|
pending_bios->tail->bi_next = bio;
|
|
|
|
pending_bios->tail = bio;
|
|
if (!pending_bios->head)
|
|
pending_bios->head = bio;
|
|
if (device->running_pending)
|
|
should_queue = 0;
|
|
|
|
spin_unlock(&device->io_lock);
|
|
|
|
if (should_queue)
|
|
btrfs_queue_work(fs_info->submit_workers, &device->work);
|
|
}
|
|
|
|
static void submit_stripe_bio(struct btrfs_bio *bbio, struct bio *bio,
|
|
u64 physical, int dev_nr, int async)
|
|
{
|
|
struct btrfs_device *dev = bbio->stripes[dev_nr].dev;
|
|
struct btrfs_fs_info *fs_info = bbio->fs_info;
|
|
|
|
bio->bi_private = bbio;
|
|
btrfs_io_bio(bio)->stripe_index = dev_nr;
|
|
bio->bi_end_io = btrfs_end_bio;
|
|
bio->bi_iter.bi_sector = physical >> 9;
|
|
#ifdef DEBUG
|
|
{
|
|
struct rcu_string *name;
|
|
|
|
rcu_read_lock();
|
|
name = rcu_dereference(dev->name);
|
|
btrfs_debug(fs_info,
|
|
"btrfs_map_bio: rw %d 0x%x, sector=%llu, dev=%lu (%s id %llu), size=%u",
|
|
bio_op(bio), bio->bi_opf,
|
|
(u64)bio->bi_iter.bi_sector,
|
|
(u_long)dev->bdev->bd_dev, name->str, dev->devid,
|
|
bio->bi_iter.bi_size);
|
|
rcu_read_unlock();
|
|
}
|
|
#endif
|
|
bio->bi_bdev = dev->bdev;
|
|
|
|
btrfs_bio_counter_inc_noblocked(fs_info);
|
|
|
|
if (async)
|
|
btrfs_schedule_bio(dev, bio);
|
|
else
|
|
btrfsic_submit_bio(bio);
|
|
}
|
|
|
|
static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
|
|
{
|
|
atomic_inc(&bbio->error);
|
|
if (atomic_dec_and_test(&bbio->stripes_pending)) {
|
|
/* Should be the original bio. */
|
|
WARN_ON(bio != bbio->orig_bio);
|
|
|
|
btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
|
|
bio->bi_iter.bi_sector = logical >> 9;
|
|
bio->bi_error = -EIO;
|
|
btrfs_end_bbio(bbio, bio);
|
|
}
|
|
}
|
|
|
|
int btrfs_map_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
|
|
int mirror_num, int async_submit)
|
|
{
|
|
struct btrfs_device *dev;
|
|
struct bio *first_bio = bio;
|
|
u64 logical = (u64)bio->bi_iter.bi_sector << 9;
|
|
u64 length = 0;
|
|
u64 map_length;
|
|
int ret;
|
|
int dev_nr;
|
|
int total_devs;
|
|
struct btrfs_bio *bbio = NULL;
|
|
|
|
length = bio->bi_iter.bi_size;
|
|
map_length = length;
|
|
|
|
btrfs_bio_counter_inc_blocked(fs_info);
|
|
ret = __btrfs_map_block(fs_info, bio_op(bio), logical,
|
|
&map_length, &bbio, mirror_num, 1);
|
|
if (ret) {
|
|
btrfs_bio_counter_dec(fs_info);
|
|
return ret;
|
|
}
|
|
|
|
total_devs = bbio->num_stripes;
|
|
bbio->orig_bio = first_bio;
|
|
bbio->private = first_bio->bi_private;
|
|
bbio->end_io = first_bio->bi_end_io;
|
|
bbio->fs_info = fs_info;
|
|
atomic_set(&bbio->stripes_pending, bbio->num_stripes);
|
|
|
|
if ((bbio->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) &&
|
|
((bio_op(bio) == REQ_OP_WRITE) || (mirror_num > 1))) {
|
|
/* In this case, map_length has been set to the length of
|
|
a single stripe; not the whole write */
|
|
if (bio_op(bio) == REQ_OP_WRITE) {
|
|
ret = raid56_parity_write(fs_info, bio, bbio,
|
|
map_length);
|
|
} else {
|
|
ret = raid56_parity_recover(fs_info, bio, bbio,
|
|
map_length, mirror_num, 1);
|
|
}
|
|
|
|
btrfs_bio_counter_dec(fs_info);
|
|
return ret;
|
|
}
|
|
|
|
if (map_length < length) {
|
|
btrfs_crit(fs_info,
|
|
"mapping failed logical %llu bio len %llu len %llu",
|
|
logical, length, map_length);
|
|
BUG();
|
|
}
|
|
|
|
for (dev_nr = 0; dev_nr < total_devs; dev_nr++) {
|
|
dev = bbio->stripes[dev_nr].dev;
|
|
if (!dev || !dev->bdev ||
|
|
(bio_op(first_bio) == REQ_OP_WRITE && !dev->writeable)) {
|
|
bbio_error(bbio, first_bio, logical);
|
|
continue;
|
|
}
|
|
|
|
if (dev_nr < total_devs - 1) {
|
|
bio = btrfs_bio_clone(first_bio, GFP_NOFS);
|
|
BUG_ON(!bio); /* -ENOMEM */
|
|
} else
|
|
bio = first_bio;
|
|
|
|
submit_stripe_bio(bbio, bio, bbio->stripes[dev_nr].physical,
|
|
dev_nr, async_submit);
|
|
}
|
|
btrfs_bio_counter_dec(fs_info);
|
|
return 0;
|
|
}
|
|
|
|
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
|
|
u8 *uuid, u8 *fsid)
|
|
{
|
|
struct btrfs_device *device;
|
|
struct btrfs_fs_devices *cur_devices;
|
|
|
|
cur_devices = fs_info->fs_devices;
|
|
while (cur_devices) {
|
|
if (!fsid ||
|
|
!memcmp(cur_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
|
|
device = __find_device(&cur_devices->devices,
|
|
devid, uuid);
|
|
if (device)
|
|
return device;
|
|
}
|
|
cur_devices = cur_devices->seed;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static struct btrfs_device *add_missing_dev(struct btrfs_fs_devices *fs_devices,
|
|
u64 devid, u8 *dev_uuid)
|
|
{
|
|
struct btrfs_device *device;
|
|
|
|
device = btrfs_alloc_device(NULL, &devid, dev_uuid);
|
|
if (IS_ERR(device))
|
|
return NULL;
|
|
|
|
list_add(&device->dev_list, &fs_devices->devices);
|
|
device->fs_devices = fs_devices;
|
|
fs_devices->num_devices++;
|
|
|
|
device->missing = 1;
|
|
fs_devices->missing_devices++;
|
|
|
|
return device;
|
|
}
|
|
|
|
/**
|
|
* btrfs_alloc_device - allocate struct btrfs_device
|
|
* @fs_info: used only for generating a new devid, can be NULL if
|
|
* devid is provided (i.e. @devid != NULL).
|
|
* @devid: a pointer to devid for this device. If NULL a new devid
|
|
* is generated.
|
|
* @uuid: a pointer to UUID for this device. If NULL a new UUID
|
|
* is generated.
|
|
*
|
|
* Return: a pointer to a new &struct btrfs_device on success; ERR_PTR()
|
|
* on error. Returned struct is not linked onto any lists and can be
|
|
* destroyed with kfree() right away.
|
|
*/
|
|
struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
|
|
const u64 *devid,
|
|
const u8 *uuid)
|
|
{
|
|
struct btrfs_device *dev;
|
|
u64 tmp;
|
|
|
|
if (WARN_ON(!devid && !fs_info))
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
dev = __alloc_device();
|
|
if (IS_ERR(dev))
|
|
return dev;
|
|
|
|
if (devid)
|
|
tmp = *devid;
|
|
else {
|
|
int ret;
|
|
|
|
ret = find_next_devid(fs_info, &tmp);
|
|
if (ret) {
|
|
kfree(dev);
|
|
return ERR_PTR(ret);
|
|
}
|
|
}
|
|
dev->devid = tmp;
|
|
|
|
if (uuid)
|
|
memcpy(dev->uuid, uuid, BTRFS_UUID_SIZE);
|
|
else
|
|
generate_random_uuid(dev->uuid);
|
|
|
|
btrfs_init_work(&dev->work, btrfs_submit_helper,
|
|
pending_bios_fn, NULL, NULL);
|
|
|
|
return dev;
|
|
}
|
|
|
|
/* Return -EIO if any error, otherwise return 0. */
|
|
static int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
|
|
struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk, u64 logical)
|
|
{
|
|
u64 length;
|
|
u64 stripe_len;
|
|
u16 num_stripes;
|
|
u16 sub_stripes;
|
|
u64 type;
|
|
|
|
length = btrfs_chunk_length(leaf, chunk);
|
|
stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
|
|
num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
|
|
sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
|
|
type = btrfs_chunk_type(leaf, chunk);
|
|
|
|
if (!num_stripes) {
|
|
btrfs_err(fs_info, "invalid chunk num_stripes: %u",
|
|
num_stripes);
|
|
return -EIO;
|
|
}
|
|
if (!IS_ALIGNED(logical, fs_info->sectorsize)) {
|
|
btrfs_err(fs_info, "invalid chunk logical %llu", logical);
|
|
return -EIO;
|
|
}
|
|
if (btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize) {
|
|
btrfs_err(fs_info, "invalid chunk sectorsize %u",
|
|
btrfs_chunk_sector_size(leaf, chunk));
|
|
return -EIO;
|
|
}
|
|
if (!length || !IS_ALIGNED(length, fs_info->sectorsize)) {
|
|
btrfs_err(fs_info, "invalid chunk length %llu", length);
|
|
return -EIO;
|
|
}
|
|
if (!is_power_of_2(stripe_len) || stripe_len != BTRFS_STRIPE_LEN) {
|
|
btrfs_err(fs_info, "invalid chunk stripe length: %llu",
|
|
stripe_len);
|
|
return -EIO;
|
|
}
|
|
if (~(BTRFS_BLOCK_GROUP_TYPE_MASK | BTRFS_BLOCK_GROUP_PROFILE_MASK) &
|
|
type) {
|
|
btrfs_err(fs_info, "unrecognized chunk type: %llu",
|
|
~(BTRFS_BLOCK_GROUP_TYPE_MASK |
|
|
BTRFS_BLOCK_GROUP_PROFILE_MASK) &
|
|
btrfs_chunk_type(leaf, chunk));
|
|
return -EIO;
|
|
}
|
|
if ((type & BTRFS_BLOCK_GROUP_RAID10 && sub_stripes != 2) ||
|
|
(type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes < 1) ||
|
|
(type & BTRFS_BLOCK_GROUP_RAID5 && num_stripes < 2) ||
|
|
(type & BTRFS_BLOCK_GROUP_RAID6 && num_stripes < 3) ||
|
|
(type & BTRFS_BLOCK_GROUP_DUP && num_stripes > 2) ||
|
|
((type & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 &&
|
|
num_stripes != 1)) {
|
|
btrfs_err(fs_info,
|
|
"invalid num_stripes:sub_stripes %u:%u for profile %llu",
|
|
num_stripes, sub_stripes,
|
|
type & BTRFS_BLOCK_GROUP_PROFILE_MASK);
|
|
return -EIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int read_one_chunk(struct btrfs_fs_info *fs_info, struct btrfs_key *key,
|
|
struct extent_buffer *leaf,
|
|
struct btrfs_chunk *chunk)
|
|
{
|
|
struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
|
|
struct map_lookup *map;
|
|
struct extent_map *em;
|
|
u64 logical;
|
|
u64 length;
|
|
u64 stripe_len;
|
|
u64 devid;
|
|
u8 uuid[BTRFS_UUID_SIZE];
|
|
int num_stripes;
|
|
int ret;
|
|
int i;
|
|
|
|
logical = key->offset;
|
|
length = btrfs_chunk_length(leaf, chunk);
|
|
stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
|
|
num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
|
|
|
|
ret = btrfs_check_chunk_valid(fs_info, leaf, chunk, logical);
|
|
if (ret)
|
|
return ret;
|
|
|
|
read_lock(&map_tree->map_tree.lock);
|
|
em = lookup_extent_mapping(&map_tree->map_tree, logical, 1);
|
|
read_unlock(&map_tree->map_tree.lock);
|
|
|
|
/* already mapped? */
|
|
if (em && em->start <= logical && em->start + em->len > logical) {
|
|
free_extent_map(em);
|
|
return 0;
|
|
} else if (em) {
|
|
free_extent_map(em);
|
|
}
|
|
|
|
em = alloc_extent_map();
|
|
if (!em)
|
|
return -ENOMEM;
|
|
map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
|
|
if (!map) {
|
|
free_extent_map(em);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags);
|
|
em->map_lookup = map;
|
|
em->start = logical;
|
|
em->len = length;
|
|
em->orig_start = 0;
|
|
em->block_start = 0;
|
|
em->block_len = em->len;
|
|
|
|
map->num_stripes = num_stripes;
|
|
map->io_width = btrfs_chunk_io_width(leaf, chunk);
|
|
map->io_align = btrfs_chunk_io_align(leaf, chunk);
|
|
map->sector_size = btrfs_chunk_sector_size(leaf, chunk);
|
|
map->stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
|
|
map->type = btrfs_chunk_type(leaf, chunk);
|
|
map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
|
|
for (i = 0; i < num_stripes; i++) {
|
|
map->stripes[i].physical =
|
|
btrfs_stripe_offset_nr(leaf, chunk, i);
|
|
devid = btrfs_stripe_devid_nr(leaf, chunk, i);
|
|
read_extent_buffer(leaf, uuid, (unsigned long)
|
|
btrfs_stripe_dev_uuid_nr(chunk, i),
|
|
BTRFS_UUID_SIZE);
|
|
map->stripes[i].dev = btrfs_find_device(fs_info, devid,
|
|
uuid, NULL);
|
|
if (!map->stripes[i].dev &&
|
|
!btrfs_test_opt(fs_info, DEGRADED)) {
|
|
free_extent_map(em);
|
|
return -EIO;
|
|
}
|
|
if (!map->stripes[i].dev) {
|
|
map->stripes[i].dev =
|
|
add_missing_dev(fs_info->fs_devices, devid,
|
|
uuid);
|
|
if (!map->stripes[i].dev) {
|
|
free_extent_map(em);
|
|
return -EIO;
|
|
}
|
|
btrfs_warn(fs_info, "devid %llu uuid %pU is missing",
|
|
devid, uuid);
|
|
}
|
|
map->stripes[i].dev->in_fs_metadata = 1;
|
|
}
|
|
|
|
write_lock(&map_tree->map_tree.lock);
|
|
ret = add_extent_mapping(&map_tree->map_tree, em, 0);
|
|
write_unlock(&map_tree->map_tree.lock);
|
|
BUG_ON(ret); /* Tree corruption */
|
|
free_extent_map(em);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void fill_device_from_item(struct extent_buffer *leaf,
|
|
struct btrfs_dev_item *dev_item,
|
|
struct btrfs_device *device)
|
|
{
|
|
unsigned long ptr;
|
|
|
|
device->devid = btrfs_device_id(leaf, dev_item);
|
|
device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);
|
|
device->total_bytes = device->disk_total_bytes;
|
|
device->commit_total_bytes = device->disk_total_bytes;
|
|
device->bytes_used = btrfs_device_bytes_used(leaf, dev_item);
|
|
device->commit_bytes_used = device->bytes_used;
|
|
device->type = btrfs_device_type(leaf, dev_item);
|
|
device->io_align = btrfs_device_io_align(leaf, dev_item);
|
|
device->io_width = btrfs_device_io_width(leaf, dev_item);
|
|
device->sector_size = btrfs_device_sector_size(leaf, dev_item);
|
|
WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID);
|
|
device->is_tgtdev_for_dev_replace = 0;
|
|
|
|
ptr = btrfs_device_uuid(dev_item);
|
|
read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
|
|
}
|
|
|
|
static struct btrfs_fs_devices *open_seed_devices(struct btrfs_fs_info *fs_info,
|
|
u8 *fsid)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices;
|
|
int ret;
|
|
|
|
BUG_ON(!mutex_is_locked(&uuid_mutex));
|
|
|
|
fs_devices = fs_info->fs_devices->seed;
|
|
while (fs_devices) {
|
|
if (!memcmp(fs_devices->fsid, fsid, BTRFS_UUID_SIZE))
|
|
return fs_devices;
|
|
|
|
fs_devices = fs_devices->seed;
|
|
}
|
|
|
|
fs_devices = find_fsid(fsid);
|
|
if (!fs_devices) {
|
|
if (!btrfs_test_opt(fs_info, DEGRADED))
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
fs_devices = alloc_fs_devices(fsid);
|
|
if (IS_ERR(fs_devices))
|
|
return fs_devices;
|
|
|
|
fs_devices->seeding = 1;
|
|
fs_devices->opened = 1;
|
|
return fs_devices;
|
|
}
|
|
|
|
fs_devices = clone_fs_devices(fs_devices);
|
|
if (IS_ERR(fs_devices))
|
|
return fs_devices;
|
|
|
|
ret = __btrfs_open_devices(fs_devices, FMODE_READ,
|
|
fs_info->bdev_holder);
|
|
if (ret) {
|
|
free_fs_devices(fs_devices);
|
|
fs_devices = ERR_PTR(ret);
|
|
goto out;
|
|
}
|
|
|
|
if (!fs_devices->seeding) {
|
|
__btrfs_close_devices(fs_devices);
|
|
free_fs_devices(fs_devices);
|
|
fs_devices = ERR_PTR(-EINVAL);
|
|
goto out;
|
|
}
|
|
|
|
fs_devices->seed = fs_info->fs_devices->seed;
|
|
fs_info->fs_devices->seed = fs_devices;
|
|
out:
|
|
return fs_devices;
|
|
}
|
|
|
|
static int read_one_dev(struct btrfs_fs_info *fs_info,
|
|
struct extent_buffer *leaf,
|
|
struct btrfs_dev_item *dev_item)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
struct btrfs_device *device;
|
|
u64 devid;
|
|
int ret;
|
|
u8 fs_uuid[BTRFS_UUID_SIZE];
|
|
u8 dev_uuid[BTRFS_UUID_SIZE];
|
|
|
|
devid = btrfs_device_id(leaf, dev_item);
|
|
read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
|
|
BTRFS_UUID_SIZE);
|
|
read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
|
|
BTRFS_UUID_SIZE);
|
|
|
|
if (memcmp(fs_uuid, fs_info->fsid, BTRFS_UUID_SIZE)) {
|
|
fs_devices = open_seed_devices(fs_info, fs_uuid);
|
|
if (IS_ERR(fs_devices))
|
|
return PTR_ERR(fs_devices);
|
|
}
|
|
|
|
device = btrfs_find_device(fs_info, devid, dev_uuid, fs_uuid);
|
|
if (!device) {
|
|
if (!btrfs_test_opt(fs_info, DEGRADED))
|
|
return -EIO;
|
|
|
|
device = add_missing_dev(fs_devices, devid, dev_uuid);
|
|
if (!device)
|
|
return -ENOMEM;
|
|
btrfs_warn(fs_info, "devid %llu uuid %pU missing",
|
|
devid, dev_uuid);
|
|
} else {
|
|
if (!device->bdev && !btrfs_test_opt(fs_info, DEGRADED))
|
|
return -EIO;
|
|
|
|
if(!device->bdev && !device->missing) {
|
|
/*
|
|
* this happens when a device that was properly setup
|
|
* in the device info lists suddenly goes bad.
|
|
* device->bdev is NULL, and so we have to set
|
|
* device->missing to one here
|
|
*/
|
|
device->fs_devices->missing_devices++;
|
|
device->missing = 1;
|
|
}
|
|
|
|
/* Move the device to its own fs_devices */
|
|
if (device->fs_devices != fs_devices) {
|
|
ASSERT(device->missing);
|
|
|
|
list_move(&device->dev_list, &fs_devices->devices);
|
|
device->fs_devices->num_devices--;
|
|
fs_devices->num_devices++;
|
|
|
|
device->fs_devices->missing_devices--;
|
|
fs_devices->missing_devices++;
|
|
|
|
device->fs_devices = fs_devices;
|
|
}
|
|
}
|
|
|
|
if (device->fs_devices != fs_info->fs_devices) {
|
|
BUG_ON(device->writeable);
|
|
if (device->generation !=
|
|
btrfs_device_generation(leaf, dev_item))
|
|
return -EINVAL;
|
|
}
|
|
|
|
fill_device_from_item(leaf, dev_item, device);
|
|
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);
|
|
}
|
|
ret = 0;
|
|
return ret;
|
|
}
|
|
|
|
int btrfs_read_sys_array(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_root *root = fs_info->tree_root;
|
|
struct btrfs_super_block *super_copy = fs_info->super_copy;
|
|
struct extent_buffer *sb;
|
|
struct btrfs_disk_key *disk_key;
|
|
struct btrfs_chunk *chunk;
|
|
u8 *array_ptr;
|
|
unsigned long sb_array_offset;
|
|
int ret = 0;
|
|
u32 num_stripes;
|
|
u32 array_size;
|
|
u32 len = 0;
|
|
u32 cur_offset;
|
|
u64 type;
|
|
struct btrfs_key key;
|
|
|
|
ASSERT(BTRFS_SUPER_INFO_SIZE <= fs_info->nodesize);
|
|
/*
|
|
* This will create extent buffer of nodesize, superblock size is
|
|
* fixed to BTRFS_SUPER_INFO_SIZE. If nodesize > sb size, this will
|
|
* overallocate but we can keep it as-is, only the first page is used.
|
|
*/
|
|
sb = btrfs_find_create_tree_block(fs_info, BTRFS_SUPER_INFO_OFFSET);
|
|
if (IS_ERR(sb))
|
|
return PTR_ERR(sb);
|
|
set_extent_buffer_uptodate(sb);
|
|
btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0);
|
|
/*
|
|
* The sb extent buffer is artificial and just used to read the system array.
|
|
* set_extent_buffer_uptodate() call does not properly mark all it's
|
|
* pages up-to-date when the page is larger: extent does not cover the
|
|
* whole page and consequently check_page_uptodate does not find all
|
|
* the page's extents up-to-date (the hole beyond sb),
|
|
* write_extent_buffer then triggers a WARN_ON.
|
|
*
|
|
* Regular short extents go through mark_extent_buffer_dirty/writeback cycle,
|
|
* but sb spans only this function. Add an explicit SetPageUptodate call
|
|
* to silence the warning eg. on PowerPC 64.
|
|
*/
|
|
if (PAGE_SIZE > BTRFS_SUPER_INFO_SIZE)
|
|
SetPageUptodate(sb->pages[0]);
|
|
|
|
write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE);
|
|
array_size = btrfs_super_sys_array_size(super_copy);
|
|
|
|
array_ptr = super_copy->sys_chunk_array;
|
|
sb_array_offset = offsetof(struct btrfs_super_block, sys_chunk_array);
|
|
cur_offset = 0;
|
|
|
|
while (cur_offset < array_size) {
|
|
disk_key = (struct btrfs_disk_key *)array_ptr;
|
|
len = sizeof(*disk_key);
|
|
if (cur_offset + len > array_size)
|
|
goto out_short_read;
|
|
|
|
btrfs_disk_key_to_cpu(&key, disk_key);
|
|
|
|
array_ptr += len;
|
|
sb_array_offset += len;
|
|
cur_offset += len;
|
|
|
|
if (key.type == BTRFS_CHUNK_ITEM_KEY) {
|
|
chunk = (struct btrfs_chunk *)sb_array_offset;
|
|
/*
|
|
* At least one btrfs_chunk with one stripe must be
|
|
* present, exact stripe count check comes afterwards
|
|
*/
|
|
len = btrfs_chunk_item_size(1);
|
|
if (cur_offset + len > array_size)
|
|
goto out_short_read;
|
|
|
|
num_stripes = btrfs_chunk_num_stripes(sb, chunk);
|
|
if (!num_stripes) {
|
|
btrfs_err(fs_info,
|
|
"invalid number of stripes %u in sys_array at offset %u",
|
|
num_stripes, cur_offset);
|
|
ret = -EIO;
|
|
break;
|
|
}
|
|
|
|
type = btrfs_chunk_type(sb, chunk);
|
|
if ((type & BTRFS_BLOCK_GROUP_SYSTEM) == 0) {
|
|
btrfs_err(fs_info,
|
|
"invalid chunk type %llu in sys_array at offset %u",
|
|
type, cur_offset);
|
|
ret = -EIO;
|
|
break;
|
|
}
|
|
|
|
len = btrfs_chunk_item_size(num_stripes);
|
|
if (cur_offset + len > array_size)
|
|
goto out_short_read;
|
|
|
|
ret = read_one_chunk(fs_info, &key, sb, chunk);
|
|
if (ret)
|
|
break;
|
|
} else {
|
|
btrfs_err(fs_info,
|
|
"unexpected item type %u in sys_array at offset %u",
|
|
(u32)key.type, cur_offset);
|
|
ret = -EIO;
|
|
break;
|
|
}
|
|
array_ptr += len;
|
|
sb_array_offset += len;
|
|
cur_offset += len;
|
|
}
|
|
clear_extent_buffer_uptodate(sb);
|
|
free_extent_buffer_stale(sb);
|
|
return ret;
|
|
|
|
out_short_read:
|
|
btrfs_err(fs_info, "sys_array too short to read %u bytes at offset %u",
|
|
len, cur_offset);
|
|
clear_extent_buffer_uptodate(sb);
|
|
free_extent_buffer_stale(sb);
|
|
return -EIO;
|
|
}
|
|
|
|
int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_root *root = fs_info->chunk_root;
|
|
struct btrfs_path *path;
|
|
struct extent_buffer *leaf;
|
|
struct btrfs_key key;
|
|
struct btrfs_key found_key;
|
|
int ret;
|
|
int slot;
|
|
u64 total_dev = 0;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
|
|
mutex_lock(&uuid_mutex);
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
|
|
/*
|
|
* Read all device items, and then all the chunk items. All
|
|
* device items are found before any chunk item (their object id
|
|
* is smaller than the lowest possible object id for a chunk
|
|
* item - BTRFS_FIRST_CHUNK_TREE_OBJECTID).
|
|
*/
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
key.offset = 0;
|
|
key.type = 0;
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
if (ret < 0)
|
|
goto error;
|
|
while (1) {
|
|
leaf = path->nodes[0];
|
|
slot = path->slots[0];
|
|
if (slot >= btrfs_header_nritems(leaf)) {
|
|
ret = btrfs_next_leaf(root, path);
|
|
if (ret == 0)
|
|
continue;
|
|
if (ret < 0)
|
|
goto error;
|
|
break;
|
|
}
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
|
if (found_key.type == BTRFS_DEV_ITEM_KEY) {
|
|
struct btrfs_dev_item *dev_item;
|
|
dev_item = btrfs_item_ptr(leaf, slot,
|
|
struct btrfs_dev_item);
|
|
ret = read_one_dev(fs_info, leaf, dev_item);
|
|
if (ret)
|
|
goto error;
|
|
total_dev++;
|
|
} else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) {
|
|
struct btrfs_chunk *chunk;
|
|
chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
|
|
ret = read_one_chunk(fs_info, &found_key, leaf, chunk);
|
|
if (ret)
|
|
goto error;
|
|
}
|
|
path->slots[0]++;
|
|
}
|
|
|
|
/*
|
|
* After loading chunk tree, we've got all device information,
|
|
* do another round of validation checks.
|
|
*/
|
|
if (total_dev != fs_info->fs_devices->total_devices) {
|
|
btrfs_err(fs_info,
|
|
"super_num_devices %llu mismatch with num_devices %llu found here",
|
|
btrfs_super_num_devices(fs_info->super_copy),
|
|
total_dev);
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
if (btrfs_super_total_bytes(fs_info->super_copy) <
|
|
fs_info->fs_devices->total_rw_bytes) {
|
|
btrfs_err(fs_info,
|
|
"super_total_bytes %llu mismatch with fs_devices total_rw_bytes %llu",
|
|
btrfs_super_total_bytes(fs_info->super_copy),
|
|
fs_info->fs_devices->total_rw_bytes);
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
ret = 0;
|
|
error:
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
void btrfs_init_devices_late(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
struct btrfs_device *device;
|
|
|
|
while (fs_devices) {
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
list_for_each_entry(device, &fs_devices->devices, dev_list)
|
|
device->fs_info = fs_info;
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
fs_devices = fs_devices->seed;
|
|
}
|
|
}
|
|
|
|
static void __btrfs_reset_dev_stats(struct btrfs_device *dev)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
|
|
btrfs_dev_stat_reset(dev, i);
|
|
}
|
|
|
|
int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_key key;
|
|
struct btrfs_key found_key;
|
|
struct btrfs_root *dev_root = fs_info->dev_root;
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
struct extent_buffer *eb;
|
|
int slot;
|
|
int ret = 0;
|
|
struct btrfs_device *device;
|
|
struct btrfs_path *path = NULL;
|
|
int i;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
list_for_each_entry(device, &fs_devices->devices, dev_list) {
|
|
int item_size;
|
|
struct btrfs_dev_stats_item *ptr;
|
|
|
|
key.objectid = BTRFS_DEV_STATS_OBJECTID;
|
|
key.type = BTRFS_PERSISTENT_ITEM_KEY;
|
|
key.offset = device->devid;
|
|
ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
|
|
if (ret) {
|
|
__btrfs_reset_dev_stats(device);
|
|
device->dev_stats_valid = 1;
|
|
btrfs_release_path(path);
|
|
continue;
|
|
}
|
|
slot = path->slots[0];
|
|
eb = path->nodes[0];
|
|
btrfs_item_key_to_cpu(eb, &found_key, slot);
|
|
item_size = btrfs_item_size_nr(eb, slot);
|
|
|
|
ptr = btrfs_item_ptr(eb, slot,
|
|
struct btrfs_dev_stats_item);
|
|
|
|
for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
|
|
if (item_size >= (1 + i) * sizeof(__le64))
|
|
btrfs_dev_stat_set(device, i,
|
|
btrfs_dev_stats_value(eb, ptr, i));
|
|
else
|
|
btrfs_dev_stat_reset(device, i);
|
|
}
|
|
|
|
device->dev_stats_valid = 1;
|
|
btrfs_dev_stat_print_on_load(device);
|
|
btrfs_release_path(path);
|
|
}
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret < 0 ? ret : 0;
|
|
}
|
|
|
|
static int update_dev_stat_item(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info,
|
|
struct btrfs_device *device)
|
|
{
|
|
struct btrfs_root *dev_root = fs_info->dev_root;
|
|
struct btrfs_path *path;
|
|
struct btrfs_key key;
|
|
struct extent_buffer *eb;
|
|
struct btrfs_dev_stats_item *ptr;
|
|
int ret;
|
|
int i;
|
|
|
|
key.objectid = BTRFS_DEV_STATS_OBJECTID;
|
|
key.type = BTRFS_PERSISTENT_ITEM_KEY;
|
|
key.offset = device->devid;
|
|
|
|
path = btrfs_alloc_path();
|
|
if (!path)
|
|
return -ENOMEM;
|
|
ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
|
|
if (ret < 0) {
|
|
btrfs_warn_in_rcu(fs_info,
|
|
"error %d while searching for dev_stats item for device %s",
|
|
ret, rcu_str_deref(device->name));
|
|
goto out;
|
|
}
|
|
|
|
if (ret == 0 &&
|
|
btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
|
|
/* need to delete old one and insert a new one */
|
|
ret = btrfs_del_item(trans, dev_root, path);
|
|
if (ret != 0) {
|
|
btrfs_warn_in_rcu(fs_info,
|
|
"delete too small dev_stats item for device %s failed %d",
|
|
rcu_str_deref(device->name), ret);
|
|
goto out;
|
|
}
|
|
ret = 1;
|
|
}
|
|
|
|
if (ret == 1) {
|
|
/* need to insert a new item */
|
|
btrfs_release_path(path);
|
|
ret = btrfs_insert_empty_item(trans, dev_root, path,
|
|
&key, sizeof(*ptr));
|
|
if (ret < 0) {
|
|
btrfs_warn_in_rcu(fs_info,
|
|
"insert dev_stats item for device %s failed %d",
|
|
rcu_str_deref(device->name), ret);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
eb = path->nodes[0];
|
|
ptr = btrfs_item_ptr(eb, path->slots[0], struct btrfs_dev_stats_item);
|
|
for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
|
|
btrfs_set_dev_stats_value(eb, ptr, i,
|
|
btrfs_dev_stat_read(device, i));
|
|
btrfs_mark_buffer_dirty(eb);
|
|
|
|
out:
|
|
btrfs_free_path(path);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* called from commit_transaction. Writes all changed device stats to disk.
|
|
*/
|
|
int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
|
|
struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
struct btrfs_device *device;
|
|
int stats_cnt;
|
|
int ret = 0;
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
list_for_each_entry(device, &fs_devices->devices, dev_list) {
|
|
if (!device->dev_stats_valid || !btrfs_dev_stats_dirty(device))
|
|
continue;
|
|
|
|
stats_cnt = atomic_read(&device->dev_stats_ccnt);
|
|
ret = update_dev_stat_item(trans, fs_info, device);
|
|
if (!ret)
|
|
atomic_sub(stats_cnt, &device->dev_stats_ccnt);
|
|
}
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index)
|
|
{
|
|
btrfs_dev_stat_inc(dev, index);
|
|
btrfs_dev_stat_print_on_error(dev);
|
|
}
|
|
|
|
static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
|
|
{
|
|
if (!dev->dev_stats_valid)
|
|
return;
|
|
btrfs_err_rl_in_rcu(dev->fs_info,
|
|
"bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u",
|
|
rcu_str_deref(dev->name),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
|
|
}
|
|
|
|
static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
|
|
if (btrfs_dev_stat_read(dev, i) != 0)
|
|
break;
|
|
if (i == BTRFS_DEV_STAT_VALUES_MAX)
|
|
return; /* all values == 0, suppress message */
|
|
|
|
btrfs_info_in_rcu(dev->fs_info,
|
|
"bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u",
|
|
rcu_str_deref(dev->name),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
|
|
}
|
|
|
|
int btrfs_get_dev_stats(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_ioctl_get_dev_stats *stats)
|
|
{
|
|
struct btrfs_device *dev;
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
int i;
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
dev = btrfs_find_device(fs_info, stats->devid, NULL, NULL);
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
if (!dev) {
|
|
btrfs_warn(fs_info, "get dev_stats failed, device not found");
|
|
return -ENODEV;
|
|
} else if (!dev->dev_stats_valid) {
|
|
btrfs_warn(fs_info, "get dev_stats failed, not yet valid");
|
|
return -ENODEV;
|
|
} else if (stats->flags & BTRFS_DEV_STATS_RESET) {
|
|
for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++) {
|
|
if (stats->nr_items > i)
|
|
stats->values[i] =
|
|
btrfs_dev_stat_read_and_reset(dev, i);
|
|
else
|
|
btrfs_dev_stat_reset(dev, i);
|
|
}
|
|
} else {
|
|
for (i = 0; i < BTRFS_DEV_STAT_VALUES_MAX; i++)
|
|
if (stats->nr_items > i)
|
|
stats->values[i] = btrfs_dev_stat_read(dev, i);
|
|
}
|
|
if (stats->nr_items > BTRFS_DEV_STAT_VALUES_MAX)
|
|
stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX;
|
|
return 0;
|
|
}
|
|
|
|
void btrfs_scratch_superblocks(struct block_device *bdev, const char *device_path)
|
|
{
|
|
struct buffer_head *bh;
|
|
struct btrfs_super_block *disk_super;
|
|
int copy_num;
|
|
|
|
if (!bdev)
|
|
return;
|
|
|
|
for (copy_num = 0; copy_num < BTRFS_SUPER_MIRROR_MAX;
|
|
copy_num++) {
|
|
|
|
if (btrfs_read_dev_one_super(bdev, copy_num, &bh))
|
|
continue;
|
|
|
|
disk_super = (struct btrfs_super_block *)bh->b_data;
|
|
|
|
memset(&disk_super->magic, 0, sizeof(disk_super->magic));
|
|
set_buffer_dirty(bh);
|
|
sync_dirty_buffer(bh);
|
|
brelse(bh);
|
|
}
|
|
|
|
/* Notify udev that device has changed */
|
|
btrfs_kobject_uevent(bdev, KOBJ_CHANGE);
|
|
|
|
/* Update ctime/mtime for device path for libblkid */
|
|
update_dev_time(device_path);
|
|
}
|
|
|
|
/*
|
|
* Update the size of all devices, which is used for writing out the
|
|
* super blocks.
|
|
*/
|
|
void btrfs_update_commit_device_size(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
struct btrfs_device *curr, *next;
|
|
|
|
if (list_empty(&fs_devices->resized_devices))
|
|
return;
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
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;
|
|
}
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
}
|
|
|
|
/* Must be invoked during the transaction commit */
|
|
void btrfs_update_commit_device_bytes_used(struct btrfs_fs_info *fs_info,
|
|
struct btrfs_transaction *transaction)
|
|
{
|
|
struct extent_map *em;
|
|
struct map_lookup *map;
|
|
struct btrfs_device *dev;
|
|
int i;
|
|
|
|
if (list_empty(&transaction->pending_chunks))
|
|
return;
|
|
|
|
/* In order to kick the device replace finish process */
|
|
mutex_lock(&fs_info->chunk_mutex);
|
|
list_for_each_entry(em, &transaction->pending_chunks, list) {
|
|
map = em->map_lookup;
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
dev = map->stripes[i].dev;
|
|
dev->commit_bytes_used = dev->bytes_used;
|
|
}
|
|
}
|
|
mutex_unlock(&fs_info->chunk_mutex);
|
|
}
|
|
|
|
void btrfs_set_fs_info_ptr(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
while (fs_devices) {
|
|
fs_devices->fs_info = fs_info;
|
|
fs_devices = fs_devices->seed;
|
|
}
|
|
}
|
|
|
|
void btrfs_reset_fs_info_ptr(struct btrfs_fs_info *fs_info)
|
|
{
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
while (fs_devices) {
|
|
fs_devices->fs_info = NULL;
|
|
fs_devices = fs_devices->seed;
|
|
}
|
|
}
|