2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2012 Fusion-io All rights reserved.
|
|
|
|
* Copyright (C) 2012 Intel Corp. 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/wait.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/iocontext.h>
|
|
|
|
#include <linux/capability.h>
|
|
|
|
#include <linux/ratelimit.h>
|
|
|
|
#include <linux/kthread.h>
|
|
|
|
#include <linux/raid/pq.h>
|
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/list_sort.h>
|
|
|
|
#include <linux/raid/xor.h>
|
2017-05-31 18:40:02 +02:00
|
|
|
#include <linux/mm.h>
|
2013-01-30 00:40:14 +01:00
|
|
|
#include <asm/div64.h>
|
|
|
|
#include "ctree.h"
|
|
|
|
#include "extent_map.h"
|
|
|
|
#include "disk-io.h"
|
|
|
|
#include "transaction.h"
|
|
|
|
#include "print-tree.h"
|
|
|
|
#include "volumes.h"
|
|
|
|
#include "raid56.h"
|
|
|
|
#include "async-thread.h"
|
|
|
|
#include "check-integrity.h"
|
|
|
|
#include "rcu-string.h"
|
|
|
|
|
|
|
|
/* set when additional merges to this rbio are not allowed */
|
|
|
|
#define RBIO_RMW_LOCKED_BIT 1
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* set when this rbio is sitting in the hash, but it is just a cache
|
|
|
|
* of past RMW
|
|
|
|
*/
|
|
|
|
#define RBIO_CACHE_BIT 2
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set when it is safe to trust the stripe_pages for caching
|
|
|
|
*/
|
|
|
|
#define RBIO_CACHE_READY_BIT 3
|
|
|
|
|
|
|
|
#define RBIO_CACHE_SIZE 1024
|
|
|
|
|
2014-11-06 09:14:21 +01:00
|
|
|
enum btrfs_rbio_ops {
|
2015-06-19 20:52:50 +02:00
|
|
|
BTRFS_RBIO_WRITE,
|
|
|
|
BTRFS_RBIO_READ_REBUILD,
|
|
|
|
BTRFS_RBIO_PARITY_SCRUB,
|
|
|
|
BTRFS_RBIO_REBUILD_MISSING,
|
2014-11-06 09:14:21 +01:00
|
|
|
};
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
struct btrfs_raid_bio {
|
|
|
|
struct btrfs_fs_info *fs_info;
|
|
|
|
struct btrfs_bio *bbio;
|
|
|
|
|
|
|
|
/* while we're doing rmw on a stripe
|
|
|
|
* we put it into a hash table so we can
|
|
|
|
* lock the stripe and merge more rbios
|
|
|
|
* into it.
|
|
|
|
*/
|
|
|
|
struct list_head hash_list;
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* LRU list for the stripe cache
|
|
|
|
*/
|
|
|
|
struct list_head stripe_cache;
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* for scheduling work in the helper threads
|
|
|
|
*/
|
|
|
|
struct btrfs_work work;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bio list and bio_list_lock are used
|
|
|
|
* to add more bios into the stripe
|
|
|
|
* in hopes of avoiding the full rmw
|
|
|
|
*/
|
|
|
|
struct bio_list bio_list;
|
|
|
|
spinlock_t bio_list_lock;
|
|
|
|
|
2013-01-31 20:42:28 +01:00
|
|
|
/* also protected by the bio_list_lock, the
|
|
|
|
* plug list is used by the plugging code
|
|
|
|
* to collect partial bios while plugged. The
|
|
|
|
* stripe locking code also uses it to hand off
|
2013-01-30 00:40:14 +01:00
|
|
|
* the stripe lock to the next pending IO
|
|
|
|
*/
|
|
|
|
struct list_head plug_list;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* flags that tell us if it is safe to
|
|
|
|
* merge with this bio
|
|
|
|
*/
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* size of each individual stripe on disk */
|
|
|
|
int stripe_len;
|
|
|
|
|
|
|
|
/* number of data stripes (no p/q) */
|
|
|
|
int nr_data;
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
int real_stripes;
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
int stripe_npages;
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* set if we're doing a parity rebuild
|
|
|
|
* for a read from higher up, which is handled
|
|
|
|
* differently from a parity rebuild as part of
|
|
|
|
* rmw
|
|
|
|
*/
|
2014-11-06 09:14:21 +01:00
|
|
|
enum btrfs_rbio_ops operation;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/* first bad stripe */
|
|
|
|
int faila;
|
|
|
|
|
|
|
|
/* second bad stripe (for raid6 use) */
|
|
|
|
int failb;
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
int scrubp;
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* number of pages needed to represent the full
|
|
|
|
* stripe
|
|
|
|
*/
|
|
|
|
int nr_pages;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* size of all the bios in the bio_list. This
|
|
|
|
* helps us decide if the rbio maps to a full
|
|
|
|
* stripe or not
|
|
|
|
*/
|
|
|
|
int bio_list_bytes;
|
|
|
|
|
2014-11-25 09:39:28 +01:00
|
|
|
int generic_bio_cnt;
|
|
|
|
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_t refs;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_t stripes_pending;
|
|
|
|
|
|
|
|
atomic_t error;
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* these are two arrays of pointers. We allocate the
|
|
|
|
* rbio big enough to hold them both and setup their
|
|
|
|
* locations when the rbio is allocated
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* pointers to pages that we allocated for
|
|
|
|
* reading/writing stripes directly from the disk (including P/Q)
|
|
|
|
*/
|
|
|
|
struct page **stripe_pages;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pointers to the pages in the bio_list. Stored
|
|
|
|
* here for faster lookup
|
|
|
|
*/
|
|
|
|
struct page **bio_pages;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* bitmap to record which horizontal stripe has data
|
|
|
|
*/
|
|
|
|
unsigned long *dbitmap;
|
2013-01-30 00:40:14 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __raid56_parity_recover(struct btrfs_raid_bio *rbio);
|
|
|
|
static noinline void finish_rmw(struct btrfs_raid_bio *rbio);
|
|
|
|
static void rmw_work(struct btrfs_work *work);
|
|
|
|
static void read_rebuild_work(struct btrfs_work *work);
|
|
|
|
static void async_rmw_stripe(struct btrfs_raid_bio *rbio);
|
|
|
|
static void async_read_rebuild(struct btrfs_raid_bio *rbio);
|
|
|
|
static int fail_bio_stripe(struct btrfs_raid_bio *rbio, struct bio *bio);
|
|
|
|
static int fail_rbio_index(struct btrfs_raid_bio *rbio, int failed);
|
|
|
|
static void __free_raid_bio(struct btrfs_raid_bio *rbio);
|
|
|
|
static void index_rbio_pages(struct btrfs_raid_bio *rbio);
|
|
|
|
static int alloc_rbio_pages(struct btrfs_raid_bio *rbio);
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
static noinline void finish_parity_scrub(struct btrfs_raid_bio *rbio,
|
|
|
|
int need_check);
|
|
|
|
static void async_scrub_parity(struct btrfs_raid_bio *rbio);
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* the stripe hash table is used for locking, and to collect
|
|
|
|
* bios in hopes of making a full stripe
|
|
|
|
*/
|
|
|
|
int btrfs_alloc_stripe_hash_table(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
struct btrfs_stripe_hash_table *table;
|
|
|
|
struct btrfs_stripe_hash_table *x;
|
|
|
|
struct btrfs_stripe_hash *cur;
|
|
|
|
struct btrfs_stripe_hash *h;
|
|
|
|
int num_entries = 1 << BTRFS_STRIPE_HASH_TABLE_BITS;
|
|
|
|
int i;
|
2013-03-01 16:03:00 +01:00
|
|
|
int table_size;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
if (info->stripe_hash_table)
|
|
|
|
return 0;
|
|
|
|
|
2013-03-01 16:03:00 +01:00
|
|
|
/*
|
|
|
|
* The table is large, starting with order 4 and can go as high as
|
|
|
|
* order 7 in case lock debugging is turned on.
|
|
|
|
*
|
|
|
|
* Try harder to allocate and fallback to vmalloc to lower the chance
|
|
|
|
* of a failing mount.
|
|
|
|
*/
|
|
|
|
table_size = sizeof(*table) + sizeof(*h) * num_entries;
|
2017-05-31 18:40:02 +02:00
|
|
|
table = kvzalloc(table_size, GFP_KERNEL);
|
|
|
|
if (!table)
|
|
|
|
return -ENOMEM;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
spin_lock_init(&table->cache_lock);
|
|
|
|
INIT_LIST_HEAD(&table->stripe_cache);
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
h = table->table;
|
|
|
|
|
|
|
|
for (i = 0; i < num_entries; i++) {
|
|
|
|
cur = h + i;
|
|
|
|
INIT_LIST_HEAD(&cur->hash_list);
|
|
|
|
spin_lock_init(&cur->lock);
|
|
|
|
init_waitqueue_head(&cur->wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
x = cmpxchg(&info->stripe_hash_table, NULL, table);
|
2014-11-22 14:13:10 +01:00
|
|
|
if (x)
|
|
|
|
kvfree(x);
|
2013-01-30 00:40:14 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* caching an rbio means to copy anything from the
|
|
|
|
* bio_pages array into the stripe_pages array. We
|
|
|
|
* use the page uptodate bit in the stripe cache array
|
|
|
|
* to indicate if it has valid data
|
|
|
|
*
|
|
|
|
* once the caching is done, we set the cache ready
|
|
|
|
* bit.
|
|
|
|
*/
|
|
|
|
static void cache_rbio_pages(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *s;
|
|
|
|
char *d;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = alloc_rbio_pages(rbio);
|
|
|
|
if (ret)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < rbio->nr_pages; i++) {
|
|
|
|
if (!rbio->bio_pages[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
s = kmap(rbio->bio_pages[i]);
|
|
|
|
d = kmap(rbio->stripe_pages[i]);
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
memcpy(d, s, PAGE_SIZE);
|
2013-01-31 20:42:09 +01:00
|
|
|
|
|
|
|
kunmap(rbio->bio_pages[i]);
|
|
|
|
kunmap(rbio->stripe_pages[i]);
|
|
|
|
SetPageUptodate(rbio->stripe_pages[i]);
|
|
|
|
}
|
|
|
|
set_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
|
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* we hash on the first logical address of the stripe
|
|
|
|
*/
|
|
|
|
static int rbio_bucket(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
2015-01-20 08:11:33 +01:00
|
|
|
u64 num = rbio->bbio->raid_map[0];
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we shift down quite a bit. We're using byte
|
|
|
|
* addressing, and most of the lower bits are zeros.
|
|
|
|
* This tends to upset hash_64, and it consistently
|
|
|
|
* returns just one or two different values.
|
|
|
|
*
|
|
|
|
* shifting off the lower bits fixes things.
|
|
|
|
*/
|
|
|
|
return hash_64(num >> 16, BTRFS_STRIPE_HASH_TABLE_BITS);
|
|
|
|
}
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* stealing an rbio means taking all the uptodate pages from the stripe
|
|
|
|
* array in the source rbio and putting them into the destination rbio
|
|
|
|
*/
|
|
|
|
static void steal_rbio(struct btrfs_raid_bio *src, struct btrfs_raid_bio *dest)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct page *s;
|
|
|
|
struct page *d;
|
|
|
|
|
|
|
|
if (!test_bit(RBIO_CACHE_READY_BIT, &src->flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < dest->nr_pages; i++) {
|
|
|
|
s = src->stripe_pages[i];
|
|
|
|
if (!s || !PageUptodate(s)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
d = dest->stripe_pages[i];
|
|
|
|
if (d)
|
|
|
|
__free_page(d);
|
|
|
|
|
|
|
|
dest->stripe_pages[i] = s;
|
|
|
|
src->stripe_pages[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* merging means we take the bio_list from the victim and
|
|
|
|
* splice it into the destination. The victim should
|
|
|
|
* be discarded afterwards.
|
|
|
|
*
|
|
|
|
* must be called with dest->rbio_list_lock held
|
|
|
|
*/
|
|
|
|
static void merge_rbio(struct btrfs_raid_bio *dest,
|
|
|
|
struct btrfs_raid_bio *victim)
|
|
|
|
{
|
|
|
|
bio_list_merge(&dest->bio_list, &victim->bio_list);
|
|
|
|
dest->bio_list_bytes += victim->bio_list_bytes;
|
2014-11-25 09:39:28 +01:00
|
|
|
dest->generic_bio_cnt += victim->generic_bio_cnt;
|
2013-01-30 00:40:14 +01:00
|
|
|
bio_list_init(&victim->bio_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2013-01-31 20:42:09 +01:00
|
|
|
* used to prune items that are in the cache. The caller
|
|
|
|
* must hold the hash table lock.
|
|
|
|
*/
|
|
|
|
static void __remove_rbio_from_cache(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int bucket = rbio_bucket(rbio);
|
|
|
|
struct btrfs_stripe_hash_table *table;
|
|
|
|
struct btrfs_stripe_hash *h;
|
|
|
|
int freeit = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check the bit again under the hash table lock.
|
|
|
|
*/
|
|
|
|
if (!test_bit(RBIO_CACHE_BIT, &rbio->flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
table = rbio->fs_info->stripe_hash_table;
|
|
|
|
h = table->table + bucket;
|
|
|
|
|
|
|
|
/* hold the lock for the bucket because we may be
|
|
|
|
* removing it from the hash table
|
|
|
|
*/
|
|
|
|
spin_lock(&h->lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* hold the lock for the bio list because we need
|
|
|
|
* to make sure the bio list is empty
|
|
|
|
*/
|
|
|
|
spin_lock(&rbio->bio_list_lock);
|
|
|
|
|
|
|
|
if (test_and_clear_bit(RBIO_CACHE_BIT, &rbio->flags)) {
|
|
|
|
list_del_init(&rbio->stripe_cache);
|
|
|
|
table->cache_size -= 1;
|
|
|
|
freeit = 1;
|
|
|
|
|
|
|
|
/* if the bio list isn't empty, this rbio is
|
|
|
|
* still involved in an IO. We take it out
|
|
|
|
* of the cache list, and drop the ref that
|
|
|
|
* was held for the list.
|
|
|
|
*
|
|
|
|
* If the bio_list was empty, we also remove
|
|
|
|
* the rbio from the hash_table, and drop
|
|
|
|
* the corresponding ref
|
|
|
|
*/
|
|
|
|
if (bio_list_empty(&rbio->bio_list)) {
|
|
|
|
if (!list_empty(&rbio->hash_list)) {
|
|
|
|
list_del_init(&rbio->hash_list);
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_dec(&rbio->refs);
|
2013-01-31 20:42:09 +01:00
|
|
|
BUG_ON(!list_empty(&rbio->plug_list));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&rbio->bio_list_lock);
|
|
|
|
spin_unlock(&h->lock);
|
|
|
|
|
|
|
|
if (freeit)
|
|
|
|
__free_raid_bio(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* prune a given rbio from the cache
|
|
|
|
*/
|
|
|
|
static void remove_rbio_from_cache(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
struct btrfs_stripe_hash_table *table;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!test_bit(RBIO_CACHE_BIT, &rbio->flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
table = rbio->fs_info->stripe_hash_table;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&table->cache_lock, flags);
|
|
|
|
__remove_rbio_from_cache(rbio);
|
|
|
|
spin_unlock_irqrestore(&table->cache_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* remove everything in the cache
|
|
|
|
*/
|
2013-04-25 22:41:01 +02:00
|
|
|
static void btrfs_clear_rbio_cache(struct btrfs_fs_info *info)
|
2013-01-31 20:42:09 +01:00
|
|
|
{
|
|
|
|
struct btrfs_stripe_hash_table *table;
|
|
|
|
unsigned long flags;
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
|
|
|
|
table = info->stripe_hash_table;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&table->cache_lock, flags);
|
|
|
|
while (!list_empty(&table->stripe_cache)) {
|
|
|
|
rbio = list_entry(table->stripe_cache.next,
|
|
|
|
struct btrfs_raid_bio,
|
|
|
|
stripe_cache);
|
|
|
|
__remove_rbio_from_cache(rbio);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&table->cache_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* remove all cached entries and free the hash table
|
|
|
|
* used by unmount
|
2013-01-30 00:40:14 +01:00
|
|
|
*/
|
|
|
|
void btrfs_free_stripe_hash_table(struct btrfs_fs_info *info)
|
|
|
|
{
|
|
|
|
if (!info->stripe_hash_table)
|
|
|
|
return;
|
2013-01-31 20:42:09 +01:00
|
|
|
btrfs_clear_rbio_cache(info);
|
2014-11-22 14:13:10 +01:00
|
|
|
kvfree(info->stripe_hash_table);
|
2013-01-30 00:40:14 +01:00
|
|
|
info->stripe_hash_table = NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* insert an rbio into the stripe cache. It
|
|
|
|
* must have already been prepared by calling
|
|
|
|
* cache_rbio_pages
|
|
|
|
*
|
|
|
|
* If this rbio was already cached, it gets
|
|
|
|
* moved to the front of the lru.
|
|
|
|
*
|
|
|
|
* If the size of the rbio cache is too big, we
|
|
|
|
* prune an item.
|
|
|
|
*/
|
|
|
|
static void cache_rbio(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
struct btrfs_stripe_hash_table *table;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!test_bit(RBIO_CACHE_READY_BIT, &rbio->flags))
|
|
|
|
return;
|
|
|
|
|
|
|
|
table = rbio->fs_info->stripe_hash_table;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&table->cache_lock, flags);
|
|
|
|
spin_lock(&rbio->bio_list_lock);
|
|
|
|
|
|
|
|
/* bump our ref if we were not in the list before */
|
|
|
|
if (!test_and_set_bit(RBIO_CACHE_BIT, &rbio->flags))
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_inc(&rbio->refs);
|
2013-01-31 20:42:09 +01:00
|
|
|
|
|
|
|
if (!list_empty(&rbio->stripe_cache)){
|
|
|
|
list_move(&rbio->stripe_cache, &table->stripe_cache);
|
|
|
|
} else {
|
|
|
|
list_add(&rbio->stripe_cache, &table->stripe_cache);
|
|
|
|
table->cache_size += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&rbio->bio_list_lock);
|
|
|
|
|
|
|
|
if (table->cache_size > RBIO_CACHE_SIZE) {
|
|
|
|
struct btrfs_raid_bio *found;
|
|
|
|
|
|
|
|
found = list_entry(table->stripe_cache.prev,
|
|
|
|
struct btrfs_raid_bio,
|
|
|
|
stripe_cache);
|
|
|
|
|
|
|
|
if (found != rbio)
|
|
|
|
__remove_rbio_from_cache(found);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&table->cache_lock, flags);
|
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* helper function to run the xor_blocks api. It is only
|
|
|
|
* able to do MAX_XOR_BLOCKS at a time, so we need to
|
|
|
|
* loop through.
|
|
|
|
*/
|
|
|
|
static void run_xor(void **pages, int src_cnt, ssize_t len)
|
|
|
|
{
|
|
|
|
int src_off = 0;
|
|
|
|
int xor_src_cnt = 0;
|
|
|
|
void *dest = pages[src_cnt];
|
|
|
|
|
|
|
|
while(src_cnt > 0) {
|
|
|
|
xor_src_cnt = min(src_cnt, MAX_XOR_BLOCKS);
|
|
|
|
xor_blocks(xor_src_cnt, len, dest, pages + src_off);
|
|
|
|
|
|
|
|
src_cnt -= xor_src_cnt;
|
|
|
|
src_off += xor_src_cnt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns true if the bio list inside this rbio
|
|
|
|
* covers an entire stripe (no rmw required).
|
|
|
|
* Must be called with the bio list lock held, or
|
|
|
|
* at a time when you know it is impossible to add
|
|
|
|
* new bios into the list
|
|
|
|
*/
|
|
|
|
static int __rbio_is_full(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
unsigned long size = rbio->bio_list_bytes;
|
|
|
|
int ret = 1;
|
|
|
|
|
|
|
|
if (size != rbio->nr_data * rbio->stripe_len)
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
BUG_ON(size > rbio->nr_data * rbio->stripe_len);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rbio_is_full(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rbio->bio_list_lock, flags);
|
|
|
|
ret = __rbio_is_full(rbio);
|
|
|
|
spin_unlock_irqrestore(&rbio->bio_list_lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns 1 if it is safe to merge two rbios together.
|
|
|
|
* The merging is safe if the two rbios correspond to
|
|
|
|
* the same stripe and if they are both going in the same
|
|
|
|
* direction (read vs write), and if neither one is
|
|
|
|
* locked for final IO
|
|
|
|
*
|
|
|
|
* The caller is responsible for locking such that
|
|
|
|
* rmw_locked is safe to test
|
|
|
|
*/
|
|
|
|
static int rbio_can_merge(struct btrfs_raid_bio *last,
|
|
|
|
struct btrfs_raid_bio *cur)
|
|
|
|
{
|
|
|
|
if (test_bit(RBIO_RMW_LOCKED_BIT, &last->flags) ||
|
|
|
|
test_bit(RBIO_RMW_LOCKED_BIT, &cur->flags))
|
|
|
|
return 0;
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* we can't merge with cached rbios, since the
|
|
|
|
* idea is that when we merge the destination
|
|
|
|
* rbio is going to run our IO for us. We can
|
2016-05-20 03:18:45 +02:00
|
|
|
* steal from cached rbios though, other functions
|
2013-01-31 20:42:09 +01:00
|
|
|
* handle that.
|
|
|
|
*/
|
|
|
|
if (test_bit(RBIO_CACHE_BIT, &last->flags) ||
|
|
|
|
test_bit(RBIO_CACHE_BIT, &cur->flags))
|
|
|
|
return 0;
|
|
|
|
|
2015-01-20 08:11:33 +01:00
|
|
|
if (last->bbio->raid_map[0] !=
|
|
|
|
cur->bbio->raid_map[0])
|
2013-01-30 00:40:14 +01:00
|
|
|
return 0;
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
/* we can't merge with different operations */
|
|
|
|
if (last->operation != cur->operation)
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* We've need read the full stripe from the drive.
|
|
|
|
* check and repair the parity and write the new results.
|
|
|
|
*
|
|
|
|
* We're not allowed to add any new bios to the
|
|
|
|
* bio list here, anyone else that wants to
|
|
|
|
* change this stripe needs to do their own rmw.
|
|
|
|
*/
|
|
|
|
if (last->operation == BTRFS_RBIO_PARITY_SCRUB ||
|
|
|
|
cur->operation == BTRFS_RBIO_PARITY_SCRUB)
|
2013-01-30 00:40:14 +01:00
|
|
|
return 0;
|
|
|
|
|
2015-06-19 20:52:50 +02:00
|
|
|
if (last->operation == BTRFS_RBIO_REBUILD_MISSING ||
|
|
|
|
cur->operation == BTRFS_RBIO_REBUILD_MISSING)
|
|
|
|
return 0;
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-03-03 13:38:46 +01:00
|
|
|
static int rbio_stripe_page_index(struct btrfs_raid_bio *rbio, int stripe,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
return stripe * rbio->stripe_npages + index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* these are just the pages from the rbio array, not from anything
|
|
|
|
* the FS sent down to us
|
|
|
|
*/
|
|
|
|
static struct page *rbio_stripe_page(struct btrfs_raid_bio *rbio, int stripe,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
return rbio->stripe_pages[rbio_stripe_page_index(rbio, stripe, index)];
|
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* helper to index into the pstripe
|
|
|
|
*/
|
|
|
|
static struct page *rbio_pstripe_page(struct btrfs_raid_bio *rbio, int index)
|
|
|
|
{
|
2015-03-03 13:38:46 +01:00
|
|
|
return rbio_stripe_page(rbio, rbio->nr_data, index);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper to index into the qstripe, returns null
|
|
|
|
* if there is no qstripe
|
|
|
|
*/
|
|
|
|
static struct page *rbio_qstripe_page(struct btrfs_raid_bio *rbio, int index)
|
|
|
|
{
|
2014-11-14 09:06:25 +01:00
|
|
|
if (rbio->nr_data + 1 == rbio->real_stripes)
|
2013-01-30 00:40:14 +01:00
|
|
|
return NULL;
|
2015-03-03 13:38:46 +01:00
|
|
|
return rbio_stripe_page(rbio, rbio->nr_data + 1, index);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The first stripe in the table for a logical address
|
|
|
|
* has the lock. rbios are added in one of three ways:
|
|
|
|
*
|
|
|
|
* 1) Nobody has the stripe locked yet. The rbio is given
|
|
|
|
* the lock and 0 is returned. The caller must start the IO
|
|
|
|
* themselves.
|
|
|
|
*
|
|
|
|
* 2) Someone has the stripe locked, but we're able to merge
|
|
|
|
* with the lock owner. The rbio is freed and the IO will
|
|
|
|
* start automatically along with the existing rbio. 1 is returned.
|
|
|
|
*
|
|
|
|
* 3) Someone has the stripe locked, but we're not able to merge.
|
|
|
|
* The rbio is added to the lock owner's plug list, or merged into
|
|
|
|
* an rbio already on the plug list. When the lock owner unlocks,
|
|
|
|
* the next rbio on the list is run and the IO is started automatically.
|
|
|
|
* 1 is returned
|
|
|
|
*
|
|
|
|
* If we return 0, the caller still owns the rbio and must continue with
|
|
|
|
* IO submission. If we return 1, the caller must assume the rbio has
|
|
|
|
* already been freed.
|
|
|
|
*/
|
|
|
|
static noinline int lock_stripe_add(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int bucket = rbio_bucket(rbio);
|
|
|
|
struct btrfs_stripe_hash *h = rbio->fs_info->stripe_hash_table->table + bucket;
|
|
|
|
struct btrfs_raid_bio *cur;
|
|
|
|
struct btrfs_raid_bio *pending;
|
|
|
|
unsigned long flags;
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
struct btrfs_raid_bio *freeit = NULL;
|
2013-01-31 20:42:09 +01:00
|
|
|
struct btrfs_raid_bio *cache_drop = NULL;
|
2013-01-30 00:40:14 +01:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&h->lock, flags);
|
|
|
|
list_for_each_entry(cur, &h->hash_list, hash_list) {
|
2015-01-20 08:11:33 +01:00
|
|
|
if (cur->bbio->raid_map[0] == rbio->bbio->raid_map[0]) {
|
2013-01-30 00:40:14 +01:00
|
|
|
spin_lock(&cur->bio_list_lock);
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
/* can we steal this cached rbio's pages? */
|
|
|
|
if (bio_list_empty(&cur->bio_list) &&
|
|
|
|
list_empty(&cur->plug_list) &&
|
|
|
|
test_bit(RBIO_CACHE_BIT, &cur->flags) &&
|
|
|
|
!test_bit(RBIO_RMW_LOCKED_BIT, &cur->flags)) {
|
|
|
|
list_del_init(&cur->hash_list);
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_dec(&cur->refs);
|
2013-01-31 20:42:09 +01:00
|
|
|
|
|
|
|
steal_rbio(cur, rbio);
|
|
|
|
cache_drop = cur;
|
|
|
|
spin_unlock(&cur->bio_list_lock);
|
|
|
|
|
|
|
|
goto lockit;
|
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/* can we merge into the lock owner? */
|
|
|
|
if (rbio_can_merge(cur, rbio)) {
|
|
|
|
merge_rbio(cur, rbio);
|
|
|
|
spin_unlock(&cur->bio_list_lock);
|
|
|
|
freeit = rbio;
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* we couldn't merge with the running
|
|
|
|
* rbio, see if we can merge with the
|
|
|
|
* pending ones. We don't have to
|
|
|
|
* check for rmw_locked because there
|
|
|
|
* is no way they are inside finish_rmw
|
|
|
|
* right now
|
|
|
|
*/
|
|
|
|
list_for_each_entry(pending, &cur->plug_list,
|
|
|
|
plug_list) {
|
|
|
|
if (rbio_can_merge(pending, rbio)) {
|
|
|
|
merge_rbio(pending, rbio);
|
|
|
|
spin_unlock(&cur->bio_list_lock);
|
|
|
|
freeit = rbio;
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* no merging, put us on the tail of the plug list,
|
|
|
|
* our rbio will be started with the currently
|
|
|
|
* running rbio unlocks
|
|
|
|
*/
|
|
|
|
list_add_tail(&rbio->plug_list, &cur->plug_list);
|
|
|
|
spin_unlock(&cur->bio_list_lock);
|
|
|
|
ret = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2013-01-31 20:42:09 +01:00
|
|
|
lockit:
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_inc(&rbio->refs);
|
2013-01-30 00:40:14 +01:00
|
|
|
list_add(&rbio->hash_list, &h->hash_list);
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&h->lock, flags);
|
2013-01-31 20:42:09 +01:00
|
|
|
if (cache_drop)
|
|
|
|
remove_rbio_from_cache(cache_drop);
|
2013-01-30 00:40:14 +01:00
|
|
|
if (freeit)
|
|
|
|
__free_raid_bio(freeit);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called as rmw or parity rebuild is completed. If the plug list has more
|
|
|
|
* rbios waiting for this stripe, the next one on the list will be started
|
|
|
|
*/
|
|
|
|
static noinline void unlock_stripe(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int bucket;
|
|
|
|
struct btrfs_stripe_hash *h;
|
|
|
|
unsigned long flags;
|
2013-01-31 20:42:09 +01:00
|
|
|
int keep_cache = 0;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
bucket = rbio_bucket(rbio);
|
|
|
|
h = rbio->fs_info->stripe_hash_table->table + bucket;
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
if (list_empty(&rbio->plug_list))
|
|
|
|
cache_rbio(rbio);
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
spin_lock_irqsave(&h->lock, flags);
|
|
|
|
spin_lock(&rbio->bio_list_lock);
|
|
|
|
|
|
|
|
if (!list_empty(&rbio->hash_list)) {
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* if we're still cached and there is no other IO
|
|
|
|
* to perform, just leave this rbio here for others
|
|
|
|
* to steal from later
|
|
|
|
*/
|
|
|
|
if (list_empty(&rbio->plug_list) &&
|
|
|
|
test_bit(RBIO_CACHE_BIT, &rbio->flags)) {
|
|
|
|
keep_cache = 1;
|
|
|
|
clear_bit(RBIO_RMW_LOCKED_BIT, &rbio->flags);
|
|
|
|
BUG_ON(!bio_list_empty(&rbio->bio_list));
|
|
|
|
goto done;
|
|
|
|
}
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
list_del_init(&rbio->hash_list);
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_dec(&rbio->refs);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we use the plug list to hold all the rbios
|
|
|
|
* waiting for the chance to lock this stripe.
|
|
|
|
* hand the lock over to one of them.
|
|
|
|
*/
|
|
|
|
if (!list_empty(&rbio->plug_list)) {
|
|
|
|
struct btrfs_raid_bio *next;
|
|
|
|
struct list_head *head = rbio->plug_list.next;
|
|
|
|
|
|
|
|
next = list_entry(head, struct btrfs_raid_bio,
|
|
|
|
plug_list);
|
|
|
|
|
|
|
|
list_del_init(&rbio->plug_list);
|
|
|
|
|
|
|
|
list_add(&next->hash_list, &h->hash_list);
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_inc(&next->refs);
|
2013-01-30 00:40:14 +01:00
|
|
|
spin_unlock(&rbio->bio_list_lock);
|
|
|
|
spin_unlock_irqrestore(&h->lock, flags);
|
|
|
|
|
2014-11-06 09:14:21 +01:00
|
|
|
if (next->operation == BTRFS_RBIO_READ_REBUILD)
|
2013-01-30 00:40:14 +01:00
|
|
|
async_read_rebuild(next);
|
2015-06-19 20:52:50 +02:00
|
|
|
else if (next->operation == BTRFS_RBIO_REBUILD_MISSING) {
|
|
|
|
steal_rbio(rbio, next);
|
|
|
|
async_read_rebuild(next);
|
|
|
|
} else if (next->operation == BTRFS_RBIO_WRITE) {
|
2013-01-31 20:42:09 +01:00
|
|
|
steal_rbio(rbio, next);
|
2013-01-30 00:40:14 +01:00
|
|
|
async_rmw_stripe(next);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
} else if (next->operation == BTRFS_RBIO_PARITY_SCRUB) {
|
|
|
|
steal_rbio(rbio, next);
|
|
|
|
async_scrub_parity(next);
|
2013-01-31 20:42:09 +01:00
|
|
|
}
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
goto done_nolock;
|
2015-10-10 18:35:10 +02:00
|
|
|
/*
|
|
|
|
* The barrier for this waitqueue_active is not needed,
|
|
|
|
* we're protected by h->lock and can't miss a wakeup.
|
|
|
|
*/
|
|
|
|
} else if (waitqueue_active(&h->wait)) {
|
2013-01-30 00:40:14 +01:00
|
|
|
spin_unlock(&rbio->bio_list_lock);
|
|
|
|
spin_unlock_irqrestore(&h->lock, flags);
|
|
|
|
wake_up(&h->wait);
|
|
|
|
goto done_nolock;
|
|
|
|
}
|
|
|
|
}
|
2013-01-31 20:42:09 +01:00
|
|
|
done:
|
2013-01-30 00:40:14 +01:00
|
|
|
spin_unlock(&rbio->bio_list_lock);
|
|
|
|
spin_unlock_irqrestore(&h->lock, flags);
|
|
|
|
|
|
|
|
done_nolock:
|
2013-01-31 20:42:09 +01:00
|
|
|
if (!keep_cache)
|
|
|
|
remove_rbio_from_cache(rbio);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __free_raid_bio(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2017-03-03 09:55:26 +01:00
|
|
|
if (!refcount_dec_and_test(&rbio->refs))
|
2013-01-30 00:40:14 +01:00
|
|
|
return;
|
|
|
|
|
2013-01-31 20:42:09 +01:00
|
|
|
WARN_ON(!list_empty(&rbio->stripe_cache));
|
2013-01-30 00:40:14 +01:00
|
|
|
WARN_ON(!list_empty(&rbio->hash_list));
|
|
|
|
WARN_ON(!bio_list_empty(&rbio->bio_list));
|
|
|
|
|
|
|
|
for (i = 0; i < rbio->nr_pages; i++) {
|
|
|
|
if (rbio->stripe_pages[i]) {
|
|
|
|
__free_page(rbio->stripe_pages[i]);
|
|
|
|
rbio->stripe_pages[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
2014-10-23 08:42:50 +02:00
|
|
|
|
2015-01-20 08:11:34 +01:00
|
|
|
btrfs_put_bbio(rbio->bbio);
|
2013-01-30 00:40:14 +01:00
|
|
|
kfree(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_raid_bio(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
unlock_stripe(rbio);
|
|
|
|
__free_raid_bio(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this frees the rbio and runs through all the bios in the
|
|
|
|
* bio_list and calls end_io on them
|
|
|
|
*/
|
2017-06-03 09:38:06 +02:00
|
|
|
static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, blk_status_t err)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct bio *cur = bio_list_get(&rbio->bio_list);
|
|
|
|
struct bio *next;
|
2014-11-25 09:39:28 +01:00
|
|
|
|
|
|
|
if (rbio->generic_bio_cnt)
|
|
|
|
btrfs_bio_counter_sub(rbio->fs_info, rbio->generic_bio_cnt);
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
free_raid_bio(rbio);
|
|
|
|
|
|
|
|
while (cur) {
|
|
|
|
next = cur->bi_next;
|
|
|
|
cur->bi_next = NULL;
|
2017-06-03 09:38:06 +02:00
|
|
|
cur->bi_status = err;
|
2015-07-20 15:29:37 +02:00
|
|
|
bio_endio(cur);
|
2013-01-30 00:40:14 +01:00
|
|
|
cur = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* end io function used by finish_rmw. When we finally
|
|
|
|
* get here, we've written a full stripe
|
|
|
|
*/
|
2015-07-20 15:29:37 +02:00
|
|
|
static void raid_write_end_io(struct bio *bio)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio = bio->bi_private;
|
2017-06-03 09:38:06 +02:00
|
|
|
blk_status_t err = bio->bi_status;
|
2016-01-12 10:52:13 +01:00
|
|
|
int max_errors;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
fail_bio_stripe(rbio, bio);
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
if (!atomic_dec_and_test(&rbio->stripes_pending))
|
2013-01-30 00:40:14 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
/* OK, we have read all the stripes we need to. */
|
2016-01-12 10:52:13 +01:00
|
|
|
max_errors = (rbio->operation == BTRFS_RBIO_PARITY_SCRUB) ?
|
|
|
|
0 : rbio->bbio->max_errors;
|
|
|
|
if (atomic_read(&rbio->error) > max_errors)
|
2017-06-03 09:38:06 +02:00
|
|
|
err = BLK_STS_IOERR;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, err);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the read/modify/write code wants to use the original bio for
|
|
|
|
* any pages it included, and then use the rbio for everything
|
|
|
|
* else. This function decides if a given index (stripe number)
|
|
|
|
* and page number in that stripe fall inside the original bio
|
|
|
|
* or the rbio.
|
|
|
|
*
|
|
|
|
* if you set bio_list_only, you'll get a NULL back for any ranges
|
|
|
|
* that are outside the bio_list
|
|
|
|
*
|
|
|
|
* This doesn't take any refs on anything, you get a bare page pointer
|
|
|
|
* and the caller must bump refs as required.
|
|
|
|
*
|
|
|
|
* You must call index_rbio_pages once before you can trust
|
|
|
|
* the answers from this function.
|
|
|
|
*/
|
|
|
|
static struct page *page_in_rbio(struct btrfs_raid_bio *rbio,
|
|
|
|
int index, int pagenr, int bio_list_only)
|
|
|
|
{
|
|
|
|
int chunk_page;
|
|
|
|
struct page *p = NULL;
|
|
|
|
|
|
|
|
chunk_page = index * (rbio->stripe_len >> PAGE_SHIFT) + pagenr;
|
|
|
|
|
|
|
|
spin_lock_irq(&rbio->bio_list_lock);
|
|
|
|
p = rbio->bio_pages[chunk_page];
|
|
|
|
spin_unlock_irq(&rbio->bio_list_lock);
|
|
|
|
|
|
|
|
if (p || bio_list_only)
|
|
|
|
return p;
|
|
|
|
|
|
|
|
return rbio->stripe_pages[chunk_page];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* number of pages we need for the entire stripe across all the
|
|
|
|
* drives
|
|
|
|
*/
|
|
|
|
static unsigned long rbio_nr_pages(unsigned long stripe_len, int nr_stripes)
|
|
|
|
{
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
return DIV_ROUND_UP(stripe_len, PAGE_SIZE) * nr_stripes;
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocation and initial setup for the btrfs_raid_bio. Not
|
|
|
|
* this does not allocate any pages for rbio->pages.
|
|
|
|
*/
|
2016-06-23 00:54:24 +02:00
|
|
|
static struct btrfs_raid_bio *alloc_rbio(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_bio *bbio,
|
|
|
|
u64 stripe_len)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
int nr_data = 0;
|
2014-11-14 09:06:25 +01:00
|
|
|
int real_stripes = bbio->num_stripes - bbio->num_tgtdevs;
|
|
|
|
int num_pages = rbio_nr_pages(stripe_len, real_stripes);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
int stripe_npages = DIV_ROUND_UP(stripe_len, PAGE_SIZE);
|
2013-01-30 00:40:14 +01:00
|
|
|
void *p;
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
rbio = kzalloc(sizeof(*rbio) + num_pages * sizeof(struct page *) * 2 +
|
2014-12-08 12:55:57 +01:00
|
|
|
DIV_ROUND_UP(stripe_npages, BITS_PER_LONG) *
|
|
|
|
sizeof(long), GFP_NOFS);
|
2014-10-23 08:42:50 +02:00
|
|
|
if (!rbio)
|
2013-01-30 00:40:14 +01:00
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
bio_list_init(&rbio->bio_list);
|
|
|
|
INIT_LIST_HEAD(&rbio->plug_list);
|
|
|
|
spin_lock_init(&rbio->bio_list_lock);
|
2013-01-31 20:42:09 +01:00
|
|
|
INIT_LIST_HEAD(&rbio->stripe_cache);
|
2013-01-30 00:40:14 +01:00
|
|
|
INIT_LIST_HEAD(&rbio->hash_list);
|
|
|
|
rbio->bbio = bbio;
|
2016-06-23 00:54:24 +02:00
|
|
|
rbio->fs_info = fs_info;
|
2013-01-30 00:40:14 +01:00
|
|
|
rbio->stripe_len = stripe_len;
|
|
|
|
rbio->nr_pages = num_pages;
|
2014-11-14 09:06:25 +01:00
|
|
|
rbio->real_stripes = real_stripes;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
rbio->stripe_npages = stripe_npages;
|
2013-01-30 00:40:14 +01:00
|
|
|
rbio->faila = -1;
|
|
|
|
rbio->failb = -1;
|
2017-03-03 09:55:26 +01:00
|
|
|
refcount_set(&rbio->refs, 1);
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->error, 0);
|
|
|
|
atomic_set(&rbio->stripes_pending, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* the stripe_pages and bio_pages array point to the extra
|
|
|
|
* memory we allocated past the end of the rbio
|
|
|
|
*/
|
|
|
|
p = rbio + 1;
|
|
|
|
rbio->stripe_pages = p;
|
|
|
|
rbio->bio_pages = p + sizeof(struct page *) * num_pages;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
rbio->dbitmap = p + sizeof(struct page *) * num_pages * 2;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2015-01-20 08:11:43 +01:00
|
|
|
if (bbio->map_type & BTRFS_BLOCK_GROUP_RAID5)
|
|
|
|
nr_data = real_stripes - 1;
|
|
|
|
else if (bbio->map_type & BTRFS_BLOCK_GROUP_RAID6)
|
2014-11-14 09:06:25 +01:00
|
|
|
nr_data = real_stripes - 2;
|
2013-01-30 00:40:14 +01:00
|
|
|
else
|
2015-01-20 08:11:43 +01:00
|
|
|
BUG();
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
rbio->nr_data = nr_data;
|
|
|
|
return rbio;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate pages for all the stripes in the bio, including parity */
|
|
|
|
static int alloc_rbio_pages(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
for (i = 0; i < rbio->nr_pages; i++) {
|
|
|
|
if (rbio->stripe_pages[i])
|
|
|
|
continue;
|
|
|
|
page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
|
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
rbio->stripe_pages[i] = page;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-03 13:38:46 +01:00
|
|
|
/* only allocate pages for p/q stripes */
|
2013-01-30 00:40:14 +01:00
|
|
|
static int alloc_rbio_parity_pages(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct page *page;
|
|
|
|
|
2015-03-03 13:38:46 +01:00
|
|
|
i = rbio_stripe_page_index(rbio, rbio->nr_data, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
for (; i < rbio->nr_pages; i++) {
|
|
|
|
if (rbio->stripe_pages[i])
|
|
|
|
continue;
|
|
|
|
page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
|
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
rbio->stripe_pages[i] = page;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* add a single page from a specific stripe into our list of bios for IO
|
|
|
|
* this will try to merge into existing bios if possible, and returns
|
|
|
|
* zero if all went well.
|
|
|
|
*/
|
2013-04-25 22:41:01 +02:00
|
|
|
static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
|
|
|
|
struct bio_list *bio_list,
|
|
|
|
struct page *page,
|
|
|
|
int stripe_nr,
|
|
|
|
unsigned long page_index,
|
|
|
|
unsigned long bio_max_len)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct bio *last = bio_list->tail;
|
|
|
|
u64 last_end = 0;
|
|
|
|
int ret;
|
|
|
|
struct bio *bio;
|
|
|
|
struct btrfs_bio_stripe *stripe;
|
|
|
|
u64 disk_start;
|
|
|
|
|
|
|
|
stripe = &rbio->bbio->stripes[stripe_nr];
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
disk_start = stripe->physical + (page_index << PAGE_SHIFT);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/* if the device is missing, just fail this stripe */
|
|
|
|
if (!stripe->dev->bdev)
|
|
|
|
return fail_rbio_index(rbio, stripe_nr);
|
|
|
|
|
|
|
|
/* see if we can add this page onto our existing bio */
|
|
|
|
if (last) {
|
2013-10-12 00:44:27 +02:00
|
|
|
last_end = (u64)last->bi_iter.bi_sector << 9;
|
|
|
|
last_end += last->bi_iter.bi_size;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we can't merge these if they are from different
|
|
|
|
* devices or if they are not contiguous
|
|
|
|
*/
|
|
|
|
if (last_end == disk_start && stripe->dev->bdev &&
|
2017-06-03 09:38:06 +02:00
|
|
|
!last->bi_status &&
|
2013-01-30 00:40:14 +01:00
|
|
|
last->bi_bdev == stripe->dev->bdev) {
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
ret = bio_add_page(last, page, PAGE_SIZE, 0);
|
|
|
|
if (ret == PAGE_SIZE)
|
2013-01-30 00:40:14 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* put a new bio on the list */
|
2017-06-12 17:29:41 +02:00
|
|
|
bio = btrfs_io_bio_alloc(bio_max_len >> PAGE_SHIFT ?: 1);
|
2013-10-12 00:44:27 +02:00
|
|
|
bio->bi_iter.bi_size = 0;
|
2013-01-30 00:40:14 +01:00
|
|
|
bio->bi_bdev = stripe->dev->bdev;
|
2013-10-12 00:44:27 +02:00
|
|
|
bio->bi_iter.bi_sector = disk_start >> 9;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
bio_add_page(bio, page, PAGE_SIZE, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
bio_list_add(bio_list, bio);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* while we're doing the read/modify/write cycle, we could
|
|
|
|
* have errors in reading pages off the disk. This checks
|
|
|
|
* for errors and if we're not able to read the page it'll
|
|
|
|
* trigger parity reconstruction. The rmw will be finished
|
|
|
|
* after we've reconstructed the failed stripes
|
|
|
|
*/
|
|
|
|
static void validate_rbio_for_rmw(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
if (rbio->faila >= 0 || rbio->failb >= 0) {
|
2014-11-14 09:06:25 +01:00
|
|
|
BUG_ON(rbio->faila == rbio->real_stripes - 1);
|
2013-01-30 00:40:14 +01:00
|
|
|
__raid56_parity_recover(rbio);
|
|
|
|
} else {
|
|
|
|
finish_rmw(rbio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper function to walk our bio list and populate the bio_pages array with
|
|
|
|
* the result. This seems expensive, but it is faster than constantly
|
|
|
|
* searching through the bio list as we setup the IO in finish_rmw or stripe
|
|
|
|
* reconstruction.
|
|
|
|
*
|
|
|
|
* This must be called before you trust the answers from page_in_rbio
|
|
|
|
*/
|
|
|
|
static void index_rbio_pages(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
2016-11-25 09:07:47 +01:00
|
|
|
struct bio_vec *bvec;
|
2013-01-30 00:40:14 +01:00
|
|
|
u64 start;
|
|
|
|
unsigned long stripe_offset;
|
|
|
|
unsigned long page_index;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_irq(&rbio->bio_list_lock);
|
|
|
|
bio_list_for_each(bio, &rbio->bio_list) {
|
2013-10-12 00:44:27 +02:00
|
|
|
start = (u64)bio->bi_iter.bi_sector << 9;
|
2015-01-20 08:11:33 +01:00
|
|
|
stripe_offset = start - rbio->bbio->raid_map[0];
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
page_index = stripe_offset >> PAGE_SHIFT;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-11-25 09:07:47 +01:00
|
|
|
bio_for_each_segment_all(bvec, bio, i)
|
|
|
|
rbio->bio_pages[page_index + i] = bvec->bv_page;
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
spin_unlock_irq(&rbio->bio_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this is called from one of two situations. We either
|
|
|
|
* have a full stripe from the higher layers, or we've read all
|
|
|
|
* the missing bits off disk.
|
|
|
|
*
|
|
|
|
* This will calculate the parity and then send down any
|
|
|
|
* changed blocks.
|
|
|
|
*/
|
|
|
|
static noinline void finish_rmw(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
struct btrfs_bio *bbio = rbio->bbio;
|
2014-11-14 09:06:25 +01:00
|
|
|
void *pointers[rbio->real_stripes];
|
2013-01-30 00:40:14 +01:00
|
|
|
int nr_data = rbio->nr_data;
|
|
|
|
int stripe;
|
|
|
|
int pagenr;
|
|
|
|
int p_stripe = -1;
|
|
|
|
int q_stripe = -1;
|
|
|
|
struct bio_list bio_list;
|
|
|
|
struct bio *bio;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
bio_list_init(&bio_list);
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
if (rbio->real_stripes - rbio->nr_data == 1) {
|
|
|
|
p_stripe = rbio->real_stripes - 1;
|
|
|
|
} else if (rbio->real_stripes - rbio->nr_data == 2) {
|
|
|
|
p_stripe = rbio->real_stripes - 2;
|
|
|
|
q_stripe = rbio->real_stripes - 1;
|
2013-01-30 00:40:14 +01:00
|
|
|
} else {
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* at this point we either have a full stripe,
|
|
|
|
* or we've read the full stripe from the drive.
|
|
|
|
* recalculate the parity and write the new results.
|
|
|
|
*
|
|
|
|
* We're not allowed to add any new bios to the
|
|
|
|
* bio list here, anyone else that wants to
|
|
|
|
* change this stripe needs to do their own rmw.
|
|
|
|
*/
|
|
|
|
spin_lock_irq(&rbio->bio_list_lock);
|
|
|
|
set_bit(RBIO_RMW_LOCKED_BIT, &rbio->flags);
|
|
|
|
spin_unlock_irq(&rbio->bio_list_lock);
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->error, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* now that we've set rmw_locked, run through the
|
|
|
|
* bio list one last time and map the page pointers
|
2013-01-31 20:42:09 +01:00
|
|
|
*
|
|
|
|
* We don't cache full rbios because we're assuming
|
|
|
|
* the higher layers are unlikely to use this area of
|
|
|
|
* the disk again soon. If they do use it again,
|
|
|
|
* hopefully they will send another full bio.
|
2013-01-30 00:40:14 +01:00
|
|
|
*/
|
|
|
|
index_rbio_pages(rbio);
|
2013-01-31 20:42:09 +01:00
|
|
|
if (!rbio_is_full(rbio))
|
|
|
|
cache_rbio_pages(rbio);
|
|
|
|
else
|
|
|
|
clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2015-03-03 13:42:48 +01:00
|
|
|
for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
struct page *p;
|
|
|
|
/* first collect one page from each data stripe */
|
|
|
|
for (stripe = 0; stripe < nr_data; stripe++) {
|
|
|
|
p = page_in_rbio(rbio, stripe, pagenr, 0);
|
|
|
|
pointers[stripe] = kmap(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* then add the parity stripe */
|
|
|
|
p = rbio_pstripe_page(rbio, pagenr);
|
|
|
|
SetPageUptodate(p);
|
|
|
|
pointers[stripe++] = kmap(p);
|
|
|
|
|
|
|
|
if (q_stripe != -1) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* raid6, add the qstripe and call the
|
|
|
|
* library function to fill in our p/q
|
|
|
|
*/
|
|
|
|
p = rbio_qstripe_page(rbio, pagenr);
|
|
|
|
SetPageUptodate(p);
|
|
|
|
pointers[stripe++] = kmap(p);
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
raid6_call.gen_syndrome(rbio->real_stripes, PAGE_SIZE,
|
2013-01-30 00:40:14 +01:00
|
|
|
pointers);
|
|
|
|
} else {
|
|
|
|
/* raid5 */
|
|
|
|
memcpy(pointers[nr_data], pointers[0], PAGE_SIZE);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
run_xor(pointers + 1, nr_data - 1, PAGE_SIZE);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++)
|
2013-01-30 00:40:14 +01:00
|
|
|
kunmap(page_in_rbio(rbio, stripe, pagenr, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* time to start writing. Make bios for everything from the
|
|
|
|
* higher layers (the bio_list in our rbio) and our p/q. Ignore
|
|
|
|
* everything else.
|
|
|
|
*/
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
|
2015-03-03 13:42:48 +01:00
|
|
|
for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
struct page *page;
|
|
|
|
if (stripe < rbio->nr_data) {
|
|
|
|
page = page_in_rbio(rbio, stripe, pagenr, 1);
|
|
|
|
if (!page)
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
page = rbio_stripe_page(rbio, stripe, pagenr);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rbio_add_io_page(rbio, &bio_list,
|
|
|
|
page, stripe, pagenr, rbio->stripe_len);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
if (likely(!bbio->num_tgtdevs))
|
|
|
|
goto write_data;
|
|
|
|
|
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
|
|
|
|
if (!bbio->tgtdev_map[stripe])
|
|
|
|
continue;
|
|
|
|
|
2015-03-03 13:42:48 +01:00
|
|
|
for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
|
2014-11-14 09:06:25 +01:00
|
|
|
struct page *page;
|
|
|
|
if (stripe < rbio->nr_data) {
|
|
|
|
page = page_in_rbio(rbio, stripe, pagenr, 1);
|
|
|
|
if (!page)
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
page = rbio_stripe_page(rbio, stripe, pagenr);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rbio_add_io_page(rbio, &bio_list, page,
|
|
|
|
rbio->bbio->tgtdev_map[stripe],
|
|
|
|
pagenr, rbio->stripe_len);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
write_data:
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->stripes_pending, bio_list_size(&bio_list));
|
|
|
|
BUG_ON(atomic_read(&rbio->stripes_pending) == 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
bio = bio_list_pop(&bio_list);
|
|
|
|
if (!bio)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bio->bi_private = rbio;
|
|
|
|
bio->bi_end_io = raid_write_end_io;
|
2016-06-05 21:31:52 +02:00
|
|
|
bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
|
2016-06-05 21:31:41 +02:00
|
|
|
|
|
|
|
submit_bio(bio);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
cleanup:
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper to find the stripe number for a given bio. Used to figure out which
|
|
|
|
* stripe has failed. This expects the bio to correspond to a physical disk,
|
|
|
|
* so it looks up based on physical sector numbers.
|
|
|
|
*/
|
|
|
|
static int find_bio_stripe(struct btrfs_raid_bio *rbio,
|
|
|
|
struct bio *bio)
|
|
|
|
{
|
2013-10-12 00:44:27 +02:00
|
|
|
u64 physical = bio->bi_iter.bi_sector;
|
2013-01-30 00:40:14 +01:00
|
|
|
u64 stripe_start;
|
|
|
|
int i;
|
|
|
|
struct btrfs_bio_stripe *stripe;
|
|
|
|
|
|
|
|
physical <<= 9;
|
|
|
|
|
|
|
|
for (i = 0; i < rbio->bbio->num_stripes; i++) {
|
|
|
|
stripe = &rbio->bbio->stripes[i];
|
|
|
|
stripe_start = stripe->physical;
|
|
|
|
if (physical >= stripe_start &&
|
2014-11-14 09:06:25 +01:00
|
|
|
physical < stripe_start + rbio->stripe_len &&
|
|
|
|
bio->bi_bdev == stripe->dev->bdev) {
|
2013-01-30 00:40:14 +01:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper to find the stripe number for a given
|
|
|
|
* bio (before mapping). Used to figure out which stripe has
|
|
|
|
* failed. This looks up based on logical block numbers.
|
|
|
|
*/
|
|
|
|
static int find_logical_bio_stripe(struct btrfs_raid_bio *rbio,
|
|
|
|
struct bio *bio)
|
|
|
|
{
|
2013-10-12 00:44:27 +02:00
|
|
|
u64 logical = bio->bi_iter.bi_sector;
|
2013-01-30 00:40:14 +01:00
|
|
|
u64 stripe_start;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
logical <<= 9;
|
|
|
|
|
|
|
|
for (i = 0; i < rbio->nr_data; i++) {
|
2015-01-20 08:11:33 +01:00
|
|
|
stripe_start = rbio->bbio->raid_map[i];
|
2013-01-30 00:40:14 +01:00
|
|
|
if (logical >= stripe_start &&
|
|
|
|
logical < stripe_start + rbio->stripe_len) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns -EIO if we had too many failures
|
|
|
|
*/
|
|
|
|
static int fail_rbio_index(struct btrfs_raid_bio *rbio, int failed)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rbio->bio_list_lock, flags);
|
|
|
|
|
|
|
|
/* we already know this stripe is bad, move on */
|
|
|
|
if (rbio->faila == failed || rbio->failb == failed)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (rbio->faila == -1) {
|
|
|
|
/* first failure on this rbio */
|
|
|
|
rbio->faila = failed;
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_inc(&rbio->error);
|
2013-01-30 00:40:14 +01:00
|
|
|
} else if (rbio->failb == -1) {
|
|
|
|
/* second failure on this rbio */
|
|
|
|
rbio->failb = failed;
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_inc(&rbio->error);
|
2013-01-30 00:40:14 +01:00
|
|
|
} else {
|
|
|
|
ret = -EIO;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&rbio->bio_list_lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* helper to fail a stripe based on a physical disk
|
|
|
|
* bio.
|
|
|
|
*/
|
|
|
|
static int fail_bio_stripe(struct btrfs_raid_bio *rbio,
|
|
|
|
struct bio *bio)
|
|
|
|
{
|
|
|
|
int failed = find_bio_stripe(rbio, bio);
|
|
|
|
|
|
|
|
if (failed < 0)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return fail_rbio_index(rbio, failed);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this sets each page in the bio uptodate. It should only be used on private
|
|
|
|
* rbio pages, nothing that comes in from the higher layers
|
|
|
|
*/
|
|
|
|
static void set_bio_pages_uptodate(struct bio *bio)
|
|
|
|
{
|
2016-11-25 09:07:47 +01:00
|
|
|
struct bio_vec *bvec;
|
2013-01-30 00:40:14 +01:00
|
|
|
int i;
|
|
|
|
|
2016-11-25 09:07:47 +01:00
|
|
|
bio_for_each_segment_all(bvec, bio, i)
|
|
|
|
SetPageUptodate(bvec->bv_page);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* end io for the read phase of the rmw cycle. All the bios here are physical
|
|
|
|
* stripe bios we've read from the disk so we can recalculate the parity of the
|
|
|
|
* stripe.
|
|
|
|
*
|
|
|
|
* This will usually kick off finish_rmw once all the bios are read in, but it
|
|
|
|
* may trigger parity reconstruction if we had any errors along the way
|
|
|
|
*/
|
2015-07-20 15:29:37 +02:00
|
|
|
static void raid_rmw_end_io(struct bio *bio)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio = bio->bi_private;
|
|
|
|
|
2017-06-03 09:38:06 +02:00
|
|
|
if (bio->bi_status)
|
2013-01-30 00:40:14 +01:00
|
|
|
fail_bio_stripe(rbio, bio);
|
|
|
|
else
|
|
|
|
set_bio_pages_uptodate(bio);
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
if (!atomic_dec_and_test(&rbio->stripes_pending))
|
2013-01-30 00:40:14 +01:00
|
|
|
return;
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
|
2013-01-30 00:40:14 +01:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this will normally call finish_rmw to start our write
|
|
|
|
* but if there are any failed stripes we'll reconstruct
|
|
|
|
* from parity first
|
|
|
|
*/
|
|
|
|
validate_rbio_for_rmw(rbio);
|
|
|
|
return;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void async_rmw_stripe(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_init_work(&rbio->work, btrfs_rmw_helper, rmw_work, NULL, NULL);
|
|
|
|
btrfs_queue_work(rbio->fs_info->rmw_workers, &rbio->work);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void async_read_rebuild(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
Btrfs: fix task hang under heavy compressed write
This has been reported and discussed for a long time, and this hang occurs in
both 3.15 and 3.16.
Btrfs now migrates to use kernel workqueue, but it introduces this hang problem.
Btrfs has a kind of work queued as an ordered way, which means that its
ordered_func() must be processed in the way of FIFO, so it usually looks like --
normal_work_helper(arg)
work = container_of(arg, struct btrfs_work, normal_work);
work->func() <---- (we name it work X)
for ordered_work in wq->ordered_list
ordered_work->ordered_func()
ordered_work->ordered_free()
The hang is a rare case, first when we find free space, we get an uncached block
group, then we go to read its free space cache inode for free space information,
so it will
file a readahead request
btrfs_readpages()
for page that is not in page cache
__do_readpage()
submit_extent_page()
btrfs_submit_bio_hook()
btrfs_bio_wq_end_io()
submit_bio()
end_workqueue_bio() <--(ret by the 1st endio)
queue a work(named work Y) for the 2nd
also the real endio()
So the hang occurs when work Y's work_struct and work X's work_struct happens
to share the same address.
A bit more explanation,
A,B,C -- struct btrfs_work
arg -- struct work_struct
kthread:
worker_thread()
pick up a work_struct from @worklist
process_one_work(arg)
worker->current_work = arg; <-- arg is A->normal_work
worker->current_func(arg)
normal_work_helper(arg)
A = container_of(arg, struct btrfs_work, normal_work);
A->func()
A->ordered_func()
A->ordered_free() <-- A gets freed
B->ordered_func()
submit_compressed_extents()
find_free_extent()
load_free_space_inode()
... <-- (the above readhead stack)
end_workqueue_bio()
btrfs_queue_work(work C)
B->ordered_free()
As if work A has a high priority in wq->ordered_list and there are more ordered
works queued after it, such as B->ordered_func(), its memory could have been
freed before normal_work_helper() returns, which means that kernel workqueue
code worker_thread() still has worker->current_work pointer to be work
A->normal_work's, ie. arg's address.
Meanwhile, work C is allocated after work A is freed, work C->normal_work
and work A->normal_work are likely to share the same address(I confirmed this
with ftrace output, so I'm not just guessing, it's rare though).
When another kthread picks up work C->normal_work to process, and finds our
kthread is processing it(see find_worker_executing_work()), it'll think
work C as a collision and skip then, which ends up nobody processing work C.
So the situation is that our kthread is waiting forever on work C.
Besides, there're other cases that can lead to deadlock, but the real problem
is that all btrfs workqueue shares one work->func, -- normal_work_helper,
so this makes each workqueue to have its own helper function, but only a
wraper pf normal_work_helper.
With this patch, I no long hit the above hang.
Signed-off-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-08-15 17:36:53 +02:00
|
|
|
btrfs_init_work(&rbio->work, btrfs_rmw_helper,
|
|
|
|
read_rebuild_work, NULL, NULL);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_queue_work(rbio->fs_info->rmw_workers, &rbio->work);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the stripe must be locked by the caller. It will
|
|
|
|
* unlock after all the writes are done
|
|
|
|
*/
|
|
|
|
static int raid56_rmw_stripe(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int bios_to_read = 0;
|
|
|
|
struct bio_list bio_list;
|
|
|
|
int ret;
|
|
|
|
int pagenr;
|
|
|
|
int stripe;
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
bio_list_init(&bio_list);
|
|
|
|
|
|
|
|
ret = alloc_rbio_pages(rbio);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
index_rbio_pages(rbio);
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->error, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* build a list of bios to read all the missing parts of this
|
|
|
|
* stripe
|
|
|
|
*/
|
|
|
|
for (stripe = 0; stripe < rbio->nr_data; stripe++) {
|
2015-03-03 13:42:48 +01:00
|
|
|
for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
struct page *page;
|
|
|
|
/*
|
|
|
|
* we want to find all the pages missing from
|
|
|
|
* the rbio and read them from the disk. If
|
|
|
|
* page_in_rbio finds a page in the bio list
|
|
|
|
* we don't need to read it off the stripe.
|
|
|
|
*/
|
|
|
|
page = page_in_rbio(rbio, stripe, pagenr, 1);
|
|
|
|
if (page)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
page = rbio_stripe_page(rbio, stripe, pagenr);
|
2013-01-31 20:42:09 +01:00
|
|
|
/*
|
|
|
|
* the bio cache may have handed us an uptodate
|
|
|
|
* page. If so, be happy and use it
|
|
|
|
*/
|
|
|
|
if (PageUptodate(page))
|
|
|
|
continue;
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
ret = rbio_add_io_page(rbio, &bio_list, page,
|
|
|
|
stripe, pagenr, rbio->stripe_len);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bios_to_read = bio_list_size(&bio_list);
|
|
|
|
if (!bios_to_read) {
|
|
|
|
/*
|
|
|
|
* this can happen if others have merged with
|
|
|
|
* us, it means there is nothing left to read.
|
|
|
|
* But if there are missing devices it may not be
|
|
|
|
* safe to do the full stripe write yet.
|
|
|
|
*/
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the bbio may be freed once we submit the last bio. Make sure
|
|
|
|
* not to touch it after that
|
|
|
|
*/
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->stripes_pending, bios_to_read);
|
2013-01-30 00:40:14 +01:00
|
|
|
while (1) {
|
|
|
|
bio = bio_list_pop(&bio_list);
|
|
|
|
if (!bio)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bio->bi_private = rbio;
|
|
|
|
bio->bi_end_io = raid_rmw_end_io;
|
2016-06-05 21:31:52 +02:00
|
|
|
bio_set_op_attrs(bio, REQ_OP_READ, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_wq_end_io(rbio->fs_info, bio, BTRFS_WQ_ENDIO_RAID56);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-06-05 21:31:41 +02:00
|
|
|
submit_bio(bio);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
/* the actual write will happen once the reads are done */
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
2013-01-30 00:40:14 +01:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
finish:
|
|
|
|
validate_rbio_for_rmw(rbio);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the upper layers pass in a full stripe, we thank them by only allocating
|
|
|
|
* enough pages to hold the parity, and sending it all down quickly.
|
|
|
|
*/
|
|
|
|
static int full_stripe_write(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = alloc_rbio_parity_pages(rbio);
|
2013-07-22 10:36:57 +02:00
|
|
|
if (ret) {
|
|
|
|
__free_raid_bio(rbio);
|
2013-01-30 00:40:14 +01:00
|
|
|
return ret;
|
2013-07-22 10:36:57 +02:00
|
|
|
}
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
ret = lock_stripe_add(rbio);
|
|
|
|
if (ret == 0)
|
|
|
|
finish_rmw(rbio);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* partial stripe writes get handed over to async helpers.
|
|
|
|
* We're really hoping to merge a few more writes into this
|
|
|
|
* rbio before calculating new parity
|
|
|
|
*/
|
|
|
|
static int partial_stripe_write(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = lock_stripe_add(rbio);
|
|
|
|
if (ret == 0)
|
|
|
|
async_rmw_stripe(rbio);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sometimes while we were reading from the drive to
|
|
|
|
* recalculate parity, enough new bios come into create
|
|
|
|
* a full stripe. So we do a check here to see if we can
|
|
|
|
* go directly to finish_rmw
|
|
|
|
*/
|
|
|
|
static int __raid56_parity_write(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
/* head off into rmw land if we don't have a full stripe */
|
|
|
|
if (!rbio_is_full(rbio))
|
|
|
|
return partial_stripe_write(rbio);
|
|
|
|
return full_stripe_write(rbio);
|
|
|
|
}
|
|
|
|
|
2013-01-31 20:42:28 +01:00
|
|
|
/*
|
|
|
|
* We use plugging call backs to collect full stripes.
|
|
|
|
* Any time we get a partial stripe write while plugged
|
|
|
|
* we collect it into a list. When the unplug comes down,
|
|
|
|
* we sort the list by logical block number and merge
|
|
|
|
* everything we can into the same rbios
|
|
|
|
*/
|
|
|
|
struct btrfs_plug_cb {
|
|
|
|
struct blk_plug_cb cb;
|
|
|
|
struct btrfs_fs_info *info;
|
|
|
|
struct list_head rbio_list;
|
|
|
|
struct btrfs_work work;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* rbios on the plug list are sorted for easier merging.
|
|
|
|
*/
|
|
|
|
static int plug_cmp(void *priv, struct list_head *a, struct list_head *b)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *ra = container_of(a, struct btrfs_raid_bio,
|
|
|
|
plug_list);
|
|
|
|
struct btrfs_raid_bio *rb = container_of(b, struct btrfs_raid_bio,
|
|
|
|
plug_list);
|
2013-10-12 00:44:27 +02:00
|
|
|
u64 a_sector = ra->bio_list.head->bi_iter.bi_sector;
|
|
|
|
u64 b_sector = rb->bio_list.head->bi_iter.bi_sector;
|
2013-01-31 20:42:28 +01:00
|
|
|
|
|
|
|
if (a_sector < b_sector)
|
|
|
|
return -1;
|
|
|
|
if (a_sector > b_sector)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void run_plug(struct btrfs_plug_cb *plug)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *cur;
|
|
|
|
struct btrfs_raid_bio *last = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sort our plug list then try to merge
|
|
|
|
* everything we can in hopes of creating full
|
|
|
|
* stripes.
|
|
|
|
*/
|
|
|
|
list_sort(NULL, &plug->rbio_list, plug_cmp);
|
|
|
|
while (!list_empty(&plug->rbio_list)) {
|
|
|
|
cur = list_entry(plug->rbio_list.next,
|
|
|
|
struct btrfs_raid_bio, plug_list);
|
|
|
|
list_del_init(&cur->plug_list);
|
|
|
|
|
|
|
|
if (rbio_is_full(cur)) {
|
|
|
|
/* we have a full stripe, send it down */
|
|
|
|
full_stripe_write(cur);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (last) {
|
|
|
|
if (rbio_can_merge(last, cur)) {
|
|
|
|
merge_rbio(last, cur);
|
|
|
|
__free_raid_bio(cur);
|
|
|
|
continue;
|
|
|
|
|
|
|
|
}
|
|
|
|
__raid56_parity_write(last);
|
|
|
|
}
|
|
|
|
last = cur;
|
|
|
|
}
|
|
|
|
if (last) {
|
|
|
|
__raid56_parity_write(last);
|
|
|
|
}
|
|
|
|
kfree(plug);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the unplug comes from schedule, we have to push the
|
|
|
|
* work off to a helper thread
|
|
|
|
*/
|
|
|
|
static void unplug_work(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_plug_cb *plug;
|
|
|
|
plug = container_of(work, struct btrfs_plug_cb, work);
|
|
|
|
run_plug(plug);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void btrfs_raid_unplug(struct blk_plug_cb *cb, bool from_schedule)
|
|
|
|
{
|
|
|
|
struct btrfs_plug_cb *plug;
|
|
|
|
plug = container_of(cb, struct btrfs_plug_cb, cb);
|
|
|
|
|
|
|
|
if (from_schedule) {
|
Btrfs: fix task hang under heavy compressed write
This has been reported and discussed for a long time, and this hang occurs in
both 3.15 and 3.16.
Btrfs now migrates to use kernel workqueue, but it introduces this hang problem.
Btrfs has a kind of work queued as an ordered way, which means that its
ordered_func() must be processed in the way of FIFO, so it usually looks like --
normal_work_helper(arg)
work = container_of(arg, struct btrfs_work, normal_work);
work->func() <---- (we name it work X)
for ordered_work in wq->ordered_list
ordered_work->ordered_func()
ordered_work->ordered_free()
The hang is a rare case, first when we find free space, we get an uncached block
group, then we go to read its free space cache inode for free space information,
so it will
file a readahead request
btrfs_readpages()
for page that is not in page cache
__do_readpage()
submit_extent_page()
btrfs_submit_bio_hook()
btrfs_bio_wq_end_io()
submit_bio()
end_workqueue_bio() <--(ret by the 1st endio)
queue a work(named work Y) for the 2nd
also the real endio()
So the hang occurs when work Y's work_struct and work X's work_struct happens
to share the same address.
A bit more explanation,
A,B,C -- struct btrfs_work
arg -- struct work_struct
kthread:
worker_thread()
pick up a work_struct from @worklist
process_one_work(arg)
worker->current_work = arg; <-- arg is A->normal_work
worker->current_func(arg)
normal_work_helper(arg)
A = container_of(arg, struct btrfs_work, normal_work);
A->func()
A->ordered_func()
A->ordered_free() <-- A gets freed
B->ordered_func()
submit_compressed_extents()
find_free_extent()
load_free_space_inode()
... <-- (the above readhead stack)
end_workqueue_bio()
btrfs_queue_work(work C)
B->ordered_free()
As if work A has a high priority in wq->ordered_list and there are more ordered
works queued after it, such as B->ordered_func(), its memory could have been
freed before normal_work_helper() returns, which means that kernel workqueue
code worker_thread() still has worker->current_work pointer to be work
A->normal_work's, ie. arg's address.
Meanwhile, work C is allocated after work A is freed, work C->normal_work
and work A->normal_work are likely to share the same address(I confirmed this
with ftrace output, so I'm not just guessing, it's rare though).
When another kthread picks up work C->normal_work to process, and finds our
kthread is processing it(see find_worker_executing_work()), it'll think
work C as a collision and skip then, which ends up nobody processing work C.
So the situation is that our kthread is waiting forever on work C.
Besides, there're other cases that can lead to deadlock, but the real problem
is that all btrfs workqueue shares one work->func, -- normal_work_helper,
so this makes each workqueue to have its own helper function, but only a
wraper pf normal_work_helper.
With this patch, I no long hit the above hang.
Signed-off-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Chris Mason <clm@fb.com>
2014-08-15 17:36:53 +02:00
|
|
|
btrfs_init_work(&plug->work, btrfs_rmw_helper,
|
|
|
|
unplug_work, NULL, NULL);
|
2014-02-28 03:46:11 +01:00
|
|
|
btrfs_queue_work(plug->info->rmw_workers,
|
|
|
|
&plug->work);
|
2013-01-31 20:42:28 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
run_plug(plug);
|
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* our main entry point for writes from the rest of the FS.
|
|
|
|
*/
|
2016-06-23 00:54:24 +02:00
|
|
|
int raid56_parity_write(struct btrfs_fs_info *fs_info, struct bio *bio,
|
2015-01-20 08:11:33 +01:00
|
|
|
struct btrfs_bio *bbio, u64 stripe_len)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
2013-01-31 20:42:28 +01:00
|
|
|
struct btrfs_plug_cb *plug = NULL;
|
|
|
|
struct blk_plug_cb *cb;
|
2014-11-25 09:39:28 +01:00
|
|
|
int ret;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-06-23 00:54:24 +02:00
|
|
|
rbio = alloc_rbio(fs_info, bbio, stripe_len);
|
2014-10-23 08:42:50 +02:00
|
|
|
if (IS_ERR(rbio)) {
|
2015-01-20 08:11:34 +01:00
|
|
|
btrfs_put_bbio(bbio);
|
2013-01-30 00:40:14 +01:00
|
|
|
return PTR_ERR(rbio);
|
2014-10-23 08:42:50 +02:00
|
|
|
}
|
2013-01-30 00:40:14 +01:00
|
|
|
bio_list_add(&rbio->bio_list, bio);
|
2013-10-12 00:44:27 +02:00
|
|
|
rbio->bio_list_bytes = bio->bi_iter.bi_size;
|
2014-11-06 09:14:21 +01:00
|
|
|
rbio->operation = BTRFS_RBIO_WRITE;
|
2013-01-31 20:42:28 +01:00
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_counter_inc_noblocked(fs_info);
|
2014-11-25 09:39:28 +01:00
|
|
|
rbio->generic_bio_cnt = 1;
|
|
|
|
|
2013-01-31 20:42:28 +01:00
|
|
|
/*
|
|
|
|
* don't plug on full rbios, just get them out the door
|
|
|
|
* as quickly as we can
|
|
|
|
*/
|
2014-11-25 09:39:28 +01:00
|
|
|
if (rbio_is_full(rbio)) {
|
|
|
|
ret = full_stripe_write(rbio);
|
|
|
|
if (ret)
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_counter_dec(fs_info);
|
2014-11-25 09:39:28 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2013-01-31 20:42:28 +01:00
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
cb = blk_check_plugged(btrfs_raid_unplug, fs_info, sizeof(*plug));
|
2013-01-31 20:42:28 +01:00
|
|
|
if (cb) {
|
|
|
|
plug = container_of(cb, struct btrfs_plug_cb, cb);
|
|
|
|
if (!plug->info) {
|
2016-06-23 00:54:23 +02:00
|
|
|
plug->info = fs_info;
|
2013-01-31 20:42:28 +01:00
|
|
|
INIT_LIST_HEAD(&plug->rbio_list);
|
|
|
|
}
|
|
|
|
list_add_tail(&rbio->plug_list, &plug->rbio_list);
|
2014-11-25 09:39:28 +01:00
|
|
|
ret = 0;
|
2013-01-31 20:42:28 +01:00
|
|
|
} else {
|
2014-11-25 09:39:28 +01:00
|
|
|
ret = __raid56_parity_write(rbio);
|
|
|
|
if (ret)
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_counter_dec(fs_info);
|
2013-01-31 20:42:28 +01:00
|
|
|
}
|
2014-11-25 09:39:28 +01:00
|
|
|
return ret;
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* all parity reconstruction happens here. We've read in everything
|
|
|
|
* we can find from the drives and this does the heavy lifting of
|
|
|
|
* sorting the good from the bad.
|
|
|
|
*/
|
|
|
|
static void __raid_recover_end_io(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int pagenr, stripe;
|
|
|
|
void **pointers;
|
|
|
|
int faila = -1, failb = -1;
|
|
|
|
struct page *page;
|
|
|
|
int err;
|
|
|
|
int i;
|
|
|
|
|
2015-02-20 18:00:26 +01:00
|
|
|
pointers = kcalloc(rbio->real_stripes, sizeof(void *), GFP_NOFS);
|
2013-01-30 00:40:14 +01:00
|
|
|
if (!pointers) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto cleanup_io;
|
|
|
|
}
|
|
|
|
|
|
|
|
faila = rbio->faila;
|
|
|
|
failb = rbio->failb;
|
|
|
|
|
2015-06-19 20:52:50 +02:00
|
|
|
if (rbio->operation == BTRFS_RBIO_READ_REBUILD ||
|
|
|
|
rbio->operation == BTRFS_RBIO_REBUILD_MISSING) {
|
2013-01-30 00:40:14 +01:00
|
|
|
spin_lock_irq(&rbio->bio_list_lock);
|
|
|
|
set_bit(RBIO_RMW_LOCKED_BIT, &rbio->flags);
|
|
|
|
spin_unlock_irq(&rbio->bio_list_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
index_rbio_pages(rbio);
|
|
|
|
|
2015-03-03 13:42:48 +01:00
|
|
|
for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
/*
|
|
|
|
* Now we just use bitmap to mark the horizontal stripes in
|
|
|
|
* which we have data when doing parity scrub.
|
|
|
|
*/
|
|
|
|
if (rbio->operation == BTRFS_RBIO_PARITY_SCRUB &&
|
|
|
|
!test_bit(pagenr, rbio->dbitmap))
|
|
|
|
continue;
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/* setup our array of pointers with pages
|
|
|
|
* from each stripe
|
|
|
|
*/
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* if we're rebuilding a read, we have to use
|
|
|
|
* pages from the bio list
|
|
|
|
*/
|
2015-06-19 20:52:50 +02:00
|
|
|
if ((rbio->operation == BTRFS_RBIO_READ_REBUILD ||
|
|
|
|
rbio->operation == BTRFS_RBIO_REBUILD_MISSING) &&
|
2013-01-30 00:40:14 +01:00
|
|
|
(stripe == faila || stripe == failb)) {
|
|
|
|
page = page_in_rbio(rbio, stripe, pagenr, 0);
|
|
|
|
} else {
|
|
|
|
page = rbio_stripe_page(rbio, stripe, pagenr);
|
|
|
|
}
|
|
|
|
pointers[stripe] = kmap(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* all raid6 handling here */
|
2015-01-20 08:11:43 +01:00
|
|
|
if (rbio->bbio->map_type & BTRFS_BLOCK_GROUP_RAID6) {
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* single failure, rebuild from parity raid5
|
|
|
|
* style
|
|
|
|
*/
|
|
|
|
if (failb < 0) {
|
|
|
|
if (faila == rbio->nr_data) {
|
|
|
|
/*
|
|
|
|
* Just the P stripe has failed, without
|
|
|
|
* a bad data or Q stripe.
|
|
|
|
* TODO, we should redo the xor here.
|
|
|
|
*/
|
|
|
|
err = -EIO;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* a single failure in raid6 is rebuilt
|
|
|
|
* in the pstripe code below
|
|
|
|
*/
|
|
|
|
goto pstripe;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure our ps and qs are in order */
|
|
|
|
if (faila > failb) {
|
|
|
|
int tmp = failb;
|
|
|
|
failb = faila;
|
|
|
|
faila = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if the q stripe is failed, do a pstripe reconstruction
|
|
|
|
* from the xors.
|
|
|
|
* If both the q stripe and the P stripe are failed, we're
|
|
|
|
* here due to a crc mismatch and we can't give them the
|
|
|
|
* data they want
|
|
|
|
*/
|
2015-01-20 08:11:33 +01:00
|
|
|
if (rbio->bbio->raid_map[failb] == RAID6_Q_STRIPE) {
|
|
|
|
if (rbio->bbio->raid_map[faila] ==
|
|
|
|
RAID5_P_STRIPE) {
|
2013-01-30 00:40:14 +01:00
|
|
|
err = -EIO;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* otherwise we have one bad data stripe and
|
|
|
|
* a good P stripe. raid5!
|
|
|
|
*/
|
|
|
|
goto pstripe;
|
|
|
|
}
|
|
|
|
|
2015-01-20 08:11:33 +01:00
|
|
|
if (rbio->bbio->raid_map[failb] == RAID5_P_STRIPE) {
|
2014-11-14 09:06:25 +01:00
|
|
|
raid6_datap_recov(rbio->real_stripes,
|
2013-01-30 00:40:14 +01:00
|
|
|
PAGE_SIZE, faila, pointers);
|
|
|
|
} else {
|
2014-11-14 09:06:25 +01:00
|
|
|
raid6_2data_recov(rbio->real_stripes,
|
2013-01-30 00:40:14 +01:00
|
|
|
PAGE_SIZE, faila, failb,
|
|
|
|
pointers);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
/* rebuild from P stripe here (raid5 or raid6) */
|
|
|
|
BUG_ON(failb != -1);
|
|
|
|
pstripe:
|
|
|
|
/* Copy parity block into failed block to start with */
|
|
|
|
memcpy(pointers[faila],
|
|
|
|
pointers[rbio->nr_data],
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
PAGE_SIZE);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/* rearrange the pointer array */
|
|
|
|
p = pointers[faila];
|
|
|
|
for (stripe = faila; stripe < rbio->nr_data - 1; stripe++)
|
|
|
|
pointers[stripe] = pointers[stripe + 1];
|
|
|
|
pointers[rbio->nr_data - 1] = p;
|
|
|
|
|
|
|
|
/* xor in the rest */
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
run_xor(pointers, rbio->nr_data - 1, PAGE_SIZE);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
/* if we're doing this rebuild as part of an rmw, go through
|
|
|
|
* and set all of our private rbio pages in the
|
|
|
|
* failed stripes as uptodate. This way finish_rmw will
|
|
|
|
* know they can be trusted. If this was a read reconstruction,
|
|
|
|
* other endio functions will fiddle the uptodate bits
|
|
|
|
*/
|
2014-11-06 09:14:21 +01:00
|
|
|
if (rbio->operation == BTRFS_RBIO_WRITE) {
|
2015-03-03 13:42:48 +01:00
|
|
|
for (i = 0; i < rbio->stripe_npages; i++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
if (faila != -1) {
|
|
|
|
page = rbio_stripe_page(rbio, faila, i);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
}
|
|
|
|
if (failb != -1) {
|
|
|
|
page = rbio_stripe_page(rbio, failb, i);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* if we're rebuilding a read, we have to use
|
|
|
|
* pages from the bio list
|
|
|
|
*/
|
2015-06-19 20:52:50 +02:00
|
|
|
if ((rbio->operation == BTRFS_RBIO_READ_REBUILD ||
|
|
|
|
rbio->operation == BTRFS_RBIO_REBUILD_MISSING) &&
|
2013-01-30 00:40:14 +01:00
|
|
|
(stripe == faila || stripe == failb)) {
|
|
|
|
page = page_in_rbio(rbio, stripe, pagenr, 0);
|
|
|
|
} else {
|
|
|
|
page = rbio_stripe_page(rbio, stripe, pagenr);
|
|
|
|
}
|
|
|
|
kunmap(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err = 0;
|
|
|
|
cleanup:
|
|
|
|
kfree(pointers);
|
|
|
|
|
|
|
|
cleanup_io:
|
2014-11-06 09:14:21 +01:00
|
|
|
if (rbio->operation == BTRFS_RBIO_READ_REBUILD) {
|
2015-01-20 08:11:34 +01:00
|
|
|
if (err == 0)
|
2013-01-31 20:42:09 +01:00
|
|
|
cache_rbio_pages(rbio);
|
|
|
|
else
|
|
|
|
clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
|
|
|
|
|
2015-09-06 00:14:43 +02:00
|
|
|
rbio_orig_end_io(rbio, err);
|
2015-06-19 20:52:50 +02:00
|
|
|
} else if (rbio->operation == BTRFS_RBIO_REBUILD_MISSING) {
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, err);
|
2013-01-30 00:40:14 +01:00
|
|
|
} else if (err == 0) {
|
|
|
|
rbio->faila = -1;
|
|
|
|
rbio->failb = -1;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
|
|
|
|
if (rbio->operation == BTRFS_RBIO_WRITE)
|
|
|
|
finish_rmw(rbio);
|
|
|
|
else if (rbio->operation == BTRFS_RBIO_PARITY_SCRUB)
|
|
|
|
finish_parity_scrub(rbio, 0);
|
|
|
|
else
|
|
|
|
BUG();
|
2013-01-30 00:40:14 +01:00
|
|
|
} else {
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, err);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called only for stripes we've read from disk to
|
|
|
|
* reconstruct the parity.
|
|
|
|
*/
|
2015-07-20 15:29:37 +02:00
|
|
|
static void raid_recover_end_io(struct bio *bio)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio = bio->bi_private;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we only read stripe pages off the disk, set them
|
|
|
|
* up to date if there were no errors
|
|
|
|
*/
|
2017-06-03 09:38:06 +02:00
|
|
|
if (bio->bi_status)
|
2013-01-30 00:40:14 +01:00
|
|
|
fail_bio_stripe(rbio, bio);
|
|
|
|
else
|
|
|
|
set_bio_pages_uptodate(bio);
|
|
|
|
bio_put(bio);
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
if (!atomic_dec_and_test(&rbio->stripes_pending))
|
2013-01-30 00:40:14 +01:00
|
|
|
return;
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
2013-01-30 00:40:14 +01:00
|
|
|
else
|
|
|
|
__raid_recover_end_io(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* reads everything we need off the disk to reconstruct
|
|
|
|
* the parity. endio handlers trigger final reconstruction
|
|
|
|
* when the IO is done.
|
|
|
|
*
|
|
|
|
* This is used both for reads from the higher layers and for
|
|
|
|
* parity construction required to finish a rmw cycle.
|
|
|
|
*/
|
|
|
|
static int __raid56_parity_recover(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int bios_to_read = 0;
|
|
|
|
struct bio_list bio_list;
|
|
|
|
int ret;
|
|
|
|
int pagenr;
|
|
|
|
int stripe;
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
bio_list_init(&bio_list);
|
|
|
|
|
|
|
|
ret = alloc_rbio_pages(rbio);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->error, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
/*
|
2013-01-31 20:42:09 +01:00
|
|
|
* read everything that hasn't failed. Thanks to the
|
|
|
|
* stripe cache, it is possible that some or all of these
|
|
|
|
* pages are going to be uptodate.
|
2013-01-30 00:40:14 +01:00
|
|
|
*/
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
|
2014-06-24 09:39:16 +02:00
|
|
|
if (rbio->faila == stripe || rbio->failb == stripe) {
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_inc(&rbio->error);
|
2013-01-30 00:40:14 +01:00
|
|
|
continue;
|
2014-06-24 09:39:16 +02:00
|
|
|
}
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2015-03-03 13:42:48 +01:00
|
|
|
for (pagenr = 0; pagenr < rbio->stripe_npages; pagenr++) {
|
2013-01-30 00:40:14 +01:00
|
|
|
struct page *p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the rmw code may have already read this
|
|
|
|
* page in
|
|
|
|
*/
|
|
|
|
p = rbio_stripe_page(rbio, stripe, pagenr);
|
|
|
|
if (PageUptodate(p))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = rbio_add_io_page(rbio, &bio_list,
|
|
|
|
rbio_stripe_page(rbio, stripe, pagenr),
|
|
|
|
stripe, pagenr, rbio->stripe_len);
|
|
|
|
if (ret < 0)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bios_to_read = bio_list_size(&bio_list);
|
|
|
|
if (!bios_to_read) {
|
|
|
|
/*
|
|
|
|
* we might have no bios to read just because the pages
|
|
|
|
* were up to date, or we might have no bios to read because
|
|
|
|
* the devices were gone.
|
|
|
|
*/
|
2014-10-15 05:18:44 +02:00
|
|
|
if (atomic_read(&rbio->error) <= rbio->bbio->max_errors) {
|
2013-01-30 00:40:14 +01:00
|
|
|
__raid_recover_end_io(rbio);
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the bbio may be freed once we submit the last bio. Make sure
|
|
|
|
* not to touch it after that
|
|
|
|
*/
|
2014-10-15 05:18:44 +02:00
|
|
|
atomic_set(&rbio->stripes_pending, bios_to_read);
|
2013-01-30 00:40:14 +01:00
|
|
|
while (1) {
|
|
|
|
bio = bio_list_pop(&bio_list);
|
|
|
|
if (!bio)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bio->bi_private = rbio;
|
|
|
|
bio->bi_end_io = raid_recover_end_io;
|
2016-06-05 21:31:52 +02:00
|
|
|
bio_set_op_attrs(bio, REQ_OP_READ, 0);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_wq_end_io(rbio->fs_info, bio, BTRFS_WQ_ENDIO_RAID56);
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2016-06-05 21:31:41 +02:00
|
|
|
submit_bio(bio);
|
2013-01-30 00:40:14 +01:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
2015-06-19 20:52:50 +02:00
|
|
|
if (rbio->operation == BTRFS_RBIO_READ_REBUILD ||
|
|
|
|
rbio->operation == BTRFS_RBIO_REBUILD_MISSING)
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
2013-01-30 00:40:14 +01:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the main entry point for reads from the higher layers. This
|
|
|
|
* is really only called when the normal read path had a failure,
|
|
|
|
* so we assume the bio they send down corresponds to a failed part
|
|
|
|
* of the drive.
|
|
|
|
*/
|
2016-06-23 00:54:24 +02:00
|
|
|
int raid56_parity_recover(struct btrfs_fs_info *fs_info, struct bio *bio,
|
2015-01-20 08:11:33 +01:00
|
|
|
struct btrfs_bio *bbio, u64 stripe_len,
|
|
|
|
int mirror_num, int generic_io)
|
2013-01-30 00:40:14 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
int ret;
|
|
|
|
|
2017-03-29 19:54:26 +02:00
|
|
|
if (generic_io) {
|
|
|
|
ASSERT(bbio->mirror_num == mirror_num);
|
|
|
|
btrfs_io_bio(bio)->mirror_num = mirror_num;
|
|
|
|
}
|
|
|
|
|
2016-06-23 00:54:24 +02:00
|
|
|
rbio = alloc_rbio(fs_info, bbio, stripe_len);
|
2014-10-23 08:42:50 +02:00
|
|
|
if (IS_ERR(rbio)) {
|
2015-01-20 08:11:34 +01:00
|
|
|
if (generic_io)
|
|
|
|
btrfs_put_bbio(bbio);
|
2013-01-30 00:40:14 +01:00
|
|
|
return PTR_ERR(rbio);
|
2014-10-23 08:42:50 +02:00
|
|
|
}
|
2013-01-30 00:40:14 +01:00
|
|
|
|
2014-11-06 09:14:21 +01:00
|
|
|
rbio->operation = BTRFS_RBIO_READ_REBUILD;
|
2013-01-30 00:40:14 +01:00
|
|
|
bio_list_add(&rbio->bio_list, bio);
|
2013-10-12 00:44:27 +02:00
|
|
|
rbio->bio_list_bytes = bio->bi_iter.bi_size;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
rbio->faila = find_logical_bio_stripe(rbio, bio);
|
|
|
|
if (rbio->faila == -1) {
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_warn(fs_info,
|
2016-07-29 19:57:55 +02:00
|
|
|
"%s could not find the bad stripe in raid56 so that we cannot recover any more (bio has logical %llu len %llu, bbio has map_type %llu)",
|
|
|
|
__func__, (u64)bio->bi_iter.bi_sector << 9,
|
|
|
|
(u64)bio->bi_iter.bi_size, bbio->map_type);
|
2015-01-20 08:11:34 +01:00
|
|
|
if (generic_io)
|
|
|
|
btrfs_put_bbio(bbio);
|
2013-01-30 00:40:14 +01:00
|
|
|
kfree(rbio);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2014-11-25 09:39:28 +01:00
|
|
|
if (generic_io) {
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_counter_inc_noblocked(fs_info);
|
2014-11-25 09:39:28 +01:00
|
|
|
rbio->generic_bio_cnt = 1;
|
|
|
|
} else {
|
2015-01-20 08:11:34 +01:00
|
|
|
btrfs_get_bbio(bbio);
|
2014-11-25 09:39:28 +01:00
|
|
|
}
|
|
|
|
|
2013-01-30 00:40:14 +01:00
|
|
|
/*
|
|
|
|
* reconstruct from the q stripe if they are
|
|
|
|
* asking for mirror 3
|
|
|
|
*/
|
|
|
|
if (mirror_num == 3)
|
2014-11-14 09:06:25 +01:00
|
|
|
rbio->failb = rbio->real_stripes - 2;
|
2013-01-30 00:40:14 +01:00
|
|
|
|
|
|
|
ret = lock_stripe_add(rbio);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* __raid56_parity_recover will end the bio with
|
|
|
|
* any errors it hits. We don't want to return
|
|
|
|
* its error value up the stack because our caller
|
|
|
|
* will end up calling bio_endio with any nonzero
|
|
|
|
* return
|
|
|
|
*/
|
|
|
|
if (ret == 0)
|
|
|
|
__raid56_parity_recover(rbio);
|
|
|
|
/*
|
|
|
|
* our rbio has been added to the list of
|
|
|
|
* rbios that will be handled after the
|
|
|
|
* currently lock owner is done
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rmw_work(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
|
|
|
|
rbio = container_of(work, struct btrfs_raid_bio, work);
|
|
|
|
raid56_rmw_stripe(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void read_rebuild_work(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
|
|
|
|
rbio = container_of(work, struct btrfs_raid_bio, work);
|
|
|
|
__raid56_parity_recover(rbio);
|
|
|
|
}
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The following code is used to scrub/replace the parity stripe
|
|
|
|
*
|
btrfs: Wait for in-flight bios before freeing target device for raid56
When raid56 dev-replace is cancelled by running scrub, we will free
target device without waiting for in-flight bios, causing the following
NULL pointer deference or general protection failure.
BUG: unable to handle kernel NULL pointer dereference at 00000000000005e0
IP: generic_make_request_checks+0x4d/0x610
CPU: 1 PID: 11676 Comm: kworker/u4:14 Tainted: G O 4.11.0-rc2 #72
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.2-20170228_101828-anatol 04/01/2014
Workqueue: btrfs-endio-raid56 btrfs_endio_raid56_helper [btrfs]
task: ffff88002875b4c0 task.stack: ffffc90001334000
RIP: 0010:generic_make_request_checks+0x4d/0x610
Call Trace:
? generic_make_request+0xc7/0x360
generic_make_request+0x24/0x360
? generic_make_request+0xc7/0x360
submit_bio+0x64/0x120
? page_in_rbio+0x4d/0x80 [btrfs]
? rbio_orig_end_io+0x80/0x80 [btrfs]
finish_rmw+0x3f4/0x540 [btrfs]
validate_rbio_for_rmw+0x36/0x40 [btrfs]
raid_rmw_end_io+0x7a/0x90 [btrfs]
bio_endio+0x56/0x60
end_workqueue_fn+0x3c/0x40 [btrfs]
btrfs_scrubparity_helper+0xef/0x620 [btrfs]
btrfs_endio_raid56_helper+0xe/0x10 [btrfs]
process_one_work+0x2af/0x720
? process_one_work+0x22b/0x720
worker_thread+0x4b/0x4f0
kthread+0x10f/0x150
? process_one_work+0x720/0x720
? kthread_create_on_node+0x40/0x40
ret_from_fork+0x2e/0x40
RIP: generic_make_request_checks+0x4d/0x610 RSP: ffffc90001337bb8
In btrfs_dev_replace_finishing(), we will call
btrfs_rm_dev_replace_blocked() to wait bios before destroying the target
device when scrub is finished normally.
However when dev-replace is aborted, either due to error or cancelled by
scrub, we didn't wait for bios, this can lead to use-after-free if there
are bios holding the target device.
Furthermore, for raid56 scrub, at least 2 places are calling
btrfs_map_sblock() without protection of bio_counter, leading to the
problem.
This patch fixes the problem:
1) Wait for bio_counter before freeing target device when canceling
replace
2) When calling btrfs_map_sblock() for raid56, use bio_counter to
protect the call.
Cc: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-03-29 03:33:21 +02:00
|
|
|
* Caller must have already increased bio_counter for getting @bbio.
|
|
|
|
*
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
* Note: We need make sure all the pages that add into the scrub/replace
|
|
|
|
* raid bio are correct and not be changed during the scrub/replace. That
|
|
|
|
* is those pages just hold metadata or file data with checksum.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct btrfs_raid_bio *
|
2016-06-23 00:54:24 +02:00
|
|
|
raid56_parity_alloc_scrub_rbio(struct btrfs_fs_info *fs_info, struct bio *bio,
|
2015-01-20 08:11:33 +01:00
|
|
|
struct btrfs_bio *bbio, u64 stripe_len,
|
|
|
|
struct btrfs_device *scrub_dev,
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
unsigned long *dbitmap, int stripe_nsectors)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
int i;
|
|
|
|
|
2016-06-23 00:54:24 +02:00
|
|
|
rbio = alloc_rbio(fs_info, bbio, stripe_len);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
if (IS_ERR(rbio))
|
|
|
|
return NULL;
|
|
|
|
bio_list_add(&rbio->bio_list, bio);
|
|
|
|
/*
|
|
|
|
* This is a special bio which is used to hold the completion handler
|
|
|
|
* and make the scrub rbio is similar to the other types
|
|
|
|
*/
|
|
|
|
ASSERT(!bio->bi_iter.bi_size);
|
|
|
|
rbio->operation = BTRFS_RBIO_PARITY_SCRUB;
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
for (i = 0; i < rbio->real_stripes; i++) {
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
if (bbio->stripes[i].dev == scrub_dev) {
|
|
|
|
rbio->scrubp = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now we just support the sectorsize equals to page size */
|
2016-06-23 00:54:23 +02:00
|
|
|
ASSERT(fs_info->sectorsize == PAGE_SIZE);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
ASSERT(rbio->stripe_npages == stripe_nsectors);
|
|
|
|
bitmap_copy(rbio->dbitmap, dbitmap, stripe_nsectors);
|
|
|
|
|
btrfs: Wait for in-flight bios before freeing target device for raid56
When raid56 dev-replace is cancelled by running scrub, we will free
target device without waiting for in-flight bios, causing the following
NULL pointer deference or general protection failure.
BUG: unable to handle kernel NULL pointer dereference at 00000000000005e0
IP: generic_make_request_checks+0x4d/0x610
CPU: 1 PID: 11676 Comm: kworker/u4:14 Tainted: G O 4.11.0-rc2 #72
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.2-20170228_101828-anatol 04/01/2014
Workqueue: btrfs-endio-raid56 btrfs_endio_raid56_helper [btrfs]
task: ffff88002875b4c0 task.stack: ffffc90001334000
RIP: 0010:generic_make_request_checks+0x4d/0x610
Call Trace:
? generic_make_request+0xc7/0x360
generic_make_request+0x24/0x360
? generic_make_request+0xc7/0x360
submit_bio+0x64/0x120
? page_in_rbio+0x4d/0x80 [btrfs]
? rbio_orig_end_io+0x80/0x80 [btrfs]
finish_rmw+0x3f4/0x540 [btrfs]
validate_rbio_for_rmw+0x36/0x40 [btrfs]
raid_rmw_end_io+0x7a/0x90 [btrfs]
bio_endio+0x56/0x60
end_workqueue_fn+0x3c/0x40 [btrfs]
btrfs_scrubparity_helper+0xef/0x620 [btrfs]
btrfs_endio_raid56_helper+0xe/0x10 [btrfs]
process_one_work+0x2af/0x720
? process_one_work+0x22b/0x720
worker_thread+0x4b/0x4f0
kthread+0x10f/0x150
? process_one_work+0x720/0x720
? kthread_create_on_node+0x40/0x40
ret_from_fork+0x2e/0x40
RIP: generic_make_request_checks+0x4d/0x610 RSP: ffffc90001337bb8
In btrfs_dev_replace_finishing(), we will call
btrfs_rm_dev_replace_blocked() to wait bios before destroying the target
device when scrub is finished normally.
However when dev-replace is aborted, either due to error or cancelled by
scrub, we didn't wait for bios, this can lead to use-after-free if there
are bios holding the target device.
Furthermore, for raid56 scrub, at least 2 places are calling
btrfs_map_sblock() without protection of bio_counter, leading to the
problem.
This patch fixes the problem:
1) Wait for bio_counter before freeing target device when canceling
replace
2) When calling btrfs_map_sblock() for raid56, use bio_counter to
protect the call.
Cc: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-03-29 03:33:21 +02:00
|
|
|
/*
|
|
|
|
* We have already increased bio_counter when getting bbio, record it
|
|
|
|
* so we can free it at rbio_orig_end_io().
|
|
|
|
*/
|
|
|
|
rbio->generic_bio_cnt = 1;
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
return rbio;
|
|
|
|
}
|
|
|
|
|
2015-06-19 20:52:50 +02:00
|
|
|
/* Used for both parity scrub and missing. */
|
|
|
|
void raid56_add_scrub_pages(struct btrfs_raid_bio *rbio, struct page *page,
|
|
|
|
u64 logical)
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
{
|
|
|
|
int stripe_offset;
|
|
|
|
int index;
|
|
|
|
|
2015-01-20 08:11:33 +01:00
|
|
|
ASSERT(logical >= rbio->bbio->raid_map[0]);
|
|
|
|
ASSERT(logical + PAGE_SIZE <= rbio->bbio->raid_map[0] +
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
rbio->stripe_len * rbio->nr_data);
|
2015-01-20 08:11:33 +01:00
|
|
|
stripe_offset = (int)(logical - rbio->bbio->raid_map[0]);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
index = stripe_offset >> PAGE_SHIFT;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
rbio->bio_pages[index] = page;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We just scrub the parity that we have correct data on the same horizontal,
|
|
|
|
* so we needn't allocate all pages for all the stripes.
|
|
|
|
*/
|
|
|
|
static int alloc_rbio_essential_pages(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int bit;
|
|
|
|
int index;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
for_each_set_bit(bit, rbio->dbitmap, rbio->stripe_npages) {
|
2014-11-14 09:06:25 +01:00
|
|
|
for (i = 0; i < rbio->real_stripes; i++) {
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
index = i * rbio->stripe_npages + bit;
|
|
|
|
if (rbio->stripe_pages[index])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
|
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
rbio->stripe_pages[index] = page;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static noinline void finish_parity_scrub(struct btrfs_raid_bio *rbio,
|
|
|
|
int need_check)
|
|
|
|
{
|
2014-11-14 10:45:42 +01:00
|
|
|
struct btrfs_bio *bbio = rbio->bbio;
|
2014-11-14 09:06:25 +01:00
|
|
|
void *pointers[rbio->real_stripes];
|
2014-11-14 10:45:42 +01:00
|
|
|
DECLARE_BITMAP(pbitmap, rbio->stripe_npages);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
int nr_data = rbio->nr_data;
|
|
|
|
int stripe;
|
|
|
|
int pagenr;
|
|
|
|
int p_stripe = -1;
|
|
|
|
int q_stripe = -1;
|
|
|
|
struct page *p_page = NULL;
|
|
|
|
struct page *q_page = NULL;
|
|
|
|
struct bio_list bio_list;
|
|
|
|
struct bio *bio;
|
2014-11-14 10:45:42 +01:00
|
|
|
int is_replace = 0;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
bio_list_init(&bio_list);
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
if (rbio->real_stripes - rbio->nr_data == 1) {
|
|
|
|
p_stripe = rbio->real_stripes - 1;
|
|
|
|
} else if (rbio->real_stripes - rbio->nr_data == 2) {
|
|
|
|
p_stripe = rbio->real_stripes - 2;
|
|
|
|
q_stripe = rbio->real_stripes - 1;
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
} else {
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2014-11-14 10:45:42 +01:00
|
|
|
if (bbio->num_tgtdevs && bbio->tgtdev_map[rbio->scrubp]) {
|
|
|
|
is_replace = 1;
|
|
|
|
bitmap_copy(pbitmap, rbio->dbitmap, rbio->stripe_npages);
|
|
|
|
}
|
|
|
|
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
/*
|
|
|
|
* Because the higher layers(scrubber) are unlikely to
|
|
|
|
* use this area of the disk again soon, so don't cache
|
|
|
|
* it.
|
|
|
|
*/
|
|
|
|
clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
|
|
|
|
|
|
|
|
if (!need_check)
|
|
|
|
goto writeback;
|
|
|
|
|
|
|
|
p_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
|
|
|
|
if (!p_page)
|
|
|
|
goto cleanup;
|
|
|
|
SetPageUptodate(p_page);
|
|
|
|
|
|
|
|
if (q_stripe != -1) {
|
|
|
|
q_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
|
|
|
|
if (!q_page) {
|
|
|
|
__free_page(p_page);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
SetPageUptodate(q_page);
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_set(&rbio->error, 0);
|
|
|
|
|
|
|
|
for_each_set_bit(pagenr, rbio->dbitmap, rbio->stripe_npages) {
|
|
|
|
struct page *p;
|
|
|
|
void *parity;
|
|
|
|
/* first collect one page from each data stripe */
|
|
|
|
for (stripe = 0; stripe < nr_data; stripe++) {
|
|
|
|
p = page_in_rbio(rbio, stripe, pagenr, 0);
|
|
|
|
pointers[stripe] = kmap(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* then add the parity stripe */
|
|
|
|
pointers[stripe++] = kmap(p_page);
|
|
|
|
|
|
|
|
if (q_stripe != -1) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* raid6, add the qstripe and call the
|
|
|
|
* library function to fill in our p/q
|
|
|
|
*/
|
|
|
|
pointers[stripe++] = kmap(q_page);
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
raid6_call.gen_syndrome(rbio->real_stripes, PAGE_SIZE,
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
pointers);
|
|
|
|
} else {
|
|
|
|
/* raid5 */
|
|
|
|
memcpy(pointers[nr_data], pointers[0], PAGE_SIZE);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
run_xor(pointers + 1, nr_data - 1, PAGE_SIZE);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
}
|
|
|
|
|
2016-05-20 03:18:45 +02:00
|
|
|
/* Check scrubbing parity and repair it */
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
p = rbio_stripe_page(rbio, rbio->scrubp, pagenr);
|
|
|
|
parity = kmap(p);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 14:29:47 +02:00
|
|
|
if (memcmp(parity, pointers[rbio->scrubp], PAGE_SIZE))
|
|
|
|
memcpy(parity, pointers[rbio->scrubp], PAGE_SIZE);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
else
|
|
|
|
/* Parity is right, needn't writeback */
|
|
|
|
bitmap_clear(rbio->dbitmap, pagenr, 1);
|
|
|
|
kunmap(p);
|
|
|
|
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++)
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
kunmap(page_in_rbio(rbio, stripe, pagenr, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
__free_page(p_page);
|
|
|
|
if (q_page)
|
|
|
|
__free_page(q_page);
|
|
|
|
|
|
|
|
writeback:
|
|
|
|
/*
|
|
|
|
* time to start writing. Make bios for everything from the
|
|
|
|
* higher layers (the bio_list in our rbio) and our p/q. Ignore
|
|
|
|
* everything else.
|
|
|
|
*/
|
|
|
|
for_each_set_bit(pagenr, rbio->dbitmap, rbio->stripe_npages) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = rbio_stripe_page(rbio, rbio->scrubp, pagenr);
|
|
|
|
ret = rbio_add_io_page(rbio, &bio_list,
|
|
|
|
page, rbio->scrubp, pagenr, rbio->stripe_len);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2014-11-14 10:45:42 +01:00
|
|
|
if (!is_replace)
|
|
|
|
goto submit_write;
|
|
|
|
|
|
|
|
for_each_set_bit(pagenr, pbitmap, rbio->stripe_npages) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
page = rbio_stripe_page(rbio, rbio->scrubp, pagenr);
|
|
|
|
ret = rbio_add_io_page(rbio, &bio_list, page,
|
|
|
|
bbio->tgtdev_map[rbio->scrubp],
|
|
|
|
pagenr, rbio->stripe_len);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
submit_write:
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
nr_data = bio_list_size(&bio_list);
|
|
|
|
if (!nr_data) {
|
|
|
|
/* Every parity is right */
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, 0);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_set(&rbio->stripes_pending, nr_data);
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
bio = bio_list_pop(&bio_list);
|
|
|
|
if (!bio)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bio->bi_private = rbio;
|
2016-01-12 10:52:13 +01:00
|
|
|
bio->bi_end_io = raid_write_end_io;
|
2016-06-05 21:31:52 +02:00
|
|
|
bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
|
2016-06-05 21:31:41 +02:00
|
|
|
|
|
|
|
submit_bio(bio);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
cleanup:
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_data_stripe(struct btrfs_raid_bio *rbio, int stripe)
|
|
|
|
{
|
|
|
|
if (stripe >= 0 && stripe < rbio->nr_data)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* While we're doing the parity check and repair, we could have errors
|
|
|
|
* in reading pages off the disk. This checks for errors and if we're
|
|
|
|
* not able to read the page it'll trigger parity reconstruction. The
|
|
|
|
* parity scrub will be finished after we've reconstructed the failed
|
|
|
|
* stripes
|
|
|
|
*/
|
|
|
|
static void validate_rbio_for_parity_scrub(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (rbio->faila >= 0 || rbio->failb >= 0) {
|
|
|
|
int dfail = 0, failp = -1;
|
|
|
|
|
|
|
|
if (is_data_stripe(rbio, rbio->faila))
|
|
|
|
dfail++;
|
|
|
|
else if (is_parity_stripe(rbio->faila))
|
|
|
|
failp = rbio->faila;
|
|
|
|
|
|
|
|
if (is_data_stripe(rbio, rbio->failb))
|
|
|
|
dfail++;
|
|
|
|
else if (is_parity_stripe(rbio->failb))
|
|
|
|
failp = rbio->failb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because we can not use a scrubbing parity to repair
|
|
|
|
* the data, so the capability of the repair is declined.
|
|
|
|
* (In the case of RAID5, we can not repair anything)
|
|
|
|
*/
|
|
|
|
if (dfail > rbio->bbio->max_errors - 1)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If all data is good, only parity is correctly, just
|
|
|
|
* repair the parity.
|
|
|
|
*/
|
|
|
|
if (dfail == 0) {
|
|
|
|
finish_parity_scrub(rbio, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Here means we got one corrupted data stripe and one
|
|
|
|
* corrupted parity on RAID6, if the corrupted parity
|
2016-05-20 03:18:45 +02:00
|
|
|
* is scrubbing parity, luckily, use the other one to repair
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
* the data, or we can not repair the data stripe.
|
|
|
|
*/
|
|
|
|
if (failp != rbio->scrubp)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
__raid_recover_end_io(rbio);
|
|
|
|
} else {
|
|
|
|
finish_parity_scrub(rbio, 1);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
cleanup:
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* end io for the read phase of the rmw cycle. All the bios here are physical
|
|
|
|
* stripe bios we've read from the disk so we can recalculate the parity of the
|
|
|
|
* stripe.
|
|
|
|
*
|
|
|
|
* This will usually kick off finish_rmw once all the bios are read in, but it
|
|
|
|
* may trigger parity reconstruction if we had any errors along the way
|
|
|
|
*/
|
2015-07-20 15:29:37 +02:00
|
|
|
static void raid56_parity_scrub_end_io(struct bio *bio)
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio = bio->bi_private;
|
|
|
|
|
2017-06-03 09:38:06 +02:00
|
|
|
if (bio->bi_status)
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
fail_bio_stripe(rbio, bio);
|
|
|
|
else
|
|
|
|
set_bio_pages_uptodate(bio);
|
|
|
|
|
|
|
|
bio_put(bio);
|
|
|
|
|
|
|
|
if (!atomic_dec_and_test(&rbio->stripes_pending))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this will normally call finish_rmw to start our write
|
|
|
|
* but if there are any failed stripes we'll reconstruct
|
|
|
|
* from parity first
|
|
|
|
*/
|
|
|
|
validate_rbio_for_parity_scrub(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void raid56_parity_scrub_stripe(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
int bios_to_read = 0;
|
|
|
|
struct bio_list bio_list;
|
|
|
|
int ret;
|
|
|
|
int pagenr;
|
|
|
|
int stripe;
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
ret = alloc_rbio_essential_pages(rbio);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
bio_list_init(&bio_list);
|
|
|
|
|
|
|
|
atomic_set(&rbio->error, 0);
|
|
|
|
/*
|
|
|
|
* build a list of bios to read all the missing parts of this
|
|
|
|
* stripe
|
|
|
|
*/
|
2014-11-14 09:06:25 +01:00
|
|
|
for (stripe = 0; stripe < rbio->real_stripes; stripe++) {
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
for_each_set_bit(pagenr, rbio->dbitmap, rbio->stripe_npages) {
|
|
|
|
struct page *page;
|
|
|
|
/*
|
|
|
|
* we want to find all the pages missing from
|
|
|
|
* the rbio and read them from the disk. If
|
|
|
|
* page_in_rbio finds a page in the bio list
|
|
|
|
* we don't need to read it off the stripe.
|
|
|
|
*/
|
|
|
|
page = page_in_rbio(rbio, stripe, pagenr, 1);
|
|
|
|
if (page)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
page = rbio_stripe_page(rbio, stripe, pagenr);
|
|
|
|
/*
|
|
|
|
* the bio cache may have handed us an uptodate
|
|
|
|
* page. If so, be happy and use it
|
|
|
|
*/
|
|
|
|
if (PageUptodate(page))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = rbio_add_io_page(rbio, &bio_list, page,
|
|
|
|
stripe, pagenr, rbio->stripe_len);
|
|
|
|
if (ret)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bios_to_read = bio_list_size(&bio_list);
|
|
|
|
if (!bios_to_read) {
|
|
|
|
/*
|
|
|
|
* this can happen if others have merged with
|
|
|
|
* us, it means there is nothing left to read.
|
|
|
|
* But if there are missing devices it may not be
|
|
|
|
* safe to do the full stripe write yet.
|
|
|
|
*/
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the bbio may be freed once we submit the last bio. Make sure
|
|
|
|
* not to touch it after that
|
|
|
|
*/
|
|
|
|
atomic_set(&rbio->stripes_pending, bios_to_read);
|
|
|
|
while (1) {
|
|
|
|
bio = bio_list_pop(&bio_list);
|
|
|
|
if (!bio)
|
|
|
|
break;
|
|
|
|
|
|
|
|
bio->bi_private = rbio;
|
|
|
|
bio->bi_end_io = raid56_parity_scrub_end_io;
|
2016-06-05 21:31:52 +02:00
|
|
|
bio_set_op_attrs(bio, REQ_OP_READ, 0);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_bio_wq_end_io(rbio->fs_info, bio, BTRFS_WQ_ENDIO_RAID56);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
|
2016-06-05 21:31:41 +02:00
|
|
|
submit_bio(bio);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
}
|
|
|
|
/* the actual write will happen once the reads are done */
|
|
|
|
return;
|
|
|
|
|
|
|
|
cleanup:
|
2015-07-20 15:29:37 +02:00
|
|
|
rbio_orig_end_io(rbio, -EIO);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
finish:
|
|
|
|
validate_rbio_for_parity_scrub(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scrub_parity_work(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
|
|
|
|
rbio = container_of(work, struct btrfs_raid_bio, work);
|
|
|
|
raid56_parity_scrub_stripe(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void async_scrub_parity(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
btrfs_init_work(&rbio->work, btrfs_rmw_helper,
|
|
|
|
scrub_parity_work, NULL, NULL);
|
|
|
|
|
2016-06-23 00:54:23 +02:00
|
|
|
btrfs_queue_work(rbio->fs_info->rmw_workers, &rbio->work);
|
Btrfs, raid56: support parity scrub on raid56
The implementation is:
- Read and check all the data with checksum in the same stripe.
All the data which has checksum is COW data, and we are sure
that it is not changed though we don't lock the stripe. because
the space of that data just can be reclaimed after the current
transction is committed, and then the fs can use it to store the
other data, but when doing scrub, we hold the current transaction,
that is that data can not be recovered, it is safe that read and check
it out of the stripe lock.
- Lock the stripe
- Read out all the data without checksum and parity
The data without checksum and the parity may be changed if we don't
lock the stripe, so we need read it in the stripe lock context.
- Check the parity
- Re-calculate the new parity and write back it if the old parity
is not right
- Unlock the stripe
If we can not read out the data or the data we read is corrupted,
we will try to repair it. If the repair fails. we will mark the
horizontal sub-stripe(pages on the same horizontal) as corrupted
sub-stripe, and we will skip the parity check and repair of that
horizontal sub-stripe.
And in order to skip the horizontal sub-stripe that has no data, we
introduce a bitmap. If there is some data on the horizontal sub-stripe,
we will the relative bit to 1, and when we check and repair the
parity, we will skip those horizontal sub-stripes that the relative
bits is 0.
Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
2014-11-06 10:20:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void raid56_parity_submit_scrub_rbio(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
if (!lock_stripe_add(rbio))
|
|
|
|
async_scrub_parity(rbio);
|
|
|
|
}
|
2015-06-19 20:52:50 +02:00
|
|
|
|
|
|
|
/* The following code is used for dev replace of a missing RAID 5/6 device. */
|
|
|
|
|
|
|
|
struct btrfs_raid_bio *
|
2016-06-23 00:54:24 +02:00
|
|
|
raid56_alloc_missing_rbio(struct btrfs_fs_info *fs_info, struct bio *bio,
|
2015-06-19 20:52:50 +02:00
|
|
|
struct btrfs_bio *bbio, u64 length)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
|
2016-06-23 00:54:24 +02:00
|
|
|
rbio = alloc_rbio(fs_info, bbio, length);
|
2015-06-19 20:52:50 +02:00
|
|
|
if (IS_ERR(rbio))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
rbio->operation = BTRFS_RBIO_REBUILD_MISSING;
|
|
|
|
bio_list_add(&rbio->bio_list, bio);
|
|
|
|
/*
|
|
|
|
* This is a special bio which is used to hold the completion handler
|
|
|
|
* and make the scrub rbio is similar to the other types
|
|
|
|
*/
|
|
|
|
ASSERT(!bio->bi_iter.bi_size);
|
|
|
|
|
|
|
|
rbio->faila = find_logical_bio_stripe(rbio, bio);
|
|
|
|
if (rbio->faila == -1) {
|
|
|
|
BUG();
|
|
|
|
kfree(rbio);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
btrfs: Wait for in-flight bios before freeing target device for raid56
When raid56 dev-replace is cancelled by running scrub, we will free
target device without waiting for in-flight bios, causing the following
NULL pointer deference or general protection failure.
BUG: unable to handle kernel NULL pointer dereference at 00000000000005e0
IP: generic_make_request_checks+0x4d/0x610
CPU: 1 PID: 11676 Comm: kworker/u4:14 Tainted: G O 4.11.0-rc2 #72
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.10.2-20170228_101828-anatol 04/01/2014
Workqueue: btrfs-endio-raid56 btrfs_endio_raid56_helper [btrfs]
task: ffff88002875b4c0 task.stack: ffffc90001334000
RIP: 0010:generic_make_request_checks+0x4d/0x610
Call Trace:
? generic_make_request+0xc7/0x360
generic_make_request+0x24/0x360
? generic_make_request+0xc7/0x360
submit_bio+0x64/0x120
? page_in_rbio+0x4d/0x80 [btrfs]
? rbio_orig_end_io+0x80/0x80 [btrfs]
finish_rmw+0x3f4/0x540 [btrfs]
validate_rbio_for_rmw+0x36/0x40 [btrfs]
raid_rmw_end_io+0x7a/0x90 [btrfs]
bio_endio+0x56/0x60
end_workqueue_fn+0x3c/0x40 [btrfs]
btrfs_scrubparity_helper+0xef/0x620 [btrfs]
btrfs_endio_raid56_helper+0xe/0x10 [btrfs]
process_one_work+0x2af/0x720
? process_one_work+0x22b/0x720
worker_thread+0x4b/0x4f0
kthread+0x10f/0x150
? process_one_work+0x720/0x720
? kthread_create_on_node+0x40/0x40
ret_from_fork+0x2e/0x40
RIP: generic_make_request_checks+0x4d/0x610 RSP: ffffc90001337bb8
In btrfs_dev_replace_finishing(), we will call
btrfs_rm_dev_replace_blocked() to wait bios before destroying the target
device when scrub is finished normally.
However when dev-replace is aborted, either due to error or cancelled by
scrub, we didn't wait for bios, this can lead to use-after-free if there
are bios holding the target device.
Furthermore, for raid56 scrub, at least 2 places are calling
btrfs_map_sblock() without protection of bio_counter, leading to the
problem.
This patch fixes the problem:
1) Wait for bio_counter before freeing target device when canceling
replace
2) When calling btrfs_map_sblock() for raid56, use bio_counter to
protect the call.
Cc: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Reviewed-by: Liu Bo <bo.li.liu@oracle.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2017-03-29 03:33:21 +02:00
|
|
|
/*
|
|
|
|
* When we get bbio, we have already increased bio_counter, record it
|
|
|
|
* so we can free it at rbio_orig_end_io()
|
|
|
|
*/
|
|
|
|
rbio->generic_bio_cnt = 1;
|
|
|
|
|
2015-06-19 20:52:50 +02:00
|
|
|
return rbio;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void missing_raid56_work(struct btrfs_work *work)
|
|
|
|
{
|
|
|
|
struct btrfs_raid_bio *rbio;
|
|
|
|
|
|
|
|
rbio = container_of(work, struct btrfs_raid_bio, work);
|
|
|
|
__raid56_parity_recover(rbio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void async_missing_raid56(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
btrfs_init_work(&rbio->work, btrfs_rmw_helper,
|
|
|
|
missing_raid56_work, NULL, NULL);
|
|
|
|
|
|
|
|
btrfs_queue_work(rbio->fs_info->rmw_workers, &rbio->work);
|
|
|
|
}
|
|
|
|
|
|
|
|
void raid56_submit_missing_rbio(struct btrfs_raid_bio *rbio)
|
|
|
|
{
|
|
|
|
if (!lock_stripe_add(rbio))
|
|
|
|
async_missing_raid56(rbio);
|
|
|
|
}
|