Bcache fixes - please apply
Subsystems (3)
PATCH 1/1 Bcache fixes - please apply
Linus, please apply the following patch series. There's fixes for _three_ different data corruption bugs, all of which were found by users hitting them in the wild.
The first one isn't bcache specific - in 3.11 bcache was switched to the bio_copy_data in fs/bio.c, and that's when the bug in that code was discovered, but it's also used by raid1 and pktcdvd. (That was my code too, so the bug's doubly embarassing given that it was or should've been just a cut and paste from bcache code. Dunno what happened there).
Most of these (all the non data corruption bugs, actually) were ready before the merge window and have been sitting in Jens' tree, but I don't know what's been up with him lately...
PATCH 1/11 block: Fix bio_copy_data()
The memcpy() in bio_copy_data() was using the wrong offset vars, leading to data corruption in weird unusual setups.
--- fs/bio.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/bio.c +2 -2
@@ -917,8 +917,8 @@ void bio_copy_data(struct bio *dst, struct bio *src) src_p =kmap_atomic (src_bv->bv_page); dst_p =kmap_atomic (dst_bv->bv_page); -memcpy (dst_p + dst_bv->bv_offset, - src_p + src_bv->bv_offset, +memcpy (dst_p + dst_offset, + src_p + src_offset, bytes);kunmap_atomic (dst_p);
Signature · 1 line
1.8.4.rc3
PATCH 2/11 bcache: Fix a dumb journal discard bug
In reply to Kent OverstreetThat switch statement was obviously wrong, leading to some sort of weird spinning on rare occasion with discards enabled...
--- drivers/md/bcache/journal.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/bcache/journal.c +1 -1
@@ -428,7 +428,7 @@ static void do_journal_discard(struct cache *ca)return ; } -switch (atomic_read (&ja->discard_in_flight) ==DISCARD_IN_FLIGHT ) { +switch (atomic_read (&ja->discard_in_flight)) {case DISCARD_IN_FLIGHT :return ;
Signature · 1 line
1.8.4.rc3
PATCH 3/11 bcache: Strip endline when writing the label through sysfs
In reply to Kent OverstreetFrom: Gabriel de Perthuis <[email protected]>
sysfs attributes with unusual characters have crappy failure modes in Squeeze (udev 164); later versions of udev are unaffected.
This should make these characters more unusual.
--- drivers/md/bcache/sysfs.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
drivers/md/bcache/sysfs.c +7 -2
@@ -223,8 +223,13 @@ STORE(__cached_dev) }if (attr == &sysfs_label) { -/* note: endlines are preserved */ -memcpy (dc->sb.label, buf,SB_LABEL_SIZE ); +if (size >SB_LABEL_SIZE ) +return -EINVAL ; +memcpy (dc->sb.label, buf, size); +if (size <SB_LABEL_SIZE ) + dc->sb.label[size] ='\0' ; +if (size && dc->sb.label[size -1 ] =='\n' ) + dc->sb.label[size -1 ] ='\0' ;bch_write_bdev_super (dc,NULL );if (dc->disk.c) { memcpy(dc->disk.c->uuids[dc->disk.id].label,
Signature · 1 line
1.8.4.rc3
PATCH 4/11 bcache: Fix for when no journal entries are found
In reply to Kent OverstreetThe journal replay code didn't handle this case, causing it to go into an infinite loop...
--- drivers/md/bcache/journal.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-)
drivers/md/bcache/journal.c +18 -12
@@ -153,7 +153,8 @@ int bch_journal_read(struct cache_set *c, struct list_head *list,bitmap_zero (bitmap,SB_JOURNAL_BUCKETS );pr_debug ("%u journal buckets" , ca->sb.njournal_buckets); -/* Read journal buckets ordered by golden ratio hash to quickly +/* +* Read journal buckets ordered by golden ratio hash to quickly * find a sequence of buckets with valid journal entries */ for (i =0 ; i < ca->sb.njournal_buckets; i++) {
@@ -166,18 +167,20 @@ int bch_journal_read(struct cache_set *c, struct list_head *list, goto bsearch; } -/* If that fails, check all the buckets we haven't checked +/* +* If that fails, check all the buckets we haven't checked * already */ pr_debug ("falling back to linear search" ); -for (l =0 ; l < ca->sb.njournal_buckets; l++) { -if (test_bit (l, bitmap)) -continue ; - +for (l =find_first_zero_bit (bitmap, ca->sb.njournal_buckets); + l < ca->sb.njournal_buckets; + l =find_next_zero_bit (bitmap, ca->sb.njournal_buckets, l +1 ))if (read_bucket (l)) goto bsearch; - } + +if (list_empty (list)) +continue ; bsearch:/* Binary search */ m = r =find_next_bit (bitmap, ca->sb.njournal_buckets, l +1 );
@@ -197,10 +200,12 @@ bsearch: r = m; } -/* Read buckets in reverse order until we stop finding more +/* +* Read buckets in reverse order until we stop finding more * journal entries */ -pr_debug ("finishing up" ); +pr_debug ("finishing up: m %u njournal_buckets %u" , + m, ca->sb.njournal_buckets); l = m;while (1 ) {
@@ -228,9 +233,10 @@ bsearch: } } - c->journal.seq =list_entry (list->prev, - struct journal_replay, - list)->j.seq; +if (!list_empty (list)) + c->journal.seq =list_entry (list->prev, + struct journal_replay, + list)->j.seq;return 0 ;#undef read_bucket
Signature · 1 line
1.8.4.rc3
PATCH 5/11 bcache: Correct printf()-style format length modifier
In reply to Kent OverstreetFrom: Geert Uytterhoeven <[email protected]>
drivers/md/bcache/btree.c: In function ‘bch_btree_node_read’:drivers/md/bcache/btree.c:259: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 3 has type ‘size_t’
--- drivers/md/bcache/btree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/bcache/btree.c +1 -1
@@ -255,7 +255,7 @@ void bch_btree_node_read(struct btree *b)return ; err: -bch_cache_set_error (b->c,"io error reading bucket %lu" , +bch_cache_set_error (b->c,"io error reading bucket %zu" ,PTR_BUCKET_NR (b->c, &b->key,0 )); }
Signature · 1 line
1.8.4.rc3
PATCH 6/11 bcache: Fix a writeback performance regression
In reply to Kent OverstreetBackground writeback works by scanning the btree for dirty data and adding those keys into a fixed size buffer, then for each dirty key in the keybuf writing it to the backing device.
When read_dirty() finishes and it's time to scan for more dirty data, we need to wait for the outstanding writeback IO to finish - they still take up slots in the keybuf (so that foreground writes can check for them to avoid races) - without that wait, we'll continually rescan when we'll be able to add at most a key or two to the keybuf, and that takes locks that starves foreground IO. Doh.
--- drivers/md/bcache/bcache.h | 7 +++---- drivers/md/bcache/util.c | 11 ++++++++++- drivers/md/bcache/util.h | 12 +++++++++--- drivers/md/bcache/writeback.c | 43 +++++++++++++++++++++---------------------- 4 files changed, 43 insertions(+), 30 deletions(-)
drivers/md/bcache/bcache.h +3 -4
@@ -498,7 +498,7 @@ struct cached_dev {*/ atomic_t has_dirty; -struct ratelimit writeback_rate; +struct bch_ratelimit writeback_rate;struct delayed_work writeback_rate_update;/*
@@ -507,10 +507,9 @@ struct cached_dev {*/ sector_t last_read; -/* Number of writeback bios in flight */ -atomic_t in_flight; +/* Limit number of writeback bios in flight */ +struct semaphore in_flight;struct closure_with_timer writeback; -struct closure_waitlist writeback_wait;struct keybuf writeback_keys;
drivers/md/bcache/util.c +10 -1
@@ -190,7 +190,16 @@ void bch_time_stats_update(struct time_stats *stats, uint64_t start_time) stats->last = now ?:1 ; } -unsigned bch_next_delay (struct ratelimit *d,uint64_t done) +/** +* bch_next_delay() - increment @d by the amount of work done, and return how +* long to delay until the next time to do some work. +* +* @d - the struct bch_ratelimit to update +* @done - the amount of work done, in arbitrary units +* +* Returns the amount of time to delay by, in jiffies +*/ +uint64_t bch_next_delay (struct bch_ratelimit *d,uint64_t done) {uint64_t now =local_clock ();
drivers/md/bcache/util.h +9 -3
@@ -450,17 +450,23 @@ read_attribute(name ## _last_ ## frequency_units) (ewma) >> factor; \ }) -struct ratelimit { +struct bch_ratelimit { +/* Next time we want to do some work, in nanoseconds */ uint64_t next; + +/* +* Rate at which we want to do work, in units per nanosecond +* The units here correspond to the units passed to bch_next_delay() +*/ unsigned rate; }; -static inline void ratelimit_reset (struct ratelimit *d) +static inline void bch_ratelimit_reset (struct bch_ratelimit *d) { d->next =local_clock (); } -unsigned bch_next_delay (struct ratelimit *d,uint64_t done); +uint64_t bch_next_delay (struct bch_ratelimit *d,uint64_t done);#define __DIV_SAFE (n, d, zero) \ ({ \
drivers/md/bcache/writeback.c +21 -22
109 lines not on this page · raw message
Signature · 1 line
1.8.4.rc3
PATCH 7/11 bcache: Fix a flush/fua performance bug
In reply to Kent Overstreetbch_journal_meta() was missing the flush to make the journal write actually go down (instead of waiting up to journal_delay_ms)...
Whoops
--- drivers/md/bcache/journal.c | 1 + 1 file changed, 1 insertion(+)
drivers/md/bcache/journal.c +1 -0
@@ -695,6 +695,7 @@ void bch_journal_meta(struct cache_set *c, struct closure *cl)if (cl)BUG_ON (!closure_wait (&w->wait, cl)); +closure_flush (&c->journal.io);__journal_try_write (c, true); } }
Signature · 1 line
1.8.4.rc3
PATCH 8/11 bcache: Fix a dumb CPU spinning bug in writeback
In reply to Kent Overstreetschedule_timeout() != schedule_timeout_uninterruptible()
--- drivers/md/bcache/writeback.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/md/bcache/writeback.c +1 -2
@@ -397,8 +397,7 @@ static void read_dirty(struct closure *cl)if (delay >0 && (KEY_START (&w->key) != dc->last_read ||jiffies_to_msecs (delay) >50 )) -while (delay) - delay =schedule_timeout (delay); + delay =schedule_timeout_uninterruptible (delay); dc->last_read =KEY_OFFSET (&w->key);
Signature · 1 line
1.8.4.rc3
PATCH 9/11 bcache: Fix a shrinker deadlock
In reply to Kent OverstreetGFP_NOIO means we could be getting called recursively - mca_alloc() -> mca_data_alloc() - definitely can't use mutex_lock(bucket_lock) then. Whoops.
--- drivers/md/bcache/btree.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/md/bcache/btree.c +1 -1
@@ -612,7 +612,7 @@ static unsigned long bch_mca_scan(struct shrinker *shrink,return SHRINK_STOP ;/* Return -1 if we can't do anything right now */ -if (sc->gfp_mask & __GFP_WAIT) +if (sc->gfp_mask & __GFP_IO)mutex_lock (&c->bucket_lock);else if (!mutex_trylock (&c->bucket_lock))return -1 ;
Signature · 1 line
1.8.4.rc3
PATCH 10/11 bcache: Fix for handling overlapping extents when reading in a btree node
In reply to Kent Overstreetbtree_sort_fixup() was overly clever, because it was trying to avoid pulling a key off the btree iterator in more than one place.
This led to a really obscure bug where we'd break early from the loop in btree_sort_fixup() if the current key overlapped with keys in more than one older set, and the next key it overlapped with was zero size.
--- drivers/md/bcache/bset.c | 39 ++++++++++++++++++++++++++++----------- 1 file changed, 28 insertions(+), 11 deletions(-)
drivers/md/bcache/bset.c +28 -11
@@ -926,28 +926,45 @@ struct bkey *bch_next_recurse_key(struct btree *b, struct bkey *search)/* Mergesort */ +static void sort_key_next (struct btree_iter *iter, +struct btree_iter_set *i) +{ + i->k =bkey_next (i->k); + +if (i->k == i->end) + *i = iter->data[--iter->used]; +} +static void btree_sort_fixup (struct btree_iter *iter) {while (iter->used >1 ) {struct btree_iter_set *top = iter->data, *i = top +1 ; -struct bkey *k;if (iter->used >2 &&btree_iter_cmp (i[0 ], i[1 ])) i++; -for (k = i->k; - k != i->end &&bkey_cmp (top->k, &START_KEY (k)) >0 ; - k =bkey_next (k)) -if (top->k > i->k) -__bch_cut_front (top->k, k); -else if (KEY_SIZE (k)) -bch_cut_back (&START_KEY (k), top->k); - -if (top->k < i->k || k == i->k) +if (bkey_cmp (top->k, &START_KEY (i->k)) <=0 )break ; -heap_sift (iter, i - top, btree_iter_cmp); +if (!KEY_SIZE (i->k)) { +sort_key_next (iter, i); +heap_sift (iter, i - top, btree_iter_cmp); +continue ; + } + +if (top->k > i->k) { +if (bkey_cmp (top->k, i->k) >=0 ) +sort_key_next (iter, i); +else +bch_cut_front (top->k, i->k); + +heap_sift (iter, i - top, btree_iter_cmp); + }else { +/* can't happen because of comparison func */ +BUG_ON (!bkey_cmp (&START_KEY (top->k), &START_KEY (i->k))); +bch_cut_back (&START_KEY (i->k), top->k); + } } }
Signature · 1 line
1.8.4.rc3
PATCH 11/11 bcache: Fix flushes in writeback mode
In reply to Kent OverstreetIn writeback mode, when we get a cache flush we need to make sure we issue a flush to the backing device.
The code for sending down an extra flush was wrong - by cloning the bio we were probably getting flags that didn't make sense for a bare flush, and also the old code was firing for FUA bios, for which we don't need to send a flush to the backing device.
This was causing data corruption somehow - the mechanism was never determined, but this patch fixes it for the users that were seeing it.
--- drivers/md/bcache/request.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)
drivers/md/bcache/request.c +9 -6
@@ -997,14 +997,17 @@ static void request_write(struct cached_dev *dc, struct search *s) }else {bch_writeback_add (dc); -if (s->op.flush_journal) { +if (bio->bi_rw &REQ_FLUSH ) {/* Also need to send a flush to the backing device */ - s->op.cache_bio =bio_clone_bioset (bio,GFP_NOIO , - dc->disk.bio_split); +struct bio *flush =bio_alloc_bioset (0 ,GFP_NOIO , + dc->disk.bio_split); - bio->bi_size =0 ; - bio->bi_vcnt =0 ; -closure_bio_submit (bio, cl, s->d); + flush->bi_rw =WRITE_FLUSH ; + flush->bi_bdev = bio->bi_bdev; + flush->bi_end_io = request_endio; + flush->bi_private = cl; + +closure_bio_submit (flush, cl, s->d); }else { s->op.cache_bio = bio; }
Signature · 1 line
1.8.4.rc3