drivers/md/bcache/io.c

   1 /*
   2  * Some low level IO code, and hacks for various block layer limitations
   3  *
   4  * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
   5  * Copyright 2012 Google, Inc.
   6  */
   7
   8 #include "bcache.h"
   9 #include "bset.h"
  10 #include "debug.h"
  11
  12 #include <linux/blkdev.h>
  13
  14 static void bch_bi_idx_hack_endio(struct bio *bio, int error)
  15 {
  16         struct bio *p = bio->bi_private;
  17
  18         bio_endio(p, error);
  19         bio_put(bio);
  20 }
  21
  22 static void bch_generic_make_request_hack(struct bio *bio)
  23 {
  24         if (bio->bi_iter.bi_idx) {
  25                 struct bio_vec bv;
  26                 struct bvec_iter iter;
  27                 struct bio *clone = bio_alloc(GFP_NOIO, bio_segments(bio));
  28
  29                 bio_for_each_segment(bv, bio, iter)
  30                         clone->bi_io_vec[clone->bi_vcnt++] = bv;
  31
  32                 clone->bi_iter.bi_sector = bio->bi_iter.bi_sector;
  33                 clone->bi_bdev          = bio->bi_bdev;
  34                 clone->bi_rw            = bio->bi_rw;
  35                 clone->bi_vcnt          = bio_segments(bio);
  36                 clone->bi_iter.bi_size  = bio->bi_iter.bi_size;
  37
  38                 clone->bi_private       = bio;
  39                 clone->bi_end_io        = bch_bi_idx_hack_endio;
  40
  41                 bio = clone;
  42         }
  43
  44         /*
  45          * Hack, since drivers that clone bios clone up to bi_max_vecs, but our
  46          * bios might have had more than that (before we split them per device
  47          * limitations).
  48          *
  49          * To be taken out once immutable bvec stuff is in.
  50          */
  51         bio->bi_max_vecs = bio->bi_vcnt;
  52
  53         generic_make_request(bio);
  54 }
  55
  56 /**
  57  * bch_bio_split - split a bio
  58  * @bio:        bio to split
  59  * @sectors:    number of sectors to split from the front of @bio
  60  * @gfp:        gfp mask
  61  * @bs:         bio set to allocate from
  62  *
  63  * Allocates and returns a new bio which represents @sectors from the start of
  64  * @bio, and updates @bio to represent the remaining sectors.
  65  *
  66  * If bio_sectors(@bio) was less than or equal to @sectors, returns @bio
  67  * unchanged.
  68  *
  69  * The newly allocated bio will point to @bio's bi_io_vec, if the split was on a
  70  * bvec boundry; it is the caller's responsibility to ensure that @bio is not
  71  * freed before the split.
  72  */
  73 struct bio *bch_bio_split(struct bio *bio, int sectors,
  74                           gfp_t gfp, struct bio_set *bs)
  75 {
  76         unsigned vcnt = 0, nbytes = sectors << 9;
  77         struct bio_vec bv;
  78         struct bvec_iter iter;
  79         struct bio *ret = NULL;
  80
  81         BUG_ON(sectors <= 0);
  82
  83         if (sectors >= bio_sectors(bio))
  84                 return bio;
  85
  86         if (bio->bi_rw & REQ_DISCARD) {
  87                 ret = bio_alloc_bioset(gfp, 1, bs);
  88                 if (!ret)
  89                         return NULL;
  90                 goto out;
  91         }
  92
  93         bio_for_each_segment(bv, bio, iter) {
  94                 vcnt++;
  95
  96                 if (nbytes <= bv.bv_len)
  97                         break;
  98
  99                 nbytes -= bv.bv_len;
 100         }
 101
 102         ret = bio_alloc_bioset(gfp, vcnt, bs);
 103         if (!ret)
 104                 return NULL;
 105
 106         bio_for_each_segment(bv, bio, iter) {
 107                 ret->bi_io_vec[ret->bi_vcnt++] = bv;
 108
 109                 if (ret->bi_vcnt == vcnt)
 110                         break;
 111         }
 112
 113         ret->bi_io_vec[ret->bi_vcnt - 1].bv_len = nbytes;
 114 out:
 115         ret->bi_bdev    = bio->bi_bdev;
 116         ret->bi_iter.bi_sector  = bio->bi_iter.bi_sector;
 117         ret->bi_iter.bi_size    = sectors << 9;
 118         ret->bi_rw      = bio->bi_rw;
 119
 120         if (bio_integrity(bio)) {
 121                 if (bio_integrity_clone(ret, bio, gfp)) {
 122                         bio_put(ret);
 123                         return NULL;
 124                 }
 125
 126                 bio_integrity_trim(ret, 0, bio_sectors(ret));
 127         }
 128
 129         bio_advance(bio, ret->bi_iter.bi_size);
 130
 131         return ret;
 132 }
 133
 134 static unsigned bch_bio_max_sectors(struct bio *bio)
 135 {
 136         unsigned ret = bio_sectors(bio);
 137         struct request_queue *q = bdev_get_queue(bio->bi_bdev);
 138         unsigned max_segments = min_t(unsigned, BIO_MAX_PAGES,
 139                                       queue_max_segments(q));
 140
 141         if (bio->bi_rw & REQ_DISCARD)
 142                 return min(ret, q->limits.max_discard_sectors);
 143
 144         if (bio_segments(bio) > max_segments ||
 145             q->merge_bvec_fn) {
 146                 struct bio_vec bv;
 147                 struct bvec_iter iter;
 148                 unsigned seg = 0;
 149
 150                 ret = 0;
 151
 152                 bio_for_each_segment(bv, bio, iter) {
 153                         struct bvec_merge_data bvm = {
 154                                 .bi_bdev        = bio->bi_bdev,
 155                                 .bi_sector      = bio->bi_iter.bi_sector,
 156                                 .bi_size        = ret << 9,
 157                                 .bi_rw          = bio->bi_rw,
 158                         };
 159
 160                         if (seg == max_segments)
 161                                 break;
 162
 163                         if (q->merge_bvec_fn &&
 164                             q->merge_bvec_fn(q, &bvm, &bv) < (int) bv.bv_len)
 165                                 break;
 166
 167                         seg++;
 168                         ret += bv.bv_len >> 9;
 169                 }
 170         }
 171
 172         ret = min(ret, queue_max_sectors(q));
 173
 174         WARN_ON(!ret);
 175         ret = max_t(int, ret, bio_iovec(bio).bv_len >> 9);
 176
 177         return ret;
 178 }
 179
 180 static void bch_bio_submit_split_done(struct closure *cl)
 181 {
 182         struct bio_split_hook *s = container_of(cl, struct bio_split_hook, cl);
 183
 184         s->bio->bi_end_io = s->bi_end_io;
 185         s->bio->bi_private = s->bi_private;
 186         bio_endio(s->bio, 0);
 187
 188         closure_debug_destroy(&s->cl);
 189         mempool_free(s, s->p->bio_split_hook);
 190 }
 191
 192 static void bch_bio_submit_split_endio(struct bio *bio, int error)
 193 {
 194         struct closure *cl = bio->bi_private;
 195         struct bio_split_hook *s = container_of(cl, struct bio_split_hook, cl);
 196
 197         if (error)
 198                 clear_bit(BIO_UPTODATE, &s->bio->bi_flags);
 199
 200         bio_put(bio);
 201         closure_put(cl);
 202 }
 203
 204 void bch_generic_make_request(struct bio *bio, struct bio_split_pool *p)
 205 {
 206         struct bio_split_hook *s;
 207         struct bio *n;
 208
 209         if (!bio_has_data(bio) && !(bio->bi_rw & REQ_DISCARD))
 210                 goto submit;
 211
 212         if (bio_sectors(bio) <= bch_bio_max_sectors(bio))
 213                 goto submit;
 214
 215         s = mempool_alloc(p->bio_split_hook, GFP_NOIO);
 216         closure_init(&s->cl, NULL);
 217
 218         s->bio          = bio;
 219         s->p            = p;
 220         s->bi_end_io    = bio->bi_end_io;
 221         s->bi_private   = bio->bi_private;
 222         bio_get(bio);
 223
 224         do {
 225                 n = bch_bio_split(bio, bch_bio_max_sectors(bio),
 226                                   GFP_NOIO, s->p->bio_split);
 227
 228                 n->bi_end_io    = bch_bio_submit_split_endio;
 229                 n->bi_private   = &s->cl;
 230
 231                 closure_get(&s->cl);
 232                 bch_generic_make_request_hack(n);
 233         } while (n != bio);
 234
 235         continue_at(&s->cl, bch_bio_submit_split_done, NULL);
 236 submit:
 237         bch_generic_make_request_hack(bio);
 238 }
 239
 240 /* Bios with headers */
 241
 242 void bch_bbio_free(struct bio *bio, struct cache_set *c)
 243 {
 244         struct bbio *b = container_of(bio, struct bbio, bio);
 245         mempool_free(b, c->bio_meta);
 246 }
 247
 248 struct bio *bch_bbio_alloc(struct cache_set *c)
 249 {
 250         struct bbio *b = mempool_alloc(c->bio_meta, GFP_NOIO);
 251         struct bio *bio = &b->bio;
 252
 253         bio_init(bio);
 254         bio->bi_flags           |= BIO_POOL_NONE << BIO_POOL_OFFSET;
 255         bio->bi_max_vecs         = bucket_pages(c);
 256         bio->bi_io_vec           = bio->bi_inline_vecs;
 257
 258         return bio;
 259 }
 260
 261 void __bch_submit_bbio(struct bio *bio, struct cache_set *c)
 262 {
 263         struct bbio *b = container_of(bio, struct bbio, bio);
 264
 265         bio->bi_iter.bi_sector  = PTR_OFFSET(&b->key, 0);
 266         bio->bi_bdev            = PTR_CACHE(c, &b->key, 0)->bdev;
 267
 268         b->submit_time_us = local_clock_us();
 269         closure_bio_submit(bio, bio->bi_private, PTR_CACHE(c, &b->key, 0));
 270 }
 271
 272 void bch_submit_bbio(struct bio *bio, struct cache_set *c,
 273                      struct bkey *k, unsigned ptr)
 274 {
 275         struct bbio *b = container_of(bio, struct bbio, bio);
 276         bch_bkey_copy_single_ptr(&b->key, k, ptr);
 277         __bch_submit_bbio(bio, c);
 278 }
 279
 280 /* IO errors */
 281
 282 void bch_count_io_errors(struct cache *ca, int error, const char *m)
 283 {
 284         /*
 285          * The halflife of an error is:
 286          * log2(1/2)/log2(127/128) * refresh ~= 88 * refresh
 287          */
 288
 289         if (ca->set->error_decay) {
 290                 unsigned count = atomic_inc_return(&ca->io_count);
 291
 292                 while (count > ca->set->error_decay) {
 293                         unsigned errors;
 294                         unsigned old = count;
 295                         unsigned new = count - ca->set->error_decay;
 296
 297                         /*
 298                          * First we subtract refresh from count; each time we
 299                          * succesfully do so, we rescale the errors once:
 300                          */
 301
 302                         count = atomic_cmpxchg(&ca->io_count, old, new);
 303
 304                         if (count == old) {
 305                                 count = new;
 306
 307                                 errors = atomic_read(&ca->io_errors);
 308                                 do {
 309                                         old = errors;
 310                                         new = ((uint64_t) errors * 127) / 128;
 311                                         errors = atomic_cmpxchg(&ca->io_errors,
 312                                                                 old, new);
 313                                 } while (old != errors);
 314                         }
 315                 }
 316         }
 317
 318         if (error) {
 319                 char buf[BDEVNAME_SIZE];
 320                 unsigned errors = atomic_add_return(1 << IO_ERROR_SHIFT,
 321                                                     &ca->io_errors);
 322                 errors >>= IO_ERROR_SHIFT;
 323
 324                 if (errors < ca->set->error_limit)
 325                         pr_err("%s: IO error on %s, recovering",
 326                                bdevname(ca->bdev, buf), m);
 327                 else
 328                         bch_cache_set_error(ca->set,
 329                                             "%s: too many IO errors %s",
 330                                             bdevname(ca->bdev, buf), m);
 331         }
 332 }
 333
 334 void bch_bbio_count_io_errors(struct cache_set *c, struct bio *bio,
 335                               int error, const char *m)
 336 {
 337         struct bbio *b = container_of(bio, struct bbio, bio);
 338         struct cache *ca = PTR_CACHE(c, &b->key, 0);
 339
 340         unsigned threshold = bio->bi_rw & REQ_WRITE
 341                 ? c->congested_write_threshold_us
 342                 : c->congested_read_threshold_us;
 343
 344         if (threshold) {
 345                 unsigned t = local_clock_us();
 346
 347                 int us = t - b->submit_time_us;
 348                 int congested = atomic_read(&c->congested);
 349
 350                 if (us > (int) threshold) {
 351                         int ms = us / 1024;
 352                         c->congested_last_us = t;
 353
 354                         ms = min(ms, CONGESTED_MAX + congested);
 355                         atomic_sub(ms, &c->congested);
 356                 } else if (congested < 0)
 357                         atomic_inc(&c->congested);
 358         }
 359
 360         bch_count_io_errors(ca, error, m);
 361 }
 362
 363 void bch_bbio_endio(struct cache_set *c, struct bio *bio,
 364                     int error, const char *m)
 365 {
 366         struct closure *cl = bio->bi_private;
 367
 368         bch_bbio_count_io_errors(c, bio, error, m);
 369         bio_put(bio);
 370         closure_put(cl);
 371 }