2008-03-24 19:01:56 +00:00
|
|
|
/*
|
|
|
|
* 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 cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-03-24 19:02:07 +00:00
|
|
|
#include <linux/buffer_head.h>
|
2008-04-21 14:03:05 +00:00
|
|
|
#include <linux/blkdev.h>
|
2008-04-28 19:29:42 +00:00
|
|
|
#include <linux/random.h>
|
2009-04-03 14:27:10 +00:00
|
|
|
#include <linux/iocontext.h>
|
2010-12-29 14:55:03 +00:00
|
|
|
#include <linux/capability.h>
|
2012-05-25 14:06:08 +00:00
|
|
|
#include <linux/ratelimit.h>
|
2012-01-16 20:04:48 +00:00
|
|
|
#include <linux/kthread.h>
|
2013-01-29 23:40:14 +00:00
|
|
|
#include <linux/raid/pq.h>
|
2013-08-15 15:11:21 +00:00
|
|
|
#include <linux/semaphore.h>
|
2013-01-29 23:40:14 +00:00
|
|
|
#include <asm/div64.h>
|
2008-03-24 19:01:56 +00:00
|
|
|
#include "ctree.h"
|
|
|
|
#include "extent_map.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "transaction.h"
|
|
|
|
#include "print-tree.h"
|
|
|
|
#include "volumes.h"
|
2013-01-29 23:40:14 +00:00
|
|
|
#include "raid56.h"
|
2008-06-11 20:50:36 +00:00
|
|
|
#include "async-thread.h"
|
2011-11-09 12:44:05 +00:00
|
|
|
#include "check-integrity.h"
|
2012-06-04 18:03:51 +00:00
|
|
|
#include "rcu-string.h"
|
2012-09-13 10:51:36 +00:00
|
|
|
#include "math.h"
|
2012-11-06 12:15:27 +00:00
|
|
|
#include "dev-replace.h"
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
static int init_first_rw_device(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_device *device);
|
|
|
|
static int btrfs_relocate_sys_chunks(struct btrfs_root *root);
|
2012-05-25 14:06:10 +00:00
|
|
|
static void __btrfs_reset_dev_stats(struct btrfs_device *dev);
|
2013-04-25 20:41:01 +00:00
|
|
|
static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev);
|
2012-05-25 14:06:10 +00:00
|
|
|
static void btrfs_dev_stat_print_on_load(struct btrfs_device *device);
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
static DEFINE_MUTEX(uuid_mutex);
|
|
|
|
static LIST_HEAD(fs_uuids);
|
|
|
|
|
2008-07-08 18:19:17 +00:00
|
|
|
static void lock_chunks(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
mutex_lock(&root->fs_info->chunk_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void unlock_chunks(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
mutex_unlock(&root->fs_info->chunk_mutex);
|
|
|
|
}
|
|
|
|
|
2013-08-12 11:33:03 +00:00
|
|
|
static struct btrfs_fs_devices *__alloc_fs_devices(void)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_devices *fs_devs;
|
|
|
|
|
|
|
|
fs_devs = kzalloc(sizeof(*fs_devs), GFP_NOFS);
|
|
|
|
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->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;
|
|
|
|
}
|
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
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);
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_string_free(device->name);
|
2008-12-12 15:03:26 +00:00
|
|
|
kfree(device);
|
|
|
|
}
|
|
|
|
kfree(fs_devices);
|
|
|
|
}
|
|
|
|
|
2012-12-06 19:25:48 +00:00
|
|
|
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)
|
2013-12-20 16:37:06 +00:00
|
|
|
pr_warn("BTRFS: Sending event '%d' to kobject: '%s' (%p): failed\n",
|
2012-12-06 19:25:48 +00:00
|
|
|
action,
|
|
|
|
kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
|
|
|
|
&disk_to_dev(bdev->bd_disk)->kobj);
|
|
|
|
}
|
|
|
|
|
2012-03-01 13:56:26 +00:00
|
|
|
void btrfs_cleanup_fs_uuids(void)
|
2008-03-24 19:02:07 +00:00
|
|
|
{
|
|
|
|
struct btrfs_fs_devices *fs_devices;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
while (!list_empty(&fs_uuids)) {
|
|
|
|
fs_devices = list_entry(fs_uuids.next,
|
|
|
|
struct btrfs_fs_devices, list);
|
|
|
|
list_del(&fs_devices->list);
|
2008-12-12 15:03:26 +00:00
|
|
|
free_fs_devices(fs_devices);
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
static struct btrfs_device *__alloc_device(void)
|
|
|
|
{
|
|
|
|
struct btrfs_device *dev;
|
|
|
|
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_NOFS);
|
|
|
|
if (!dev)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&dev->dev_list);
|
|
|
|
INIT_LIST_HEAD(&dev->dev_alloc_list);
|
|
|
|
|
|
|
|
spin_lock_init(&dev->io_lock);
|
|
|
|
|
|
|
|
spin_lock_init(&dev->reada_lock);
|
|
|
|
atomic_set(&dev->reada_in_flight, 0);
|
|
|
|
INIT_RADIX_TREE(&dev->reada_zones, GFP_NOFS & ~__GFP_WAIT);
|
|
|
|
INIT_RADIX_TREE(&dev->reada_extents, GFP_NOFS & ~__GFP_WAIT);
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
2008-09-05 20:09:51 +00:00
|
|
|
static noinline struct btrfs_device *__find_device(struct list_head *head,
|
|
|
|
u64 devid, u8 *uuid)
|
2008-03-24 19:02:07 +00:00
|
|
|
{
|
|
|
|
struct btrfs_device *dev;
|
|
|
|
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(dev, head, dev_list) {
|
2008-04-18 14:29:38 +00:00
|
|
|
if (dev->devid == devid &&
|
2008-04-25 20:53:30 +00:00
|
|
|
(!uuid || !memcmp(dev->uuid, uuid, BTRFS_UUID_SIZE))) {
|
2008-03-24 19:02:07 +00:00
|
|
|
return dev;
|
2008-04-18 14:29:38 +00:00
|
|
|
}
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-09-05 20:09:51 +00:00
|
|
|
static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
|
2008-03-24 19:02:07 +00:00
|
|
|
{
|
|
|
|
struct btrfs_fs_devices *fs_devices;
|
|
|
|
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(fs_devices, &fs_uuids, list) {
|
2008-03-24 19:02:07 +00:00
|
|
|
if (memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE) == 0)
|
|
|
|
return fs_devices;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-11-12 13:03:45 +00:00
|
|
|
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);
|
2013-12-20 16:37:06 +00:00
|
|
|
printk(KERN_INFO "BTRFS: open %s failed\n", device_path);
|
2012-11-12 13:03:45 +00:00
|
|
|
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 (!*bh) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
blkdev_put(*bdev, flags);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
*bdev = NULL;
|
|
|
|
*bh = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-04-20 19:50:09 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-03-01 13:56:26 +00:00
|
|
|
static noinline void run_scheduled_bios(struct btrfs_device *device)
|
2008-06-11 20:50:36 +00:00
|
|
|
{
|
|
|
|
struct bio *pending;
|
|
|
|
struct backing_dev_info *bdi;
|
2008-08-20 17:39:41 +00:00
|
|
|
struct btrfs_fs_info *fs_info;
|
2009-04-20 19:50:09 +00:00
|
|
|
struct btrfs_pending_bios *pending_bios;
|
2008-06-11 20:50:36 +00:00
|
|
|
struct bio *tail;
|
|
|
|
struct bio *cur;
|
|
|
|
int again = 0;
|
2009-04-20 19:50:09 +00:00
|
|
|
unsigned long num_run;
|
2009-06-09 19:59:22 +00:00
|
|
|
unsigned long batch_run = 0;
|
2008-08-20 17:39:41 +00:00
|
|
|
unsigned long limit;
|
2009-04-03 14:27:10 +00:00
|
|
|
unsigned long last_waited = 0;
|
2009-06-09 19:39:08 +00:00
|
|
|
int force_reg = 0;
|
2011-08-05 09:32:37 +00:00
|
|
|
int sync_pending = 0;
|
2011-04-20 00:12:40 +00:00
|
|
|
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);
|
2008-06-11 20:50:36 +00:00
|
|
|
|
2009-04-03 14:32:58 +00:00
|
|
|
bdi = blk_get_backing_dev_info(device->bdev);
|
2008-08-20 17:39:41 +00:00
|
|
|
fs_info = device->dev_root->fs_info;
|
|
|
|
limit = btrfs_async_submit_limit(fs_info);
|
|
|
|
limit = limit * 2 / 3;
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
loop:
|
|
|
|
spin_lock(&device->io_lock);
|
|
|
|
|
2009-02-04 14:19:41 +00:00
|
|
|
loop_lock:
|
2009-06-09 19:39:08 +00:00
|
|
|
num_run = 0;
|
2009-04-20 19:50:09 +00:00
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
/* 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
|
|
|
|
*/
|
2009-06-09 19:39:08 +00:00
|
|
|
if (!force_reg && device->pending_sync_bios.head) {
|
2009-04-20 19:50:09 +00:00
|
|
|
pending_bios = &device->pending_sync_bios;
|
2009-06-09 19:39:08 +00:00
|
|
|
force_reg = 1;
|
|
|
|
} else {
|
2009-04-20 19:50:09 +00:00
|
|
|
pending_bios = &device->pending_bios;
|
2009-06-09 19:39:08 +00:00
|
|
|
force_reg = 0;
|
|
|
|
}
|
2009-04-20 19:50:09 +00:00
|
|
|
|
|
|
|
pending = pending_bios->head;
|
|
|
|
tail = pending_bios->tail;
|
2008-06-11 20:50:36 +00:00
|
|
|
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.
|
|
|
|
*/
|
2009-04-20 19:50:09 +00:00
|
|
|
if (device->pending_sync_bios.head == NULL &&
|
|
|
|
device->pending_bios.head == NULL) {
|
2008-06-11 20:50:36 +00:00
|
|
|
again = 0;
|
|
|
|
device->running_pending = 0;
|
2009-04-20 19:50:09 +00:00
|
|
|
} else {
|
|
|
|
again = 1;
|
|
|
|
device->running_pending = 1;
|
2008-06-11 20:50:36 +00:00
|
|
|
}
|
2009-04-20 19:50:09 +00:00
|
|
|
|
|
|
|
pending_bios->head = NULL;
|
|
|
|
pending_bios->tail = NULL;
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
spin_unlock(&device->io_lock);
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (pending) {
|
2009-04-20 19:50:09 +00:00
|
|
|
|
|
|
|
rmb();
|
2009-06-09 19:39:08 +00:00
|
|
|
/* 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)) {
|
2009-04-20 19:50:09 +00:00
|
|
|
spin_lock(&device->io_lock);
|
|
|
|
requeue_list(pending_bios, pending, tail);
|
|
|
|
goto loop_lock;
|
|
|
|
}
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
cur = pending;
|
|
|
|
pending = pending->bi_next;
|
|
|
|
cur->bi_next = NULL;
|
2008-08-20 17:39:41 +00:00
|
|
|
|
2012-08-01 19:36:24 +00:00
|
|
|
if (atomic_dec_return(&fs_info->nr_async_bios) < limit &&
|
2008-08-20 17:39:41 +00:00
|
|
|
waitqueue_active(&fs_info->async_submit_wait))
|
|
|
|
wake_up(&fs_info->async_submit_wait);
|
2008-07-31 20:29:02 +00:00
|
|
|
|
|
|
|
BUG_ON(atomic_read(&cur->bi_cnt) == 0);
|
2009-06-09 19:59:22 +00:00
|
|
|
|
2011-08-04 18:28:36 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2011-11-09 12:44:05 +00:00
|
|
|
btrfsic_submit_bio(cur->bi_rw, cur);
|
2010-03-15 14:21:30 +00:00
|
|
|
num_run++;
|
|
|
|
batch_run++;
|
2011-03-10 07:52:07 +00:00
|
|
|
if (need_resched())
|
2009-04-20 19:50:09 +00:00
|
|
|
cond_resched();
|
2008-06-11 20:50:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we made progress, there is more work to do and the bdi
|
|
|
|
* is now congested. Back off and let other work structs
|
|
|
|
* run instead
|
|
|
|
*/
|
2009-08-07 13:59:15 +00:00
|
|
|
if (pending && bdi_write_congested(bdi) && batch_run > 8 &&
|
2008-11-07 23:22:45 +00:00
|
|
|
fs_info->fs_devices->open_devices > 1) {
|
2009-04-03 14:27:10 +00:00
|
|
|
struct io_context *ioc;
|
2008-06-11 20:50:36 +00:00
|
|
|
|
2009-04-03 14:27:10 +00:00
|
|
|
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;
|
2011-03-10 07:52:07 +00:00
|
|
|
if (need_resched())
|
2009-04-20 19:50:09 +00:00
|
|
|
cond_resched();
|
2009-04-03 14:27:10 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-06-11 20:50:36 +00:00
|
|
|
spin_lock(&device->io_lock);
|
2009-04-20 19:50:09 +00:00
|
|
|
requeue_list(pending_bios, pending, tail);
|
2009-02-04 14:19:41 +00:00
|
|
|
device->running_pending = 1;
|
2008-06-11 20:50:36 +00:00
|
|
|
|
|
|
|
spin_unlock(&device->io_lock);
|
|
|
|
btrfs_requeue_work(&device->work);
|
|
|
|
goto done;
|
|
|
|
}
|
2011-12-15 20:38:41 +00:00
|
|
|
/* unplug every 64 requests just for good measure */
|
|
|
|
if (batch_run % 64 == 0) {
|
|
|
|
blk_finish_plug(&plug);
|
|
|
|
blk_start_plug(&plug);
|
|
|
|
sync_pending = 0;
|
|
|
|
}
|
2008-06-11 20:50:36 +00:00
|
|
|
}
|
2009-04-20 19:50:09 +00:00
|
|
|
|
2010-03-10 20:33:32 +00:00
|
|
|
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);
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
done:
|
2011-04-20 00:12:40 +00:00
|
|
|
blk_finish_plug(&plug);
|
2008-06-11 20:50:36 +00:00
|
|
|
}
|
|
|
|
|
2008-12-02 14:54:17 +00:00
|
|
|
static void pending_bios_fn(struct btrfs_work *work)
|
2008-06-11 20:50:36 +00:00
|
|
|
{
|
|
|
|
struct btrfs_device *device;
|
|
|
|
|
|
|
|
device = container_of(work, struct btrfs_device, work);
|
|
|
|
run_scheduled_bios(device);
|
|
|
|
}
|
|
|
|
|
2008-09-05 20:09:51 +00:00
|
|
|
static noinline int device_list_add(const char *path,
|
2008-03-24 19:02:07 +00:00
|
|
|
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;
|
2012-06-04 18:03:51 +00:00
|
|
|
struct rcu_string *name;
|
2008-03-24 19:02:07 +00:00
|
|
|
u64 found_transid = btrfs_super_generation(disk_super);
|
|
|
|
|
|
|
|
fs_devices = find_fsid(disk_super->fsid);
|
|
|
|
if (!fs_devices) {
|
2013-08-12 11:33:03 +00:00
|
|
|
fs_devices = alloc_fs_devices(disk_super->fsid);
|
|
|
|
if (IS_ERR(fs_devices))
|
|
|
|
return PTR_ERR(fs_devices);
|
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
list_add(&fs_devices->list, &fs_uuids);
|
|
|
|
fs_devices->latest_devid = devid;
|
|
|
|
fs_devices->latest_trans = found_transid;
|
2013-08-12 11:33:03 +00:00
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
device = NULL;
|
|
|
|
} else {
|
2008-04-18 14:29:38 +00:00
|
|
|
device = __find_device(&fs_devices->devices, devid,
|
|
|
|
disk_super->dev_item.uuid);
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
|
|
|
if (!device) {
|
2008-11-18 02:11:30 +00:00
|
|
|
if (fs_devices->opened)
|
|
|
|
return -EBUSY;
|
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
device = btrfs_alloc_device(NULL, &devid,
|
|
|
|
disk_super->dev_item.uuid);
|
|
|
|
if (IS_ERR(device)) {
|
2008-03-24 19:02:07 +00:00
|
|
|
/* we can safely leave the fs_devices entry around */
|
2013-08-23 10:20:17 +00:00
|
|
|
return PTR_ERR(device);
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
2012-06-04 18:03:51 +00:00
|
|
|
|
|
|
|
name = rcu_string_strdup(path, GFP_NOFS);
|
|
|
|
if (!name) {
|
2008-03-24 19:02:07 +00:00
|
|
|
kfree(device);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_assign_pointer(device->name, name);
|
2011-05-23 12:30:00 +00:00
|
|
|
|
2009-06-10 19:17:02 +00:00
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
2011-04-20 10:09:16 +00:00
|
|
|
list_add_rcu(&device->dev_list, &fs_devices->devices);
|
Btrfs: fix race conditions in BTRFS_IOC_FS_INFO ioctl
The handler for the ioctl BTRFS_IOC_FS_INFO was reading the
number of devices before acquiring the device list mutex.
This could lead to inconsistent results because the update of
the device list and the number of devices counter (amongst other
counters related to the device list) are updated in volumes.c
while holding the device list mutex - except for 2 places, one
was volumes.c:btrfs_prepare_sprout() and the other was
volumes.c:device_list_add().
For example, if we have 2 devices, with IDs 1 and 2 and then add
a new device, with ID 3, and while adding the device is in progress
an BTRFS_IOC_FS_INFO ioctl arrives, it could return a number of
devices of 2 and a max dev id of 3. This would be incorrect.
Also, this ioctl handler was reading the fsid while it can be
updated concurrently. This can happen when while a new device is
being added and the current filesystem is in seeding mode.
Example:
$ mkfs.btrfs -f /dev/sdb1
$ mkfs.btrfs -f /dev/sdb2
$ btrfstune -S 1 /dev/sdb1
$ mount /dev/sdb1 /mnt/test
$ btrfs device add /dev/sdb2 /mnt/test
If during the last step a BTRFS_IOC_FS_INFO ioctl was requested, it
could read an fsid that was never valid (some bits part of the old
fsid and others part of the new fsid). Also, it could read a number
of devices that doesn't match the number of devices in the list and
the max device id, as explained before.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2013-08-12 19:56:58 +00:00
|
|
|
fs_devices->num_devices++;
|
2009-06-10 19:17:02 +00:00
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
device->fs_devices = fs_devices;
|
2012-06-04 18:03:51 +00:00
|
|
|
} else if (!device->name || strcmp(device->name->str, path)) {
|
|
|
|
name = rcu_string_strdup(path, GFP_NOFS);
|
2010-02-09 06:36:45 +00:00
|
|
|
if (!name)
|
|
|
|
return -ENOMEM;
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_string_free(device->name);
|
|
|
|
rcu_assign_pointer(device->name, name);
|
2010-12-13 19:56:23 +00:00
|
|
|
if (device->missing) {
|
|
|
|
fs_devices->missing_devices--;
|
|
|
|
device->missing = 0;
|
|
|
|
}
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (found_transid > fs_devices->latest_trans) {
|
|
|
|
fs_devices->latest_devid = devid;
|
|
|
|
fs_devices->latest_trans = found_transid;
|
|
|
|
}
|
|
|
|
*fs_devices_ret = fs_devices;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
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;
|
|
|
|
|
2013-08-12 11:33:03 +00:00
|
|
|
fs_devices = alloc_fs_devices(orig->fsid);
|
|
|
|
if (IS_ERR(fs_devices))
|
|
|
|
return fs_devices;
|
2008-12-12 15:03:26 +00:00
|
|
|
|
|
|
|
fs_devices->latest_devid = orig->latest_devid;
|
|
|
|
fs_devices->latest_trans = orig->latest_trans;
|
2012-06-21 20:03:58 +00:00
|
|
|
fs_devices->total_devices = orig->total_devices;
|
2008-12-12 15:03:26 +00:00
|
|
|
|
2011-04-20 10:08:47 +00:00
|
|
|
/* We have held the volume lock, it is safe to get the devices. */
|
2008-12-12 15:03:26 +00:00
|
|
|
list_for_each_entry(orig_dev, &orig->devices, dev_list) {
|
2012-06-04 18:03:51 +00:00
|
|
|
struct rcu_string *name;
|
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
device = btrfs_alloc_device(NULL, &orig_dev->devid,
|
|
|
|
orig_dev->uuid);
|
|
|
|
if (IS_ERR(device))
|
2008-12-12 15:03:26 +00:00
|
|
|
goto error;
|
|
|
|
|
2012-06-04 18:03:51 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
name = rcu_string_strdup(orig_dev->name->str, GFP_NOFS);
|
|
|
|
if (!name) {
|
2009-09-29 17:51:04 +00:00
|
|
|
kfree(device);
|
2008-12-12 15:03:26 +00:00
|
|
|
goto error;
|
2009-09-29 17:51:04 +00:00
|
|
|
}
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_assign_pointer(device->name, name);
|
2008-12-12 15:03:26 +00:00
|
|
|
|
|
|
|
list_add(&device->dev_list, &fs_devices->devices);
|
|
|
|
device->fs_devices = fs_devices;
|
|
|
|
fs_devices->num_devices++;
|
|
|
|
}
|
|
|
|
return fs_devices;
|
|
|
|
error:
|
|
|
|
free_fs_devices(fs_devices);
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
2012-11-06 12:15:27 +00:00
|
|
|
void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_fs_devices *fs_devices, int step)
|
2008-05-13 17:46:40 +00:00
|
|
|
{
|
2009-01-21 15:59:08 +00:00
|
|
|
struct btrfs_device *device, *next;
|
2008-05-13 17:46:40 +00:00
|
|
|
|
2012-02-21 01:53:43 +00:00
|
|
|
struct block_device *latest_bdev = NULL;
|
|
|
|
u64 latest_devid = 0;
|
|
|
|
u64 latest_transid = 0;
|
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
again:
|
2011-04-20 10:08:47 +00:00
|
|
|
/* This is the initialized path, it is safe to release the devices. */
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
|
2012-02-21 01:53:43 +00:00
|
|
|
if (device->in_fs_metadata) {
|
2012-11-05 17:29:28 +00:00
|
|
|
if (!device->is_tgtdev_for_dev_replace &&
|
|
|
|
(!latest_transid ||
|
|
|
|
device->generation > latest_transid)) {
|
2012-02-21 01:53:43 +00:00
|
|
|
latest_devid = device->devid;
|
|
|
|
latest_transid = device->generation;
|
|
|
|
latest_bdev = device->bdev;
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
continue;
|
2012-02-21 01:53:43 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2012-11-06 12:15:27 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
if (device->bdev) {
|
2010-11-13 10:55:18 +00:00
|
|
|
blkdev_put(device->bdev, device->mode);
|
2008-11-18 02:11:30 +00:00
|
|
|
device->bdev = NULL;
|
|
|
|
fs_devices->open_devices--;
|
|
|
|
}
|
|
|
|
if (device->writeable) {
|
|
|
|
list_del_init(&device->dev_alloc_list);
|
|
|
|
device->writeable = 0;
|
2012-11-06 12:15:27 +00:00
|
|
|
if (!device->is_tgtdev_for_dev_replace)
|
|
|
|
fs_devices->rw_devices--;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-12-12 15:03:26 +00:00
|
|
|
list_del_init(&device->dev_list);
|
|
|
|
fs_devices->num_devices--;
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_string_free(device->name);
|
2008-12-12 15:03:26 +00:00
|
|
|
kfree(device);
|
2008-05-13 17:46:40 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
if (fs_devices->seed) {
|
|
|
|
fs_devices = fs_devices->seed;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2012-02-21 01:53:43 +00:00
|
|
|
fs_devices->latest_bdev = latest_bdev;
|
|
|
|
fs_devices->latest_devid = latest_devid;
|
|
|
|
fs_devices->latest_trans = latest_transid;
|
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
}
|
2008-05-13 20:03:06 +00:00
|
|
|
|
2011-04-20 10:09:16 +00:00
|
|
|
static void __free_device(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct btrfs_device *device;
|
|
|
|
|
|
|
|
device = container_of(work, struct btrfs_device, rcu_work);
|
|
|
|
|
|
|
|
if (device->bdev)
|
|
|
|
blkdev_put(device->bdev, device->mode);
|
|
|
|
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_string_free(device->name);
|
2011-04-20 10:09:16 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
|
2008-03-24 19:02:07 +00:00
|
|
|
{
|
|
|
|
struct btrfs_device *device;
|
2008-12-12 15:03:26 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (--fs_devices->opened > 0)
|
|
|
|
return 0;
|
2008-03-24 19:02:07 +00:00
|
|
|
|
2011-04-20 10:07:30 +00:00
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(device, &fs_devices->devices, dev_list) {
|
2011-04-20 10:09:16 +00:00
|
|
|
struct btrfs_device *new_device;
|
2012-06-04 18:03:51 +00:00
|
|
|
struct rcu_string *name;
|
2011-04-20 10:09:16 +00:00
|
|
|
|
|
|
|
if (device->bdev)
|
2008-05-13 20:03:06 +00:00
|
|
|
fs_devices->open_devices--;
|
2011-04-20 10:09:16 +00:00
|
|
|
|
2013-10-10 17:37:29 +00:00
|
|
|
if (device->writeable &&
|
|
|
|
device->devid != BTRFS_DEV_REPLACE_DEVID) {
|
2008-11-18 02:11:30 +00:00
|
|
|
list_del_init(&device->dev_alloc_list);
|
|
|
|
fs_devices->rw_devices--;
|
|
|
|
}
|
|
|
|
|
2011-08-04 14:52:27 +00:00
|
|
|
if (device->can_discard)
|
|
|
|
fs_devices->num_can_discard--;
|
2013-08-26 17:45:53 +00:00
|
|
|
if (device->missing)
|
|
|
|
fs_devices->missing_devices--;
|
2011-08-04 14:52:27 +00:00
|
|
|
|
2013-08-12 11:33:04 +00:00
|
|
|
new_device = btrfs_alloc_device(NULL, &device->devid,
|
|
|
|
device->uuid);
|
|
|
|
BUG_ON(IS_ERR(new_device)); /* -ENOMEM */
|
2012-06-04 18:03:51 +00:00
|
|
|
|
|
|
|
/* Safe because we are under uuid_mutex */
|
2012-08-02 14:23:59 +00:00
|
|
|
if (device->name) {
|
|
|
|
name = rcu_string_strdup(device->name->str, GFP_NOFS);
|
2013-08-12 11:33:04 +00:00
|
|
|
BUG_ON(!name); /* -ENOMEM */
|
2012-08-02 14:23:59 +00:00
|
|
|
rcu_assign_pointer(new_device->name, name);
|
|
|
|
}
|
2013-08-12 11:33:04 +00:00
|
|
|
|
2011-04-20 10:09:16 +00:00
|
|
|
list_replace_rcu(&device->dev_list, &new_device->dev_list);
|
2013-08-12 11:33:04 +00:00
|
|
|
new_device->fs_devices = device->fs_devices;
|
2011-04-20 10:09:16 +00:00
|
|
|
|
|
|
|
call_rcu(&device->rcu, free_device);
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
2011-04-20 10:07:30 +00:00
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
WARN_ON(fs_devices->open_devices);
|
|
|
|
WARN_ON(fs_devices->rw_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
fs_devices->opened = 0;
|
|
|
|
fs_devices->seeding = 0;
|
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
int btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
|
|
|
|
{
|
2008-12-12 15:03:26 +00:00
|
|
|
struct btrfs_fs_devices *seed_devices = NULL;
|
2008-11-18 02:11:30 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
ret = __btrfs_close_devices(fs_devices);
|
2008-12-12 15:03:26 +00:00
|
|
|
if (!fs_devices->opened) {
|
|
|
|
seed_devices = fs_devices->seed;
|
|
|
|
fs_devices->seed = NULL;
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2008-12-12 15:03:26 +00:00
|
|
|
|
|
|
|
while (seed_devices) {
|
|
|
|
fs_devices = seed_devices;
|
|
|
|
seed_devices = fs_devices->seed;
|
|
|
|
__btrfs_close_devices(fs_devices);
|
|
|
|
free_fs_devices(fs_devices);
|
|
|
|
}
|
2013-03-09 15:18:39 +00:00
|
|
|
/*
|
|
|
|
* Wait for rcu kworkers under __btrfs_close_devices
|
|
|
|
* to finish all blkdev_puts so device is really
|
|
|
|
* free when umount is done.
|
|
|
|
*/
|
|
|
|
rcu_barrier();
|
2008-11-18 02:11:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
|
|
|
|
fmode_t flags, void *holder)
|
2008-03-24 19:02:07 +00:00
|
|
|
{
|
2011-08-04 14:52:27 +00:00
|
|
|
struct request_queue *q;
|
2008-03-24 19:02:07 +00:00
|
|
|
struct block_device *bdev;
|
|
|
|
struct list_head *head = &fs_devices->devices;
|
|
|
|
struct btrfs_device *device;
|
2008-05-13 20:03:06 +00:00
|
|
|
struct block_device *latest_bdev = NULL;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct btrfs_super_block *disk_super;
|
|
|
|
u64 latest_devid = 0;
|
|
|
|
u64 latest_transid = 0;
|
|
|
|
u64 devid;
|
2008-11-18 02:11:30 +00:00
|
|
|
int seeding = 1;
|
2008-05-13 20:03:06 +00:00
|
|
|
int ret = 0;
|
2008-03-24 19:02:07 +00:00
|
|
|
|
2010-11-13 10:55:18 +00:00
|
|
|
flags |= FMODE_EXCL;
|
|
|
|
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(device, head, dev_list) {
|
2008-05-08 19:05:58 +00:00
|
|
|
if (device->bdev)
|
|
|
|
continue;
|
2008-05-13 17:46:40 +00:00
|
|
|
if (!device->name)
|
|
|
|
continue;
|
|
|
|
|
2013-04-04 20:45:08 +00:00
|
|
|
/* Just open everything we can; ignore failures here */
|
|
|
|
if (btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
|
|
|
|
&bdev, &bh))
|
2012-11-12 13:03:45 +00:00
|
|
|
continue;
|
2008-05-13 20:03:06 +00:00
|
|
|
|
|
|
|
disk_super = (struct btrfs_super_block *)bh->b_data;
|
2010-01-06 11:48:18 +00:00
|
|
|
devid = btrfs_stack_device_id(&disk_super->dev_item);
|
2008-05-13 20:03:06 +00:00
|
|
|
if (devid != device->devid)
|
|
|
|
goto error_brelse;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (memcmp(device->uuid, disk_super->dev_item.uuid,
|
|
|
|
BTRFS_UUID_SIZE))
|
|
|
|
goto error_brelse;
|
|
|
|
|
|
|
|
device->generation = btrfs_super_generation(disk_super);
|
|
|
|
if (!latest_transid || device->generation > latest_transid) {
|
2008-05-13 20:03:06 +00:00
|
|
|
latest_devid = devid;
|
2008-11-18 02:11:30 +00:00
|
|
|
latest_transid = device->generation;
|
2008-05-13 20:03:06 +00:00
|
|
|
latest_bdev = bdev;
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_SEEDING) {
|
|
|
|
device->writeable = 0;
|
|
|
|
} else {
|
|
|
|
device->writeable = !bdev_read_only(bdev);
|
|
|
|
seeding = 0;
|
|
|
|
}
|
|
|
|
|
2011-08-04 14:52:27 +00:00
|
|
|
q = bdev_get_queue(bdev);
|
|
|
|
if (blk_queue_discard(q)) {
|
|
|
|
device->can_discard = 1;
|
|
|
|
fs_devices->num_can_discard++;
|
|
|
|
}
|
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
device->bdev = bdev;
|
2008-05-13 17:46:40 +00:00
|
|
|
device->in_fs_metadata = 0;
|
2008-11-20 02:17:22 +00:00
|
|
|
device->mode = flags;
|
|
|
|
|
2009-06-10 13:51:32 +00:00
|
|
|
if (!blk_queue_nonrot(bdev_get_queue(bdev)))
|
|
|
|
fs_devices->rotating = 1;
|
|
|
|
|
2008-05-13 20:03:06 +00:00
|
|
|
fs_devices->open_devices++;
|
2013-09-01 15:56:44 +00:00
|
|
|
if (device->writeable &&
|
|
|
|
device->devid != BTRFS_DEV_REPLACE_DEVID) {
|
2008-11-18 02:11:30 +00:00
|
|
|
fs_devices->rw_devices++;
|
|
|
|
list_add(&device->dev_alloc_list,
|
|
|
|
&fs_devices->alloc_list);
|
|
|
|
}
|
2011-04-20 10:06:40 +00:00
|
|
|
brelse(bh);
|
2008-05-13 20:03:06 +00:00
|
|
|
continue;
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2008-05-13 20:03:06 +00:00
|
|
|
error_brelse:
|
|
|
|
brelse(bh);
|
2010-11-13 10:55:18 +00:00
|
|
|
blkdev_put(bdev, flags);
|
2008-05-13 20:03:06 +00:00
|
|
|
continue;
|
2008-03-24 19:02:07 +00:00
|
|
|
}
|
2008-05-13 20:03:06 +00:00
|
|
|
if (fs_devices->open_devices == 0) {
|
2011-10-19 21:06:20 +00:00
|
|
|
ret = -EINVAL;
|
2008-05-13 20:03:06 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
fs_devices->seeding = seeding;
|
|
|
|
fs_devices->opened = 1;
|
2008-05-13 20:03:06 +00:00
|
|
|
fs_devices->latest_bdev = latest_bdev;
|
|
|
|
fs_devices->latest_devid = latest_devid;
|
|
|
|
fs_devices->latest_trans = latest_transid;
|
2008-11-18 02:11:30 +00:00
|
|
|
fs_devices->total_rw_bytes = 0;
|
2008-05-13 20:03:06 +00:00
|
|
|
out:
|
2008-11-18 02:11:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
|
2008-12-02 11:36:09 +00:00
|
|
|
fmode_t flags, void *holder)
|
2008-11-18 02:11:30 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
if (fs_devices->opened) {
|
2008-12-12 15:03:26 +00:00
|
|
|
fs_devices->opened++;
|
|
|
|
ret = 0;
|
2008-11-18 02:11:30 +00:00
|
|
|
} else {
|
2008-11-20 02:17:22 +00:00
|
|
|
ret = __btrfs_open_devices(fs_devices, flags, holder);
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-03-24 19:02:07 +00:00
|
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-02-15 18:31:02 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2008-12-02 11:36:09 +00:00
|
|
|
int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
|
2008-03-24 19:02:07 +00:00
|
|
|
struct btrfs_fs_devices **fs_devices_ret)
|
|
|
|
{
|
|
|
|
struct btrfs_super_block *disk_super;
|
|
|
|
struct block_device *bdev;
|
2013-02-15 18:31:02 +00:00
|
|
|
struct page *page;
|
|
|
|
void *p;
|
|
|
|
int ret = -EINVAL;
|
2008-03-24 19:02:07 +00:00
|
|
|
u64 devid;
|
2008-04-10 20:19:33 +00:00
|
|
|
u64 transid;
|
2012-06-21 20:03:58 +00:00
|
|
|
u64 total_devices;
|
2013-02-15 18:31:02 +00:00
|
|
|
u64 bytenr;
|
|
|
|
pgoff_t index;
|
2008-03-24 19:02:07 +00:00
|
|
|
|
2013-02-15 18:31:02 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2010-11-13 10:55:18 +00:00
|
|
|
flags |= FMODE_EXCL;
|
2011-11-17 20:05:22 +00:00
|
|
|
mutex_lock(&uuid_mutex);
|
2013-02-15 18:31:02 +00:00
|
|
|
|
|
|
|
bdev = blkdev_get_by_path(path, flags, holder);
|
|
|
|
|
|
|
|
if (IS_ERR(bdev)) {
|
|
|
|
ret = PTR_ERR(bdev);
|
2012-11-12 13:03:45 +00:00
|
|
|
goto error;
|
2013-02-15 18:31:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure our super fits in the device */
|
|
|
|
if (bytenr + PAGE_CACHE_SIZE >= i_size_read(bdev->bd_inode))
|
|
|
|
goto error_bdev_put;
|
|
|
|
|
|
|
|
/* make sure our super fits in the page */
|
|
|
|
if (sizeof(*disk_super) > PAGE_CACHE_SIZE)
|
|
|
|
goto error_bdev_put;
|
|
|
|
|
|
|
|
/* make sure our super doesn't straddle pages on disk */
|
|
|
|
index = bytenr >> PAGE_CACHE_SHIFT;
|
|
|
|
if ((bytenr + sizeof(*disk_super) - 1) >> PAGE_CACHE_SHIFT != index)
|
|
|
|
goto error_bdev_put;
|
|
|
|
|
|
|
|
/* pull in the page with our super */
|
|
|
|
page = read_cache_page_gfp(bdev->bd_inode->i_mapping,
|
|
|
|
index, GFP_NOFS);
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(page))
|
|
|
|
goto error_bdev_put;
|
|
|
|
|
|
|
|
p = kmap(page);
|
|
|
|
|
|
|
|
/* align our pointer to the offset of the super block */
|
|
|
|
disk_super = p + (bytenr & ~PAGE_CACHE_MASK);
|
|
|
|
|
|
|
|
if (btrfs_super_bytenr(disk_super) != bytenr ||
|
2013-07-16 03:19:18 +00:00
|
|
|
btrfs_super_magic(disk_super) != BTRFS_MAGIC)
|
2013-02-15 18:31:02 +00:00
|
|
|
goto error_unmap;
|
|
|
|
|
2010-01-06 11:48:18 +00:00
|
|
|
devid = btrfs_stack_device_id(&disk_super->dev_item);
|
2008-04-10 20:19:33 +00:00
|
|
|
transid = btrfs_super_generation(disk_super);
|
2012-06-21 20:03:58 +00:00
|
|
|
total_devices = btrfs_super_num_devices(disk_super);
|
2013-02-15 18:31:02 +00:00
|
|
|
|
2012-11-05 13:10:49 +00:00
|
|
|
if (disk_super->label[0]) {
|
|
|
|
if (disk_super->label[BTRFS_LABEL_SIZE - 1])
|
|
|
|
disk_super->label[BTRFS_LABEL_SIZE - 1] = '\0';
|
2013-12-20 16:37:06 +00:00
|
|
|
printk(KERN_INFO "BTRFS: device label %s ", disk_super->label);
|
2012-11-05 13:10:49 +00:00
|
|
|
} else {
|
2013-12-20 16:37:06 +00:00
|
|
|
printk(KERN_INFO "BTRFS: device fsid %pU ", disk_super->fsid);
|
2012-11-05 13:10:49 +00:00
|
|
|
}
|
2013-02-15 18:31:02 +00:00
|
|
|
|
2013-08-20 11:20:07 +00:00
|
|
|
printk(KERN_CONT "devid %llu transid %llu %s\n", devid, transid, path);
|
2013-02-15 18:31:02 +00:00
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
ret = device_list_add(path, disk_super, devid, fs_devices_ret);
|
2012-06-21 20:03:58 +00:00
|
|
|
if (!ret && fs_devices_ret)
|
|
|
|
(*fs_devices_ret)->total_devices = total_devices;
|
2013-02-15 18:31:02 +00:00
|
|
|
|
|
|
|
error_unmap:
|
|
|
|
kunmap(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
|
|
|
|
error_bdev_put:
|
2010-11-13 10:55:18 +00:00
|
|
|
blkdev_put(bdev, flags);
|
2008-03-24 19:02:07 +00:00
|
|
|
error:
|
2012-11-12 13:03:45 +00:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2008-03-24 19:02:07 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 10:07:31 +00:00
|
|
|
/* helper to account the used device space in the range */
|
|
|
|
int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
|
|
|
|
u64 end, u64 *length)
|
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_root *root = device->dev_root;
|
|
|
|
struct btrfs_dev_extent *dev_extent;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
u64 extent_end;
|
|
|
|
int ret;
|
|
|
|
int slot;
|
|
|
|
struct extent_buffer *l;
|
|
|
|
|
|
|
|
*length = 0;
|
|
|
|
|
2012-11-05 17:29:28 +00:00
|
|
|
if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
|
btrfs: fix wrong free space information of btrfs
When we store data by raid profile in btrfs with two or more different size
disks, df command shows there is some free space in the filesystem, but the
user can not write any data in fact, df command shows the wrong free space
information of btrfs.
# mkfs.btrfs -d raid1 /dev/sda9 /dev/sda10
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 28.00KB
devid 1 size 5.01GB used 2.03GB path /dev/sda9
devid 2 size 10.00GB used 2.01GB path /dev/sda10
# btrfs device scan /dev/sda9 /dev/sda10
# mount /dev/sda9 /mnt
# dd if=/dev/zero of=tmpfile0 bs=4K count=9999999999
(fill the filesystem)
# sync
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 5.4G 62% /mnt
# btrfs-show
Label: none uuid: a95cd49e-6e33-45b8-8741-a36153ce4b64
Total devices 2 FS bytes used 3.99GB
devid 1 size 5.01GB used 5.01GB path /dev/sda9
devid 2 size 10.00GB used 4.99GB path /dev/sda10
It is because btrfs cannot allocate chunks when one of the pairing disks has
no space, the free space on the other disks can not be used for ever, and should
be subtracted from the total space, but btrfs doesn't subtract this space from
the total. It is strange to the user.
This patch fixes it by calcing the free space that can be used to allocate
chunks.
Implementation:
1. get all the devices free space, and align them by stripe length.
2. sort the devices by the free space.
3. check the free space of the devices,
3.1. if it is not zero, and then check the number of the devices that has
more free space than this device,
if the number of the devices is beyond the min stripe number, the free
space can be used, and add into total free space.
if the number of the devices is below the min stripe number, we can not
use the free space, the check ends.
3.2. if the free space is zero, check the next devices, goto 3.1
This implementation is just likely fake chunk allocation.
After appling this patch, df can show correct space information:
# df -TH
Filesystem Type Size Used Avail Use% Mounted on
/dev/sda9 btrfs 17G 8.6G 0 100% /mnt
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-01-05 10:07:31 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
path->reada = 2;
|
|
|
|
|
|
|
|
key.objectid = device->devid;
|
|
|
|
key.offset = start;
|
|
|
|
key.type = BTRFS_DEV_EXTENT_KEY;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
if (ret > 0) {
|
|
|
|
ret = btrfs_previous_item(root, path, key.objectid, key.type);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
l = path->nodes[0];
|
|
|
|
slot = path->slots[0];
|
|
|
|
if (slot >= btrfs_header_nritems(l)) {
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret == 0)
|
|
|
|
continue;
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(l, &key, slot);
|
|
|
|
|
|
|
|
if (key.objectid < device->devid)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
if (key.objectid > device->devid)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
|
|
|
|
extent_end = key.offset + btrfs_dev_extent_length(l,
|
|
|
|
dev_extent);
|
|
|
|
if (key.offset <= start && extent_end > end) {
|
|
|
|
*length = end - start + 1;
|
|
|
|
break;
|
|
|
|
} else if (key.offset <= start && extent_end > start)
|
|
|
|
*length += extent_end - start;
|
|
|
|
else if (key.offset > start && extent_end <= end)
|
|
|
|
*length += extent_end - key.offset;
|
|
|
|
else if (key.offset > start && key.offset <= end) {
|
|
|
|
*length += end - key.offset + 1;
|
|
|
|
break;
|
|
|
|
} else if (key.offset > end)
|
|
|
|
break;
|
|
|
|
|
|
|
|
next:
|
|
|
|
path->slots[0]++;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
static int contains_pending_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_device *device,
|
|
|
|
u64 *start, u64 len)
|
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(em, &trans->transaction->pending_chunks, list) {
|
|
|
|
struct map_lookup *map;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
|
|
if (map->stripes[i].dev != device)
|
|
|
|
continue;
|
|
|
|
if (map->stripes[i].physical >= *start + len ||
|
|
|
|
map->stripes[i].physical + em->orig_block_len <=
|
|
|
|
*start)
|
|
|
|
continue;
|
|
|
|
*start = map->stripes[i].physical +
|
|
|
|
em->orig_block_len;
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
/*
|
2011-01-05 10:07:26 +00:00
|
|
|
* find_free_dev_extent - 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
|
|
|
|
* @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
|
|
|
|
*
|
2008-03-24 19:01:56 +00:00
|
|
|
* 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
|
2011-01-05 10:07:26 +00:00
|
|
|
*
|
|
|
|
* @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.
|
2008-03-24 19:01:56 +00:00
|
|
|
*/
|
2013-06-27 17:22:46 +00:00
|
|
|
int find_free_dev_extent(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_device *device, u64 num_bytes,
|
2011-01-05 10:07:26 +00:00
|
|
|
u64 *start, u64 *len)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_root *root = device->dev_root;
|
2011-01-05 10:07:26 +00:00
|
|
|
struct btrfs_dev_extent *dev_extent;
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_path *path;
|
2011-01-05 10:07:26 +00:00
|
|
|
u64 hole_size;
|
|
|
|
u64 max_hole_start;
|
|
|
|
u64 max_hole_size;
|
|
|
|
u64 extent_end;
|
|
|
|
u64 search_start;
|
2008-03-24 19:01:56 +00:00
|
|
|
u64 search_end = device->total_bytes;
|
|
|
|
int ret;
|
2011-01-05 10:07:26 +00:00
|
|
|
int slot;
|
2008-03-24 19:01:56 +00:00
|
|
|
struct extent_buffer *l;
|
|
|
|
|
|
|
|
/* FIXME use last free of some kind */
|
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
/* we don't want to overwrite the superblock on the drive,
|
|
|
|
* so we make sure to start at an offset of at least 1MB
|
|
|
|
*/
|
2011-04-12 09:01:20 +00:00
|
|
|
search_start = max(root->fs_info->alloc_start, 1024ull * 1024);
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
again:
|
2011-01-05 10:07:26 +00:00
|
|
|
max_hole_start = search_start;
|
|
|
|
max_hole_size = 0;
|
Btrfs: fix a bug of balance on full multi-disk partitions
When balancing, we'll first try to shrink devices for some space,
but if it is working on a full multi-disk partition with raid protection,
we may encounter a bug, that is, while shrinking, total_bytes may be less
than bytes_used, and btrfs may allocate a dev extent that accesses out of
device's bounds.
Then we will not be able to write or read the data which stores at the end
of the device, and get the followings:
device fsid 0939f071-7ea3-46c8-95df-f176d773bfb6 devid 1 transid 10 /dev/sdb5
Btrfs detected SSD devices, enabling SSD mode
btrfs: relocating block group 476315648 flags 9
btrfs: found 4 extents
attempt to access beyond end of device
sdb5: rw=145, want=546176, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546304, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546432, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546560, limit=546147
attempt to access beyond end of device
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-08-02 02:39:03 +00:00
|
|
|
hole_size = 0;
|
2011-01-05 10:07:26 +00:00
|
|
|
|
2012-11-05 17:29:28 +00:00
|
|
|
if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
|
2011-01-05 10:07:26 +00:00
|
|
|
ret = -ENOSPC;
|
2013-06-27 17:22:46 +00:00
|
|
|
goto out;
|
2011-01-05 10:07:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
path->reada = 2;
|
2013-06-27 17:22:46 +00:00
|
|
|
path->search_commit_root = 1;
|
|
|
|
path->skip_locking = 1;
|
2011-01-05 10:07:26 +00:00
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
key.objectid = device->devid;
|
|
|
|
key.offset = search_start;
|
|
|
|
key.type = BTRFS_DEV_EXTENT_KEY;
|
2011-01-05 10:07:26 +00:00
|
|
|
|
2011-12-08 07:07:24 +00:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
2008-03-24 19:01:56 +00:00
|
|
|
if (ret < 0)
|
2011-01-05 10:07:26 +00:00
|
|
|
goto out;
|
2009-07-24 15:06:53 +00:00
|
|
|
if (ret > 0) {
|
|
|
|
ret = btrfs_previous_item(root, path, key.objectid, key.type);
|
|
|
|
if (ret < 0)
|
2011-01-05 10:07:26 +00:00
|
|
|
goto out;
|
2009-07-24 15:06:53 +00:00
|
|
|
}
|
2011-01-05 10:07:26 +00:00
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
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)
|
2011-01-05 10:07:26 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
break;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
btrfs_item_key_to_cpu(l, &key, slot);
|
|
|
|
|
|
|
|
if (key.objectid < device->devid)
|
|
|
|
goto next;
|
|
|
|
|
|
|
|
if (key.objectid > device->devid)
|
2011-01-05 10:07:26 +00:00
|
|
|
break;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2011-01-05 10:07:26 +00:00
|
|
|
if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
|
|
|
|
goto next;
|
2009-07-24 20:41:41 +00:00
|
|
|
|
2011-01-05 10:07:26 +00:00
|
|
|
if (key.offset > search_start) {
|
|
|
|
hole_size = key.offset - search_start;
|
2009-07-24 20:41:41 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
/*
|
|
|
|
* Have to check before we set max_hole_start, otherwise
|
|
|
|
* we could end up sending back this offset anyway.
|
|
|
|
*/
|
|
|
|
if (contains_pending_extent(trans, device,
|
|
|
|
&search_start,
|
|
|
|
hole_size))
|
|
|
|
hole_size = 0;
|
|
|
|
|
2011-01-05 10:07:26 +00:00
|
|
|
if (hole_size > max_hole_size) {
|
|
|
|
max_hole_start = search_start;
|
|
|
|
max_hole_size = hole_size;
|
|
|
|
}
|
2009-07-24 20:41:41 +00:00
|
|
|
|
2011-01-05 10:07:26 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
|
2011-01-05 10:07:26 +00:00
|
|
|
extent_end = key.offset + btrfs_dev_extent_length(l,
|
|
|
|
dev_extent);
|
|
|
|
if (extent_end > search_start)
|
|
|
|
search_start = extent_end;
|
2008-03-24 19:01:56 +00:00
|
|
|
next:
|
|
|
|
path->slots[0]++;
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
|
Btrfs: fix a bug of balance on full multi-disk partitions
When balancing, we'll first try to shrink devices for some space,
but if it is working on a full multi-disk partition with raid protection,
we may encounter a bug, that is, while shrinking, total_bytes may be less
than bytes_used, and btrfs may allocate a dev extent that accesses out of
device's bounds.
Then we will not be able to write or read the data which stores at the end
of the device, and get the followings:
device fsid 0939f071-7ea3-46c8-95df-f176d773bfb6 devid 1 transid 10 /dev/sdb5
Btrfs detected SSD devices, enabling SSD mode
btrfs: relocating block group 476315648 flags 9
btrfs: found 4 extents
attempt to access beyond end of device
sdb5: rw=145, want=546176, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546304, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546432, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546560, limit=546147
attempt to access beyond end of device
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-08-02 02:39:03 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2011-01-05 10:07:26 +00:00
|
|
|
if (hole_size > max_hole_size) {
|
|
|
|
max_hole_start = search_start;
|
|
|
|
max_hole_size = hole_size;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
if (contains_pending_extent(trans, device, &search_start, hole_size)) {
|
|
|
|
btrfs_release_path(path);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
|
2011-01-05 10:07:26 +00:00
|
|
|
/* See above. */
|
|
|
|
if (hole_size < num_bytes)
|
|
|
|
ret = -ENOSPC;
|
|
|
|
else
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
out:
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_free_path(path);
|
2011-01-05 10:07:26 +00:00
|
|
|
*start = max_hole_start;
|
2011-01-05 10:07:28 +00:00
|
|
|
if (len)
|
2011-01-05 10:07:26 +00:00
|
|
|
*len = max_hole_size;
|
2008-03-24 19:01:56 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-02 14:54:17 +00:00
|
|
|
static int btrfs_free_dev_extent(struct btrfs_trans_handle *trans,
|
2008-04-25 20:53:30 +00:00
|
|
|
struct btrfs_device *device,
|
|
|
|
u64 start)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_root *root = device->dev_root;
|
|
|
|
struct btrfs_key key;
|
2008-05-07 15:43:44 +00:00
|
|
|
struct btrfs_key found_key;
|
|
|
|
struct extent_buffer *leaf = NULL;
|
|
|
|
struct btrfs_dev_extent *extent = NULL;
|
2008-04-25 20:53:30 +00:00
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
key.objectid = device->devid;
|
|
|
|
key.offset = start;
|
|
|
|
key.type = BTRFS_DEV_EXTENT_KEY;
|
2011-11-11 01:45:04 +00:00
|
|
|
again:
|
2008-04-25 20:53:30 +00:00
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
|
2008-05-07 15:43:44 +00:00
|
|
|
if (ret > 0) {
|
|
|
|
ret = btrfs_previous_item(root, path, key.objectid,
|
|
|
|
BTRFS_DEV_EXTENT_KEY);
|
2011-05-19 07:03:42 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-05-07 15:43:44 +00:00
|
|
|
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);
|
2011-11-11 01:45:04 +00:00
|
|
|
key = found_key;
|
|
|
|
btrfs_release_path(path);
|
|
|
|
goto again;
|
2008-05-07 15:43:44 +00:00
|
|
|
} else if (ret == 0) {
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
extent = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_dev_extent);
|
2012-03-12 15:03:00 +00:00
|
|
|
} else {
|
|
|
|
btrfs_error(root->fs_info, ret, "Slot search failed");
|
|
|
|
goto out;
|
2008-05-07 15:43:44 +00:00
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2011-09-26 21:12:22 +00:00
|
|
|
if (device->bytes_used > 0) {
|
|
|
|
u64 len = btrfs_dev_extent_length(leaf, extent);
|
|
|
|
device->bytes_used -= len;
|
|
|
|
spin_lock(&root->fs_info->free_chunk_lock);
|
|
|
|
root->fs_info->free_chunk_space += len;
|
|
|
|
spin_unlock(&root->fs_info->free_chunk_lock);
|
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
ret = btrfs_del_item(trans, root, path);
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret) {
|
|
|
|
btrfs_error(root->fs_info, ret,
|
|
|
|
"Failed to remove dev extent item");
|
|
|
|
}
|
2011-05-19 07:03:42 +00:00
|
|
|
out:
|
2008-04-25 20:53:30 +00:00
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-04-25 20:41:01 +00:00
|
|
|
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)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_root *root = device->dev_root;
|
|
|
|
struct btrfs_dev_extent *extent;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
WARN_ON(!device->in_fs_metadata);
|
2012-11-05 17:29:28 +00:00
|
|
|
WARN_ON(device->is_tgtdev_for_dev_replace);
|
2008-03-24 19:01:56 +00:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
key.objectid = device->devid;
|
2008-11-18 02:11:30 +00:00
|
|
|
key.offset = start;
|
2008-03-24 19:01:56 +00:00
|
|
|
key.type = BTRFS_DEV_EXTENT_KEY;
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, &key,
|
|
|
|
sizeof(*extent));
|
2011-09-09 00:14:32 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
extent = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_dev_extent);
|
2008-04-15 19:41:47 +00:00
|
|
|
btrfs_set_dev_extent_chunk_tree(leaf, extent, chunk_tree);
|
|
|
|
btrfs_set_dev_extent_chunk_objectid(leaf, extent, chunk_objectid);
|
|
|
|
btrfs_set_dev_extent_chunk_offset(leaf, extent, chunk_offset);
|
|
|
|
|
|
|
|
write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
|
2013-08-20 11:20:13 +00:00
|
|
|
btrfs_dev_extent_chunk_tree_uuid(extent), BTRFS_UUID_SIZE);
|
2008-04-15 19:41:47 +00:00
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_set_dev_extent_length(leaf, extent, num_bytes);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
2011-09-09 00:14:32 +00:00
|
|
|
out:
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
static u64 find_next_chunk(struct btrfs_fs_info *fs_info)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
2013-06-27 17:22:46 +00:00
|
|
|
struct extent_map_tree *em_tree;
|
|
|
|
struct extent_map *em;
|
|
|
|
struct rb_node *n;
|
|
|
|
u64 ret = 0;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
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;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
2013-06-27 17:22:46 +00:00
|
|
|
read_unlock(&em_tree->lock);
|
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-08-12 11:33:01 +00:00
|
|
|
static noinline int find_next_devid(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 *devid_ret)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_path *path;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
|
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
|
|
key.type = BTRFS_DEV_ITEM_KEY;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
|
2013-08-12 11:33:01 +00:00
|
|
|
ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
|
2008-03-24 19:01:56 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(ret == 0); /* Corruption */
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-08-12 11:33:01 +00:00
|
|
|
ret = btrfs_previous_item(fs_info->chunk_root, path,
|
|
|
|
BTRFS_DEV_ITEMS_OBJECTID,
|
2008-03-24 19:01:56 +00:00
|
|
|
BTRFS_DEV_ITEM_KEY);
|
|
|
|
if (ret) {
|
2013-08-12 11:33:01 +00:00
|
|
|
*devid_ret = 1;
|
2008-03-24 19:01:56 +00:00
|
|
|
} else {
|
|
|
|
btrfs_item_key_to_cpu(path->nodes[0], &found_key,
|
|
|
|
path->slots[0]);
|
2013-08-12 11:33:01 +00:00
|
|
|
*devid_ret = found_key.offset + 1;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
error:
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_free_path(path);
|
2008-03-24 19:01:56 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the device information is stored in the chunk root
|
|
|
|
* the btrfs_device struct should be fully filled in
|
|
|
|
*/
|
2013-04-25 20:41:01 +00:00
|
|
|
static int btrfs_add_device(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_device *device)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_dev_item *dev_item;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
|
|
|
unsigned long ptr;
|
|
|
|
|
|
|
|
root = root->fs_info->chunk_root;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
|
|
key.type = BTRFS_DEV_ITEM_KEY;
|
2008-11-18 02:11:30 +00:00
|
|
|
key.offset = device->devid;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
|
|
|
ret = btrfs_insert_empty_item(trans, root, path, &key,
|
2008-03-24 19:02:07 +00:00
|
|
|
sizeof(*dev_item));
|
2008-03-24 19:01:56 +00:00
|
|
|
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);
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_set_device_generation(leaf, dev_item, 0);
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_set_device_type(leaf, dev_item, device->type);
|
|
|
|
btrfs_set_device_io_align(leaf, dev_item, device->io_align);
|
|
|
|
btrfs_set_device_io_width(leaf, dev_item, device->io_width);
|
|
|
|
btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
|
|
|
|
btrfs_set_device_total_bytes(leaf, dev_item, device->total_bytes);
|
|
|
|
btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
|
2008-04-15 19:41:47 +00:00
|
|
|
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);
|
2008-12-08 21:40:21 +00:00
|
|
|
btrfs_set_device_start_offset(leaf, dev_item, 0);
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-08-20 11:20:11 +00:00
|
|
|
ptr = btrfs_device_uuid(dev_item);
|
2008-04-15 19:41:47 +00:00
|
|
|
write_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
|
2013-08-20 11:20:12 +00:00
|
|
|
ptr = btrfs_device_fsid(dev_item);
|
2008-11-18 02:11:30 +00:00
|
|
|
write_extent_buffer(leaf, root->fs_info->fsid, ptr, BTRFS_UUID_SIZE);
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = 0;
|
2008-03-24 19:01:56 +00:00
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2008-05-07 15:43:44 +00:00
|
|
|
static int btrfs_rm_dev_item(struct btrfs_root *root,
|
|
|
|
struct btrfs_device *device)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
|
|
|
|
root = root->fs_info->chunk_root;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2011-01-20 06:19:37 +00:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return PTR_ERR(trans);
|
|
|
|
}
|
2008-05-07 15:43:44 +00:00
|
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
|
|
key.type = BTRFS_DEV_ITEM_KEY;
|
|
|
|
key.offset = device->devid;
|
2008-07-08 18:19:17 +00:00
|
|
|
lock_chunks(root);
|
2008-05-07 15:43:44 +00:00
|
|
|
|
|
|
|
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);
|
2008-07-08 18:19:17 +00:00
|
|
|
unlock_chunks(root);
|
2008-05-07 15:43:44 +00:00
|
|
|
btrfs_commit_transaction(trans, root);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_rm_device(struct btrfs_root *root, char *device_path)
|
|
|
|
{
|
|
|
|
struct btrfs_device *device;
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_device *next_device;
|
2008-05-07 15:43:44 +00:00
|
|
|
struct block_device *bdev;
|
2008-05-13 17:46:40 +00:00
|
|
|
struct buffer_head *bh = NULL;
|
2008-05-07 15:43:44 +00:00
|
|
|
struct btrfs_super_block *disk_super;
|
2011-04-20 10:09:16 +00:00
|
|
|
struct btrfs_fs_devices *cur_devices;
|
2008-05-07 15:43:44 +00:00
|
|
|
u64 all_avail;
|
|
|
|
u64 devid;
|
2008-11-18 02:11:30 +00:00
|
|
|
u64 num_devices;
|
|
|
|
u8 *dev_uuid;
|
2013-01-29 10:13:12 +00:00
|
|
|
unsigned seq;
|
2008-05-07 15:43:44 +00:00
|
|
|
int ret = 0;
|
2011-04-20 10:09:16 +00:00
|
|
|
bool clear_super = false;
|
2008-05-07 15:43:44 +00:00
|
|
|
|
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
|
2013-01-29 10:13:12 +00:00
|
|
|
do {
|
|
|
|
seq = read_seqbegin(&root->fs_info->profiles_lock);
|
|
|
|
|
|
|
|
all_avail = root->fs_info->avail_data_alloc_bits |
|
|
|
|
root->fs_info->avail_system_alloc_bits |
|
|
|
|
root->fs_info->avail_metadata_alloc_bits;
|
|
|
|
} while (read_seqretry(&root->fs_info->profiles_lock, seq));
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2012-11-06 12:15:27 +00:00
|
|
|
num_devices = root->fs_info->fs_devices->num_devices;
|
|
|
|
btrfs_dev_replace_lock(&root->fs_info->dev_replace);
|
|
|
|
if (btrfs_dev_replace_is_ongoing(&root->fs_info->dev_replace)) {
|
|
|
|
WARN_ON(num_devices < 1);
|
|
|
|
num_devices--;
|
|
|
|
}
|
|
|
|
btrfs_dev_replace_unlock(&root->fs_info->dev_replace);
|
|
|
|
|
|
|
|
if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && num_devices <= 4) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET;
|
2008-05-07 15:43:44 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-11-06 12:15:27 +00:00
|
|
|
if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && num_devices <= 2) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET;
|
2008-05-07 15:43:44 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
if ((all_avail & BTRFS_BLOCK_GROUP_RAID5) &&
|
|
|
|
root->fs_info->fs_devices->rw_devices <= 2) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET;
|
2013-01-29 23:40:14 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if ((all_avail & BTRFS_BLOCK_GROUP_RAID6) &&
|
|
|
|
root->fs_info->fs_devices->rw_devices <= 3) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET;
|
2013-01-29 23:40:14 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
if (strcmp(device_path, "missing") == 0) {
|
|
|
|
struct list_head *devices;
|
|
|
|
struct btrfs_device *tmp;
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
device = NULL;
|
|
|
|
devices = &root->fs_info->fs_devices->devices;
|
2011-04-20 10:08:47 +00:00
|
|
|
/*
|
|
|
|
* It is safe to read the devices since the volume_mutex
|
|
|
|
* is held.
|
|
|
|
*/
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(tmp, devices, dev_list) {
|
2012-11-05 17:29:28 +00:00
|
|
|
if (tmp->in_fs_metadata &&
|
|
|
|
!tmp->is_tgtdev_for_dev_replace &&
|
|
|
|
!tmp->bdev) {
|
2008-05-13 17:46:40 +00:00
|
|
|
device = tmp;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bdev = NULL;
|
|
|
|
bh = NULL;
|
|
|
|
disk_super = NULL;
|
|
|
|
if (!device) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_MISSING_NOT_FOUND;
|
2008-05-13 17:46:40 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
2012-11-12 13:03:45 +00:00
|
|
|
ret = btrfs_get_bdev_and_sb(device_path,
|
2012-12-07 10:09:19 +00:00
|
|
|
FMODE_WRITE | FMODE_EXCL,
|
2012-11-12 13:03:45 +00:00
|
|
|
root->fs_info->bdev_holder, 0,
|
|
|
|
&bdev, &bh);
|
|
|
|
if (ret)
|
2008-05-13 17:46:40 +00:00
|
|
|
goto out;
|
|
|
|
disk_super = (struct btrfs_super_block *)bh->b_data;
|
2010-01-06 11:48:18 +00:00
|
|
|
devid = btrfs_stack_device_id(&disk_super->dev_item);
|
2008-11-18 02:11:30 +00:00
|
|
|
dev_uuid = disk_super->dev_item.uuid;
|
2012-11-05 16:03:39 +00:00
|
|
|
device = btrfs_find_device(root->fs_info, devid, dev_uuid,
|
2008-11-18 02:11:30 +00:00
|
|
|
disk_super->fsid);
|
2008-05-13 17:46:40 +00:00
|
|
|
if (!device) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto error_brelse;
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-05-13 17:46:40 +00:00
|
|
|
|
2012-11-05 17:29:28 +00:00
|
|
|
if (device->is_tgtdev_for_dev_replace) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_TGT_REPLACE;
|
2012-11-05 17:29:28 +00:00
|
|
|
goto error_brelse;
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
|
2013-05-17 10:52:45 +00:00
|
|
|
ret = BTRFS_ERROR_DEV_ONLY_WRITABLE;
|
2008-11-18 02:11:30 +00:00
|
|
|
goto error_brelse;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (device->writeable) {
|
2011-04-20 10:08:16 +00:00
|
|
|
lock_chunks(root);
|
2008-11-18 02:11:30 +00:00
|
|
|
list_del_init(&device->dev_alloc_list);
|
2011-04-20 10:08:16 +00:00
|
|
|
unlock_chunks(root);
|
2008-11-18 02:11:30 +00:00
|
|
|
root->fs_info->fs_devices->rw_devices--;
|
2011-04-20 10:09:16 +00:00
|
|
|
clear_super = true;
|
2008-05-13 17:46:40 +00:00
|
|
|
}
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2013-03-04 22:37:06 +00:00
|
|
|
mutex_unlock(&uuid_mutex);
|
2008-05-07 15:43:44 +00:00
|
|
|
ret = btrfs_shrink_device(device, 0);
|
2013-03-04 22:37:06 +00:00
|
|
|
mutex_lock(&uuid_mutex);
|
2008-05-07 15:43:44 +00:00
|
|
|
if (ret)
|
2011-02-15 18:14:25 +00:00
|
|
|
goto error_undo;
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2012-11-05 17:29:28 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-05-07 15:43:44 +00:00
|
|
|
ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
|
|
|
|
if (ret)
|
2011-02-15 18:14:25 +00:00
|
|
|
goto error_undo;
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2011-09-26 21:12:22 +00:00
|
|
|
spin_lock(&root->fs_info->free_chunk_lock);
|
|
|
|
root->fs_info->free_chunk_space = device->total_bytes -
|
|
|
|
device->bytes_used;
|
|
|
|
spin_unlock(&root->fs_info->free_chunk_lock);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
device->in_fs_metadata = 0;
|
2012-11-05 16:03:39 +00:00
|
|
|
btrfs_scrub_cancel_dev(root->fs_info, device);
|
2009-06-10 19:17:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* the device list mutex makes sure that we don't change
|
|
|
|
* the device list while someone else is writing out all
|
Btrfs: fix race between removing a dev and writing sbs
This change fixes an issue when removing a device and writing
all super blocks run simultaneously. Here's the steps necessary
for the issue to happen:
1) disk-io.c:write_all_supers() gets a number of N devices from the
super_copy, so it will not panic if it fails to write super blocks
for N - 1 devices;
2) Then it tries to acquire the device_list_mutex, but blocks because
volumes.c:btrfs_rm_device() got it first;
3) btrfs_rm_device() removes the device from the list, then unlocks the
mutex and after the unlock it updates the number of devices in
super_copy to N - 1.
4) write_all_supers() finally acquires the mutex, iterates over all the
devices in the list and gets N - 1 errors, that is, it failed to write
super blocks to all the devices;
5) Because write_all_supers() thinks there are a total of N devices, it
considers N - 1 errors to be ok, and therefore won't panic.
So this change just makes sure that write_all_supers() reads the number
of devices from super_copy after it acquires the device_list_mutex.
Conversely, it changes btrfs_rm_device() to update the number of devices
in super_copy before it releases the device list mutex.
The code path to add a new device (volumes.c:btrfs_init_new_device),
already has the right behaviour: it updates the number of devices in
super_copy while holding the device_list_mutex.
The only code path that doesn't lock the device list mutex
before updating the number of devices in the super copy is
disk-io.c:next_root_backup(), called by open_ctree() during
mount time where concurrency issues can't happen.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2013-08-09 14:41:36 +00:00
|
|
|
* 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.
|
2009-06-10 19:17:02 +00:00
|
|
|
*/
|
2011-04-20 10:09:16 +00:00
|
|
|
|
|
|
|
cur_devices = device->fs_devices;
|
2009-06-10 19:17:02 +00:00
|
|
|
mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
2011-04-20 10:09:16 +00:00
|
|
|
list_del_rcu(&device->dev_list);
|
2009-06-10 19:17:02 +00:00
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
device->fs_devices->num_devices--;
|
2012-06-21 20:03:58 +00:00
|
|
|
device->fs_devices->total_devices--;
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2010-12-13 19:56:23 +00:00
|
|
|
if (device->missing)
|
|
|
|
root->fs_info->fs_devices->missing_devices--;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
next_device = list_entry(root->fs_info->fs_devices->devices.next,
|
|
|
|
struct btrfs_device, dev_list);
|
|
|
|
if (device->bdev == root->fs_info->sb->s_bdev)
|
|
|
|
root->fs_info->sb->s_bdev = next_device->bdev;
|
|
|
|
if (device->bdev == root->fs_info->fs_devices->latest_bdev)
|
|
|
|
root->fs_info->fs_devices->latest_bdev = next_device->bdev;
|
|
|
|
|
2011-04-20 10:09:16 +00:00
|
|
|
if (device->bdev)
|
2008-12-12 15:03:26 +00:00
|
|
|
device->fs_devices->open_devices--;
|
2011-04-20 10:09:16 +00:00
|
|
|
|
|
|
|
call_rcu(&device->rcu, free_device);
|
2008-12-12 15:03:26 +00:00
|
|
|
|
2011-04-13 13:41:04 +00:00
|
|
|
num_devices = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
|
|
|
|
btrfs_set_super_num_devices(root->fs_info->super_copy, num_devices);
|
Btrfs: fix race between removing a dev and writing sbs
This change fixes an issue when removing a device and writing
all super blocks run simultaneously. Here's the steps necessary
for the issue to happen:
1) disk-io.c:write_all_supers() gets a number of N devices from the
super_copy, so it will not panic if it fails to write super blocks
for N - 1 devices;
2) Then it tries to acquire the device_list_mutex, but blocks because
volumes.c:btrfs_rm_device() got it first;
3) btrfs_rm_device() removes the device from the list, then unlocks the
mutex and after the unlock it updates the number of devices in
super_copy to N - 1.
4) write_all_supers() finally acquires the mutex, iterates over all the
devices in the list and gets N - 1 errors, that is, it failed to write
super blocks to all the devices;
5) Because write_all_supers() thinks there are a total of N devices, it
considers N - 1 errors to be ok, and therefore won't panic.
So this change just makes sure that write_all_supers() reads the number
of devices from super_copy after it acquires the device_list_mutex.
Conversely, it changes btrfs_rm_device() to update the number of devices
in super_copy before it releases the device list mutex.
The code path to add a new device (volumes.c:btrfs_init_new_device),
already has the right behaviour: it updates the number of devices in
super_copy while holding the device_list_mutex.
The only code path that doesn't lock the device list mutex
before updating the number of devices in the super copy is
disk-io.c:next_root_backup(), called by open_ctree() during
mount time where concurrency issues can't happen.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2013-08-09 14:41:36 +00:00
|
|
|
mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2011-04-20 10:09:16 +00:00
|
|
|
if (cur_devices->open_devices == 0) {
|
2008-12-12 15:03:26 +00:00
|
|
|
struct btrfs_fs_devices *fs_devices;
|
|
|
|
fs_devices = root->fs_info->fs_devices;
|
|
|
|
while (fs_devices) {
|
2011-04-20 10:09:16 +00:00
|
|
|
if (fs_devices->seed == cur_devices)
|
2008-12-12 15:03:26 +00:00
|
|
|
break;
|
|
|
|
fs_devices = fs_devices->seed;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2011-04-20 10:09:16 +00:00
|
|
|
fs_devices->seed = cur_devices->seed;
|
|
|
|
cur_devices->seed = NULL;
|
2011-04-20 10:08:16 +00:00
|
|
|
lock_chunks(root);
|
2011-04-20 10:09:16 +00:00
|
|
|
__btrfs_close_devices(cur_devices);
|
2011-04-20 10:08:16 +00:00
|
|
|
unlock_chunks(root);
|
2011-04-20 10:09:16 +00:00
|
|
|
free_fs_devices(cur_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
|
2012-08-01 16:56:49 +00:00
|
|
|
root->fs_info->num_tolerated_disk_barrier_failures =
|
|
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
/*
|
|
|
|
* at this point, the device is zero sized. We want to
|
|
|
|
* remove it from the devices list and zero out the old super
|
|
|
|
*/
|
2012-11-05 16:03:39 +00:00
|
|
|
if (clear_super && disk_super) {
|
2008-05-13 17:46:40 +00:00
|
|
|
/* make sure this device isn't detected as part of
|
|
|
|
* the FS anymore
|
|
|
|
*/
|
|
|
|
memset(&disk_super->magic, 0, sizeof(disk_super->magic));
|
|
|
|
set_buffer_dirty(bh);
|
|
|
|
sync_dirty_buffer(bh);
|
|
|
|
}
|
2008-05-07 15:43:44 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2012-12-06 19:25:48 +00:00
|
|
|
/* Notify udev that device has changed */
|
2013-01-31 00:55:02 +00:00
|
|
|
if (bdev)
|
|
|
|
btrfs_kobject_uevent(bdev, KOBJ_CHANGE);
|
2012-12-06 19:25:48 +00:00
|
|
|
|
2008-05-07 15:43:44 +00:00
|
|
|
error_brelse:
|
|
|
|
brelse(bh);
|
2008-05-13 17:46:40 +00:00
|
|
|
if (bdev)
|
block: make blkdev_get/put() handle exclusive access
Over time, block layer has accumulated a set of APIs dealing with bdev
open, close, claim and release.
* blkdev_get/put() are the primary open and close functions.
* bd_claim/release() deal with exclusive open.
* open/close_bdev_exclusive() are combination of open and claim and
the other way around, respectively.
* bd_link/unlink_disk_holder() to create and remove holder/slave
symlinks.
* open_by_devnum() wraps bdget() + blkdev_get().
The interface is a bit confusing and the decoupling of open and claim
makes it impossible to properly guarantee exclusive access as
in-kernel open + claim sequence can disturb the existing exclusive
open even before the block layer knows the current open if for another
exclusive access. Reorganize the interface such that,
* blkdev_get() is extended to include exclusive access management.
@holder argument is added and, if is @FMODE_EXCL specified, it will
gain exclusive access atomically w.r.t. other exclusive accesses.
* blkdev_put() is similarly extended. It now takes @mode argument and
if @FMODE_EXCL is set, it releases an exclusive access. Also, when
the last exclusive claim is released, the holder/slave symlinks are
removed automatically.
* bd_claim/release() and close_bdev_exclusive() are no longer
necessary and either made static or removed.
* bd_link_disk_holder() remains the same but bd_unlink_disk_holder()
is no longer necessary and removed.
* open_bdev_exclusive() becomes a simple wrapper around lookup_bdev()
and blkdev_get(). It also has an unexpected extra bdev_read_only()
test which probably should be moved into blkdev_get().
* open_by_devnum() is modified to take @holder argument and pass it to
blkdev_get().
Most of bdev open/close operations are unified into blkdev_get/put()
and most exclusive accesses are tested atomically at the open time (as
it should). This cleans up code and removes some, both valid and
invalid, but unnecessary all the same, corner cases.
open_bdev_exclusive() and open_by_devnum() can use further cleanup -
rename to blkdev_get_by_path() and blkdev_get_by_devt() and drop
special features. Well, let's leave them for another day.
Most conversions are straight-forward. drbd conversion is a bit more
involved as there was some reordering, but the logic should stay the
same.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Neil Brown <neilb@suse.de>
Acked-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Acked-by: Philipp Reisner <philipp.reisner@linbit.com>
Cc: Peter Osterlund <petero2@telia.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Cc: Alex Elder <aelder@sgi.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: dm-devel@redhat.com
Cc: drbd-dev@lists.linbit.com
Cc: Leo Chen <leochen@broadcom.com>
Cc: Scott Branden <sbranden@broadcom.com>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Cc: Dave Kleikamp <shaggy@linux.vnet.ibm.com>
Cc: Joern Engel <joern@logfs.org>
Cc: reiserfs-devel@vger.kernel.org
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
2010-11-13 10:55:17 +00:00
|
|
|
blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
|
2008-05-07 15:43:44 +00:00
|
|
|
out:
|
|
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
return ret;
|
2011-02-15 18:14:25 +00:00
|
|
|
error_undo:
|
|
|
|
if (device->writeable) {
|
2011-04-20 10:08:16 +00:00
|
|
|
lock_chunks(root);
|
2011-02-15 18:14:25 +00:00
|
|
|
list_add(&device->dev_alloc_list,
|
|
|
|
&root->fs_info->fs_devices->alloc_list);
|
2011-04-20 10:08:16 +00:00
|
|
|
unlock_chunks(root);
|
2011-02-15 18:14:25 +00:00
|
|
|
root->fs_info->fs_devices->rw_devices++;
|
|
|
|
}
|
|
|
|
goto error_brelse;
|
2008-05-07 15:43:44 +00:00
|
|
|
}
|
|
|
|
|
2012-11-05 16:33:06 +00:00
|
|
|
void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_device *srcdev)
|
|
|
|
{
|
|
|
|
WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
|
2013-10-02 17:41:01 +00:00
|
|
|
|
2012-11-05 16:33:06 +00:00
|
|
|
list_del_rcu(&srcdev->dev_list);
|
|
|
|
list_del_rcu(&srcdev->dev_alloc_list);
|
|
|
|
fs_info->fs_devices->num_devices--;
|
|
|
|
if (srcdev->missing) {
|
|
|
|
fs_info->fs_devices->missing_devices--;
|
|
|
|
fs_info->fs_devices->rw_devices++;
|
|
|
|
}
|
|
|
|
if (srcdev->can_discard)
|
|
|
|
fs_info->fs_devices->num_can_discard--;
|
2013-10-02 17:41:01 +00:00
|
|
|
if (srcdev->bdev) {
|
2012-11-05 16:33:06 +00:00
|
|
|
fs_info->fs_devices->open_devices--;
|
|
|
|
|
2013-10-02 17:41:01 +00:00
|
|
|
/* zero out the old super */
|
|
|
|
btrfs_scratch_superblock(srcdev);
|
|
|
|
}
|
|
|
|
|
2012-11-05 16:33:06 +00:00
|
|
|
call_rcu(&srcdev->rcu, free_device);
|
|
|
|
}
|
|
|
|
|
|
|
|
void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_device *tgtdev)
|
|
|
|
{
|
|
|
|
struct btrfs_device *next_device;
|
|
|
|
|
|
|
|
WARN_ON(!tgtdev);
|
|
|
|
mutex_lock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
if (tgtdev->bdev) {
|
|
|
|
btrfs_scratch_superblock(tgtdev);
|
|
|
|
fs_info->fs_devices->open_devices--;
|
|
|
|
}
|
|
|
|
fs_info->fs_devices->num_devices--;
|
|
|
|
if (tgtdev->can_discard)
|
|
|
|
fs_info->fs_devices->num_can_discard++;
|
|
|
|
|
|
|
|
next_device = list_entry(fs_info->fs_devices->devices.next,
|
|
|
|
struct btrfs_device, dev_list);
|
|
|
|
if (tgtdev->bdev == fs_info->sb->s_bdev)
|
|
|
|
fs_info->sb->s_bdev = next_device->bdev;
|
|
|
|
if (tgtdev->bdev == fs_info->fs_devices->latest_bdev)
|
|
|
|
fs_info->fs_devices->latest_bdev = next_device->bdev;
|
|
|
|
list_del_rcu(&tgtdev->dev_list);
|
|
|
|
|
|
|
|
call_rcu(&tgtdev->rcu, free_device);
|
|
|
|
|
|
|
|
mutex_unlock(&fs_info->fs_devices->device_list_mutex);
|
|
|
|
}
|
|
|
|
|
2013-04-25 20:41:01 +00:00
|
|
|
static int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
|
|
|
|
struct btrfs_device **device)
|
2012-11-05 13:42:30 +00:00
|
|
|
{
|
|
|
|
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,
|
|
|
|
root->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;
|
2012-11-05 16:03:39 +00:00
|
|
|
*device = btrfs_find_device(root->fs_info, devid, dev_uuid,
|
2012-11-05 13:42:30 +00:00
|
|
|
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_root *root,
|
|
|
|
char *device_path,
|
|
|
|
struct btrfs_device **device)
|
|
|
|
{
|
|
|
|
*device = NULL;
|
|
|
|
if (strcmp(device_path, "missing") == 0) {
|
|
|
|
struct list_head *devices;
|
|
|
|
struct btrfs_device *tmp;
|
|
|
|
|
|
|
|
devices = &root->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) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(root->fs_info, "no missing device found");
|
2012-11-05 13:42:30 +00:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
return btrfs_find_device_by_path(root, device_path, device);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
/*
|
|
|
|
* does all the dirty work required for changing file system's UUID.
|
|
|
|
*/
|
2011-12-08 07:07:24 +00:00
|
|
|
static int btrfs_prepare_sprout(struct btrfs_root *root)
|
2008-11-18 02:11:30 +00:00
|
|
|
{
|
|
|
|
struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
|
|
|
|
struct btrfs_fs_devices *old_devices;
|
2008-12-12 15:03:26 +00:00
|
|
|
struct btrfs_fs_devices *seed_devices;
|
2011-04-13 13:41:04 +00:00
|
|
|
struct btrfs_super_block *disk_super = root->fs_info->super_copy;
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_device *device;
|
|
|
|
u64 super_flags;
|
|
|
|
|
|
|
|
BUG_ON(!mutex_is_locked(&uuid_mutex));
|
2008-12-12 15:03:26 +00:00
|
|
|
if (!fs_devices->seeding)
|
2008-11-18 02:11:30 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-08-12 11:33:03 +00:00
|
|
|
seed_devices = __alloc_fs_devices();
|
|
|
|
if (IS_ERR(seed_devices))
|
|
|
|
return PTR_ERR(seed_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
old_devices = clone_fs_devices(fs_devices);
|
|
|
|
if (IS_ERR(old_devices)) {
|
|
|
|
kfree(seed_devices);
|
|
|
|
return PTR_ERR(old_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-12-12 15:03:26 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
list_add(&old_devices->list, &fs_uuids);
|
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
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);
|
2009-06-10 19:17:02 +00:00
|
|
|
mutex_init(&seed_devices->device_list_mutex);
|
2011-04-20 10:07:30 +00:00
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
2011-04-20 10:09:16 +00:00
|
|
|
list_splice_init_rcu(&fs_devices->devices, &seed_devices->devices,
|
|
|
|
synchronize_rcu);
|
2011-04-20 10:07:30 +00:00
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
list_splice_init(&fs_devices->alloc_list, &seed_devices->alloc_list);
|
|
|
|
list_for_each_entry(device, &seed_devices->devices, dev_list) {
|
|
|
|
device->fs_devices = seed_devices;
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
fs_devices->seeding = 0;
|
|
|
|
fs_devices->num_devices = 0;
|
|
|
|
fs_devices->open_devices = 0;
|
2012-06-21 20:03:58 +00:00
|
|
|
fs_devices->total_devices = 0;
|
2008-12-12 15:03:26 +00:00
|
|
|
fs_devices->seed = seed_devices;
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
generate_random_uuid(fs_devices->fsid);
|
|
|
|
memcpy(root->fs_info->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
|
|
|
|
memcpy(disk_super->fsid, fs_devices->fsid, BTRFS_FSID_SIZE);
|
Btrfs: fix race conditions in BTRFS_IOC_FS_INFO ioctl
The handler for the ioctl BTRFS_IOC_FS_INFO was reading the
number of devices before acquiring the device list mutex.
This could lead to inconsistent results because the update of
the device list and the number of devices counter (amongst other
counters related to the device list) are updated in volumes.c
while holding the device list mutex - except for 2 places, one
was volumes.c:btrfs_prepare_sprout() and the other was
volumes.c:device_list_add().
For example, if we have 2 devices, with IDs 1 and 2 and then add
a new device, with ID 3, and while adding the device is in progress
an BTRFS_IOC_FS_INFO ioctl arrives, it could return a number of
devices of 2 and a max dev id of 3. This would be incorrect.
Also, this ioctl handler was reading the fsid while it can be
updated concurrently. This can happen when while a new device is
being added and the current filesystem is in seeding mode.
Example:
$ mkfs.btrfs -f /dev/sdb1
$ mkfs.btrfs -f /dev/sdb2
$ btrfstune -S 1 /dev/sdb1
$ mount /dev/sdb1 /mnt/test
$ btrfs device add /dev/sdb2 /mnt/test
If during the last step a BTRFS_IOC_FS_INFO ioctl was requested, it
could read an fsid that was never valid (some bits part of the old
fsid and others part of the new fsid). Also, it could read a number
of devices that doesn't match the number of devices in the list and
the max device id, as explained before.
Signed-off-by: Filipe David Borba Manana <fdmanana@gmail.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>
Signed-off-by: Chris Mason <chris.mason@fusionio.com>
2013-08-12 19:56:58 +00:00
|
|
|
mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
super_flags = btrfs_super_flags(disk_super) &
|
|
|
|
~BTRFS_SUPER_FLAG_SEEDING;
|
|
|
|
btrfs_set_super_flags(disk_super, super_flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* strore the expected generation for seed devices in device items.
|
|
|
|
*/
|
|
|
|
static int btrfs_finish_sprout(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_dev_item *dev_item;
|
|
|
|
struct btrfs_device *device;
|
|
|
|
struct btrfs_key key;
|
|
|
|
u8 fs_uuid[BTRFS_UUID_SIZE];
|
|
|
|
u8 dev_uuid[BTRFS_UUID_SIZE];
|
|
|
|
u64 devid;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
root = root->fs_info->chunk_root;
|
|
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
|
|
key.offset = 0;
|
|
|
|
key.type = BTRFS_DEV_ITEM_KEY;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
next_slot:
|
|
|
|
if (path->slots[0] >= btrfs_header_nritems(leaf)) {
|
|
|
|
ret = btrfs_next_leaf(root, path);
|
|
|
|
if (ret > 0)
|
|
|
|
break;
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2008-11-18 02:11:30 +00:00
|
|
|
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);
|
2013-08-20 11:20:11 +00:00
|
|
|
read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
|
2008-11-18 02:11:30 +00:00
|
|
|
BTRFS_UUID_SIZE);
|
2013-08-20 11:20:12 +00:00
|
|
|
read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
|
2008-11-18 02:11:30 +00:00
|
|
|
BTRFS_UUID_SIZE);
|
2012-11-05 16:03:39 +00:00
|
|
|
device = btrfs_find_device(root->fs_info, devid, dev_uuid,
|
|
|
|
fs_uuid);
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(!device); /* Logic error */
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-04-28 19:29:42 +00:00
|
|
|
int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
|
|
|
|
{
|
2011-08-04 14:52:27 +00:00
|
|
|
struct request_queue *q;
|
2008-04-28 19:29:42 +00:00
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
struct btrfs_device *device;
|
|
|
|
struct block_device *bdev;
|
|
|
|
struct list_head *devices;
|
2008-11-18 02:11:30 +00:00
|
|
|
struct super_block *sb = root->fs_info->sb;
|
2012-06-04 18:03:51 +00:00
|
|
|
struct rcu_string *name;
|
2008-04-28 19:29:42 +00:00
|
|
|
u64 total_bytes;
|
2008-11-18 02:11:30 +00:00
|
|
|
int seeding_dev = 0;
|
2008-04-28 19:29:42 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if ((sb->s_flags & MS_RDONLY) && !root->fs_info->fs_devices->seeding)
|
2012-05-10 10:10:38 +00:00
|
|
|
return -EROFS;
|
2008-04-28 19:29:42 +00:00
|
|
|
|
2011-12-08 01:08:40 +00:00
|
|
|
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
|
2010-11-13 10:55:18 +00:00
|
|
|
root->fs_info->bdev_holder);
|
2010-01-27 02:09:00 +00:00
|
|
|
if (IS_ERR(bdev))
|
|
|
|
return PTR_ERR(bdev);
|
2008-06-25 20:01:30 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (root->fs_info->fs_devices->seeding) {
|
|
|
|
seeding_dev = 1;
|
|
|
|
down_write(&sb->s_umount);
|
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
}
|
|
|
|
|
2008-09-29 15:19:10 +00:00
|
|
|
filemap_write_and_wait(bdev->bd_inode->i_mapping);
|
2008-06-25 20:01:30 +00:00
|
|
|
|
2008-04-28 19:29:42 +00:00
|
|
|
devices = &root->fs_info->fs_devices->devices;
|
2012-11-14 14:35:30 +00:00
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(device, devices, dev_list) {
|
2008-04-28 19:29:42 +00:00
|
|
|
if (device->bdev == bdev) {
|
|
|
|
ret = -EEXIST;
|
2012-11-14 14:35:30 +00:00
|
|
|
mutex_unlock(
|
|
|
|
&root->fs_info->fs_devices->device_list_mutex);
|
2008-11-18 02:11:30 +00:00
|
|
|
goto error;
|
2008-04-28 19:29:42 +00:00
|
|
|
}
|
|
|
|
}
|
2012-11-14 14:35:30 +00:00
|
|
|
mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
2008-04-28 19:29:42 +00:00
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
device = btrfs_alloc_device(root->fs_info, NULL, NULL);
|
|
|
|
if (IS_ERR(device)) {
|
2008-04-28 19:29:42 +00:00
|
|
|
/* we can safely leave the fs_devices entry around */
|
2013-08-23 10:20:17 +00:00
|
|
|
ret = PTR_ERR(device);
|
2008-11-18 02:11:30 +00:00
|
|
|
goto error;
|
2008-04-28 19:29:42 +00:00
|
|
|
}
|
|
|
|
|
2012-06-04 18:03:51 +00:00
|
|
|
name = rcu_string_strdup(device_path, GFP_NOFS);
|
|
|
|
if (!name) {
|
2008-04-28 19:29:42 +00:00
|
|
|
kfree(device);
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
2008-04-28 19:29:42 +00:00
|
|
|
}
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_assign_pointer(device->name, name);
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2011-01-20 06:19:37 +00:00
|
|
|
if (IS_ERR(trans)) {
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_string_free(device->name);
|
2011-01-20 06:19:37 +00:00
|
|
|
kfree(device);
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
lock_chunks(root);
|
|
|
|
|
2011-08-04 14:52:27 +00:00
|
|
|
q = bdev_get_queue(bdev);
|
|
|
|
if (blk_queue_discard(q))
|
|
|
|
device->can_discard = 1;
|
2008-11-18 02:11:30 +00:00
|
|
|
device->writeable = 1;
|
|
|
|
device->generation = trans->transid;
|
2008-04-28 19:29:42 +00:00
|
|
|
device->io_width = root->sectorsize;
|
|
|
|
device->io_align = root->sectorsize;
|
|
|
|
device->sector_size = root->sectorsize;
|
|
|
|
device->total_bytes = i_size_read(bdev->bd_inode);
|
2009-06-04 13:23:50 +00:00
|
|
|
device->disk_total_bytes = device->total_bytes;
|
2008-04-28 19:29:42 +00:00
|
|
|
device->dev_root = root->fs_info->dev_root;
|
|
|
|
device->bdev = bdev;
|
2008-05-13 17:46:40 +00:00
|
|
|
device->in_fs_metadata = 1;
|
2012-11-05 17:29:28 +00:00
|
|
|
device->is_tgtdev_for_dev_replace = 0;
|
2011-02-15 18:12:57 +00:00
|
|
|
device->mode = FMODE_EXCL;
|
2013-10-11 13:20:42 +00:00
|
|
|
device->dev_stats_valid = 1;
|
2008-11-18 02:11:30 +00:00
|
|
|
set_blocksize(device->bdev, 4096);
|
2008-04-28 19:29:42 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (seeding_dev) {
|
|
|
|
sb->s_flags &= ~MS_RDONLY;
|
2011-12-08 07:07:24 +00:00
|
|
|
ret = btrfs_prepare_sprout(root);
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(ret); /* -ENOMEM */
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-04-28 19:29:42 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
device->fs_devices = root->fs_info->fs_devices;
|
2009-06-10 19:17:02 +00:00
|
|
|
|
|
|
|
mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
|
2011-04-20 10:09:16 +00:00
|
|
|
list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
list_add(&device->dev_alloc_list,
|
|
|
|
&root->fs_info->fs_devices->alloc_list);
|
|
|
|
root->fs_info->fs_devices->num_devices++;
|
|
|
|
root->fs_info->fs_devices->open_devices++;
|
|
|
|
root->fs_info->fs_devices->rw_devices++;
|
2012-06-21 20:03:58 +00:00
|
|
|
root->fs_info->fs_devices->total_devices++;
|
2011-08-04 14:52:27 +00:00
|
|
|
if (device->can_discard)
|
|
|
|
root->fs_info->fs_devices->num_can_discard++;
|
2008-11-18 02:11:30 +00:00
|
|
|
root->fs_info->fs_devices->total_rw_bytes += device->total_bytes;
|
2008-09-05 20:43:54 +00:00
|
|
|
|
2011-09-26 21:12:22 +00:00
|
|
|
spin_lock(&root->fs_info->free_chunk_lock);
|
|
|
|
root->fs_info->free_chunk_space += device->total_bytes;
|
|
|
|
spin_unlock(&root->fs_info->free_chunk_lock);
|
|
|
|
|
2009-06-10 13:51:32 +00:00
|
|
|
if (!blk_queue_nonrot(bdev_get_queue(bdev)))
|
|
|
|
root->fs_info->fs_devices->rotating = 1;
|
|
|
|
|
2011-04-13 13:41:04 +00:00
|
|
|
total_bytes = btrfs_super_total_bytes(root->fs_info->super_copy);
|
|
|
|
btrfs_set_super_total_bytes(root->fs_info->super_copy,
|
2008-04-28 19:29:42 +00:00
|
|
|
total_bytes + device->total_bytes);
|
|
|
|
|
2011-04-13 13:41:04 +00:00
|
|
|
total_bytes = btrfs_super_num_devices(root->fs_info->super_copy);
|
|
|
|
btrfs_set_super_num_devices(root->fs_info->super_copy,
|
2008-04-28 19:29:42 +00:00
|
|
|
total_bytes + 1);
|
2009-06-10 19:17:02 +00:00
|
|
|
mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
|
2008-04-28 19:29:42 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (seeding_dev) {
|
|
|
|
ret = init_first_rw_device(trans, root, device);
|
2012-09-18 13:52:32 +00:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2012-03-12 15:03:00 +00:00
|
|
|
goto error_trans;
|
2012-09-18 13:52:32 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = btrfs_finish_sprout(trans, root);
|
2012-09-18 13:52:32 +00:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2012-03-12 15:03:00 +00:00
|
|
|
goto error_trans;
|
2012-09-18 13:52:32 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
} else {
|
|
|
|
ret = btrfs_add_device(trans, root, device);
|
2012-09-18 13:52:32 +00:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
2012-03-12 15:03:00 +00:00
|
|
|
goto error_trans;
|
2012-09-18 13:52:32 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
|
2009-03-10 17:17:18 +00:00
|
|
|
/*
|
|
|
|
* we've got more storage, clear any full flags on the space
|
|
|
|
* infos
|
|
|
|
*/
|
|
|
|
btrfs_clear_space_info_full(root->fs_info);
|
|
|
|
|
2008-07-08 18:19:17 +00:00
|
|
|
unlock_chunks(root);
|
2012-08-01 16:56:49 +00:00
|
|
|
root->fs_info->num_tolerated_disk_barrier_failures =
|
|
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
|
2012-03-12 15:03:00 +00:00
|
|
|
ret = btrfs_commit_transaction(trans, root);
|
2008-06-25 20:01:30 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (seeding_dev) {
|
|
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
up_write(&sb->s_umount);
|
2008-04-28 19:29:42 +00:00
|
|
|
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret) /* transaction commit */
|
|
|
|
return ret;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = btrfs_relocate_sys_chunks(root);
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret < 0)
|
|
|
|
btrfs_error(root->fs_info, ret,
|
|
|
|
"Failed to relocate sys chunks after "
|
|
|
|
"device initialization. This can be fixed "
|
|
|
|
"using the \"btrfs balance\" command.");
|
Btrfs: fix deadlock caused by the nested chunk allocation
Steps to reproduce:
# mkfs.btrfs -m raid1 <disk1> <disk2>
# btrfstune -S 1 <disk1>
# mount <disk1> <mnt>
# btrfs device add <disk3> <disk4> <mnt>
# mount -o remount,rw <mnt>
# dd if=/dev/zero of=<mnt>/tmpfile bs=1M count=1
Deadlock happened.
It is because of the nested chunk allocation. When we wrote the data
into the filesystem, we would allocate the data chunk because there was
no data chunk in the filesystem. At the end of the data chunk allocation,
we should insert the metadata of the data chunk into the extent tree, but
there was no raid1 chunk, so we tried to lock the chunk allocation mutex to
allocate the new chunk, but we had held the mutex, the deadlock happened.
By rights, we would allocate the raid1 chunk when we added the second device
because the profile of the seed filesystem is raid1 and we had two devices.
But we didn't do that in fact. It is because the last step of the first device
insertion didn't commit the transaction. So when we added the second device,
we didn't cow the tree, and just inserted the relative metadata into the leaves
which were generated by the first device insertion, and its profile was dup.
So, I fix this problem by commiting the transaction at the end of the first
device insertion.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2012-10-16 11:26:46 +00:00
|
|
|
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, root);
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2012-01-16 20:04:47 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
return ret;
|
2012-03-12 15:03:00 +00:00
|
|
|
|
|
|
|
error_trans:
|
|
|
|
unlock_chunks(root);
|
|
|
|
btrfs_end_transaction(trans, root);
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_string_free(device->name);
|
2012-03-12 15:03:00 +00:00
|
|
|
kfree(device);
|
2008-11-18 02:11:30 +00:00
|
|
|
error:
|
block: make blkdev_get/put() handle exclusive access
Over time, block layer has accumulated a set of APIs dealing with bdev
open, close, claim and release.
* blkdev_get/put() are the primary open and close functions.
* bd_claim/release() deal with exclusive open.
* open/close_bdev_exclusive() are combination of open and claim and
the other way around, respectively.
* bd_link/unlink_disk_holder() to create and remove holder/slave
symlinks.
* open_by_devnum() wraps bdget() + blkdev_get().
The interface is a bit confusing and the decoupling of open and claim
makes it impossible to properly guarantee exclusive access as
in-kernel open + claim sequence can disturb the existing exclusive
open even before the block layer knows the current open if for another
exclusive access. Reorganize the interface such that,
* blkdev_get() is extended to include exclusive access management.
@holder argument is added and, if is @FMODE_EXCL specified, it will
gain exclusive access atomically w.r.t. other exclusive accesses.
* blkdev_put() is similarly extended. It now takes @mode argument and
if @FMODE_EXCL is set, it releases an exclusive access. Also, when
the last exclusive claim is released, the holder/slave symlinks are
removed automatically.
* bd_claim/release() and close_bdev_exclusive() are no longer
necessary and either made static or removed.
* bd_link_disk_holder() remains the same but bd_unlink_disk_holder()
is no longer necessary and removed.
* open_bdev_exclusive() becomes a simple wrapper around lookup_bdev()
and blkdev_get(). It also has an unexpected extra bdev_read_only()
test which probably should be moved into blkdev_get().
* open_by_devnum() is modified to take @holder argument and pass it to
blkdev_get().
Most of bdev open/close operations are unified into blkdev_get/put()
and most exclusive accesses are tested atomically at the open time (as
it should). This cleans up code and removes some, both valid and
invalid, but unnecessary all the same, corner cases.
open_bdev_exclusive() and open_by_devnum() can use further cleanup -
rename to blkdev_get_by_path() and blkdev_get_by_devt() and drop
special features. Well, let's leave them for another day.
Most conversions are straight-forward. drbd conversion is a bit more
involved as there was some reordering, but the logic should stay the
same.
Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Neil Brown <neilb@suse.de>
Acked-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Acked-by: Philipp Reisner <philipp.reisner@linbit.com>
Cc: Peter Osterlund <petero2@telia.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Joel Becker <joel.becker@oracle.com>
Cc: Alex Elder <aelder@sgi.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: dm-devel@redhat.com
Cc: drbd-dev@lists.linbit.com
Cc: Leo Chen <leochen@broadcom.com>
Cc: Scott Branden <sbranden@broadcom.com>
Cc: Chris Mason <chris.mason@oracle.com>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Cc: Dave Kleikamp <shaggy@linux.vnet.ibm.com>
Cc: Joern Engel <joern@logfs.org>
Cc: reiserfs-devel@vger.kernel.org
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
2010-11-13 10:55:17 +00:00
|
|
|
blkdev_put(bdev, FMODE_EXCL);
|
2008-11-18 02:11:30 +00:00
|
|
|
if (seeding_dev) {
|
|
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
up_write(&sb->s_umount);
|
|
|
|
}
|
2012-01-16 20:04:47 +00:00
|
|
|
return ret;
|
2008-04-28 19:29:42 +00:00
|
|
|
}
|
|
|
|
|
2012-11-05 16:33:06 +00:00
|
|
|
int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
|
|
|
|
struct btrfs_device **device_out)
|
|
|
|
{
|
|
|
|
struct request_queue *q;
|
|
|
|
struct btrfs_device *device;
|
|
|
|
struct block_device *bdev;
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct list_head *devices;
|
|
|
|
struct rcu_string *name;
|
2013-08-23 10:20:17 +00:00
|
|
|
u64 devid = BTRFS_DEV_REPLACE_DEVID;
|
2012-11-05 16:33:06 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
*device_out = NULL;
|
|
|
|
if (fs_info->fs_devices->seeding)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
|
|
|
|
fs_info->bdev_holder);
|
|
|
|
if (IS_ERR(bdev))
|
|
|
|
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) {
|
|
|
|
ret = -EEXIST;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
device = btrfs_alloc_device(NULL, &devid, NULL);
|
|
|
|
if (IS_ERR(device)) {
|
|
|
|
ret = PTR_ERR(device);
|
2012-11-05 16:33:06 +00:00
|
|
|
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(&root->fs_info->fs_devices->device_list_mutex);
|
|
|
|
device->writeable = 1;
|
|
|
|
device->generation = 0;
|
|
|
|
device->io_width = root->sectorsize;
|
|
|
|
device->io_align = root->sectorsize;
|
|
|
|
device->sector_size = root->sectorsize;
|
|
|
|
device->total_bytes = i_size_read(bdev->bd_inode);
|
|
|
|
device->disk_total_bytes = device->total_bytes;
|
|
|
|
device->dev_root = fs_info->dev_root;
|
|
|
|
device->bdev = bdev;
|
|
|
|
device->in_fs_metadata = 1;
|
|
|
|
device->is_tgtdev_for_dev_replace = 1;
|
|
|
|
device->mode = FMODE_EXCL;
|
2013-10-11 13:20:42 +00:00
|
|
|
device->dev_stats_valid = 1;
|
2012-11-05 16:33:06 +00:00
|
|
|
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++;
|
|
|
|
if (device->can_discard)
|
|
|
|
fs_info->fs_devices->num_can_discard++;
|
|
|
|
mutex_unlock(&root->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)
|
|
|
|
{
|
|
|
|
WARN_ON(fs_info->fs_devices->rw_devices == 0);
|
|
|
|
tgtdev->io_width = fs_info->dev_root->sectorsize;
|
|
|
|
tgtdev->io_align = fs_info->dev_root->sectorsize;
|
|
|
|
tgtdev->sector_size = fs_info->dev_root->sectorsize;
|
|
|
|
tgtdev->dev_root = fs_info->dev_root;
|
|
|
|
tgtdev->in_fs_metadata = 1;
|
|
|
|
}
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_device *device)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_root *root;
|
|
|
|
struct btrfs_dev_item *dev_item;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
|
|
|
root = device->dev_root->fs_info->chunk_root;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
|
|
key.type = BTRFS_DEV_ITEM_KEY;
|
|
|
|
key.offset = device->devid;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
dev_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_item);
|
|
|
|
|
|
|
|
btrfs_set_device_id(leaf, dev_item, device->devid);
|
|
|
|
btrfs_set_device_type(leaf, dev_item, device->type);
|
|
|
|
btrfs_set_device_io_align(leaf, dev_item, device->io_align);
|
|
|
|
btrfs_set_device_io_width(leaf, dev_item, device->io_width);
|
|
|
|
btrfs_set_device_sector_size(leaf, dev_item, device->sector_size);
|
2009-04-27 11:29:03 +00:00
|
|
|
btrfs_set_device_total_bytes(leaf, dev_item, device->disk_total_bytes);
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_set_device_bytes_used(leaf, dev_item, device->bytes_used);
|
|
|
|
btrfs_mark_buffer_dirty(leaf);
|
|
|
|
|
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-08 18:19:17 +00:00
|
|
|
static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
|
2008-04-25 20:53:30 +00:00
|
|
|
struct btrfs_device *device, u64 new_size)
|
|
|
|
{
|
|
|
|
struct btrfs_super_block *super_copy =
|
2011-04-13 13:41:04 +00:00
|
|
|
device->dev_root->fs_info->super_copy;
|
2008-04-25 20:53:30 +00:00
|
|
|
u64 old_total = btrfs_super_total_bytes(super_copy);
|
|
|
|
u64 diff = new_size - device->total_bytes;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (!device->writeable)
|
|
|
|
return -EACCES;
|
2012-11-05 17:29:28 +00:00
|
|
|
if (new_size <= device->total_bytes ||
|
|
|
|
device->is_tgtdev_for_dev_replace)
|
2008-11-18 02:11:30 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
btrfs_set_super_total_bytes(super_copy, old_total + diff);
|
2008-11-18 02:11:30 +00:00
|
|
|
device->fs_devices->total_rw_bytes += diff;
|
|
|
|
|
|
|
|
device->total_bytes = new_size;
|
2009-07-24 20:41:41 +00:00
|
|
|
device->disk_total_bytes = new_size;
|
2009-03-10 16:39:20 +00:00
|
|
|
btrfs_clear_space_info_full(device->dev_root->fs_info);
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
return btrfs_update_device(trans, device);
|
|
|
|
}
|
|
|
|
|
2008-07-08 18:19:17 +00:00
|
|
|
int btrfs_grow_device(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_device *device, u64 new_size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
lock_chunks(device->dev_root);
|
|
|
|
ret = __btrfs_grow_device(trans, device, new_size);
|
|
|
|
unlock_chunks(device->dev_root);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
static int btrfs_free_chunk(struct btrfs_trans_handle *trans,
|
|
|
|
struct btrfs_root *root,
|
|
|
|
u64 chunk_tree, u64 chunk_objectid,
|
|
|
|
u64 chunk_offset)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
|
|
|
root = root->fs_info->chunk_root;
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
key.objectid = chunk_objectid;
|
|
|
|
key.offset = chunk_offset;
|
|
|
|
key.type = BTRFS_CHUNK_ITEM_KEY;
|
|
|
|
|
|
|
|
ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
else if (ret > 0) { /* Logic error or corruption */
|
|
|
|
btrfs_error(root->fs_info, -ENOENT,
|
|
|
|
"Failed lookup while freeing chunk.");
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
|
|
|
ret = btrfs_del_item(trans, root, path);
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret < 0)
|
|
|
|
btrfs_error(root->fs_info, ret,
|
|
|
|
"Failed to delete chunk item.");
|
|
|
|
out:
|
2008-04-25 20:53:30 +00:00
|
|
|
btrfs_free_path(path);
|
2011-05-19 04:37:44 +00:00
|
|
|
return ret;
|
2008-04-25 20:53:30 +00:00
|
|
|
}
|
|
|
|
|
2008-12-02 14:54:17 +00:00
|
|
|
static int btrfs_del_sys_chunk(struct btrfs_root *root, u64 chunk_objectid, u64
|
2008-04-25 20:53:30 +00:00
|
|
|
chunk_offset)
|
|
|
|
{
|
2011-04-13 13:41:04 +00:00
|
|
|
struct btrfs_super_block *super_copy = root->fs_info->super_copy;
|
2008-04-25 20:53:30 +00:00
|
|
|
struct btrfs_disk_key *disk_key;
|
|
|
|
struct btrfs_chunk *chunk;
|
|
|
|
u8 *ptr;
|
|
|
|
int ret = 0;
|
|
|
|
u32 num_stripes;
|
|
|
|
u32 array_size;
|
|
|
|
u32 len = 0;
|
|
|
|
u32 cur;
|
|
|
|
struct btrfs_key key;
|
|
|
|
|
|
|
|
array_size = btrfs_super_sys_array_size(super_copy);
|
|
|
|
|
|
|
|
ptr = super_copy->sys_chunk_array;
|
|
|
|
cur = 0;
|
|
|
|
|
|
|
|
while (cur < array_size) {
|
|
|
|
disk_key = (struct btrfs_disk_key *)ptr;
|
|
|
|
btrfs_disk_key_to_cpu(&key, disk_key);
|
|
|
|
|
|
|
|
len = sizeof(*disk_key);
|
|
|
|
|
|
|
|
if (key.type == BTRFS_CHUNK_ITEM_KEY) {
|
|
|
|
chunk = (struct btrfs_chunk *)(ptr + len);
|
|
|
|
num_stripes = btrfs_stack_chunk_num_stripes(chunk);
|
|
|
|
len += btrfs_chunk_item_size(num_stripes);
|
|
|
|
} else {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (key.objectid == chunk_objectid &&
|
|
|
|
key.offset == chunk_offset) {
|
|
|
|
memmove(ptr, ptr + len, array_size - (cur + len));
|
|
|
|
array_size -= len;
|
|
|
|
btrfs_set_super_sys_array_size(super_copy, array_size);
|
|
|
|
} else {
|
|
|
|
ptr += len;
|
|
|
|
cur += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-02 14:54:17 +00:00
|
|
|
static int btrfs_relocate_chunk(struct btrfs_root *root,
|
2008-04-25 20:53:30 +00:00
|
|
|
u64 chunk_tree, u64 chunk_objectid,
|
|
|
|
u64 chunk_offset)
|
|
|
|
{
|
|
|
|
struct extent_map_tree *em_tree;
|
|
|
|
struct btrfs_root *extent_root;
|
|
|
|
struct btrfs_trans_handle *trans;
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
root = root->fs_info->chunk_root;
|
|
|
|
extent_root = root->fs_info->extent_root;
|
|
|
|
em_tree = &root->fs_info->mapping_tree.map_tree;
|
|
|
|
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
ret = btrfs_can_relocate(extent_root, chunk_offset);
|
|
|
|
if (ret)
|
|
|
|
return -ENOSPC;
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
/* step one, relocate all the extents inside this chunk */
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 14:09:34 +00:00
|
|
|
ret = btrfs_relocate_block_group(extent_root, chunk_offset);
|
2010-05-16 14:48:46 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2013-03-04 16:25:40 +00:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
btrfs_std_error(root->fs_info, ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2008-07-08 18:19:17 +00:00
|
|
|
lock_chunks(root);
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
/*
|
|
|
|
* step two, delete the device extents and the
|
|
|
|
* chunk tree entries
|
|
|
|
*/
|
2009-09-02 20:24:52 +00:00
|
|
|
read_lock(&em_tree->lock);
|
2008-04-25 20:53:30 +00:00
|
|
|
em = lookup_extent_mapping(em_tree, chunk_offset, 1);
|
2009-09-02 20:24:52 +00:00
|
|
|
read_unlock(&em_tree->lock);
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2012-02-16 07:23:58 +00:00
|
|
|
BUG_ON(!em || em->start > chunk_offset ||
|
2008-05-07 15:43:44 +00:00
|
|
|
em->start + em->len < chunk_offset);
|
2008-04-25 20:53:30 +00:00
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
|
|
ret = btrfs_free_dev_extent(trans, map->stripes[i].dev,
|
|
|
|
map->stripes[i].physical);
|
|
|
|
BUG_ON(ret);
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
if (map->stripes[i].dev) {
|
|
|
|
ret = btrfs_update_device(trans, map->stripes[i].dev);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
}
|
|
|
|
ret = btrfs_free_chunk(trans, root, chunk_tree, chunk_objectid,
|
|
|
|
chunk_offset);
|
|
|
|
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
Btrfs: add initial tracepoint support for btrfs
Tracepoints can provide insight into why btrfs hits bugs and be greatly
helpful for debugging, e.g
dd-7822 [000] 2121.641088: btrfs_inode_request: root = 5(FS_TREE), gen = 4, ino = 256, blocks = 8, disk_i_size = 0, last_trans = 8, logged_trans = 0
dd-7822 [000] 2121.641100: btrfs_inode_new: root = 5(FS_TREE), gen = 8, ino = 257, blocks = 0, disk_i_size = 0, last_trans = 0, logged_trans = 0
btrfs-transacti-7804 [001] 2146.935420: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29368320 (orig_level = 0), cow_buf = 29388800 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.935473: btrfs_cow_block: root = 1(ROOT_TREE), refs = 2, orig_buf = 29364224 (orig_level = 0), cow_buf = 29392896 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.972221: btrfs_transaction_commit: root = 1(ROOT_TREE), gen = 8
flush-btrfs-2-7821 [001] 2155.824210: btrfs_chunk_alloc: root = 3(CHUNK_TREE), offset = 1103101952, size = 1073741824, num_stripes = 1, sub_stripes = 0, type = DATA
flush-btrfs-2-7821 [001] 2155.824241: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29388800 (orig_level = 0), cow_buf = 29396992 (cow_level = 0)
flush-btrfs-2-7821 [001] 2155.824255: btrfs_cow_block: root = 4(DEV_TREE), refs = 2, orig_buf = 29372416 (orig_level = 0), cow_buf = 29401088 (cow_level = 0)
flush-btrfs-2-7821 [000] 2155.824329: btrfs_cow_block: root = 3(CHUNK_TREE), refs = 2, orig_buf = 20971520 (orig_level = 0), cow_buf = 20975616 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898019: btrfs_cow_block: root = 5(FS_TREE), refs = 2, orig_buf = 29384704 (orig_level = 0), cow_buf = 29405184 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898043: btrfs_cow_block: root = 7(CSUM_TREE), refs = 2, orig_buf = 29376512 (orig_level = 0), cow_buf = 29409280 (cow_level = 0)
Here is what I have added:
1) ordere_extent:
btrfs_ordered_extent_add
btrfs_ordered_extent_remove
btrfs_ordered_extent_start
btrfs_ordered_extent_put
These provide critical information to understand how ordered_extents are
updated.
2) extent_map:
btrfs_get_extent
extent_map is used in both read and write cases, and it is useful for tracking
how btrfs specific IO is running.
3) writepage:
__extent_writepage
btrfs_writepage_end_io_hook
Pages are cirtical resourses and produce a lot of corner cases during writeback,
so it is valuable to know how page is written to disk.
4) inode:
btrfs_inode_new
btrfs_inode_request
btrfs_inode_evict
These can show where and when a inode is created, when a inode is evicted.
5) sync:
btrfs_sync_file
btrfs_sync_fs
These show sync arguments.
6) transaction:
btrfs_transaction_commit
In transaction based filesystem, it will be useful to know the generation and
who does commit.
7) back reference and cow:
btrfs_delayed_tree_ref
btrfs_delayed_data_ref
btrfs_delayed_ref_head
btrfs_cow_block
Btrfs natively supports back references, these tracepoints are helpful on
understanding btrfs's COW mechanism.
8) chunk:
btrfs_chunk_alloc
btrfs_chunk_free
Chunk is a link between physical offset and logical offset, and stands for space
infomation in btrfs, and these are helpful on tracing space things.
9) reserved_extent:
btrfs_reserved_extent_alloc
btrfs_reserved_extent_free
These can show how btrfs uses its space.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-24 11:18:59 +00:00
|
|
|
trace_btrfs_chunk_free(root, map, chunk_offset, em->len);
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
|
|
ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
|
|
|
|
BUG_ON(ret);
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = btrfs_remove_block_group(trans, extent_root, chunk_offset);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
write_lock(&em_tree->lock);
|
2008-11-18 02:11:30 +00:00
|
|
|
remove_extent_mapping(em_tree, em);
|
2009-09-02 20:24:52 +00:00
|
|
|
write_unlock(&em_tree->lock);
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
kfree(map);
|
|
|
|
em->bdev = NULL;
|
|
|
|
|
|
|
|
/* once for the tree */
|
|
|
|
free_extent_map(em);
|
|
|
|
/* once for us */
|
|
|
|
free_extent_map(em);
|
|
|
|
|
|
|
|
unlock_chunks(root);
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int btrfs_relocate_sys_chunks(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_root *chunk_root = root->fs_info->chunk_root;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_chunk *chunk;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
u64 chunk_tree = chunk_root->root_key.objectid;
|
|
|
|
u64 chunk_type;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
bool retried = false;
|
|
|
|
int failed = 0;
|
2008-11-18 02:11:30 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
again:
|
2008-11-18 02:11:30 +00:00
|
|
|
key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
key.type = BTRFS_CHUNK_ITEM_KEY;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(ret == 0); /* Corruption */
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
ret = btrfs_previous_item(chunk_root, path, key.objectid,
|
|
|
|
key.type);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
if (ret > 0)
|
|
|
|
break;
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 14:09:34 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
|
Btrfs: update space balancing code
This patch updates the space balancing code to utilize the new
backref format. Before, btrfs-vol -b would break any COW links
on data blocks or metadata. This was slow and caused the amount
of space used to explode if a large number of snapshots were present.
The new code can keeps the sharing of all data extents and
most of the tree blocks.
To maintain the sharing of data extents, the space balance code uses
a seperate inode hold data extent pointers, then updates the references
to point to the new location.
To maintain the sharing of tree blocks, the space balance code uses
reloc trees to relocate tree blocks in reference counted roots.
There is one reloc tree for each subvol, and all reloc trees share
same root key objectid. Reloc trees are snapshots of the latest
committed roots of subvols (root->commit_root).
To relocate a tree block referenced by a subvol, there are two steps.
COW the block through subvol's reloc tree, then update block pointer in
the subvol to point to the new block. Since all reloc trees share
same root key objectid, doing special handing for tree blocks
owned by them is easy. Once a tree block has been COWed in one
reloc tree, we can use the resulting new block directly when the
same block is required to COW again through other reloc trees.
In this way, relocated tree blocks are shared between reloc trees,
so they are also shared between subvols.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-09-26 14:09:34 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
chunk = btrfs_item_ptr(leaf, path->slots[0],
|
|
|
|
struct btrfs_chunk);
|
|
|
|
chunk_type = btrfs_chunk_type(leaf, chunk);
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (chunk_type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
|
|
ret = btrfs_relocate_chunk(chunk_root, chunk_tree,
|
|
|
|
found_key.objectid,
|
|
|
|
found_key.offset);
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (ret == -ENOSPC)
|
|
|
|
failed++;
|
|
|
|
else if (ret)
|
|
|
|
BUG();
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
if (found_key.offset == 0)
|
|
|
|
break;
|
|
|
|
key.offset = found_key.offset - 1;
|
|
|
|
}
|
|
|
|
ret = 0;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (failed && !retried) {
|
|
|
|
failed = 0;
|
|
|
|
retried = true;
|
|
|
|
goto again;
|
2013-10-31 05:00:08 +00:00
|
|
|
} else if (WARN_ON(failed && retried)) {
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
ret = -ENOSPC;
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
error:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
2008-04-25 20:53:30 +00:00
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
static int insert_balance_item(struct btrfs_root *root,
|
|
|
|
struct btrfs_balance_control *bctl)
|
|
|
|
{
|
|
|
|
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_BALANCE_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);
|
|
|
|
|
|
|
|
memset_extent_buffer(leaf, 0, (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, root);
|
|
|
|
if (err && !ret)
|
|
|
|
ret = err;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int del_balance_item(struct btrfs_root *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_BALANCE_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, root);
|
|
|
|
if (err && !ret)
|
|
|
|
ret = err;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
/*
|
|
|
|
* 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_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_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_CONVERT)) {
|
|
|
|
bctl->meta.flags |= BTRFS_BALANCE_ARGS_USAGE;
|
|
|
|
bctl->meta.usage = 90;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
/*
|
|
|
|
* Balance filters. Return 1 if chunk should be filtered out
|
|
|
|
* (should not be balanced).
|
|
|
|
*/
|
2012-03-27 14:09:16 +00:00
|
|
|
static int chunk_profiles_filter(u64 chunk_type,
|
2012-01-16 20:04:47 +00:00
|
|
|
struct btrfs_balance_args *bargs)
|
|
|
|
{
|
2012-03-27 14:09:16 +00:00
|
|
|
chunk_type = chunk_to_extended(chunk_type) &
|
|
|
|
BTRFS_EXTENDED_PROFILE_MASK;
|
2012-01-16 20:04:47 +00:00
|
|
|
|
2012-03-27 14:09:16 +00:00
|
|
|
if (bargs->profiles & chunk_type)
|
2012-01-16 20:04:47 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
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);
|
|
|
|
|
2013-01-21 13:15:56 +00:00
|
|
|
if (bargs->usage == 0)
|
2013-02-12 16:28:59 +00:00
|
|
|
user_thresh = 1;
|
2013-01-21 13:15:56 +00:00
|
|
|
else if (bargs->usage > 100)
|
|
|
|
user_thresh = cache->key.offset;
|
|
|
|
else
|
|
|
|
user_thresh = div_factor_fine(cache->key.offset,
|
|
|
|
bargs->usage);
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
if (chunk_used < user_thresh)
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
btrfs_put_block_group(cache);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
/* [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 |
|
2013-01-29 23:40:14 +00:00
|
|
|
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;
|
|
|
|
}
|
2012-01-16 20:04:48 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
do_div(stripe_length, factor);
|
|
|
|
|
|
|
|
if (stripe_offset < bargs->pend &&
|
|
|
|
stripe_offset + stripe_length > bargs->pstart)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
/* [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;
|
|
|
|
}
|
|
|
|
|
2012-03-27 14:09:16 +00:00
|
|
|
static int chunk_soft_convert_filter(u64 chunk_type,
|
2012-01-16 20:04:48 +00:00
|
|
|
struct btrfs_balance_args *bargs)
|
|
|
|
{
|
|
|
|
if (!(bargs->flags & BTRFS_BALANCE_ARGS_CONVERT))
|
|
|
|
return 0;
|
|
|
|
|
2012-03-27 14:09:16 +00:00
|
|
|
chunk_type = chunk_to_extended(chunk_type) &
|
|
|
|
BTRFS_EXTENDED_PROFILE_MASK;
|
2012-01-16 20:04:48 +00:00
|
|
|
|
2012-03-27 14:09:16 +00:00
|
|
|
if (bargs->target == chunk_type)
|
2012-01-16 20:04:48 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
static int should_balance_chunk(struct btrfs_root *root,
|
|
|
|
struct extent_buffer *leaf,
|
|
|
|
struct btrfs_chunk *chunk, u64 chunk_offset)
|
|
|
|
{
|
|
|
|
struct btrfs_balance_control *bctl = root->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;
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
/* profiles filter */
|
|
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_PROFILES) &&
|
|
|
|
chunk_profiles_filter(chunk_type, bargs)) {
|
|
|
|
return 0;
|
2012-01-16 20:04:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* usage filter */
|
|
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_USAGE) &&
|
|
|
|
chunk_usage_filter(bctl->fs_info, chunk_offset, bargs)) {
|
|
|
|
return 0;
|
2012-01-16 20:04:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* devid filter */
|
|
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_DEVID) &&
|
|
|
|
chunk_devid_filter(leaf, chunk, bargs)) {
|
|
|
|
return 0;
|
2012-01-16 20:04:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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;
|
2012-01-16 20:04:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* vrange filter */
|
|
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_VRANGE) &&
|
|
|
|
chunk_vrange_filter(leaf, chunk, chunk_offset, bargs)) {
|
|
|
|
return 0;
|
2012-01-16 20:04:47 +00:00
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
/* soft profile changing mode */
|
|
|
|
if ((bargs->flags & BTRFS_BALANCE_ARGS_SOFT) &&
|
|
|
|
chunk_soft_convert_filter(chunk_type, bargs)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
static int __btrfs_balance(struct btrfs_fs_info *fs_info)
|
2008-04-28 19:29:52 +00:00
|
|
|
{
|
2012-01-16 20:04:49 +00:00
|
|
|
struct btrfs_balance_control *bctl = fs_info->balance_ctl;
|
2012-01-16 20:04:47 +00:00
|
|
|
struct btrfs_root *chunk_root = fs_info->chunk_root;
|
|
|
|
struct btrfs_root *dev_root = fs_info->dev_root;
|
|
|
|
struct list_head *devices;
|
2008-04-28 19:29:52 +00:00
|
|
|
struct btrfs_device *device;
|
|
|
|
u64 old_size;
|
|
|
|
u64 size_to_free;
|
2012-01-16 20:04:47 +00:00
|
|
|
struct btrfs_chunk *chunk;
|
2008-04-28 19:29:52 +00:00
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
2012-01-16 20:04:47 +00:00
|
|
|
struct btrfs_trans_handle *trans;
|
2012-01-16 20:04:47 +00:00
|
|
|
struct extent_buffer *leaf;
|
|
|
|
int slot;
|
2012-01-16 20:04:47 +00:00
|
|
|
int ret;
|
|
|
|
int enospc_errors = 0;
|
2012-01-16 20:04:49 +00:00
|
|
|
bool counting = true;
|
2008-04-28 19:29:52 +00:00
|
|
|
|
|
|
|
/* step one make some room on all the devices */
|
2012-01-16 20:04:47 +00:00
|
|
|
devices = &fs_info->fs_devices->devices;
|
2009-01-21 15:59:08 +00:00
|
|
|
list_for_each_entry(device, devices, dev_list) {
|
2008-04-28 19:29:52 +00:00
|
|
|
old_size = device->total_bytes;
|
|
|
|
size_to_free = div_factor(old_size, 1);
|
|
|
|
size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
|
2008-11-18 02:11:30 +00:00
|
|
|
if (!device->writeable ||
|
2012-11-05 17:29:28 +00:00
|
|
|
device->total_bytes - device->bytes_used > size_to_free ||
|
|
|
|
device->is_tgtdev_for_dev_replace)
|
2008-04-28 19:29:52 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = btrfs_shrink_device(device, old_size - size_to_free);
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (ret == -ENOSPC)
|
|
|
|
break;
|
2008-04-28 19:29:52 +00:00
|
|
|
BUG_ON(ret);
|
|
|
|
|
2010-05-16 14:48:46 +00:00
|
|
|
trans = btrfs_start_transaction(dev_root, 0);
|
2011-01-20 06:19:37 +00:00
|
|
|
BUG_ON(IS_ERR(trans));
|
2008-04-28 19:29:52 +00:00
|
|
|
|
|
|
|
ret = btrfs_grow_device(trans, device, old_size);
|
|
|
|
BUG_ON(ret);
|
|
|
|
|
|
|
|
btrfs_end_transaction(trans, dev_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* step two, relocate all the chunks */
|
|
|
|
path = btrfs_alloc_path();
|
2011-07-12 18:10:23 +00:00
|
|
|
if (!path) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
2012-01-16 20:04:49 +00:00
|
|
|
|
|
|
|
/* zero out stat counters */
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
|
|
memset(&bctl->stat, 0, sizeof(bctl->stat));
|
|
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
again:
|
2008-04-28 19:29:52 +00:00
|
|
|
key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
key.type = BTRFS_CHUNK_ITEM_KEY;
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2012-01-16 20:04:49 +00:00
|
|
|
if ((!counting && atomic_read(&fs_info->balance_pause_req)) ||
|
2012-01-16 20:04:49 +00:00
|
|
|
atomic_read(&fs_info->balance_cancel_req)) {
|
2012-01-16 20:04:49 +00:00
|
|
|
ret = -ECANCELED;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-04-28 19:29:52 +00:00
|
|
|
ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this shouldn't happen, it means the last relocate
|
|
|
|
* failed
|
|
|
|
*/
|
|
|
|
if (ret == 0)
|
2012-01-16 20:04:47 +00:00
|
|
|
BUG(); /* FIXME break ? */
|
2008-04-28 19:29:52 +00:00
|
|
|
|
|
|
|
ret = btrfs_previous_item(chunk_root, path, 0,
|
|
|
|
BTRFS_CHUNK_ITEM_KEY);
|
2012-01-16 20:04:47 +00:00
|
|
|
if (ret) {
|
|
|
|
ret = 0;
|
2008-04-28 19:29:52 +00:00
|
|
|
break;
|
2012-01-16 20:04:47 +00:00
|
|
|
}
|
2008-07-08 18:19:17 +00:00
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
leaf = path->nodes[0];
|
|
|
|
slot = path->slots[0];
|
|
|
|
btrfs_item_key_to_cpu(leaf, &found_key, slot);
|
2008-07-08 18:19:17 +00:00
|
|
|
|
2008-04-28 19:29:52 +00:00
|
|
|
if (found_key.objectid != key.objectid)
|
|
|
|
break;
|
2008-07-08 18:19:17 +00:00
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
if (!counting) {
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
|
|
bctl->stat.considered++;
|
|
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
ret = should_balance_chunk(chunk_root, leaf, chunk,
|
|
|
|
found_key.offset);
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2012-01-16 20:04:47 +00:00
|
|
|
if (!ret)
|
|
|
|
goto loop;
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
if (counting) {
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
|
|
bctl->stat.expected++;
|
|
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
2008-04-28 19:29:52 +00:00
|
|
|
ret = btrfs_relocate_chunk(chunk_root,
|
|
|
|
chunk_root->root_key.objectid,
|
|
|
|
found_key.objectid,
|
|
|
|
found_key.offset);
|
2011-07-02 21:24:41 +00:00
|
|
|
if (ret && ret != -ENOSPC)
|
|
|
|
goto error;
|
2012-01-16 20:04:49 +00:00
|
|
|
if (ret == -ENOSPC) {
|
2012-01-16 20:04:47 +00:00
|
|
|
enospc_errors++;
|
2012-01-16 20:04:49 +00:00
|
|
|
} else {
|
|
|
|
spin_lock(&fs_info->balance_lock);
|
|
|
|
bctl->stat.completed++;
|
|
|
|
spin_unlock(&fs_info->balance_lock);
|
|
|
|
}
|
2012-01-16 20:04:47 +00:00
|
|
|
loop:
|
2013-08-27 10:50:44 +00:00
|
|
|
if (found_key.offset == 0)
|
|
|
|
break;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
key.offset = found_key.offset - 1;
|
2008-04-28 19:29:52 +00:00
|
|
|
}
|
2012-01-16 20:04:47 +00:00
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
if (counting) {
|
|
|
|
btrfs_release_path(path);
|
|
|
|
counting = false;
|
|
|
|
goto again;
|
|
|
|
}
|
2008-04-28 19:29:52 +00:00
|
|
|
error:
|
|
|
|
btrfs_free_path(path);
|
2012-01-16 20:04:47 +00:00
|
|
|
if (enospc_errors) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_info(fs_info, "%d enospc errors during balance",
|
2012-01-16 20:04:47 +00:00
|
|
|
enospc_errors);
|
|
|
|
if (!ret)
|
|
|
|
ret = -ENOSPC;
|
|
|
|
}
|
|
|
|
|
2008-04-28 19:29:52 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-27 14:09:17 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
static inline int balance_need_close(struct btrfs_fs_info *fs_info)
|
|
|
|
{
|
2012-01-16 20:04:49 +00:00
|
|
|
/* 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);
|
2012-01-16 20:04:49 +00:00
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
static void __cancel_balance(struct btrfs_fs_info *fs_info)
|
|
|
|
{
|
2012-01-16 20:04:48 +00:00
|
|
|
int ret;
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
unset_balance_control(fs_info);
|
2012-01-16 20:04:48 +00:00
|
|
|
ret = del_balance_item(fs_info->tree_root);
|
2013-03-04 16:25:40 +00:00
|
|
|
if (ret)
|
|
|
|
btrfs_std_error(fs_info, ret);
|
2013-01-20 13:57:57 +00:00
|
|
|
|
|
|
|
atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
|
2012-01-16 20:04:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2012-01-16 20:04:47 +00:00
|
|
|
u64 allowed;
|
2012-03-27 14:09:17 +00:00
|
|
|
int mixed = 0;
|
2012-01-16 20:04:47 +00:00
|
|
|
int ret;
|
2012-11-06 12:15:27 +00:00
|
|
|
u64 num_devices;
|
2013-01-29 10:13:12 +00:00
|
|
|
unsigned seq;
|
2012-01-16 20:04:47 +00:00
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
if (btrfs_fs_closing(fs_info) ||
|
2012-01-16 20:04:49 +00:00
|
|
|
atomic_read(&fs_info->balance_pause_req) ||
|
|
|
|
atomic_read(&fs_info->balance_cancel_req)) {
|
2012-01-16 20:04:47 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-03-27 14:09:17 +00:00
|
|
|
allowed = btrfs_super_incompat_flags(fs_info->super_copy);
|
|
|
|
if (allowed & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)
|
|
|
|
mixed = 1;
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
/*
|
|
|
|
* In case of mixed groups both data and meta should be picked,
|
|
|
|
* and identical options should be given for both of them.
|
|
|
|
*/
|
2012-03-27 14:09:17 +00:00
|
|
|
allowed = BTRFS_BALANCE_DATA | BTRFS_BALANCE_METADATA;
|
|
|
|
if (mixed && (bctl->flags & allowed)) {
|
2012-01-16 20:04:47 +00:00
|
|
|
if (!(bctl->flags & BTRFS_BALANCE_DATA) ||
|
|
|
|
!(bctl->flags & BTRFS_BALANCE_METADATA) ||
|
|
|
|
memcmp(&bctl->data, &bctl->meta, sizeof(bctl->data))) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(fs_info, "with mixed groups data and "
|
|
|
|
"metadata balance options must be the same");
|
2012-01-16 20:04:47 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-06 12:15:27 +00:00
|
|
|
num_devices = fs_info->fs_devices->num_devices;
|
|
|
|
btrfs_dev_replace_lock(&fs_info->dev_replace);
|
|
|
|
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);
|
2012-01-16 20:04:48 +00:00
|
|
|
allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE;
|
2012-11-06 12:15:27 +00:00
|
|
|
if (num_devices == 1)
|
2012-01-16 20:04:48 +00:00
|
|
|
allowed |= BTRFS_BLOCK_GROUP_DUP;
|
2013-05-11 11:13:03 +00:00
|
|
|
else if (num_devices > 1)
|
2012-01-16 20:04:48 +00:00
|
|
|
allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
|
2013-05-11 11:13:03 +00:00
|
|
|
if (num_devices > 2)
|
|
|
|
allowed |= BTRFS_BLOCK_GROUP_RAID5;
|
|
|
|
if (num_devices > 3)
|
|
|
|
allowed |= (BTRFS_BLOCK_GROUP_RAID10 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID6);
|
2012-03-27 14:09:17 +00:00
|
|
|
if ((bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
|
|
|
(!alloc_profile_is_valid(bctl->data.target, 1) ||
|
|
|
|
(bctl->data.target & ~allowed))) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(fs_info, "unable to start balance with target "
|
|
|
|
"data profile %llu",
|
2013-08-20 11:20:07 +00:00
|
|
|
bctl->data.target);
|
2012-01-16 20:04:48 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-03-27 14:09:17 +00:00
|
|
|
if ((bctl->meta.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
|
|
|
(!alloc_profile_is_valid(bctl->meta.target, 1) ||
|
|
|
|
(bctl->meta.target & ~allowed))) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(fs_info,
|
|
|
|
"unable to start balance with target metadata profile %llu",
|
2013-08-20 11:20:07 +00:00
|
|
|
bctl->meta.target);
|
2012-01-16 20:04:48 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-03-27 14:09:17 +00:00
|
|
|
if ((bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
|
|
|
(!alloc_profile_is_valid(bctl->sys.target, 1) ||
|
|
|
|
(bctl->sys.target & ~allowed))) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(fs_info,
|
|
|
|
"unable to start balance with target system profile %llu",
|
2013-08-20 11:20:07 +00:00
|
|
|
bctl->sys.target);
|
2012-01-16 20:04:48 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-03-27 14:09:17 +00:00
|
|
|
/* allow dup'ed data chunks only in mixed mode */
|
|
|
|
if (!mixed && (bctl->data.flags & BTRFS_BALANCE_ARGS_CONVERT) &&
|
2012-03-27 14:09:17 +00:00
|
|
|
(bctl->data.target & BTRFS_BLOCK_GROUP_DUP)) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(fs_info, "dup for data is not allowed");
|
2012-01-16 20:04:48 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allow to reduce meta or sys integrity only if force set */
|
|
|
|
allowed = BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
|
2013-01-29 23:40:14 +00:00
|
|
|
BTRFS_BLOCK_GROUP_RAID10 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID5 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID6;
|
2013-01-29 10:13:12 +00:00
|
|
|
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) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_info(fs_info, "force reducing metadata integrity");
|
2013-01-29 10:13:12 +00:00
|
|
|
} else {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(fs_info, "balance will reduce metadata "
|
|
|
|
"integrity, use force if you want this");
|
2013-01-29 10:13:12 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-01-16 20:04:48 +00:00
|
|
|
}
|
2013-01-29 10:13:12 +00:00
|
|
|
} while (read_seqretry(&fs_info->profiles_lock, seq));
|
2012-01-16 20:04:48 +00:00
|
|
|
|
2012-08-01 16:56:49 +00:00
|
|
|
if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
|
|
|
|
int num_tolerated_disk_barrier_failures;
|
|
|
|
u64 target = bctl->sys.target;
|
|
|
|
|
|
|
|
num_tolerated_disk_barrier_failures =
|
|
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
|
|
|
|
if (num_tolerated_disk_barrier_failures > 0 &&
|
|
|
|
(target &
|
|
|
|
(BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID0 |
|
|
|
|
BTRFS_AVAIL_ALLOC_BIT_SINGLE)))
|
|
|
|
num_tolerated_disk_barrier_failures = 0;
|
|
|
|
else if (num_tolerated_disk_barrier_failures > 1 &&
|
|
|
|
(target &
|
|
|
|
(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)))
|
|
|
|
num_tolerated_disk_barrier_failures = 1;
|
|
|
|
|
|
|
|
fs_info->num_tolerated_disk_barrier_failures =
|
|
|
|
num_tolerated_disk_barrier_failures;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
ret = insert_balance_item(fs_info->tree_root, bctl);
|
2012-01-16 20:04:48 +00:00
|
|
|
if (ret && ret != -EEXIST)
|
2012-01-16 20:04:48 +00:00
|
|
|
goto out;
|
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
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);
|
|
|
|
}
|
2012-01-16 20:04:47 +00:00
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
atomic_inc(&fs_info->balance_running);
|
2012-01-16 20:04:47 +00:00
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
|
|
|
|
ret = __btrfs_balance(fs_info);
|
|
|
|
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
2012-01-16 20:04:49 +00:00
|
|
|
atomic_dec(&fs_info->balance_running);
|
2012-01-16 20:04:47 +00:00
|
|
|
|
2013-02-12 16:27:46 +00:00
|
|
|
if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
|
|
|
|
fs_info->num_tolerated_disk_barrier_failures =
|
|
|
|
btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:47 +00:00
|
|
|
if (bargs) {
|
|
|
|
memset(bargs, 0, sizeof(*bargs));
|
2012-01-16 20:04:49 +00:00
|
|
|
update_ioctl_balance_args(fs_info, 0, bargs);
|
2012-01-16 20:04:47 +00:00
|
|
|
}
|
|
|
|
|
2013-03-06 08:57:55 +00:00
|
|
|
if ((ret && ret != -ECANCELED && ret != -ENOSPC) ||
|
|
|
|
balance_need_close(fs_info)) {
|
|
|
|
__cancel_balance(fs_info);
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
wake_up(&fs_info->balance_wait_q);
|
2012-01-16 20:04:47 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
out:
|
2012-01-16 20:04:48 +00:00
|
|
|
if (bctl->flags & BTRFS_BALANCE_RESUME)
|
|
|
|
__cancel_balance(fs_info);
|
2013-01-20 13:57:57 +00:00
|
|
|
else {
|
2012-01-16 20:04:48 +00:00
|
|
|
kfree(bctl);
|
2013-01-20 13:57:57 +00:00
|
|
|
atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
|
|
|
|
}
|
2012-01-16 20:04:48 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int balance_kthread(void *data)
|
|
|
|
{
|
2012-06-22 18:24:13 +00:00
|
|
|
struct btrfs_fs_info *fs_info = data;
|
2012-01-16 20:04:48 +00:00
|
|
|
int ret = 0;
|
2012-01-16 20:04:48 +00:00
|
|
|
|
|
|
|
mutex_lock(&fs_info->volume_mutex);
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
|
|
|
|
2012-06-22 18:24:13 +00:00
|
|
|
if (fs_info->balance_ctl) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_info(fs_info, "continuing balance");
|
2012-06-22 18:24:13 +00:00
|
|
|
ret = btrfs_balance(fs_info->balance_ctl, NULL);
|
2012-01-16 20:04:48 +00:00
|
|
|
}
|
2012-01-16 20:04:48 +00:00
|
|
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
mutex_unlock(&fs_info->volume_mutex);
|
2012-06-22 18:24:13 +00:00
|
|
|
|
2012-01-16 20:04:48 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-06-22 18:24:13 +00:00
|
|
|
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->tree_root, SKIP_BALANCE)) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_info(fs_info, "force skipping balance");
|
2012-06-22 18:24:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
|
2013-07-15 11:22:18 +00:00
|
|
|
return PTR_ERR_OR_ZERO(tsk);
|
2012-06-22 18:24:13 +00:00
|
|
|
}
|
|
|
|
|
2012-06-22 18:24:12 +00:00
|
|
|
int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
|
2012-01-16 20:04:48 +00:00
|
|
|
{
|
|
|
|
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_BALANCE_ITEM_KEY;
|
|
|
|
key.offset = 0;
|
|
|
|
|
2012-06-22 18:24:12 +00:00
|
|
|
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
|
2012-01-16 20:04:48 +00:00
|
|
|
if (ret < 0)
|
2012-06-22 18:24:12 +00:00
|
|
|
goto out;
|
2012-01-16 20:04:48 +00:00
|
|
|
if (ret > 0) { /* ret = -ENOENT; */
|
|
|
|
ret = 0;
|
2012-06-22 18:24:12 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
|
|
|
|
if (!bctl) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
2012-01-16 20:04:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
leaf = path->nodes[0];
|
|
|
|
item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
|
|
|
|
|
2012-06-22 18:24:12 +00:00
|
|
|
bctl->fs_info = fs_info;
|
|
|
|
bctl->flags = btrfs_balance_flags(leaf, item);
|
|
|
|
bctl->flags |= BTRFS_BALANCE_RESUME;
|
2012-01-16 20:04:48 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2013-01-20 13:57:57 +00:00
|
|
|
WARN_ON(atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1));
|
|
|
|
|
2012-06-22 18:24:12 +00:00
|
|
|
mutex_lock(&fs_info->volume_mutex);
|
|
|
|
mutex_lock(&fs_info->balance_mutex);
|
2012-01-16 20:04:48 +00:00
|
|
|
|
2012-06-22 18:24:12 +00:00
|
|
|
set_balance_control(bctl);
|
|
|
|
|
|
|
|
mutex_unlock(&fs_info->balance_mutex);
|
|
|
|
mutex_unlock(&fs_info->volume_mutex);
|
2012-01-16 20:04:48 +00:00
|
|
|
out:
|
|
|
|
btrfs_free_path(path);
|
2008-04-28 19:29:52 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
|
|
|
|
{
|
2013-10-10 17:40:21 +00:00
|
|
|
if (fs_info->sb->s_flags & MS_RDONLY)
|
|
|
|
return -EROFS;
|
|
|
|
|
2012-01-16 20:04:49 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-08-15 15:11:21 +00:00
|
|
|
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;
|
2013-08-28 09:28:34 +00:00
|
|
|
struct btrfs_trans_handle *trans = NULL;
|
2013-08-15 15:11:21 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
path->keep_locks = 1;
|
|
|
|
|
|
|
|
while (1) {
|
2013-10-01 15:13:42 +00:00
|
|
|
ret = btrfs_search_forward(root, &key, path, 0);
|
2013-08-15 15:11:21 +00:00
|
|
|
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;
|
2013-08-28 09:28:34 +00:00
|
|
|
|
|
|
|
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);
|
2013-08-15 15:11:21 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
2013-08-28 09:28:34 +00:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
goto skip;
|
|
|
|
}
|
|
|
|
update_tree:
|
|
|
|
if (!btrfs_is_empty_uuid(root_item.uuid)) {
|
2013-08-15 15:11:21 +00:00
|
|
|
ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
|
|
|
|
root_item.uuid,
|
|
|
|
BTRFS_UUID_KEY_SUBVOL,
|
|
|
|
key.objectid);
|
|
|
|
if (ret < 0) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(fs_info, "uuid_tree_add failed %d",
|
2013-08-15 15:11:21 +00:00
|
|
|
ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!btrfs_is_empty_uuid(root_item.received_uuid)) {
|
|
|
|
ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
|
|
|
|
root_item.received_uuid,
|
|
|
|
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
|
|
|
|
key.objectid);
|
|
|
|
if (ret < 0) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(fs_info, "uuid_tree_add failed %d",
|
2013-08-15 15:11:21 +00:00
|
|
|
ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-28 09:28:34 +00:00
|
|
|
skip:
|
2013-08-15 15:11:21 +00:00
|
|
|
if (trans) {
|
|
|
|
ret = btrfs_end_transaction(trans, fs_info->uuid_root);
|
2013-08-28 09:28:34 +00:00
|
|
|
trans = NULL;
|
2013-08-15 15:11:21 +00:00
|
|
|
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);
|
2013-08-28 09:28:34 +00:00
|
|
|
if (trans && !IS_ERR(trans))
|
|
|
|
btrfs_end_transaction(trans, fs_info->uuid_root);
|
2013-08-15 15:11:21 +00:00
|
|
|
if (ret)
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
|
2013-08-15 15:11:23 +00:00
|
|
|
else
|
|
|
|
fs_info->update_uuid_tree_gen = 1;
|
2013-08-15 15:11:21 +00:00
|
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-15 15:11:23 +00:00
|
|
|
/*
|
|
|
|
* Callback for btrfs_uuid_tree_iterate().
|
|
|
|
* returns:
|
|
|
|
* 0 check succeeded, the entry is not outdated.
|
|
|
|
* < 0 if an error occured.
|
|
|
|
* > 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) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(fs_info, "iterating uuid_tree failed %d", ret);
|
2013-08-15 15:11:23 +00:00
|
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return btrfs_uuid_scan_kthread(data);
|
|
|
|
}
|
|
|
|
|
2013-08-15 15:11:19 +00:00
|
|
|
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;
|
2013-08-15 15:11:21 +00:00
|
|
|
struct task_struct *task;
|
|
|
|
int ret;
|
2013-08-15 15:11:19 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)) {
|
|
|
|
btrfs_abort_transaction(trans, tree_root,
|
|
|
|
PTR_ERR(uuid_root));
|
|
|
|
return PTR_ERR(uuid_root);
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_info->uuid_root = uuid_root;
|
|
|
|
|
2013-08-15 15:11:21 +00:00
|
|
|
ret = btrfs_commit_transaction(trans, tree_root);
|
|
|
|
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)) {
|
2013-08-15 15:11:23 +00:00
|
|
|
/* fs_info->update_uuid_tree_gen remains 0 in all error case */
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(fs_info, "failed to start uuid_scan task");
|
2013-08-15 15:11:21 +00:00
|
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
|
|
return PTR_ERR(task);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2013-08-15 15:11:19 +00:00
|
|
|
}
|
2013-08-15 15:11:21 +00:00
|
|
|
|
2013-08-15 15:11:23 +00:00
|
|
|
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 */
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(fs_info, "failed to start uuid_rescan task");
|
2013-08-15 15:11:23 +00:00
|
|
|
up(&fs_info->uuid_tree_rescan_sem);
|
|
|
|
return PTR_ERR(task);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
/*
|
|
|
|
* 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_trans_handle *trans;
|
|
|
|
struct btrfs_root *root = device->dev_root;
|
|
|
|
struct btrfs_dev_extent *dev_extent = NULL;
|
|
|
|
struct btrfs_path *path;
|
|
|
|
u64 length;
|
|
|
|
u64 chunk_tree;
|
|
|
|
u64 chunk_objectid;
|
|
|
|
u64 chunk_offset;
|
|
|
|
int ret;
|
|
|
|
int slot;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
int failed = 0;
|
|
|
|
bool retried = false;
|
2008-04-25 20:53:30 +00:00
|
|
|
struct extent_buffer *l;
|
|
|
|
struct btrfs_key key;
|
2011-04-13 13:41:04 +00:00
|
|
|
struct btrfs_super_block *super_copy = root->fs_info->super_copy;
|
2008-04-25 20:53:30 +00:00
|
|
|
u64 old_total = btrfs_super_total_bytes(super_copy);
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
u64 old_size = device->total_bytes;
|
2008-04-25 20:53:30 +00:00
|
|
|
u64 diff = device->total_bytes - new_size;
|
|
|
|
|
2012-11-05 17:29:28 +00:00
|
|
|
if (device->is_tgtdev_for_dev_replace)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
path->reada = 2;
|
|
|
|
|
2008-07-08 18:19:17 +00:00
|
|
|
lock_chunks(root);
|
|
|
|
|
2008-04-25 20:53:30 +00:00
|
|
|
device->total_bytes = new_size;
|
2011-09-26 21:12:22 +00:00
|
|
|
if (device->writeable) {
|
2008-11-18 02:11:30 +00:00
|
|
|
device->fs_devices->total_rw_bytes -= diff;
|
2011-09-26 21:12:22 +00:00
|
|
|
spin_lock(&root->fs_info->free_chunk_lock);
|
|
|
|
root->fs_info->free_chunk_space -= diff;
|
|
|
|
spin_unlock(&root->fs_info->free_chunk_lock);
|
|
|
|
}
|
2008-07-08 18:19:17 +00:00
|
|
|
unlock_chunks(root);
|
2008-04-25 20:53:30 +00:00
|
|
|
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
again:
|
2008-04-25 20:53:30 +00:00
|
|
|
key.objectid = device->devid;
|
|
|
|
key.offset = (u64)-1;
|
|
|
|
key.type = BTRFS_DEV_EXTENT_KEY;
|
|
|
|
|
2012-03-27 14:09:18 +00:00
|
|
|
do {
|
2008-04-25 20:53:30 +00:00
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
|
|
|
if (ret < 0)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
ret = btrfs_previous_item(root, path, 0, key.type);
|
|
|
|
if (ret < 0)
|
|
|
|
goto done;
|
|
|
|
if (ret) {
|
|
|
|
ret = 0;
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2009-07-22 13:59:00 +00:00
|
|
|
break;
|
2008-04-25 20:53:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
l = path->nodes[0];
|
|
|
|
slot = path->slots[0];
|
|
|
|
btrfs_item_key_to_cpu(l, &key, path->slots[0]);
|
|
|
|
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (key.objectid != device->devid) {
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2009-07-22 13:59:00 +00:00
|
|
|
break;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
|
|
|
dev_extent = btrfs_item_ptr(l, slot, struct btrfs_dev_extent);
|
|
|
|
length = btrfs_dev_extent_length(l, dev_extent);
|
|
|
|
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (key.offset + length <= new_size) {
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2009-04-27 11:29:03 +00:00
|
|
|
break;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
}
|
2008-04-25 20:53:30 +00:00
|
|
|
|
|
|
|
chunk_tree = btrfs_dev_extent_chunk_tree(l, dev_extent);
|
|
|
|
chunk_objectid = btrfs_dev_extent_chunk_objectid(l, dev_extent);
|
|
|
|
chunk_offset = btrfs_dev_extent_chunk_offset(l, dev_extent);
|
2011-04-20 23:20:15 +00:00
|
|
|
btrfs_release_path(path);
|
2008-04-25 20:53:30 +00:00
|
|
|
|
|
|
|
ret = btrfs_relocate_chunk(root, chunk_tree, chunk_objectid,
|
|
|
|
chunk_offset);
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (ret && ret != -ENOSPC)
|
2008-04-25 20:53:30 +00:00
|
|
|
goto done;
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
if (ret == -ENOSPC)
|
|
|
|
failed++;
|
2012-03-27 14:09:18 +00:00
|
|
|
} while (key.offset-- > 0);
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
|
|
|
|
if (failed && !retried) {
|
|
|
|
failed = 0;
|
|
|
|
retried = true;
|
|
|
|
goto again;
|
|
|
|
} else if (failed && retried) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
lock_chunks(root);
|
|
|
|
|
|
|
|
device->total_bytes = old_size;
|
|
|
|
if (device->writeable)
|
|
|
|
device->fs_devices->total_rw_bytes += diff;
|
2011-09-26 21:12:22 +00:00
|
|
|
spin_lock(&root->fs_info->free_chunk_lock);
|
|
|
|
root->fs_info->free_chunk_space += diff;
|
|
|
|
spin_unlock(&root->fs_info->free_chunk_lock);
|
Btrfs: make balance code choose more wisely when relocating
Currently, we can panic the box if the first block group we go to move is of a
type where there is no space left to move those extents. For example, if we
fill the disk up with data, and then we try to balance and we have no room to
move the data nor room to allocate new chunks, we will panic. Change this by
checking to see if we have room to move this chunk around, and if not, return
-ENOSPC and move on to the next chunk. This will make sure we remove block
groups that are moveable, like if we have alot of empty metadata block groups,
and then that way we make room to be able to balance our data chunks as well.
Tested this with an fs that would panic on btrfs-vol -b normally, but no longer
panics with this patch.
V1->V2:
-actually search for a free extent on the device to make sure we can allocate a
chunk if need be.
-fix btrfs_shrink_device to make sure we actually try to relocate all the
chunks, and then if we can't return -ENOSPC so if we are doing a btrfs-vol -r
we don't remove the device with data still on it.
-check to make sure the block group we are going to relocate isn't the last one
in that particular space
-fix a bug in btrfs_shrink_device where we would change the device's size and
not fix it if we fail to do our relocate
Signed-off-by: Josef Bacik <jbacik@redhat.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2009-09-11 20:11:19 +00:00
|
|
|
unlock_chunks(root);
|
|
|
|
goto done;
|
2008-04-25 20:53:30 +00:00
|
|
|
}
|
|
|
|
|
2009-04-27 11:29:03 +00:00
|
|
|
/* Shrinking succeeded, else we would be at "done". */
|
2010-05-16 14:48:46 +00:00
|
|
|
trans = btrfs_start_transaction(root, 0);
|
2011-01-20 06:19:37 +00:00
|
|
|
if (IS_ERR(trans)) {
|
|
|
|
ret = PTR_ERR(trans);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2009-04-27 11:29:03 +00:00
|
|
|
lock_chunks(root);
|
|
|
|
|
|
|
|
device->disk_total_bytes = new_size;
|
|
|
|
/* Now btrfs_update_device() will change the on-disk size. */
|
|
|
|
ret = btrfs_update_device(trans, device);
|
|
|
|
if (ret) {
|
|
|
|
unlock_chunks(root);
|
|
|
|
btrfs_end_transaction(trans, root);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
WARN_ON(diff > old_total);
|
|
|
|
btrfs_set_super_total_bytes(super_copy, old_total - diff);
|
|
|
|
unlock_chunks(root);
|
|
|
|
btrfs_end_transaction(trans, root);
|
2008-04-25 20:53:30 +00:00
|
|
|
done:
|
|
|
|
btrfs_free_path(path);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-12-08 07:07:24 +00:00
|
|
|
static int btrfs_add_system_chunk(struct btrfs_root *root,
|
2008-03-24 19:01:56 +00:00
|
|
|
struct btrfs_key *key,
|
|
|
|
struct btrfs_chunk *chunk, int item_size)
|
|
|
|
{
|
2011-04-13 13:41:04 +00:00
|
|
|
struct btrfs_super_block *super_copy = root->fs_info->super_copy;
|
2008-03-24 19:01:56 +00:00
|
|
|
struct btrfs_disk_key disk_key;
|
|
|
|
u32 array_size;
|
|
|
|
u8 *ptr;
|
|
|
|
|
|
|
|
array_size = btrfs_super_sys_array_size(super_copy);
|
|
|
|
if (array_size + item_size > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE)
|
|
|
|
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);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
/*
|
|
|
|
* sort the devices in descending order by max_avail, total_avail
|
|
|
|
*/
|
|
|
|
static int btrfs_cmp_device_info(const void *a, const void *b)
|
2008-04-18 14:29:51 +00:00
|
|
|
{
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
const struct btrfs_device_info *di_a = a;
|
|
|
|
const struct btrfs_device_info *di_b = b;
|
2008-04-18 14:29:51 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (di_a->max_avail > di_b->max_avail)
|
2011-01-05 10:07:28 +00:00
|
|
|
return -1;
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (di_a->max_avail < di_b->max_avail)
|
2011-01-05 10:07:28 +00:00
|
|
|
return 1;
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (di_a->total_avail > di_b->total_avail)
|
|
|
|
return -1;
|
|
|
|
if (di_a->total_avail < di_b->total_avail)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
2011-01-05 10:07:28 +00:00
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-04-25 20:41:01 +00:00
|
|
|
static struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
|
2013-01-17 05:38:51 +00:00
|
|
|
[BTRFS_RAID_RAID10] = {
|
|
|
|
.sub_stripes = 2,
|
|
|
|
.dev_stripes = 1,
|
|
|
|
.devs_max = 0, /* 0 == as many as possible */
|
|
|
|
.devs_min = 4,
|
|
|
|
.devs_increment = 2,
|
|
|
|
.ncopies = 2,
|
|
|
|
},
|
|
|
|
[BTRFS_RAID_RAID1] = {
|
|
|
|
.sub_stripes = 1,
|
|
|
|
.dev_stripes = 1,
|
|
|
|
.devs_max = 2,
|
|
|
|
.devs_min = 2,
|
|
|
|
.devs_increment = 2,
|
|
|
|
.ncopies = 2,
|
|
|
|
},
|
|
|
|
[BTRFS_RAID_DUP] = {
|
|
|
|
.sub_stripes = 1,
|
|
|
|
.dev_stripes = 2,
|
|
|
|
.devs_max = 1,
|
|
|
|
.devs_min = 1,
|
|
|
|
.devs_increment = 1,
|
|
|
|
.ncopies = 2,
|
|
|
|
},
|
|
|
|
[BTRFS_RAID_RAID0] = {
|
|
|
|
.sub_stripes = 1,
|
|
|
|
.dev_stripes = 1,
|
|
|
|
.devs_max = 0,
|
|
|
|
.devs_min = 2,
|
|
|
|
.devs_increment = 1,
|
|
|
|
.ncopies = 1,
|
|
|
|
},
|
|
|
|
[BTRFS_RAID_SINGLE] = {
|
|
|
|
.sub_stripes = 1,
|
|
|
|
.dev_stripes = 1,
|
|
|
|
.devs_max = 1,
|
|
|
|
.devs_min = 1,
|
|
|
|
.devs_increment = 1,
|
|
|
|
.ncopies = 1,
|
|
|
|
},
|
2013-02-20 19:06:05 +00:00
|
|
|
[BTRFS_RAID_RAID5] = {
|
|
|
|
.sub_stripes = 1,
|
|
|
|
.dev_stripes = 1,
|
|
|
|
.devs_max = 0,
|
|
|
|
.devs_min = 2,
|
|
|
|
.devs_increment = 1,
|
|
|
|
.ncopies = 2,
|
|
|
|
},
|
|
|
|
[BTRFS_RAID_RAID6] = {
|
|
|
|
.sub_stripes = 1,
|
|
|
|
.dev_stripes = 1,
|
|
|
|
.devs_max = 0,
|
|
|
|
.devs_min = 3,
|
|
|
|
.devs_increment = 1,
|
|
|
|
.ncopies = 3,
|
|
|
|
},
|
2012-11-21 14:18:10 +00:00
|
|
|
};
|
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
static u32 find_raid56_stripe_len(u32 data_devices, u32 dev_stripe_target)
|
|
|
|
{
|
|
|
|
/* TODO allow them to set a preferred stripe size */
|
|
|
|
return 64 * 1024;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void check_raid56_incompat_flag(struct btrfs_fs_info *info, u64 type)
|
|
|
|
{
|
|
|
|
if (!(type & (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)))
|
|
|
|
return;
|
|
|
|
|
2013-04-11 10:30:16 +00:00
|
|
|
btrfs_set_fs_incompat(info, RAID56);
|
2013-01-29 23:40:14 +00:00
|
|
|
}
|
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
|
2013-06-27 17:22:46 +00:00
|
|
|
struct btrfs_root *extent_root, u64 start,
|
|
|
|
u64 type)
|
2011-01-05 10:07:28 +00:00
|
|
|
{
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
struct btrfs_fs_info *info = extent_root->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 */
|
2013-01-29 23:40:14 +00:00
|
|
|
int data_stripes; /* number of stripes that count for
|
|
|
|
block group size */
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
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;
|
2013-01-29 23:40:14 +00:00
|
|
|
u64 raid_stripe_len = BTRFS_STRIPE_LEN;
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
int ndevs;
|
|
|
|
int i;
|
|
|
|
int j;
|
2012-11-21 14:18:10 +00:00
|
|
|
int index;
|
2008-03-25 20:50:33 +00:00
|
|
|
|
2012-03-27 14:09:17 +00:00
|
|
|
BUG_ON(!alloc_profile_is_valid(type, 0));
|
2008-04-18 14:29:51 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (list_empty(&fs_devices->alloc_list))
|
|
|
|
return -ENOSPC;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2012-11-21 14:18:10 +00:00
|
|
|
index = __get_raid_index(type);
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
|
2012-11-21 14:18:10 +00:00
|
|
|
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;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2008-04-18 14:29:51 +00:00
|
|
|
if (type & BTRFS_BLOCK_GROUP_DATA) {
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
max_stripe_size = 1024 * 1024 * 1024;
|
|
|
|
max_chunk_size = 10 * max_stripe_size;
|
2008-04-18 14:29:51 +00:00
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_METADATA) {
|
2012-01-06 20:47:38 +00:00
|
|
|
/* for larger filesystems, use larger metadata chunks */
|
|
|
|
if (fs_devices->total_rw_bytes > 50ULL * 1024 * 1024 * 1024)
|
|
|
|
max_stripe_size = 1024 * 1024 * 1024;
|
|
|
|
else
|
|
|
|
max_stripe_size = 256 * 1024 * 1024;
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
max_chunk_size = max_stripe_size;
|
2008-04-18 15:55:51 +00:00
|
|
|
} else if (type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
2012-01-16 13:13:11 +00:00
|
|
|
max_stripe_size = 32 * 1024 * 1024;
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
max_chunk_size = 2 * max_stripe_size;
|
|
|
|
} else {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_err(info, "invalid chunk type 0x%llx requested\n",
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
type);
|
|
|
|
BUG_ON(1);
|
2008-04-18 14:29:51 +00:00
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
/* 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);
|
2008-04-18 14:29:51 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
devices_info = kzalloc(sizeof(*devices_info) * fs_devices->rw_devices,
|
|
|
|
GFP_NOFS);
|
|
|
|
if (!devices_info)
|
|
|
|
return -ENOMEM;
|
2010-03-17 20:45:56 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
cur = fs_devices->alloc_list.next;
|
2008-04-18 14:29:51 +00:00
|
|
|
|
2010-04-06 13:37:47 +00:00
|
|
|
/*
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
* in the first pass through the devices list, we gather information
|
|
|
|
* about the available holes on each device.
|
2010-04-06 13:37:47 +00:00
|
|
|
*/
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
ndevs = 0;
|
|
|
|
while (cur != &fs_devices->alloc_list) {
|
|
|
|
struct btrfs_device *device;
|
|
|
|
u64 max_avail;
|
|
|
|
u64 dev_offset;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
device = list_entry(cur, struct btrfs_device, dev_alloc_list);
|
2010-04-06 13:37:47 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
cur = cur->next;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (!device->writeable) {
|
2012-11-03 10:58:34 +00:00
|
|
|
WARN(1, KERN_ERR
|
2013-12-20 16:37:06 +00:00
|
|
|
"BTRFS: read-only device in alloc_list\n");
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2012-11-05 17:29:28 +00:00
|
|
|
if (!device->in_fs_metadata ||
|
|
|
|
device->is_tgtdev_for_dev_replace)
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
continue;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (device->total_bytes > device->bytes_used)
|
|
|
|
total_avail = device->total_bytes - device->bytes_used;
|
|
|
|
else
|
|
|
|
total_avail = 0;
|
Btrfs: fix a bug of balance on full multi-disk partitions
When balancing, we'll first try to shrink devices for some space,
but if it is working on a full multi-disk partition with raid protection,
we may encounter a bug, that is, while shrinking, total_bytes may be less
than bytes_used, and btrfs may allocate a dev extent that accesses out of
device's bounds.
Then we will not be able to write or read the data which stores at the end
of the device, and get the followings:
device fsid 0939f071-7ea3-46c8-95df-f176d773bfb6 devid 1 transid 10 /dev/sdb5
Btrfs detected SSD devices, enabling SSD mode
btrfs: relocating block group 476315648 flags 9
btrfs: found 4 extents
attempt to access beyond end of device
sdb5: rw=145, want=546176, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546304, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546432, limit=546147
attempt to access beyond end of device
sdb5: rw=145, want=546560, limit=546147
attempt to access beyond end of device
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-08-02 02:39:03 +00:00
|
|
|
|
|
|
|
/* If there is no space on this device, skip it. */
|
|
|
|
if (total_avail == 0)
|
|
|
|
continue;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
ret = find_free_dev_extent(trans, device,
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
max_stripe_size * dev_stripes,
|
|
|
|
&dev_offset, &max_avail);
|
|
|
|
if (ret && ret != -ENOSPC)
|
|
|
|
goto error;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (ret == 0)
|
|
|
|
max_avail = max_stripe_size * dev_stripes;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (max_avail < BTRFS_STRIPE_LEN * dev_stripes)
|
|
|
|
continue;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2013-01-31 00:55:01 +00:00
|
|
|
if (ndevs == fs_devices->rw_devices) {
|
|
|
|
WARN(1, "%s: found more than %llu devices\n",
|
|
|
|
__func__, fs_devices->rw_devices);
|
|
|
|
break;
|
|
|
|
}
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
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;
|
|
|
|
}
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
/*
|
|
|
|
* now sort the devices by hole size / available space
|
|
|
|
*/
|
|
|
|
sort(devices_info, ndevs, sizeof(struct btrfs_device_info),
|
|
|
|
btrfs_cmp_device_info, NULL);
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
/* round down to number of usable stripes */
|
|
|
|
ndevs -= ndevs % devs_increment;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
if (ndevs < devs_increment * sub_stripes || ndevs < devs_min) {
|
|
|
|
ret = -ENOSPC;
|
|
|
|
goto error;
|
2011-01-05 10:07:28 +00:00
|
|
|
}
|
2010-04-06 13:37:47 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
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;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
/*
|
|
|
|
* 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,
|
|
|
|
btrfs_super_stripesize(info->super_copy));
|
|
|
|
data_stripes = num_stripes - 1;
|
|
|
|
}
|
|
|
|
if (type & BTRFS_BLOCK_GROUP_RAID6) {
|
|
|
|
raid_stripe_len = find_raid56_stripe_len(ndevs - 2,
|
|
|
|
btrfs_super_stripesize(info->super_copy));
|
|
|
|
data_stripes = num_stripes - 2;
|
|
|
|
}
|
2013-02-20 21:23:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 = max_chunk_size;
|
|
|
|
do_div(stripe_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;
|
|
|
|
}
|
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
do_div(stripe_size, dev_stripes);
|
2012-04-13 14:05:08 +00:00
|
|
|
|
|
|
|
/* align to BTRFS_STRIPE_LEN */
|
2013-01-29 23:40:14 +00:00
|
|
|
do_div(stripe_size, raid_stripe_len);
|
|
|
|
stripe_size *= raid_stripe_len;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
|
|
|
map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
|
|
|
|
if (!map) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
map->num_stripes = num_stripes;
|
2008-04-18 14:29:51 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
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;
|
2008-03-24 19:01:59 +00:00
|
|
|
}
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
map->sector_size = extent_root->sectorsize;
|
2013-01-29 23:40:14 +00:00
|
|
|
map->stripe_len = raid_stripe_len;
|
|
|
|
map->io_align = raid_stripe_len;
|
|
|
|
map->io_width = raid_stripe_len;
|
2008-11-18 02:11:30 +00:00
|
|
|
map->type = type;
|
|
|
|
map->sub_stripes = sub_stripes;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
num_bytes = stripe_size * data_stripes;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
trace_btrfs_chunk_alloc(info->chunk_root, map, start, num_bytes);
|
Btrfs: add initial tracepoint support for btrfs
Tracepoints can provide insight into why btrfs hits bugs and be greatly
helpful for debugging, e.g
dd-7822 [000] 2121.641088: btrfs_inode_request: root = 5(FS_TREE), gen = 4, ino = 256, blocks = 8, disk_i_size = 0, last_trans = 8, logged_trans = 0
dd-7822 [000] 2121.641100: btrfs_inode_new: root = 5(FS_TREE), gen = 8, ino = 257, blocks = 0, disk_i_size = 0, last_trans = 0, logged_trans = 0
btrfs-transacti-7804 [001] 2146.935420: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29368320 (orig_level = 0), cow_buf = 29388800 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.935473: btrfs_cow_block: root = 1(ROOT_TREE), refs = 2, orig_buf = 29364224 (orig_level = 0), cow_buf = 29392896 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.972221: btrfs_transaction_commit: root = 1(ROOT_TREE), gen = 8
flush-btrfs-2-7821 [001] 2155.824210: btrfs_chunk_alloc: root = 3(CHUNK_TREE), offset = 1103101952, size = 1073741824, num_stripes = 1, sub_stripes = 0, type = DATA
flush-btrfs-2-7821 [001] 2155.824241: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29388800 (orig_level = 0), cow_buf = 29396992 (cow_level = 0)
flush-btrfs-2-7821 [001] 2155.824255: btrfs_cow_block: root = 4(DEV_TREE), refs = 2, orig_buf = 29372416 (orig_level = 0), cow_buf = 29401088 (cow_level = 0)
flush-btrfs-2-7821 [000] 2155.824329: btrfs_cow_block: root = 3(CHUNK_TREE), refs = 2, orig_buf = 20971520 (orig_level = 0), cow_buf = 20975616 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898019: btrfs_cow_block: root = 5(FS_TREE), refs = 2, orig_buf = 29384704 (orig_level = 0), cow_buf = 29405184 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898043: btrfs_cow_block: root = 7(CSUM_TREE), refs = 2, orig_buf = 29376512 (orig_level = 0), cow_buf = 29409280 (cow_level = 0)
Here is what I have added:
1) ordere_extent:
btrfs_ordered_extent_add
btrfs_ordered_extent_remove
btrfs_ordered_extent_start
btrfs_ordered_extent_put
These provide critical information to understand how ordered_extents are
updated.
2) extent_map:
btrfs_get_extent
extent_map is used in both read and write cases, and it is useful for tracking
how btrfs specific IO is running.
3) writepage:
__extent_writepage
btrfs_writepage_end_io_hook
Pages are cirtical resourses and produce a lot of corner cases during writeback,
so it is valuable to know how page is written to disk.
4) inode:
btrfs_inode_new
btrfs_inode_request
btrfs_inode_evict
These can show where and when a inode is created, when a inode is evicted.
5) sync:
btrfs_sync_file
btrfs_sync_fs
These show sync arguments.
6) transaction:
btrfs_transaction_commit
In transaction based filesystem, it will be useful to know the generation and
who does commit.
7) back reference and cow:
btrfs_delayed_tree_ref
btrfs_delayed_data_ref
btrfs_delayed_ref_head
btrfs_cow_block
Btrfs natively supports back references, these tracepoints are helpful on
understanding btrfs's COW mechanism.
8) chunk:
btrfs_chunk_alloc
btrfs_chunk_free
Chunk is a link between physical offset and logical offset, and stands for space
infomation in btrfs, and these are helpful on tracing space things.
9) reserved_extent:
btrfs_reserved_extent_alloc
btrfs_reserved_extent_free
These can show how btrfs uses its space.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-24 11:18:59 +00:00
|
|
|
|
2011-04-20 22:48:27 +00:00
|
|
|
em = alloc_extent_map();
|
2008-11-18 02:11:30 +00:00
|
|
|
if (!em) {
|
2011-01-05 10:07:28 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
2008-03-25 20:50:33 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
em->bdev = (struct block_device *)map;
|
|
|
|
em->start = start;
|
btrfs: quasi-round-robin for chunk allocation
In a multi device setup, the chunk allocator currently always allocates
chunks on the devices in the same order. This leads to a very uneven
distribution, especially with RAID1 or RAID10 and an uneven number of
devices.
This patch always sorts the devices before allocating, and allocates the
stripes on the devices with the most available space, as long as there
is enough space available. In a low space situation, it first tries to
maximize striping.
The patch also simplifies the allocator and reduces the checks for
corner cases.
The simplification is done by several means. First, it defines the
properties of each RAID type upfront. These properties are used afterwards
instead of differentiating cases in several places.
Second, the old allocator defined a minimum stripe size for each block
group type, tried to find a large enough chunk, and if this fails just
allocates a smaller one. This is now done in one step. The largest possible
chunk (up to max_chunk_size) is searched and allocated.
Because we now have only one pass, the allocation of the map (struct
map_lookup) is moved down to the point where the number of stripes is
already known. This way we avoid reallocation of the map.
We still avoid allocating stripes that are not a multiple of STRIPE_SIZE.
2011-04-12 10:07:57 +00:00
|
|
|
em->len = num_bytes;
|
2008-11-18 02:11:30 +00:00
|
|
|
em->block_start = 0;
|
|
|
|
em->block_len = em->len;
|
2013-06-27 17:22:46 +00:00
|
|
|
em->orig_block_len = stripe_size;
|
2008-03-25 20:50:33 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
em_tree = &extent_root->fs_info->mapping_tree.map_tree;
|
2009-09-02 20:24:52 +00:00
|
|
|
write_lock(&em_tree->lock);
|
2013-04-05 20:51:15 +00:00
|
|
|
ret = add_extent_mapping(em_tree, em, 0);
|
2013-06-27 17:22:46 +00:00
|
|
|
if (!ret) {
|
|
|
|
list_add_tail(&em->list, &trans->transaction->pending_chunks);
|
|
|
|
atomic_inc(&em->refs);
|
|
|
|
}
|
2009-09-02 20:24:52 +00:00
|
|
|
write_unlock(&em_tree->lock);
|
2013-01-31 15:23:04 +00:00
|
|
|
if (ret) {
|
|
|
|
free_extent_map(em);
|
2011-09-09 00:29:00 +00:00
|
|
|
goto error;
|
2013-01-31 15:23:04 +00:00
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-01-29 20:03:37 +00:00
|
|
|
ret = btrfs_make_block_group(trans, extent_root, 0, type,
|
|
|
|
BTRFS_FIRST_CHUNK_TREE_OBJECTID,
|
|
|
|
start, num_bytes);
|
2013-06-27 17:22:46 +00:00
|
|
|
if (ret)
|
|
|
|
goto error_del_extent;
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2013-01-31 15:23:04 +00:00
|
|
|
free_extent_map(em);
|
2013-01-29 23:40:14 +00:00
|
|
|
check_raid56_incompat_flag(extent_root->fs_info, type);
|
|
|
|
|
2011-01-05 10:07:28 +00:00
|
|
|
kfree(devices_info);
|
2008-11-18 02:11:30 +00:00
|
|
|
return 0;
|
2011-01-05 10:07:28 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
error_del_extent:
|
2013-01-31 15:23:04 +00:00
|
|
|
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);
|
2011-01-05 10:07:28 +00:00
|
|
|
error:
|
|
|
|
kfree(map);
|
|
|
|
kfree(devices_info);
|
|
|
|
return ret;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans,
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_root *extent_root,
|
2013-06-27 17:22:46 +00:00
|
|
|
u64 chunk_offset, u64 chunk_size)
|
2008-11-18 02:11:30 +00:00
|
|
|
{
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_root *chunk_root = extent_root->fs_info->chunk_root;
|
|
|
|
struct btrfs_device *device;
|
|
|
|
struct btrfs_chunk *chunk;
|
|
|
|
struct btrfs_stripe *stripe;
|
2013-06-27 17:22:46 +00:00
|
|
|
struct extent_map_tree *em_tree;
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
size_t item_size;
|
|
|
|
u64 dev_offset;
|
|
|
|
u64 stripe_size;
|
|
|
|
int i = 0;
|
2008-11-18 02:11:30 +00:00
|
|
|
int ret;
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
em_tree = &extent_root->fs_info->mapping_tree.map_tree;
|
|
|
|
read_lock(&em_tree->lock);
|
|
|
|
em = lookup_extent_mapping(em_tree, chunk_offset, chunk_size);
|
|
|
|
read_unlock(&em_tree->lock);
|
|
|
|
|
|
|
|
if (!em) {
|
|
|
|
btrfs_crit(extent_root->fs_info, "unable to find logical "
|
|
|
|
"%Lu len %Lu", chunk_offset, chunk_size);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (em->start != chunk_offset || em->len != chunk_size) {
|
|
|
|
btrfs_crit(extent_root->fs_info, "found a bad mapping, wanted"
|
|
|
|
" %Lu-%Lu, found %Lu-%Lu\n", chunk_offset,
|
|
|
|
chunk_size, em->start, em->len);
|
|
|
|
free_extent_map(em);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
item_size = btrfs_chunk_item_size(map->num_stripes);
|
|
|
|
stripe_size = em->orig_block_len;
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
chunk = kzalloc(item_size, GFP_NOFS);
|
2013-06-27 17:22:46 +00:00
|
|
|
if (!chunk) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
|
|
device = map->stripes[i].dev;
|
|
|
|
dev_offset = map->stripes[i].physical;
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
device->bytes_used += stripe_size;
|
2008-03-24 19:01:56 +00:00
|
|
|
ret = btrfs_update_device(trans, device);
|
2011-09-09 00:40:01 +00:00
|
|
|
if (ret)
|
2013-06-27 17:22:46 +00:00
|
|
|
goto out;
|
|
|
|
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)
|
|
|
|
goto out;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
|
2011-09-26 21:12:22 +00:00
|
|
|
spin_lock(&extent_root->fs_info->free_chunk_lock);
|
|
|
|
extent_root->fs_info->free_chunk_space -= (stripe_size *
|
|
|
|
map->num_stripes);
|
|
|
|
spin_unlock(&extent_root->fs_info->free_chunk_lock);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
stripe = &chunk->stripe;
|
2013-06-27 17:22:46 +00:00
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
|
|
device = map->stripes[i].dev;
|
|
|
|
dev_offset = map->stripes[i].physical;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-04-15 19:41:47 +00:00
|
|
|
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);
|
2008-11-18 02:11:30 +00:00
|
|
|
stripe++;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_set_stack_chunk_length(chunk, chunk_size);
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid);
|
2008-11-18 02:11:30 +00:00
|
|
|
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);
|
2008-03-24 19:01:56 +00:00
|
|
|
btrfs_set_stack_chunk_sector_size(chunk, extent_root->sectorsize);
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_set_stack_chunk_sub_stripes(chunk, map->sub_stripes);
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
|
|
|
|
key.type = BTRFS_CHUNK_ITEM_KEY;
|
|
|
|
key.offset = chunk_offset;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size);
|
2011-08-10 19:32:10 +00:00
|
|
|
if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
|
|
|
|
/*
|
|
|
|
* TODO: Cleanup of inserted chunk root in case of
|
|
|
|
* failure.
|
|
|
|
*/
|
2011-12-08 07:07:24 +00:00
|
|
|
ret = btrfs_add_system_chunk(chunk_root, &key, chunk,
|
2008-11-18 02:11:30 +00:00
|
|
|
item_size);
|
2008-04-25 20:53:30 +00:00
|
|
|
}
|
Btrfs: add initial tracepoint support for btrfs
Tracepoints can provide insight into why btrfs hits bugs and be greatly
helpful for debugging, e.g
dd-7822 [000] 2121.641088: btrfs_inode_request: root = 5(FS_TREE), gen = 4, ino = 256, blocks = 8, disk_i_size = 0, last_trans = 8, logged_trans = 0
dd-7822 [000] 2121.641100: btrfs_inode_new: root = 5(FS_TREE), gen = 8, ino = 257, blocks = 0, disk_i_size = 0, last_trans = 0, logged_trans = 0
btrfs-transacti-7804 [001] 2146.935420: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29368320 (orig_level = 0), cow_buf = 29388800 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.935473: btrfs_cow_block: root = 1(ROOT_TREE), refs = 2, orig_buf = 29364224 (orig_level = 0), cow_buf = 29392896 (cow_level = 0)
btrfs-transacti-7804 [001] 2146.972221: btrfs_transaction_commit: root = 1(ROOT_TREE), gen = 8
flush-btrfs-2-7821 [001] 2155.824210: btrfs_chunk_alloc: root = 3(CHUNK_TREE), offset = 1103101952, size = 1073741824, num_stripes = 1, sub_stripes = 0, type = DATA
flush-btrfs-2-7821 [001] 2155.824241: btrfs_cow_block: root = 2(EXTENT_TREE), refs = 2, orig_buf = 29388800 (orig_level = 0), cow_buf = 29396992 (cow_level = 0)
flush-btrfs-2-7821 [001] 2155.824255: btrfs_cow_block: root = 4(DEV_TREE), refs = 2, orig_buf = 29372416 (orig_level = 0), cow_buf = 29401088 (cow_level = 0)
flush-btrfs-2-7821 [000] 2155.824329: btrfs_cow_block: root = 3(CHUNK_TREE), refs = 2, orig_buf = 20971520 (orig_level = 0), cow_buf = 20975616 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898019: btrfs_cow_block: root = 5(FS_TREE), refs = 2, orig_buf = 29384704 (orig_level = 0), cow_buf = 29405184 (cow_level = 0)
btrfs-endio-wri-7800 [001] 2155.898043: btrfs_cow_block: root = 7(CSUM_TREE), refs = 2, orig_buf = 29376512 (orig_level = 0), cow_buf = 29409280 (cow_level = 0)
Here is what I have added:
1) ordere_extent:
btrfs_ordered_extent_add
btrfs_ordered_extent_remove
btrfs_ordered_extent_start
btrfs_ordered_extent_put
These provide critical information to understand how ordered_extents are
updated.
2) extent_map:
btrfs_get_extent
extent_map is used in both read and write cases, and it is useful for tracking
how btrfs specific IO is running.
3) writepage:
__extent_writepage
btrfs_writepage_end_io_hook
Pages are cirtical resourses and produce a lot of corner cases during writeback,
so it is valuable to know how page is written to disk.
4) inode:
btrfs_inode_new
btrfs_inode_request
btrfs_inode_evict
These can show where and when a inode is created, when a inode is evicted.
5) sync:
btrfs_sync_file
btrfs_sync_fs
These show sync arguments.
6) transaction:
btrfs_transaction_commit
In transaction based filesystem, it will be useful to know the generation and
who does commit.
7) back reference and cow:
btrfs_delayed_tree_ref
btrfs_delayed_data_ref
btrfs_delayed_ref_head
btrfs_cow_block
Btrfs natively supports back references, these tracepoints are helpful on
understanding btrfs's COW mechanism.
8) chunk:
btrfs_chunk_alloc
btrfs_chunk_free
Chunk is a link between physical offset and logical offset, and stands for space
infomation in btrfs, and these are helpful on tracing space things.
9) reserved_extent:
btrfs_reserved_extent_alloc
btrfs_reserved_extent_free
These can show how btrfs uses its space.
Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2011-03-24 11:18:59 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
out:
|
2008-03-24 19:01:56 +00:00
|
|
|
kfree(chunk);
|
2013-06-27 17:22:46 +00:00
|
|
|
free_extent_map(em);
|
2011-08-10 19:32:10 +00:00
|
|
|
return ret;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
/*
|
|
|
|
* 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_root *extent_root, u64 type)
|
|
|
|
{
|
|
|
|
u64 chunk_offset;
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
chunk_offset = find_next_chunk(extent_root->fs_info);
|
|
|
|
return __btrfs_alloc_chunk(trans, extent_root, chunk_offset, type);
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_root *root,
|
|
|
|
struct btrfs_device *device)
|
|
|
|
{
|
|
|
|
u64 chunk_offset;
|
|
|
|
u64 sys_chunk_offset;
|
|
|
|
u64 alloc_profile;
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct btrfs_root *extent_root = fs_info->extent_root;
|
|
|
|
int ret;
|
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
chunk_offset = find_next_chunk(fs_info);
|
2013-01-29 10:13:12 +00:00
|
|
|
alloc_profile = btrfs_get_alloc_profile(extent_root, 0);
|
2013-06-27 17:22:46 +00:00
|
|
|
ret = __btrfs_alloc_chunk(trans, extent_root, chunk_offset,
|
|
|
|
alloc_profile);
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2008-11-18 02:11:30 +00:00
|
|
|
|
2013-06-27 17:22:46 +00:00
|
|
|
sys_chunk_offset = find_next_chunk(root->fs_info);
|
2013-01-29 10:13:12 +00:00
|
|
|
alloc_profile = btrfs_get_alloc_profile(fs_info->chunk_root, 0);
|
2013-06-27 17:22:46 +00:00
|
|
|
ret = __btrfs_alloc_chunk(trans, extent_root, sys_chunk_offset,
|
|
|
|
alloc_profile);
|
2012-09-18 13:52:32 +00:00
|
|
|
if (ret) {
|
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
goto out;
|
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
ret = btrfs_add_device(trans, fs_info->chunk_root, device);
|
2012-03-12 15:03:00 +00:00
|
|
|
if (ret)
|
2012-09-18 13:52:32 +00:00
|
|
|
btrfs_abort_transaction(trans, root, ret);
|
|
|
|
out:
|
2012-03-12 15:03:00 +00:00
|
|
|
return ret;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset)
|
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
|
|
|
|
int readonly = 0;
|
|
|
|
int i;
|
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
read_lock(&map_tree->map_tree.lock);
|
2008-11-18 02:11:30 +00:00
|
|
|
em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
|
2009-09-02 20:24:52 +00:00
|
|
|
read_unlock(&map_tree->map_tree.lock);
|
2008-11-18 02:11:30 +00:00
|
|
|
if (!em)
|
|
|
|
return 1;
|
|
|
|
|
2010-01-27 02:07:59 +00:00
|
|
|
if (btrfs_test_opt(root, DEGRADED)) {
|
|
|
|
free_extent_map(em);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
for (i = 0; i < map->num_stripes; i++) {
|
|
|
|
if (!map->stripes[i].dev->writeable) {
|
|
|
|
readonly = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
free_extent_map(em);
|
2008-11-18 02:11:30 +00:00
|
|
|
return readonly;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void btrfs_mapping_init(struct btrfs_mapping_tree *tree)
|
|
|
|
{
|
2011-04-20 22:34:43 +00:00
|
|
|
extent_map_tree_init(&tree->map_tree);
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
|
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2009-09-02 20:24:52 +00:00
|
|
|
write_lock(&tree->map_tree.lock);
|
2008-03-24 19:01:56 +00:00
|
|
|
em = lookup_extent_mapping(&tree->map_tree, 0, (u64)-1);
|
|
|
|
if (em)
|
|
|
|
remove_extent_mapping(&tree->map_tree, em);
|
2009-09-02 20:24:52 +00:00
|
|
|
write_unlock(&tree->map_tree.lock);
|
2008-03-24 19:01:56 +00:00
|
|
|
if (!em)
|
|
|
|
break;
|
|
|
|
kfree(em->bdev);
|
|
|
|
/* once for us */
|
|
|
|
free_extent_map(em);
|
|
|
|
/* once for the tree */
|
|
|
|
free_extent_map(em);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-05 13:59:07 +00:00
|
|
|
int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
|
2008-04-09 20:28:12 +00:00
|
|
|
{
|
2012-11-05 13:59:07 +00:00
|
|
|
struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
|
2008-04-09 20:28:12 +00:00
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
struct extent_map_tree *em_tree = &map_tree->map_tree;
|
|
|
|
int ret;
|
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
read_lock(&em_tree->lock);
|
2008-04-09 20:28:12 +00:00
|
|
|
em = lookup_extent_mapping(em_tree, logical, len);
|
2009-09-02 20:24:52 +00:00
|
|
|
read_unlock(&em_tree->lock);
|
2008-04-09 20:28:12 +00:00
|
|
|
|
2013-04-23 14:53:18 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
if (!em) {
|
2013-07-11 13:41:11 +00:00
|
|
|
btrfs_crit(fs_info, "No mapping for %Lu-%Lu\n", logical,
|
2013-04-23 14:53:18 +00:00
|
|
|
logical+len);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (em->start > logical || em->start + em->len < logical) {
|
2013-07-11 13:41:11 +00:00
|
|
|
btrfs_crit(fs_info, "Invalid mapping for %Lu-%Lu, got "
|
2013-04-23 14:53:18 +00:00
|
|
|
"%Lu-%Lu\n", logical, logical+len, em->start,
|
|
|
|
em->start + em->len);
|
2013-09-29 02:33:16 +00:00
|
|
|
free_extent_map(em);
|
2013-04-23 14:53:18 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-04-09 20:28:12 +00:00
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1))
|
|
|
|
ret = map->num_stripes;
|
2008-04-16 14:49:51 +00:00
|
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID10)
|
|
|
|
ret = map->sub_stripes;
|
2013-01-29 23:40:14 +00:00
|
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID5)
|
|
|
|
ret = 2;
|
|
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID6)
|
|
|
|
ret = 3;
|
2008-04-09 20:28:12 +00:00
|
|
|
else
|
|
|
|
ret = 1;
|
|
|
|
free_extent_map(em);
|
2012-11-06 14:06:47 +00:00
|
|
|
|
|
|
|
btrfs_dev_replace_lock(&fs_info->dev_replace);
|
|
|
|
if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))
|
|
|
|
ret++;
|
|
|
|
btrfs_dev_replace_unlock(&fs_info->dev_replace);
|
|
|
|
|
2008-04-09 20:28:12 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
unsigned long btrfs_full_stripe_len(struct btrfs_root *root,
|
|
|
|
struct btrfs_mapping_tree *map_tree,
|
|
|
|
u64 logical)
|
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
struct extent_map_tree *em_tree = &map_tree->map_tree;
|
|
|
|
unsigned long len = root->sectorsize;
|
|
|
|
|
|
|
|
read_lock(&em_tree->lock);
|
|
|
|
em = lookup_extent_mapping(em_tree, logical, len);
|
|
|
|
read_unlock(&em_tree->lock);
|
|
|
|
BUG_ON(!em);
|
|
|
|
|
|
|
|
BUG_ON(em->start > logical || em->start + em->len < logical);
|
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID6)) {
|
|
|
|
len = map->stripe_len * nr_data_stripes(map);
|
|
|
|
}
|
|
|
|
free_extent_map(em);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_is_parity_mirror(struct btrfs_mapping_tree *map_tree,
|
|
|
|
u64 logical, u64 len, int mirror_num)
|
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
struct extent_map_tree *em_tree = &map_tree->map_tree;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
read_lock(&em_tree->lock);
|
|
|
|
em = lookup_extent_mapping(em_tree, logical, len);
|
|
|
|
read_unlock(&em_tree->lock);
|
|
|
|
BUG_ON(!em);
|
|
|
|
|
|
|
|
BUG_ON(em->start > logical || em->start + em->len < logical);
|
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID6))
|
|
|
|
ret = 1;
|
|
|
|
free_extent_map(em);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-11-06 13:52:18 +00:00
|
|
|
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)
|
2008-05-13 17:46:40 +00:00
|
|
|
{
|
|
|
|
int i;
|
2012-11-06 13:52:18 +00:00
|
|
|
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;
|
|
|
|
}
|
2008-05-13 17:46:40 +00:00
|
|
|
}
|
2012-11-06 13:52:18 +00:00
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
/* we couldn't find one that doesn't fail. Just return something
|
|
|
|
* and the io error handling code will clean up eventually
|
|
|
|
*/
|
|
|
|
return optimal;
|
|
|
|
}
|
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
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, u64 *raid_map)
|
|
|
|
{
|
|
|
|
struct btrfs_bio_stripe s;
|
|
|
|
int i;
|
|
|
|
u64 l;
|
|
|
|
int again = 1;
|
|
|
|
|
|
|
|
while (again) {
|
|
|
|
again = 0;
|
|
|
|
for (i = 0; i < bbio->num_stripes - 1; i++) {
|
|
|
|
if (parity_smaller(raid_map[i], raid_map[i+1])) {
|
|
|
|
s = bbio->stripes[i];
|
|
|
|
l = raid_map[i];
|
|
|
|
bbio->stripes[i] = bbio->stripes[i+1];
|
|
|
|
raid_map[i] = raid_map[i+1];
|
|
|
|
bbio->stripes[i+1] = s;
|
|
|
|
raid_map[i+1] = l;
|
|
|
|
again = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-05 14:46:42 +00:00
|
|
|
static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
|
2008-04-21 14:03:05 +00:00
|
|
|
u64 logical, u64 *length,
|
2011-08-04 15:15:33 +00:00
|
|
|
struct btrfs_bio **bbio_ret,
|
2013-01-29 23:40:14 +00:00
|
|
|
int mirror_num, u64 **raid_map_ret)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
2012-11-05 14:46:42 +00:00
|
|
|
struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
|
2008-03-24 19:01:56 +00:00
|
|
|
struct extent_map_tree *em_tree = &map_tree->map_tree;
|
|
|
|
u64 offset;
|
2008-03-25 20:50:33 +00:00
|
|
|
u64 stripe_offset;
|
2011-03-24 10:24:26 +00:00
|
|
|
u64 stripe_end_offset;
|
2008-03-25 20:50:33 +00:00
|
|
|
u64 stripe_nr;
|
2011-03-24 10:24:26 +00:00
|
|
|
u64 stripe_nr_orig;
|
|
|
|
u64 stripe_nr_end;
|
2013-01-29 23:40:14 +00:00
|
|
|
u64 stripe_len;
|
|
|
|
u64 *raid_map = NULL;
|
2008-03-25 20:50:33 +00:00
|
|
|
int stripe_index;
|
2008-04-09 20:28:12 +00:00
|
|
|
int i;
|
2011-12-01 04:55:47 +00:00
|
|
|
int ret = 0;
|
2008-04-21 14:03:05 +00:00
|
|
|
int num_stripes;
|
2008-04-29 13:38:00 +00:00
|
|
|
int max_errors = 0;
|
2011-08-04 15:15:33 +00:00
|
|
|
struct btrfs_bio *bbio = NULL;
|
2012-11-06 13:43:46 +00:00
|
|
|
struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
|
|
|
|
int dev_replace_is_ongoing = 0;
|
|
|
|
int num_alloc_stripes;
|
2012-11-06 14:06:47 +00:00
|
|
|
int patch_the_first_stripe_for_dev_replace = 0;
|
|
|
|
u64 physical_to_patch_in_first_stripe = 0;
|
2013-01-29 23:40:14 +00:00
|
|
|
u64 raid56_full_stripe_start = (u64)-1;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
read_lock(&em_tree->lock);
|
2008-03-24 19:01:56 +00:00
|
|
|
em = lookup_extent_mapping(em_tree, logical, *length);
|
2009-09-02 20:24:52 +00:00
|
|
|
read_unlock(&em_tree->lock);
|
2008-04-21 14:03:05 +00:00
|
|
|
|
2008-04-17 15:29:12 +00:00
|
|
|
if (!em) {
|
2013-03-19 22:41:23 +00:00
|
|
|
btrfs_crit(fs_info, "unable to find logical %llu len %llu",
|
2013-08-20 11:20:07 +00:00
|
|
|
logical, *length);
|
2013-04-20 03:45:33 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (em->start > logical || em->start + em->len < logical) {
|
|
|
|
btrfs_crit(fs_info, "found a bad mapping, wanted %Lu, "
|
|
|
|
"found %Lu-%Lu\n", logical, em->start,
|
|
|
|
em->start + em->len);
|
2013-09-29 02:33:16 +00:00
|
|
|
free_extent_map(em);
|
2013-04-20 03:45:33 +00:00
|
|
|
return -EINVAL;
|
2008-04-17 15:29:12 +00:00
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
|
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
offset = logical - em->start;
|
2008-03-25 20:50:33 +00:00
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
stripe_len = map->stripe_len;
|
2008-03-25 20:50:33 +00:00
|
|
|
stripe_nr = offset;
|
|
|
|
/*
|
|
|
|
* stripe_nr counts the total number of stripes we have to stride
|
|
|
|
* to get to this block
|
|
|
|
*/
|
2013-01-29 23:40:14 +00:00
|
|
|
do_div(stripe_nr, stripe_len);
|
2008-03-25 20:50:33 +00:00
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
stripe_offset = stripe_nr * stripe_len;
|
2008-03-25 20:50:33 +00:00
|
|
|
BUG_ON(offset < stripe_offset);
|
|
|
|
|
|
|
|
/* stripe_offset is the offset of this block in its stripe*/
|
|
|
|
stripe_offset = offset - stripe_offset;
|
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
/* if we're here for raid56, we need to know the stripe aligned start */
|
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) {
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
do_div(raid56_full_stripe_start, full_stripe_len);
|
|
|
|
raid56_full_stripe_start *= full_stripe_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rw & REQ_DISCARD) {
|
|
|
|
/* we don't discard raid56 yet */
|
|
|
|
if (map->type &
|
|
|
|
(BTRFS_BLOCK_GROUP_RAID5 | BTRFS_BLOCK_GROUP_RAID6)) {
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
|
|
|
}
|
2011-03-24 10:24:26 +00:00
|
|
|
*length = min_t(u64, em->len - offset, *length);
|
2013-01-29 23:40:14 +00:00
|
|
|
} else 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_RAID5 | BTRFS_BLOCK_GROUP_RAID6) &&
|
|
|
|
(rw & REQ_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);
|
2008-04-09 20:28:12 +00:00
|
|
|
} else {
|
|
|
|
*length = em->len - offset;
|
|
|
|
}
|
2008-04-21 14:03:05 +00:00
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
/* This is for when we're called from btrfs_merge_bio_hook() and all
|
|
|
|
it cares about is the length */
|
2011-08-04 15:15:33 +00:00
|
|
|
if (!bbio_ret)
|
2008-04-09 20:28:12 +00:00
|
|
|
goto out;
|
|
|
|
|
2012-11-06 13:43:46 +00:00
|
|
|
btrfs_dev_replace_lock(dev_replace);
|
|
|
|
dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
|
|
|
|
if (!dev_replace_is_ongoing)
|
|
|
|
btrfs_dev_replace_unlock(dev_replace);
|
|
|
|
|
2012-11-06 14:06:47 +00:00
|
|
|
if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 &&
|
|
|
|
!(rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) &&
|
|
|
|
dev_replace->tgtdev != NULL) {
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
u64 tmp_length = *length;
|
|
|
|
struct btrfs_bio *tmp_bbio = NULL;
|
|
|
|
int tmp_num_stripes;
|
|
|
|
u64 srcdev_devid = dev_replace->srcdev->devid;
|
|
|
|
int index_srcdev = 0;
|
|
|
|
int found = 0;
|
|
|
|
u64 physical_of_found = 0;
|
|
|
|
|
|
|
|
ret = __btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS,
|
2013-01-29 23:40:14 +00:00
|
|
|
logical, &tmp_length, &tmp_bbio, 0, NULL);
|
2012-11-06 14:06:47 +00:00
|
|
|
if (ret) {
|
|
|
|
WARN_ON(tmp_bbio != NULL);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp_num_stripes = tmp_bbio->num_stripes;
|
|
|
|
if (mirror_num > tmp_num_stripes) {
|
|
|
|
/*
|
|
|
|
* REQ_GET_READ_MIRRORS does not contain this
|
|
|
|
* mirror, that means that the requested area
|
|
|
|
* is not left of the left cursor
|
|
|
|
*/
|
|
|
|
ret = -EIO;
|
|
|
|
kfree(tmp_bbio);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 < tmp_num_stripes; i++) {
|
|
|
|
if (tmp_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 <=
|
|
|
|
tmp_bbio->stripes[i].physical)
|
|
|
|
continue;
|
|
|
|
index_srcdev = i;
|
|
|
|
found = 1;
|
|
|
|
physical_of_found =
|
|
|
|
tmp_bbio->stripes[i].physical;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found) {
|
|
|
|
mirror_num = index_srcdev + 1;
|
|
|
|
patch_the_first_stripe_for_dev_replace = 1;
|
|
|
|
physical_to_patch_in_first_stripe = physical_of_found;
|
|
|
|
} else {
|
|
|
|
WARN_ON(1);
|
|
|
|
ret = -EIO;
|
|
|
|
kfree(tmp_bbio);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(tmp_bbio);
|
|
|
|
} else if (mirror_num > map->num_stripes) {
|
|
|
|
mirror_num = 0;
|
|
|
|
}
|
|
|
|
|
2008-04-21 14:03:05 +00:00
|
|
|
num_stripes = 1;
|
2008-04-09 20:28:12 +00:00
|
|
|
stripe_index = 0;
|
2011-03-24 10:24:26 +00:00
|
|
|
stripe_nr_orig = stripe_nr;
|
2013-02-26 08:10:22 +00:00
|
|
|
stripe_nr_end = ALIGN(offset + *length, map->stripe_len);
|
2011-03-24 10:24:26 +00:00
|
|
|
do_div(stripe_nr_end, map->stripe_len);
|
|
|
|
stripe_end_offset = stripe_nr_end * map->stripe_len -
|
|
|
|
(offset + *length);
|
2013-01-29 23:40:14 +00:00
|
|
|
|
2011-03-24 10:24:26 +00:00
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
|
|
|
|
if (rw & REQ_DISCARD)
|
|
|
|
num_stripes = min_t(u64, map->num_stripes,
|
|
|
|
stripe_nr_end - stripe_nr_orig);
|
|
|
|
stripe_index = do_div(stripe_nr, map->num_stripes);
|
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
|
2012-11-06 13:16:24 +00:00
|
|
|
if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS))
|
2008-04-21 14:03:05 +00:00
|
|
|
num_stripes = map->num_stripes;
|
2008-04-29 18:12:09 +00:00
|
|
|
else if (mirror_num)
|
2008-04-09 20:28:12 +00:00
|
|
|
stripe_index = mirror_num - 1;
|
2008-05-13 17:46:40 +00:00
|
|
|
else {
|
2012-11-06 13:52:18 +00:00
|
|
|
stripe_index = find_live_mirror(fs_info, map, 0,
|
2008-05-13 17:46:40 +00:00
|
|
|
map->num_stripes,
|
2012-11-06 13:52:18 +00:00
|
|
|
current->pid % map->num_stripes,
|
|
|
|
dev_replace_is_ongoing);
|
2011-08-04 15:15:33 +00:00
|
|
|
mirror_num = stripe_index + 1;
|
2008-05-13 17:46:40 +00:00
|
|
|
}
|
2008-04-29 18:12:09 +00:00
|
|
|
|
2008-04-03 20:29:03 +00:00
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
|
2012-11-06 13:16:24 +00:00
|
|
|
if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) {
|
2008-04-21 14:03:05 +00:00
|
|
|
num_stripes = map->num_stripes;
|
2011-08-04 15:15:33 +00:00
|
|
|
} else if (mirror_num) {
|
2008-04-09 20:28:12 +00:00
|
|
|
stripe_index = mirror_num - 1;
|
2011-08-04 15:15:33 +00:00
|
|
|
} else {
|
|
|
|
mirror_num = 1;
|
|
|
|
}
|
2008-04-29 18:12:09 +00:00
|
|
|
|
2008-04-16 14:49:51 +00:00
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
|
|
|
|
int factor = map->num_stripes / map->sub_stripes;
|
|
|
|
|
|
|
|
stripe_index = do_div(stripe_nr, factor);
|
|
|
|
stripe_index *= map->sub_stripes;
|
|
|
|
|
2012-11-06 13:16:24 +00:00
|
|
|
if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS))
|
2008-04-21 14:03:05 +00:00
|
|
|
num_stripes = map->sub_stripes;
|
2011-03-24 10:24:26 +00:00
|
|
|
else if (rw & REQ_DISCARD)
|
|
|
|
num_stripes = min_t(u64, map->sub_stripes *
|
|
|
|
(stripe_nr_end - stripe_nr_orig),
|
|
|
|
map->num_stripes);
|
2008-04-16 14:49:51 +00:00
|
|
|
else if (mirror_num)
|
|
|
|
stripe_index += mirror_num - 1;
|
2008-05-13 17:46:40 +00:00
|
|
|
else {
|
2012-04-27 16:41:45 +00:00
|
|
|
int old_stripe_index = stripe_index;
|
2012-11-06 13:52:18 +00:00
|
|
|
stripe_index = find_live_mirror(fs_info, map,
|
|
|
|
stripe_index,
|
2008-05-13 17:46:40 +00:00
|
|
|
map->sub_stripes, stripe_index +
|
2012-11-06 13:52:18 +00:00
|
|
|
current->pid % map->sub_stripes,
|
|
|
|
dev_replace_is_ongoing);
|
2012-04-27 16:41:45 +00:00
|
|
|
mirror_num = stripe_index - old_stripe_index + 1;
|
2008-05-13 17:46:40 +00:00
|
|
|
}
|
2013-01-29 23:40:14 +00:00
|
|
|
|
|
|
|
} else if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID6)) {
|
|
|
|
u64 tmp;
|
|
|
|
|
|
|
|
if (bbio_ret && ((rw & REQ_WRITE) || mirror_num > 1)
|
|
|
|
&& raid_map_ret) {
|
|
|
|
int i, rot;
|
|
|
|
|
|
|
|
/* push stripe_nr back to the start of the full stripe */
|
|
|
|
stripe_nr = raid56_full_stripe_start;
|
|
|
|
do_div(stripe_nr, stripe_len);
|
|
|
|
|
|
|
|
stripe_index = do_div(stripe_nr, nr_data_stripes(map));
|
|
|
|
|
|
|
|
/* RAID[56] write or recovery. Return all stripes */
|
|
|
|
num_stripes = map->num_stripes;
|
|
|
|
max_errors = nr_parity_stripes(map);
|
|
|
|
|
2013-10-31 05:02:18 +00:00
|
|
|
raid_map = kmalloc_array(num_stripes, sizeof(u64),
|
2013-01-29 23:40:14 +00:00
|
|
|
GFP_NOFS);
|
|
|
|
if (!raid_map) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Work out the disk rotation on this stripe-set */
|
|
|
|
tmp = stripe_nr;
|
|
|
|
rot = do_div(tmp, num_stripes);
|
|
|
|
|
|
|
|
/* Fill in the logical address of each stripe */
|
|
|
|
tmp = stripe_nr * nr_data_stripes(map);
|
|
|
|
for (i = 0; i < nr_data_stripes(map); i++)
|
|
|
|
raid_map[(i+rot) % num_stripes] =
|
|
|
|
em->start + (tmp + i) * map->stripe_len;
|
|
|
|
|
|
|
|
raid_map[(i+rot) % map->num_stripes] = RAID5_P_STRIPE;
|
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID6)
|
|
|
|
raid_map[(i+rot+1) % num_stripes] =
|
|
|
|
RAID6_Q_STRIPE;
|
|
|
|
|
|
|
|
*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_index = do_div(stripe_nr, nr_data_stripes(map));
|
|
|
|
if (mirror_num > 1)
|
|
|
|
stripe_index = nr_data_stripes(map) +
|
|
|
|
mirror_num - 2;
|
|
|
|
|
|
|
|
/* We distribute the parity blocks across stripes */
|
|
|
|
tmp = stripe_nr + stripe_index;
|
|
|
|
stripe_index = do_div(tmp, map->num_stripes);
|
|
|
|
}
|
2008-04-03 20:29:03 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* after this do_div call, 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_index = do_div(stripe_nr, map->num_stripes);
|
2011-08-04 15:15:33 +00:00
|
|
|
mirror_num = stripe_index + 1;
|
2008-04-03 20:29:03 +00:00
|
|
|
}
|
2008-03-25 20:50:33 +00:00
|
|
|
BUG_ON(stripe_index >= map->num_stripes);
|
2008-04-09 20:28:12 +00:00
|
|
|
|
2012-11-06 13:43:46 +00:00
|
|
|
num_alloc_stripes = num_stripes;
|
2012-11-06 14:06:47 +00:00
|
|
|
if (dev_replace_is_ongoing) {
|
|
|
|
if (rw & (REQ_WRITE | REQ_DISCARD))
|
|
|
|
num_alloc_stripes <<= 1;
|
|
|
|
if (rw & REQ_GET_READ_MIRRORS)
|
|
|
|
num_alloc_stripes++;
|
|
|
|
}
|
2012-11-06 13:43:46 +00:00
|
|
|
bbio = kzalloc(btrfs_bio_size(num_alloc_stripes), GFP_NOFS);
|
2011-12-01 04:55:47 +00:00
|
|
|
if (!bbio) {
|
2013-07-30 17:42:17 +00:00
|
|
|
kfree(raid_map);
|
2011-12-01 04:55:47 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
atomic_set(&bbio->error, 0);
|
|
|
|
|
2011-03-24 10:24:26 +00:00
|
|
|
if (rw & REQ_DISCARD) {
|
2011-12-01 06:06:42 +00:00
|
|
|
int factor = 0;
|
|
|
|
int sub_stripes = 0;
|
|
|
|
u64 stripes_per_dev = 0;
|
|
|
|
u32 remaining_stripes = 0;
|
2012-04-12 20:03:56 +00:00
|
|
|
u32 last_stripe = 0;
|
2011-12-01 06:06:42 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
stripes_per_dev = div_u64_rem(stripe_nr_end -
|
|
|
|
stripe_nr_orig,
|
|
|
|
factor,
|
|
|
|
&remaining_stripes);
|
2012-04-12 20:03:56 +00:00
|
|
|
div_u64_rem(stripe_nr_end - 1, factor, &last_stripe);
|
|
|
|
last_stripe *= sub_stripes;
|
2011-12-01 06:06:42 +00:00
|
|
|
}
|
|
|
|
|
2011-03-24 10:24:26 +00:00
|
|
|
for (i = 0; i < num_stripes; i++) {
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].physical =
|
2008-04-21 14:03:05 +00:00
|
|
|
map->stripes[stripe_index].physical +
|
|
|
|
stripe_offset + stripe_nr * map->stripe_len;
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].dev = map->stripes[stripe_index].dev;
|
2011-03-24 10:24:26 +00:00
|
|
|
|
2011-12-01 06:06:42 +00:00
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID10)) {
|
|
|
|
bbio->stripes[i].length = stripes_per_dev *
|
|
|
|
map->stripe_len;
|
2012-04-12 20:03:56 +00:00
|
|
|
|
2011-12-01 06:06:42 +00:00
|
|
|
if (i / sub_stripes < remaining_stripes)
|
|
|
|
bbio->stripes[i].length +=
|
|
|
|
map->stripe_len;
|
2012-04-12 20:03:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Special for the first stripe and
|
|
|
|
* the last stripe:
|
|
|
|
*
|
|
|
|
* |-------|...|-------|
|
|
|
|
* |----------|
|
|
|
|
* off end_off
|
|
|
|
*/
|
2011-12-01 06:06:42 +00:00
|
|
|
if (i < sub_stripes)
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].length -=
|
2011-03-24 10:24:26 +00:00
|
|
|
stripe_offset;
|
2012-04-12 20:03:56 +00:00
|
|
|
|
|
|
|
if (stripe_index >= last_stripe &&
|
|
|
|
stripe_index <= (last_stripe +
|
|
|
|
sub_stripes - 1))
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].length -=
|
2011-03-24 10:24:26 +00:00
|
|
|
stripe_end_offset;
|
2012-04-12 20:03:56 +00:00
|
|
|
|
2011-12-01 06:06:42 +00:00
|
|
|
if (i == sub_stripes - 1)
|
|
|
|
stripe_offset = 0;
|
2011-03-24 10:24:26 +00:00
|
|
|
} else
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].length = *length;
|
2011-03-24 10:24:26 +00:00
|
|
|
|
|
|
|
stripe_index++;
|
|
|
|
if (stripe_index == map->num_stripes) {
|
|
|
|
/* This could only happen for RAID0/10 */
|
|
|
|
stripe_index = 0;
|
|
|
|
stripe_nr++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < num_stripes; i++) {
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].physical =
|
2011-03-28 22:31:05 +00:00
|
|
|
map->stripes[stripe_index].physical +
|
|
|
|
stripe_offset +
|
|
|
|
stripe_nr * map->stripe_len;
|
2011-08-04 15:15:33 +00:00
|
|
|
bbio->stripes[i].dev =
|
2011-03-28 22:31:05 +00:00
|
|
|
map->stripes[stripe_index].dev;
|
2011-03-24 10:24:26 +00:00
|
|
|
stripe_index++;
|
2008-04-21 14:03:05 +00:00
|
|
|
}
|
2008-03-25 20:50:33 +00:00
|
|
|
}
|
2011-12-01 04:55:47 +00:00
|
|
|
|
2012-11-06 13:16:24 +00:00
|
|
|
if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS)) {
|
2011-12-01 04:55:47 +00:00
|
|
|
if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID10 |
|
2013-01-29 23:40:14 +00:00
|
|
|
BTRFS_BLOCK_GROUP_RAID5 |
|
2011-12-01 04:55:47 +00:00
|
|
|
BTRFS_BLOCK_GROUP_DUP)) {
|
|
|
|
max_errors = 1;
|
2013-01-29 23:40:14 +00:00
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID6) {
|
|
|
|
max_errors = 2;
|
2011-12-01 04:55:47 +00:00
|
|
|
}
|
2008-04-21 14:03:05 +00:00
|
|
|
}
|
2011-12-01 04:55:47 +00:00
|
|
|
|
2012-11-06 13:43:46 +00:00
|
|
|
if (dev_replace_is_ongoing && (rw & (REQ_WRITE | REQ_DISCARD)) &&
|
|
|
|
dev_replace->tgtdev != NULL) {
|
|
|
|
int index_where_to_add;
|
|
|
|
u64 srcdev_devid = dev_replace->srcdev->devid;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
index_where_to_add++;
|
|
|
|
max_errors++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
num_stripes = index_where_to_add;
|
2012-11-06 14:06:47 +00:00
|
|
|
} else if (dev_replace_is_ongoing && (rw & REQ_GET_READ_MIRRORS) &&
|
|
|
|
dev_replace->tgtdev != NULL) {
|
|
|
|
u64 srcdev_devid = dev_replace->srcdev->devid;
|
|
|
|
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) {
|
|
|
|
u64 length = map->stripe_len;
|
|
|
|
|
|
|
|
if (physical_of_found + length <=
|
|
|
|
dev_replace->cursor_left) {
|
|
|
|
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;
|
|
|
|
|
|
|
|
num_stripes++;
|
|
|
|
}
|
|
|
|
}
|
2012-11-06 13:43:46 +00:00
|
|
|
}
|
|
|
|
|
2011-12-01 04:55:47 +00:00
|
|
|
*bbio_ret = bbio;
|
|
|
|
bbio->num_stripes = num_stripes;
|
|
|
|
bbio->max_errors = max_errors;
|
|
|
|
bbio->mirror_num = mirror_num;
|
2012-11-06 14:06:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
2013-01-29 23:40:14 +00:00
|
|
|
if (raid_map) {
|
|
|
|
sort_parity_stripes(bbio, raid_map);
|
|
|
|
*raid_map_ret = raid_map;
|
|
|
|
}
|
2008-04-09 20:28:12 +00:00
|
|
|
out:
|
2012-11-06 13:43:46 +00:00
|
|
|
if (dev_replace_is_ongoing)
|
|
|
|
btrfs_dev_replace_unlock(dev_replace);
|
2008-03-24 19:01:56 +00:00
|
|
|
free_extent_map(em);
|
2011-12-01 04:55:47 +00:00
|
|
|
return ret;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
2012-11-05 14:46:42 +00:00
|
|
|
int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
|
2008-04-21 14:03:05 +00:00
|
|
|
u64 logical, u64 *length,
|
2011-08-04 15:15:33 +00:00
|
|
|
struct btrfs_bio **bbio_ret, int mirror_num)
|
2008-04-21 14:03:05 +00:00
|
|
|
{
|
2012-11-05 14:46:42 +00:00
|
|
|
return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
|
2013-01-29 23:40:14 +00:00
|
|
|
mirror_num, NULL);
|
2008-04-21 14:03:05 +00:00
|
|
|
}
|
|
|
|
|
2008-12-08 21:46:26 +00:00
|
|
|
int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
|
|
|
|
u64 chunk_start, u64 physical, u64 devid,
|
|
|
|
u64 **logical, int *naddrs, int *stripe_len)
|
|
|
|
{
|
|
|
|
struct extent_map_tree *em_tree = &map_tree->map_tree;
|
|
|
|
struct extent_map *em;
|
|
|
|
struct map_lookup *map;
|
|
|
|
u64 *buf;
|
|
|
|
u64 bytenr;
|
|
|
|
u64 length;
|
|
|
|
u64 stripe_nr;
|
2013-01-29 23:40:14 +00:00
|
|
|
u64 rmap_len;
|
2008-12-08 21:46:26 +00:00
|
|
|
int i, j, nr = 0;
|
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
read_lock(&em_tree->lock);
|
2008-12-08 21:46:26 +00:00
|
|
|
em = lookup_extent_mapping(em_tree, chunk_start, 1);
|
2009-09-02 20:24:52 +00:00
|
|
|
read_unlock(&em_tree->lock);
|
2008-12-08 21:46:26 +00:00
|
|
|
|
2013-03-19 16:13:25 +00:00
|
|
|
if (!em) {
|
2013-12-20 16:37:06 +00:00
|
|
|
printk(KERN_ERR "BTRFS: couldn't find em for chunk %Lu\n",
|
2013-03-19 16:13:25 +00:00
|
|
|
chunk_start);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (em->start != chunk_start) {
|
2013-12-20 16:37:06 +00:00
|
|
|
printk(KERN_ERR "BTRFS: bad chunk start, em=%Lu, wanted=%Lu\n",
|
2013-03-19 16:13:25 +00:00
|
|
|
em->start, chunk_start);
|
|
|
|
free_extent_map(em);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2008-12-08 21:46:26 +00:00
|
|
|
map = (struct map_lookup *)em->bdev;
|
|
|
|
|
|
|
|
length = em->len;
|
2013-01-29 23:40:14 +00:00
|
|
|
rmap_len = map->stripe_len;
|
|
|
|
|
2008-12-08 21:46:26 +00:00
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID10)
|
|
|
|
do_div(length, map->num_stripes / map->sub_stripes);
|
|
|
|
else if (map->type & BTRFS_BLOCK_GROUP_RAID0)
|
|
|
|
do_div(length, map->num_stripes);
|
2013-01-29 23:40:14 +00:00
|
|
|
else if (map->type & (BTRFS_BLOCK_GROUP_RAID5 |
|
|
|
|
BTRFS_BLOCK_GROUP_RAID6)) {
|
|
|
|
do_div(length, nr_data_stripes(map));
|
|
|
|
rmap_len = map->stripe_len * nr_data_stripes(map);
|
|
|
|
}
|
2008-12-08 21:46:26 +00:00
|
|
|
|
|
|
|
buf = kzalloc(sizeof(u64) * map->num_stripes, GFP_NOFS);
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(!buf); /* -ENOMEM */
|
2008-12-08 21:46:26 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
do_div(stripe_nr, map->stripe_len);
|
|
|
|
|
|
|
|
if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
|
|
|
|
stripe_nr = stripe_nr * map->num_stripes + i;
|
|
|
|
do_div(stripe_nr, map->sub_stripes);
|
|
|
|
} else if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
|
|
|
|
stripe_nr = stripe_nr * map->num_stripes + i;
|
2013-01-29 23:40:14 +00:00
|
|
|
} /* 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;
|
2008-12-08 21:43:10 +00:00
|
|
|
WARN_ON(nr >= map->num_stripes);
|
2008-12-08 21:46:26 +00:00
|
|
|
for (j = 0; j < nr; j++) {
|
|
|
|
if (buf[j] == bytenr)
|
|
|
|
break;
|
|
|
|
}
|
2008-12-08 21:43:10 +00:00
|
|
|
if (j == nr) {
|
|
|
|
WARN_ON(nr >= map->num_stripes);
|
2008-12-08 21:46:26 +00:00
|
|
|
buf[nr++] = bytenr;
|
2008-12-08 21:43:10 +00:00
|
|
|
}
|
2008-12-08 21:46:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*logical = buf;
|
|
|
|
*naddrs = nr;
|
2013-01-29 23:40:14 +00:00
|
|
|
*stripe_len = rmap_len;
|
2008-12-08 21:46:26 +00:00
|
|
|
|
|
|
|
free_extent_map(em);
|
|
|
|
return 0;
|
2008-04-21 14:03:05 +00:00
|
|
|
}
|
|
|
|
|
2011-08-04 15:15:33 +00:00
|
|
|
static void btrfs_end_bio(struct bio *bio, int err)
|
2008-04-03 20:29:03 +00:00
|
|
|
{
|
2013-05-17 22:30:14 +00:00
|
|
|
struct btrfs_bio *bbio = bio->bi_private;
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
struct btrfs_device *dev = bbio->stripes[0].dev;
|
2008-08-05 14:13:57 +00:00
|
|
|
int is_orig_bio = 0;
|
2008-04-03 20:29:03 +00:00
|
|
|
|
2012-05-25 14:06:08 +00:00
|
|
|
if (err) {
|
2011-08-04 15:15:33 +00:00
|
|
|
atomic_inc(&bbio->error);
|
2012-05-25 14:06:08 +00:00
|
|
|
if (err == -EIO || err == -EREMOTEIO) {
|
|
|
|
unsigned int stripe_index =
|
2013-05-17 22:30:14 +00:00
|
|
|
btrfs_io_bio(bio)->stripe_index;
|
2012-05-25 14:06:08 +00:00
|
|
|
|
|
|
|
BUG_ON(stripe_index >= bbio->num_stripes);
|
|
|
|
dev = bbio->stripes[stripe_index].dev;
|
2012-06-14 14:42:31 +00:00
|
|
|
if (dev->bdev) {
|
|
|
|
if (bio->bi_rw & 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_rw & WRITE_FLUSH) == WRITE_FLUSH)
|
|
|
|
btrfs_dev_stat_inc(dev,
|
|
|
|
BTRFS_DEV_STAT_FLUSH_ERRS);
|
|
|
|
btrfs_dev_stat_print_on_error(dev);
|
|
|
|
}
|
2012-05-25 14:06:08 +00:00
|
|
|
}
|
|
|
|
}
|
2008-04-03 20:29:03 +00:00
|
|
|
|
2011-08-04 15:15:33 +00:00
|
|
|
if (bio == bbio->orig_bio)
|
2008-08-05 14:13:57 +00:00
|
|
|
is_orig_bio = 1;
|
|
|
|
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
btrfs_bio_counter_dec(bbio->fs_info);
|
|
|
|
|
2011-08-04 15:15:33 +00:00
|
|
|
if (atomic_dec_and_test(&bbio->stripes_pending)) {
|
2008-08-05 14:13:57 +00:00
|
|
|
if (!is_orig_bio) {
|
|
|
|
bio_put(bio);
|
2011-08-04 15:15:33 +00:00
|
|
|
bio = bbio->orig_bio;
|
2008-08-05 14:13:57 +00:00
|
|
|
}
|
2011-08-04 15:15:33 +00:00
|
|
|
bio->bi_private = bbio->private;
|
|
|
|
bio->bi_end_io = bbio->end_io;
|
2013-05-17 22:30:14 +00:00
|
|
|
btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
|
2008-04-29 13:38:00 +00:00
|
|
|
/* only send an error to the higher layers if it is
|
2013-01-29 23:40:14 +00:00
|
|
|
* beyond the tolerance of the btrfs bio
|
2008-04-29 13:38:00 +00:00
|
|
|
*/
|
2011-08-04 15:15:33 +00:00
|
|
|
if (atomic_read(&bbio->error) > bbio->max_errors) {
|
2008-04-29 13:38:00 +00:00
|
|
|
err = -EIO;
|
2011-12-09 16:07:37 +00:00
|
|
|
} else {
|
2008-05-12 17:39:03 +00:00
|
|
|
/*
|
|
|
|
* this bio is actually up to date, we didn't
|
|
|
|
* go over the max number of errors
|
|
|
|
*/
|
|
|
|
set_bit(BIO_UPTODATE, &bio->bi_flags);
|
2008-04-29 13:38:00 +00:00
|
|
|
err = 0;
|
2008-05-12 17:39:03 +00:00
|
|
|
}
|
2011-08-04 15:15:33 +00:00
|
|
|
kfree(bbio);
|
2008-04-03 20:29:03 +00:00
|
|
|
|
|
|
|
bio_endio(bio, err);
|
2008-08-05 14:13:57 +00:00
|
|
|
} else if (!is_orig_bio) {
|
2008-04-03 20:29:03 +00:00
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
struct async_sched {
|
|
|
|
struct bio *bio;
|
|
|
|
int rw;
|
|
|
|
struct btrfs_fs_info *info;
|
|
|
|
struct btrfs_work work;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2013-04-25 20:41:01 +00:00
|
|
|
static noinline void btrfs_schedule_bio(struct btrfs_root *root,
|
|
|
|
struct btrfs_device *device,
|
|
|
|
int rw, struct bio *bio)
|
2008-06-11 20:50:36 +00:00
|
|
|
{
|
|
|
|
int should_queue = 1;
|
2009-04-20 19:50:09 +00:00
|
|
|
struct btrfs_pending_bios *pending_bios;
|
2008-06-11 20:50:36 +00:00
|
|
|
|
2013-01-29 23:40:14 +00:00
|
|
|
if (device->missing || !device->bdev) {
|
|
|
|
bio_endio(bio, -EIO);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-06-11 20:50:36 +00:00
|
|
|
/* don't bother with additional async steps for reads, right now */
|
2010-08-07 16:20:39 +00:00
|
|
|
if (!(rw & REQ_WRITE)) {
|
2008-07-31 20:29:02 +00:00
|
|
|
bio_get(bio);
|
2011-11-09 12:44:05 +00:00
|
|
|
btrfsic_submit_bio(rw, bio);
|
2008-07-31 20:29:02 +00:00
|
|
|
bio_put(bio);
|
2012-03-01 13:56:26 +00:00
|
|
|
return;
|
2008-06-11 20:50:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-08-15 19:34:15 +00:00
|
|
|
* nr_async_bios allows us to reliably return congestion to the
|
2008-06-11 20:50:36 +00:00
|
|
|
* 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
|
|
|
|
*/
|
2008-08-15 19:34:15 +00:00
|
|
|
atomic_inc(&root->fs_info->nr_async_bios);
|
2008-07-31 20:29:02 +00:00
|
|
|
WARN_ON(bio->bi_next);
|
2008-06-11 20:50:36 +00:00
|
|
|
bio->bi_next = NULL;
|
|
|
|
bio->bi_rw |= rw;
|
|
|
|
|
|
|
|
spin_lock(&device->io_lock);
|
2010-08-07 16:20:39 +00:00
|
|
|
if (bio->bi_rw & REQ_SYNC)
|
2009-04-20 19:50:09 +00:00
|
|
|
pending_bios = &device->pending_sync_bios;
|
|
|
|
else
|
|
|
|
pending_bios = &device->pending_bios;
|
2008-06-11 20:50:36 +00:00
|
|
|
|
2009-04-20 19:50:09 +00:00
|
|
|
if (pending_bios->tail)
|
|
|
|
pending_bios->tail->bi_next = bio;
|
2008-06-11 20:50:36 +00:00
|
|
|
|
2009-04-20 19:50:09 +00:00
|
|
|
pending_bios->tail = bio;
|
|
|
|
if (!pending_bios->head)
|
|
|
|
pending_bios->head = bio;
|
2008-06-11 20:50:36 +00:00
|
|
|
if (device->running_pending)
|
|
|
|
should_queue = 0;
|
|
|
|
|
|
|
|
spin_unlock(&device->io_lock);
|
|
|
|
|
|
|
|
if (should_queue)
|
2008-06-12 18:46:17 +00:00
|
|
|
btrfs_queue_worker(&root->fs_info->submit_workers,
|
|
|
|
&device->work);
|
2008-06-11 20:50:36 +00:00
|
|
|
}
|
|
|
|
|
2012-10-19 20:50:56 +00:00
|
|
|
static int bio_size_ok(struct block_device *bdev, struct bio *bio,
|
|
|
|
sector_t sector)
|
|
|
|
{
|
|
|
|
struct bio_vec *prev;
|
|
|
|
struct request_queue *q = bdev_get_queue(bdev);
|
2013-11-18 13:13:18 +00:00
|
|
|
unsigned int max_sectors = queue_max_sectors(q);
|
2012-10-19 20:50:56 +00:00
|
|
|
struct bvec_merge_data bvm = {
|
|
|
|
.bi_bdev = bdev,
|
|
|
|
.bi_sector = sector,
|
|
|
|
.bi_rw = bio->bi_rw,
|
|
|
|
};
|
|
|
|
|
2013-10-31 05:00:08 +00:00
|
|
|
if (WARN_ON(bio->bi_vcnt == 0))
|
2012-10-19 20:50:56 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
|
2013-02-05 23:19:29 +00:00
|
|
|
if (bio_sectors(bio) > max_sectors)
|
2012-10-19 20:50:56 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!q->merge_bvec_fn)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
bvm.bi_size = bio->bi_size - prev->bv_len;
|
|
|
|
if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len)
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
|
|
|
|
struct bio *bio, u64 physical, int dev_nr,
|
|
|
|
int rw, int async)
|
|
|
|
{
|
|
|
|
struct btrfs_device *dev = bbio->stripes[dev_nr].dev;
|
|
|
|
|
|
|
|
bio->bi_private = bbio;
|
2013-05-17 22:30:14 +00:00
|
|
|
btrfs_io_bio(bio)->stripe_index = dev_nr;
|
2012-10-19 20:50:56 +00:00
|
|
|
bio->bi_end_io = btrfs_end_bio;
|
|
|
|
bio->bi_sector = physical >> 9;
|
|
|
|
#ifdef DEBUG
|
|
|
|
{
|
|
|
|
struct rcu_string *name;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
name = rcu_dereference(dev->name);
|
2012-10-31 15:16:32 +00:00
|
|
|
pr_debug("btrfs_map_bio: rw %d, sector=%llu, dev=%lu "
|
2012-10-19 20:50:56 +00:00
|
|
|
"(%s id %llu), size=%u\n", rw,
|
|
|
|
(u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
|
|
|
|
name->str, dev->devid, bio->bi_size);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
bio->bi_bdev = dev->bdev;
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
|
|
|
|
btrfs_bio_counter_inc_noblocked(root->fs_info);
|
|
|
|
|
2012-10-19 20:50:56 +00:00
|
|
|
if (async)
|
2013-01-29 23:40:14 +00:00
|
|
|
btrfs_schedule_bio(root, dev, rw, bio);
|
2012-10-19 20:50:56 +00:00
|
|
|
else
|
|
|
|
btrfsic_submit_bio(rw, bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int breakup_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
|
|
|
|
struct bio *first_bio, struct btrfs_device *dev,
|
|
|
|
int dev_nr, int rw, int async)
|
|
|
|
{
|
|
|
|
struct bio_vec *bvec = first_bio->bi_io_vec;
|
|
|
|
struct bio *bio;
|
|
|
|
int nr_vecs = bio_get_nr_vecs(dev->bdev);
|
|
|
|
u64 physical = bbio->stripes[dev_nr].physical;
|
|
|
|
|
|
|
|
again:
|
|
|
|
bio = btrfs_bio_alloc(dev->bdev, physical >> 9, nr_vecs, GFP_NOFS);
|
|
|
|
if (!bio)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
while (bvec <= (first_bio->bi_io_vec + first_bio->bi_vcnt - 1)) {
|
|
|
|
if (bio_add_page(bio, bvec->bv_page, bvec->bv_len,
|
|
|
|
bvec->bv_offset) < bvec->bv_len) {
|
|
|
|
u64 len = bio->bi_size;
|
|
|
|
|
|
|
|
atomic_inc(&bbio->stripes_pending);
|
|
|
|
submit_stripe_bio(root, bbio, bio, physical, dev_nr,
|
|
|
|
rw, async);
|
|
|
|
physical += len;
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
bvec++;
|
|
|
|
}
|
|
|
|
|
|
|
|
submit_stripe_bio(root, bbio, bio, physical, dev_nr, rw, async);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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)) {
|
|
|
|
bio->bi_private = bbio->private;
|
|
|
|
bio->bi_end_io = bbio->end_io;
|
2013-05-17 22:30:14 +00:00
|
|
|
btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
|
2012-10-19 20:50:56 +00:00
|
|
|
bio->bi_sector = logical >> 9;
|
|
|
|
kfree(bbio);
|
|
|
|
bio_endio(bio, -EIO);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-09 20:28:12 +00:00
|
|
|
int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
|
2008-06-11 20:50:36 +00:00
|
|
|
int mirror_num, int async_submit)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
|
|
|
struct btrfs_device *dev;
|
2008-04-03 20:29:03 +00:00
|
|
|
struct bio *first_bio = bio;
|
2008-10-03 20:31:08 +00:00
|
|
|
u64 logical = (u64)bio->bi_sector << 9;
|
2008-03-24 19:01:56 +00:00
|
|
|
u64 length = 0;
|
|
|
|
u64 map_length;
|
2013-01-29 23:40:14 +00:00
|
|
|
u64 *raid_map = NULL;
|
2008-03-24 19:01:56 +00:00
|
|
|
int ret;
|
2008-04-03 20:29:03 +00:00
|
|
|
int dev_nr = 0;
|
|
|
|
int total_devs = 1;
|
2011-08-04 15:15:33 +00:00
|
|
|
struct btrfs_bio *bbio = NULL;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-04-21 14:03:05 +00:00
|
|
|
length = bio->bi_size;
|
2008-03-24 19:01:56 +00:00
|
|
|
map_length = length;
|
2008-04-09 20:28:12 +00:00
|
|
|
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
btrfs_bio_counter_inc_blocked(root->fs_info);
|
2013-01-29 23:40:14 +00:00
|
|
|
ret = __btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
|
|
|
|
mirror_num, &raid_map);
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
if (ret) {
|
|
|
|
btrfs_bio_counter_dec(root->fs_info);
|
2012-03-12 15:03:00 +00:00
|
|
|
return ret;
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
}
|
2008-04-09 20:28:12 +00:00
|
|
|
|
2011-08-04 15:15:33 +00:00
|
|
|
total_devs = bbio->num_stripes;
|
2013-01-29 23:40:14 +00:00
|
|
|
bbio->orig_bio = first_bio;
|
|
|
|
bbio->private = first_bio->bi_private;
|
|
|
|
bbio->end_io = first_bio->bi_end_io;
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
bbio->fs_info = root->fs_info;
|
2013-01-29 23:40:14 +00:00
|
|
|
atomic_set(&bbio->stripes_pending, bbio->num_stripes);
|
|
|
|
|
|
|
|
if (raid_map) {
|
|
|
|
/* In this case, map_length has been set to the length of
|
|
|
|
a single stripe; not the whole write */
|
|
|
|
if (rw & WRITE) {
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
ret = raid56_parity_write(root, bio, bbio,
|
|
|
|
raid_map, map_length);
|
2013-01-29 23:40:14 +00:00
|
|
|
} else {
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
ret = raid56_parity_recover(root, bio, bbio,
|
|
|
|
raid_map, map_length,
|
|
|
|
mirror_num);
|
2013-01-29 23:40:14 +00:00
|
|
|
}
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
/*
|
|
|
|
* FIXME, replace dosen't support raid56 yet, please fix
|
|
|
|
* it in the future.
|
|
|
|
*/
|
|
|
|
btrfs_bio_counter_dec(root->fs_info);
|
|
|
|
return ret;
|
2013-01-29 23:40:14 +00:00
|
|
|
}
|
|
|
|
|
2008-04-09 20:28:12 +00:00
|
|
|
if (map_length < length) {
|
2013-03-19 22:41:23 +00:00
|
|
|
btrfs_crit(root->fs_info, "mapping failed logical %llu bio len %llu len %llu",
|
2013-08-20 11:20:07 +00:00
|
|
|
logical, length, map_length);
|
2008-04-09 20:28:12 +00:00
|
|
|
BUG();
|
|
|
|
}
|
2011-08-04 15:15:33 +00:00
|
|
|
|
2009-01-06 02:25:51 +00:00
|
|
|
while (dev_nr < total_devs) {
|
2012-10-19 20:50:56 +00:00
|
|
|
dev = bbio->stripes[dev_nr].dev;
|
|
|
|
if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) {
|
|
|
|
bbio_error(bbio, first_bio, logical);
|
|
|
|
dev_nr++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check and see if we're ok with this bio based on it's size
|
|
|
|
* and offset with the given device.
|
|
|
|
*/
|
|
|
|
if (!bio_size_ok(dev->bdev, first_bio,
|
|
|
|
bbio->stripes[dev_nr].physical >> 9)) {
|
|
|
|
ret = breakup_stripe_bio(root, bbio, first_bio, dev,
|
|
|
|
dev_nr, rw, async_submit);
|
|
|
|
BUG_ON(ret);
|
|
|
|
dev_nr++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-08-04 15:15:33 +00:00
|
|
|
if (dev_nr < total_devs - 1) {
|
2013-05-17 22:30:14 +00:00
|
|
|
bio = btrfs_bio_clone(first_bio, GFP_NOFS);
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(!bio); /* -ENOMEM */
|
2011-08-04 15:15:33 +00:00
|
|
|
} else {
|
|
|
|
bio = first_bio;
|
2008-04-03 20:29:03 +00:00
|
|
|
}
|
2012-10-19 20:50:56 +00:00
|
|
|
|
|
|
|
submit_stripe_bio(root, bbio, bio,
|
|
|
|
bbio->stripes[dev_nr].physical, dev_nr, rw,
|
|
|
|
async_submit);
|
2008-04-03 20:29:03 +00:00
|
|
|
dev_nr++;
|
|
|
|
}
|
Btrfs: fix use-after-free in the finishing procedure of the device replace
During device replace test, we hit a null pointer deference (It was very easy
to reproduce it by running xfstests' btrfs/011 on the devices with the virtio
scsi driver). There were two bugs that caused this problem:
- We might allocate new chunks on the replaced device after we updated
the mapping tree. And we forgot to replace the source device in those
mapping of the new chunks.
- We might get the mapping information which including the source device
before the mapping information update. And then submit the bio which was
based on that mapping information after we freed the source device.
For the first bug, we can fix it by doing mapping tree update and source
device remove in the same context of the chunk mutex. The chunk mutex is
used to protect the allocable device list, the above method can avoid
the new chunk allocation, and after we remove the source device, all
the new chunks will be allocated on the new device. So it can fix
the first bug.
For the second bug, we need make sure all flighting bios are finished and
no new bios are produced during we are removing the source device. To fix
this problem, we introduced a global @bio_counter, we not only inc/dec
@bio_counter outsize of map_blocks, but also inc it before submitting bio
and dec @bio_counter when ending bios.
Since Raid56 is a little different and device replace dosen't support raid56
yet, it is not addressed in the patch and I add comments to make sure we will
fix it in the future.
Reported-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Wang Shilong <wangsl.fnst@cn.fujitsu.com>
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fb.com>
2014-01-30 08:46:55 +00:00
|
|
|
btrfs_bio_counter_dec(root->fs_info);
|
2008-03-24 19:01:56 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-05 16:03:39 +00:00
|
|
|
struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
|
2008-11-18 02:11:30 +00:00
|
|
|
u8 *uuid, u8 *fsid)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
2008-11-18 02:11:30 +00:00
|
|
|
struct btrfs_device *device;
|
|
|
|
struct btrfs_fs_devices *cur_devices;
|
|
|
|
|
2012-11-05 16:03:39 +00:00
|
|
|
cur_devices = fs_info->fs_devices;
|
2008-11-18 02:11:30 +00:00
|
|
|
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;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
static struct btrfs_device *add_missing_dev(struct btrfs_root *root,
|
|
|
|
u64 devid, u8 *dev_uuid)
|
|
|
|
{
|
|
|
|
struct btrfs_device *device;
|
|
|
|
struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
|
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
device = btrfs_alloc_device(NULL, &devid, dev_uuid);
|
|
|
|
if (IS_ERR(device))
|
2008-11-12 19:38:54 +00:00
|
|
|
return NULL;
|
2013-08-23 10:20:17 +00:00
|
|
|
|
|
|
|
list_add(&device->dev_list, &fs_devices->devices);
|
2008-12-12 15:03:26 +00:00
|
|
|
device->fs_devices = fs_devices;
|
2008-05-13 17:46:40 +00:00
|
|
|
fs_devices->num_devices++;
|
2013-08-23 10:20:17 +00:00
|
|
|
|
|
|
|
device->missing = 1;
|
2010-12-13 19:56:23 +00:00
|
|
|
fs_devices->missing_devices++;
|
2013-08-23 10:20:17 +00:00
|
|
|
|
2008-05-13 17:46:40 +00:00
|
|
|
return device;
|
|
|
|
}
|
|
|
|
|
2013-08-23 10:20:17 +00:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2013-10-31 05:00:08 +00:00
|
|
|
if (WARN_ON(!devid && !fs_info))
|
2013-08-23 10:20:17 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
dev->work.func = pending_bios_fn;
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
|
|
|
|
struct extent_buffer *leaf,
|
|
|
|
struct btrfs_chunk *chunk)
|
|
|
|
{
|
|
|
|
struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
|
|
|
|
struct map_lookup *map;
|
|
|
|
struct extent_map *em;
|
|
|
|
u64 logical;
|
|
|
|
u64 length;
|
|
|
|
u64 devid;
|
2008-04-18 14:29:38 +00:00
|
|
|
u8 uuid[BTRFS_UUID_SIZE];
|
2008-03-25 20:50:33 +00:00
|
|
|
int num_stripes;
|
2008-03-24 19:01:56 +00:00
|
|
|
int ret;
|
2008-03-25 20:50:33 +00:00
|
|
|
int i;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-04-15 19:41:47 +00:00
|
|
|
logical = key->offset;
|
|
|
|
length = btrfs_chunk_length(leaf, chunk);
|
2008-05-07 15:43:44 +00:00
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
read_lock(&map_tree->map_tree.lock);
|
2008-03-24 19:01:56 +00:00
|
|
|
em = lookup_extent_mapping(&map_tree->map_tree, logical, 1);
|
2009-09-02 20:24:52 +00:00
|
|
|
read_unlock(&map_tree->map_tree.lock);
|
2008-03-24 19:01:56 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
2011-04-20 22:48:27 +00:00
|
|
|
em = alloc_extent_map();
|
2008-03-24 19:01:56 +00:00
|
|
|
if (!em)
|
|
|
|
return -ENOMEM;
|
2008-03-25 20:50:33 +00:00
|
|
|
num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
|
|
|
|
map = kmalloc(map_lookup_size(num_stripes), GFP_NOFS);
|
2008-03-24 19:01:56 +00:00
|
|
|
if (!map) {
|
|
|
|
free_extent_map(em);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
em->bdev = (struct block_device *)map;
|
|
|
|
em->start = logical;
|
|
|
|
em->len = length;
|
2012-10-11 20:54:30 +00:00
|
|
|
em->orig_start = 0;
|
2008-03-24 19:01:56 +00:00
|
|
|
em->block_start = 0;
|
Btrfs: Add zlib compression support
This is a large change for adding compression on reading and writing,
both for inline and regular extents. It does some fairly large
surgery to the writeback paths.
Compression is off by default and enabled by mount -o compress. Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.
If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.
* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler. This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.
* Inline extents are inserted at delalloc time now. This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.
* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.
From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field. Neither the encryption or the
'other' field are currently used.
In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k. This is a
software only limit, the disk format supports u64 sized compressed extents.
In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k. This is a software only limit
and will be subject to tuning later.
Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data. This way additional encodings can be
layered on without having to figure out which encoding to checksum.
Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread. This makes it tricky to
spread the compression load across all the cpus on the box. We'll have to
look at parallel pdflush walks of dirty inodes at a later time.
Decompression is hooked into readpages and it does spread across CPUs nicely.
Signed-off-by: Chris Mason <chris.mason@oracle.com>
2008-10-29 18:49:59 +00:00
|
|
|
em->block_len = em->len;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-03-25 20:50:33 +00:00
|
|
|
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);
|
2008-04-16 14:49:51 +00:00
|
|
|
map->sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
|
2008-03-25 20:50:33 +00:00
|
|
|
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);
|
2008-04-18 14:29:38 +00:00
|
|
|
read_extent_buffer(leaf, uuid, (unsigned long)
|
|
|
|
btrfs_stripe_dev_uuid_nr(chunk, i),
|
|
|
|
BTRFS_UUID_SIZE);
|
2012-11-05 16:03:39 +00:00
|
|
|
map->stripes[i].dev = btrfs_find_device(root->fs_info, devid,
|
|
|
|
uuid, NULL);
|
2008-05-13 17:46:40 +00:00
|
|
|
if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
|
2008-03-25 20:50:33 +00:00
|
|
|
kfree(map);
|
|
|
|
free_extent_map(em);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2008-05-13 17:46:40 +00:00
|
|
|
if (!map->stripes[i].dev) {
|
|
|
|
map->stripes[i].dev =
|
|
|
|
add_missing_dev(root, devid, uuid);
|
|
|
|
if (!map->stripes[i].dev) {
|
|
|
|
kfree(map);
|
|
|
|
free_extent_map(em);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
map->stripes[i].dev->in_fs_metadata = 1;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
2009-09-02 20:24:52 +00:00
|
|
|
write_lock(&map_tree->map_tree.lock);
|
2013-04-05 20:51:15 +00:00
|
|
|
ret = add_extent_mapping(&map_tree->map_tree, em, 0);
|
2009-09-02 20:24:52 +00:00
|
|
|
write_unlock(&map_tree->map_tree.lock);
|
2012-03-12 15:03:00 +00:00
|
|
|
BUG_ON(ret); /* Tree corruption */
|
2008-03-24 19:01:56 +00:00
|
|
|
free_extent_map(em);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-01 13:56:26 +00:00
|
|
|
static void fill_device_from_item(struct extent_buffer *leaf,
|
2008-03-24 19:01:56 +00:00
|
|
|
struct btrfs_dev_item *dev_item,
|
|
|
|
struct btrfs_device *device)
|
|
|
|
{
|
|
|
|
unsigned long ptr;
|
|
|
|
|
|
|
|
device->devid = btrfs_device_id(leaf, dev_item);
|
2009-04-27 11:29:03 +00:00
|
|
|
device->disk_total_bytes = btrfs_device_total_bytes(leaf, dev_item);
|
|
|
|
device->total_bytes = device->disk_total_bytes;
|
2008-03-24 19:01:56 +00:00
|
|
|
device->bytes_used = btrfs_device_bytes_used(leaf, dev_item);
|
|
|
|
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);
|
2012-11-06 12:15:27 +00:00
|
|
|
WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID);
|
2012-11-05 17:29:28 +00:00
|
|
|
device->is_tgtdev_for_dev_replace = 0;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2013-08-20 11:20:11 +00:00
|
|
|
ptr = btrfs_device_uuid(dev_item);
|
2008-04-15 19:41:47 +00:00
|
|
|
read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
static int open_seed_devices(struct btrfs_root *root, u8 *fsid)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_devices *fs_devices;
|
|
|
|
int ret;
|
|
|
|
|
2011-12-07 03:38:24 +00:00
|
|
|
BUG_ON(!mutex_is_locked(&uuid_mutex));
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
fs_devices = root->fs_info->fs_devices->seed;
|
|
|
|
while (fs_devices) {
|
|
|
|
if (!memcmp(fs_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
fs_devices = fs_devices->seed;
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_devices = find_fsid(fsid);
|
|
|
|
if (!fs_devices) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-12-12 15:03:26 +00:00
|
|
|
|
|
|
|
fs_devices = clone_fs_devices(fs_devices);
|
|
|
|
if (IS_ERR(fs_devices)) {
|
|
|
|
ret = PTR_ERR(fs_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2008-12-02 11:36:09 +00:00
|
|
|
ret = __btrfs_open_devices(fs_devices, FMODE_READ,
|
2008-11-20 02:17:22 +00:00
|
|
|
root->fs_info->bdev_holder);
|
2012-04-14 09:24:33 +00:00
|
|
|
if (ret) {
|
|
|
|
free_fs_devices(fs_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
goto out;
|
2012-04-14 09:24:33 +00:00
|
|
|
}
|
2008-11-18 02:11:30 +00:00
|
|
|
|
|
|
|
if (!fs_devices->seeding) {
|
|
|
|
__btrfs_close_devices(fs_devices);
|
2008-12-12 15:03:26 +00:00
|
|
|
free_fs_devices(fs_devices);
|
2008-11-18 02:11:30 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
fs_devices->seed = root->fs_info->fs_devices->seed;
|
|
|
|
root->fs_info->fs_devices->seed = fs_devices;
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
static int read_one_dev(struct btrfs_root *root,
|
2008-03-24 19:01:56 +00:00
|
|
|
struct extent_buffer *leaf,
|
|
|
|
struct btrfs_dev_item *dev_item)
|
|
|
|
{
|
|
|
|
struct btrfs_device *device;
|
|
|
|
u64 devid;
|
|
|
|
int ret;
|
2008-11-18 02:11:30 +00:00
|
|
|
u8 fs_uuid[BTRFS_UUID_SIZE];
|
2008-04-18 14:29:38 +00:00
|
|
|
u8 dev_uuid[BTRFS_UUID_SIZE];
|
|
|
|
|
2008-03-24 19:01:56 +00:00
|
|
|
devid = btrfs_device_id(leaf, dev_item);
|
2013-08-20 11:20:11 +00:00
|
|
|
read_extent_buffer(leaf, dev_uuid, btrfs_device_uuid(dev_item),
|
2008-04-18 14:29:38 +00:00
|
|
|
BTRFS_UUID_SIZE);
|
2013-08-20 11:20:12 +00:00
|
|
|
read_extent_buffer(leaf, fs_uuid, btrfs_device_fsid(dev_item),
|
2008-11-18 02:11:30 +00:00
|
|
|
BTRFS_UUID_SIZE);
|
|
|
|
|
|
|
|
if (memcmp(fs_uuid, root->fs_info->fsid, BTRFS_UUID_SIZE)) {
|
|
|
|
ret = open_seed_devices(root, fs_uuid);
|
2008-12-12 15:03:26 +00:00
|
|
|
if (ret && !btrfs_test_opt(root, DEGRADED))
|
2008-11-18 02:11:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-11-05 16:03:39 +00:00
|
|
|
device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid);
|
2008-11-18 02:11:30 +00:00
|
|
|
if (!device || !device->bdev) {
|
2008-12-12 15:03:26 +00:00
|
|
|
if (!btrfs_test_opt(root, DEGRADED))
|
2008-11-18 02:11:30 +00:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (!device) {
|
2013-08-20 11:20:07 +00:00
|
|
|
btrfs_warn(root->fs_info, "devid %llu missing", devid);
|
2008-11-18 02:11:30 +00:00
|
|
|
device = add_missing_dev(root, devid, dev_uuid);
|
|
|
|
if (!device)
|
|
|
|
return -ENOMEM;
|
2010-12-13 19:56:23 +00:00
|
|
|
} else if (!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
|
|
|
|
*/
|
|
|
|
root->fs_info->fs_devices->missing_devices++;
|
|
|
|
device->missing = 1;
|
2008-11-18 02:11:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (device->fs_devices != root->fs_info->fs_devices) {
|
|
|
|
BUG_ON(device->writeable);
|
|
|
|
if (device->generation !=
|
|
|
|
btrfs_device_generation(leaf, dev_item))
|
|
|
|
return -EINVAL;
|
2008-03-24 19:01:59 +00:00
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
|
|
|
|
fill_device_from_item(leaf, dev_item, device);
|
2008-05-13 17:46:40 +00:00
|
|
|
device->in_fs_metadata = 1;
|
2012-11-05 17:29:28 +00:00
|
|
|
if (device->writeable && !device->is_tgtdev_for_dev_replace) {
|
2008-11-18 02:11:30 +00:00
|
|
|
device->fs_devices->total_rw_bytes += device->total_bytes;
|
2011-09-26 21:12:22 +00:00
|
|
|
spin_lock(&root->fs_info->free_chunk_lock);
|
|
|
|
root->fs_info->free_chunk_space += device->total_bytes -
|
|
|
|
device->bytes_used;
|
|
|
|
spin_unlock(&root->fs_info->free_chunk_lock);
|
|
|
|
}
|
2008-03-24 19:01:56 +00:00
|
|
|
ret = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
int btrfs_read_sys_array(struct btrfs_root *root)
|
2008-03-24 19:01:56 +00:00
|
|
|
{
|
2011-04-13 13:41:04 +00:00
|
|
|
struct btrfs_super_block *super_copy = root->fs_info->super_copy;
|
2008-05-07 15:43:44 +00:00
|
|
|
struct extent_buffer *sb;
|
2008-03-24 19:01:56 +00:00
|
|
|
struct btrfs_disk_key *disk_key;
|
|
|
|
struct btrfs_chunk *chunk;
|
2008-04-25 13:04:37 +00:00
|
|
|
u8 *ptr;
|
|
|
|
unsigned long sb_ptr;
|
|
|
|
int ret = 0;
|
2008-03-24 19:01:56 +00:00
|
|
|
u32 num_stripes;
|
|
|
|
u32 array_size;
|
|
|
|
u32 len = 0;
|
|
|
|
u32 cur;
|
2008-04-25 13:04:37 +00:00
|
|
|
struct btrfs_key key;
|
2008-03-24 19:01:56 +00:00
|
|
|
|
2008-12-12 15:03:26 +00:00
|
|
|
sb = btrfs_find_create_tree_block(root, BTRFS_SUPER_INFO_OFFSET,
|
2008-05-07 15:43:44 +00:00
|
|
|
BTRFS_SUPER_INFO_SIZE);
|
|
|
|
if (!sb)
|
|
|
|
return -ENOMEM;
|
|
|
|
btrfs_set_buffer_uptodate(sb);
|
2011-07-26 20:11:19 +00:00
|
|
|
btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0);
|
2011-10-07 16:06:13 +00:00
|
|
|
/*
|
|
|
|
* The sb extent buffer is artifical and just used to read the system array.
|
|
|
|
* btrfs_set_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_CACHE_SIZE > BTRFS_SUPER_INFO_SIZE)
|
2010-08-06 17:21:20 +00:00
|
|
|
SetPageUptodate(sb->pages[0]);
|
2009-02-12 19:09:45 +00:00
|
|
|
|
2008-05-07 15:43:44 +00:00
|
|
|
write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE);
|
2008-03-24 19:01:56 +00:00
|
|
|
array_size = btrfs_super_sys_array_size(super_copy);
|
|
|
|
|
|
|
|
ptr = super_copy->sys_chunk_array;
|
|
|
|
sb_ptr = offsetof(struct btrfs_super_block, sys_chunk_array);
|
|
|
|
cur = 0;
|
|
|
|
|
|
|
|
while (cur < array_size) {
|
|
|
|
disk_key = (struct btrfs_disk_key *)ptr;
|
|
|
|
btrfs_disk_key_to_cpu(&key, disk_key);
|
|
|
|
|
2008-05-07 15:43:44 +00:00
|
|
|
len = sizeof(*disk_key); ptr += len;
|
2008-03-24 19:01:56 +00:00
|
|
|
sb_ptr += len;
|
|
|
|
cur += len;
|
|
|
|
|
2008-03-24 19:02:07 +00:00
|
|
|
if (key.type == BTRFS_CHUNK_ITEM_KEY) {
|
2008-03-24 19:01:56 +00:00
|
|
|
chunk = (struct btrfs_chunk *)sb_ptr;
|
2008-03-24 19:02:07 +00:00
|
|
|
ret = read_one_chunk(root, &key, sb, chunk);
|
2008-04-25 13:04:37 +00:00
|
|
|
if (ret)
|
|
|
|
break;
|
2008-03-24 19:01:56 +00:00
|
|
|
num_stripes = btrfs_chunk_num_stripes(sb, chunk);
|
|
|
|
len = btrfs_chunk_item_size(num_stripes);
|
|
|
|
} else {
|
2008-04-25 13:04:37 +00:00
|
|
|
ret = -EIO;
|
|
|
|
break;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
ptr += len;
|
|
|
|
sb_ptr += len;
|
|
|
|
cur += len;
|
|
|
|
}
|
2008-05-07 15:43:44 +00:00
|
|
|
free_extent_buffer(sb);
|
2008-04-25 13:04:37 +00:00
|
|
|
return ret;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_read_chunk_tree(struct btrfs_root *root)
|
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct extent_buffer *leaf;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct btrfs_key found_key;
|
|
|
|
int ret;
|
|
|
|
int slot;
|
|
|
|
|
|
|
|
root = root->fs_info->chunk_root;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-12-07 03:38:24 +00:00
|
|
|
mutex_lock(&uuid_mutex);
|
|
|
|
lock_chunks(root);
|
|
|
|
|
2013-07-30 11:03:04 +00:00
|
|
|
/*
|
|
|
|
* 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).
|
2008-03-24 19:01:56 +00:00
|
|
|
*/
|
|
|
|
key.objectid = BTRFS_DEV_ITEMS_OBJECTID;
|
|
|
|
key.offset = 0;
|
|
|
|
key.type = 0;
|
|
|
|
ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
|
2010-03-25 12:34:49 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
2009-01-06 02:25:51 +00:00
|
|
|
while (1) {
|
2008-03-24 19:01:56 +00:00
|
|
|
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);
|
2013-07-30 11:03:04 +00:00
|
|
|
if (found_key.type == BTRFS_DEV_ITEM_KEY) {
|
|
|
|
struct btrfs_dev_item *dev_item;
|
|
|
|
dev_item = btrfs_item_ptr(leaf, slot,
|
2008-03-24 19:01:56 +00:00
|
|
|
struct btrfs_dev_item);
|
2013-07-30 11:03:04 +00:00
|
|
|
ret = read_one_dev(root, leaf, dev_item);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
2008-03-24 19:01:56 +00:00
|
|
|
} 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(root, &found_key, leaf, chunk);
|
2008-11-18 02:11:30 +00:00
|
|
|
if (ret)
|
|
|
|
goto error;
|
2008-03-24 19:01:56 +00:00
|
|
|
}
|
|
|
|
path->slots[0]++;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
error:
|
2011-12-07 03:38:24 +00:00
|
|
|
unlock_chunks(root);
|
|
|
|
mutex_unlock(&uuid_mutex);
|
|
|
|
|
2008-11-18 02:11:30 +00:00
|
|
|
btrfs_free_path(path);
|
2008-03-24 19:01:56 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2012-05-25 14:06:08 +00:00
|
|
|
|
2013-05-15 07:48:19 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
|
|
|
list_for_each_entry(device, &fs_devices->devices, dev_list)
|
|
|
|
device->dev_root = fs_info->dev_root;
|
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
}
|
|
|
|
|
2012-05-25 14:06:10 +00:00
|
|
|
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 = 0;
|
|
|
|
key.type = BTRFS_DEV_STATS_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_root *dev_root,
|
|
|
|
struct btrfs_device *device)
|
|
|
|
{
|
|
|
|
struct btrfs_path *path;
|
|
|
|
struct btrfs_key key;
|
|
|
|
struct extent_buffer *eb;
|
|
|
|
struct btrfs_dev_stats_item *ptr;
|
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
key.objectid = 0;
|
|
|
|
key.type = BTRFS_DEV_STATS_KEY;
|
|
|
|
key.offset = device->devid;
|
|
|
|
|
|
|
|
path = btrfs_alloc_path();
|
|
|
|
BUG_ON(!path);
|
|
|
|
ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
|
|
|
|
if (ret < 0) {
|
2013-12-20 16:37:06 +00:00
|
|
|
printk_in_rcu(KERN_WARNING "BTRFS: "
|
|
|
|
"error %d while searching for dev_stats item for device %s!\n",
|
2012-06-04 18:03:51 +00:00
|
|
|
ret, rcu_str_deref(device->name));
|
2012-05-25 14:06:10 +00:00
|
|
|
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) {
|
2013-12-20 16:37:06 +00:00
|
|
|
printk_in_rcu(KERN_WARNING "BTRFS: "
|
|
|
|
"delete too small dev_stats item for device %s failed %d!\n",
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_str_deref(device->name), ret);
|
2012-05-25 14:06:10 +00:00
|
|
|
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) {
|
2013-12-20 16:37:06 +00:00
|
|
|
printk_in_rcu(KERN_WARNING "BTRFS: "
|
|
|
|
"insert dev_stats item for device %s failed %d!\n",
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_str_deref(device->name), ret);
|
2012-05-25 14:06:10 +00:00
|
|
|
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_root *dev_root = fs_info->dev_root;
|
|
|
|
struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
|
|
|
|
struct btrfs_device *device;
|
|
|
|
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 || !device->dev_stats_dirty)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = update_dev_stat_item(trans, dev_root, device);
|
|
|
|
if (!ret)
|
|
|
|
device->dev_stats_dirty = 0;
|
|
|
|
}
|
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-25 14:06:08 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-04-25 20:41:01 +00:00
|
|
|
static void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
|
2012-05-25 14:06:08 +00:00
|
|
|
{
|
2012-05-25 14:06:10 +00:00
|
|
|
if (!dev->dev_stats_valid)
|
|
|
|
return;
|
2013-12-20 16:37:06 +00:00
|
|
|
printk_ratelimited_in_rcu(KERN_ERR "BTRFS: "
|
|
|
|
"bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_str_deref(dev->name),
|
2012-05-25 14:06:08 +00:00
|
|
|
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),
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_CORRUPTION_ERRS),
|
|
|
|
btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_GENERATION_ERRS));
|
2012-05-25 14:06:08 +00:00
|
|
|
}
|
2012-05-25 14:06:09 +00:00
|
|
|
|
2012-05-25 14:06:10 +00:00
|
|
|
static void btrfs_dev_stat_print_on_load(struct btrfs_device *dev)
|
|
|
|
{
|
2012-07-17 15:02:11 +00:00
|
|
|
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 */
|
|
|
|
|
2013-12-20 16:37:06 +00:00
|
|
|
printk_in_rcu(KERN_INFO "BTRFS: "
|
|
|
|
"bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
|
2012-06-04 18:03:51 +00:00
|
|
|
rcu_str_deref(dev->name),
|
2012-05-25 14:06:10 +00:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2012-05-25 14:06:09 +00:00
|
|
|
int btrfs_get_dev_stats(struct btrfs_root *root,
|
2012-06-22 12:30:39 +00:00
|
|
|
struct btrfs_ioctl_get_dev_stats *stats)
|
2012-05-25 14:06:09 +00:00
|
|
|
{
|
|
|
|
struct btrfs_device *dev;
|
|
|
|
struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&fs_devices->device_list_mutex);
|
2012-11-05 16:03:39 +00:00
|
|
|
dev = btrfs_find_device(root->fs_info, stats->devid, NULL, NULL);
|
2012-05-25 14:06:09 +00:00
|
|
|
mutex_unlock(&fs_devices->device_list_mutex);
|
|
|
|
|
|
|
|
if (!dev) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(root->fs_info, "get dev_stats failed, device not found");
|
2012-05-25 14:06:09 +00:00
|
|
|
return -ENODEV;
|
2012-05-25 14:06:10 +00:00
|
|
|
} else if (!dev->dev_stats_valid) {
|
2013-12-20 16:37:06 +00:00
|
|
|
btrfs_warn(root->fs_info, "get dev_stats failed, not yet valid");
|
2012-05-25 14:06:10 +00:00
|
|
|
return -ENODEV;
|
2012-06-22 12:30:39 +00:00
|
|
|
} else if (stats->flags & BTRFS_DEV_STATS_RESET) {
|
2012-05-25 14:06:09 +00:00
|
|
|
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;
|
|
|
|
}
|
2012-11-05 14:50:14 +00:00
|
|
|
|
|
|
|
int btrfs_scratch_superblock(struct btrfs_device *device)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct btrfs_super_block *disk_super;
|
|
|
|
|
|
|
|
bh = btrfs_read_dev_super(device->bdev);
|
|
|
|
if (!bh)
|
|
|
|
return -EINVAL;
|
|
|
|
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);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|