git.sesse.net Git - bcachefs-tools-debian/blob - linux/bio.c

   1 /*
   2  * Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public Licens
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
  16  *
  17  */
  18 #include <linux/bio.h>
  19 #include <linux/blkdev.h>
  20 #include <linux/slab.h>
  21 #include <linux/kernel.h>
  22
  23 static const struct {
  24         int             err;
  25         const char      *name;
  26 } blk_errors[] = {
  27         [BLK_STS_OK]            = { 0,          "" },
  28         [BLK_STS_NOTSUPP]       = { -EOPNOTSUPP, "operation not supported" },
  29         [BLK_STS_TIMEOUT]       = { -ETIMEDOUT, "timeout" },
  30         [BLK_STS_NOSPC]         = { -ENOSPC,    "critical space allocation" },
  31         [BLK_STS_TRANSPORT]     = { -ENOLINK,   "recoverable transport" },
  32         [BLK_STS_TARGET]        = { -EREMOTEIO, "critical target" },
  33         [BLK_STS_NEXUS]         = { -EBADE,     "critical nexus" },
  34         [BLK_STS_MEDIUM]        = { -ENODATA,   "critical medium" },
  35         [BLK_STS_PROTECTION]    = { -EILSEQ,    "protection" },
  36         [BLK_STS_RESOURCE]      = { -ENOMEM,    "kernel resource" },
  37         [BLK_STS_AGAIN]         = { -EAGAIN,    "nonblocking retry" },
  38
  39         /* device mapper special case, should not leak out: */
  40         [BLK_STS_DM_REQUEUE]    = { -EREMCHG, "dm internal retry" },
  41
  42         /* everything else not covered above: */
  43         [BLK_STS_IOERR]         = { -EIO,       "I/O" },
  44 };
  45
  46 int blk_status_to_errno(blk_status_t status)
  47 {
  48         int idx = (__force int)status;
  49
  50         if (WARN_ON_ONCE(idx >= ARRAY_SIZE(blk_errors)))
  51                 return -EIO;
  52         return blk_errors[idx].err;
  53 }
  54
  55 void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
  56                         struct bio *src, struct bvec_iter *src_iter)
  57 {
  58         struct bio_vec src_bv, dst_bv;
  59         void *src_p, *dst_p;
  60         unsigned bytes;
  61
  62         while (src_iter->bi_size && dst_iter->bi_size) {
  63                 src_bv = bio_iter_iovec(src, *src_iter);
  64                 dst_bv = bio_iter_iovec(dst, *dst_iter);
  65
  66                 bytes = min(src_bv.bv_len, dst_bv.bv_len);
  67
  68                 src_p = kmap_atomic(src_bv.bv_page);
  69                 dst_p = kmap_atomic(dst_bv.bv_page);
  70
  71                 memcpy(dst_p + dst_bv.bv_offset,
  72                        src_p + src_bv.bv_offset,
  73                        bytes);
  74
  75                 kunmap_atomic(dst_p);
  76                 kunmap_atomic(src_p);
  77
  78                 flush_dcache_page(dst_bv.bv_page);
  79
  80                 bio_advance_iter(src, src_iter, bytes);
  81                 bio_advance_iter(dst, dst_iter, bytes);
  82         }
  83 }
  84
  85 /**
  86  * bio_copy_data - copy contents of data buffers from one bio to another
  87  * @src: source bio
  88  * @dst: destination bio
  89  *
  90  * Stops when it reaches the end of either @src or @dst - that is, copies
  91  * min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of bios).
  92  */
  93 void bio_copy_data(struct bio *dst, struct bio *src)
  94 {
  95         struct bvec_iter src_iter = src->bi_iter;
  96         struct bvec_iter dst_iter = dst->bi_iter;
  97
  98         bio_copy_data_iter(dst, &dst_iter, src, &src_iter);
  99 }
 100
 101 void zero_fill_bio_iter(struct bio *bio, struct bvec_iter start)
 102 {
 103         unsigned long flags;
 104         struct bio_vec bv;
 105         struct bvec_iter iter;
 106
 107         __bio_for_each_segment(bv, bio, iter, start) {
 108                 char *data = bvec_kmap_irq(&bv, &flags);
 109                 memset(data, 0, bv.bv_len);
 110                 bvec_kunmap_irq(data, &flags);
 111         }
 112 }
 113
 114 void __bio_clone_fast(struct bio *bio, struct bio *bio_src)
 115 {
 116         /*
 117          * most users will be overriding ->bi_bdev with a new target,
 118          * so we don't set nor calculate new physical/hw segment counts here
 119          */
 120         bio->bi_bdev = bio_src->bi_bdev;
 121         bio_set_flag(bio, BIO_CLONED);
 122         bio->bi_opf = bio_src->bi_opf;
 123         bio->bi_iter = bio_src->bi_iter;
 124         bio->bi_io_vec = bio_src->bi_io_vec;
 125 }
 126
 127 struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs)
 128 {
 129         struct bio *b;
 130
 131         b = bio_alloc_bioset(gfp_mask, 0, bs);
 132         if (!b)
 133                 return NULL;
 134
 135         __bio_clone_fast(b, bio);
 136         return b;
 137 }
 138
 139 struct bio *bio_split(struct bio *bio, int sectors,
 140                       gfp_t gfp, struct bio_set *bs)
 141 {
 142         struct bio *split = NULL;
 143
 144         BUG_ON(sectors <= 0);
 145         BUG_ON(sectors >= bio_sectors(bio));
 146
 147         /*
 148          * Discards need a mutable bio_vec to accommodate the payload
 149          * required by the DSM TRIM and UNMAP commands.
 150          */
 151         if (bio_op(bio) == REQ_OP_DISCARD || bio_op(bio) == REQ_OP_SECURE_ERASE)
 152                 split = bio_clone_bioset(bio, gfp, bs);
 153         else
 154                 split = bio_clone_fast(bio, gfp, bs);
 155
 156         if (!split)
 157                 return NULL;
 158
 159         split->bi_iter.bi_size = sectors << 9;
 160
 161         bio_advance(bio, split->bi_iter.bi_size);
 162
 163         return split;
 164 }
 165
 166 int bio_alloc_pages(struct bio *bio, gfp_t gfp_mask)
 167 {
 168         int i;
 169         struct bio_vec *bv;
 170
 171         bio_for_each_segment_all(bv, bio, i) {
 172                 bv->bv_page = alloc_page(gfp_mask);
 173                 if (!bv->bv_page) {
 174                         while (--bv >= bio->bi_io_vec)
 175                                 __free_page(bv->bv_page);
 176                         return -ENOMEM;
 177                 }
 178         }
 179
 180         return 0;
 181 }
 182
 183 void bio_advance(struct bio *bio, unsigned bytes)
 184 {
 185         bio_advance_iter(bio, &bio->bi_iter, bytes);
 186 }
 187
 188 static void bio_free(struct bio *bio)
 189 {
 190         unsigned front_pad = bio->bi_pool ? bio->bi_pool->front_pad : 0;
 191
 192         kfree((void *) bio - front_pad);
 193 }
 194
 195 void bio_put(struct bio *bio)
 196 {
 197         if (!bio_flagged(bio, BIO_REFFED))
 198                 bio_free(bio);
 199         else {
 200                 BUG_ON(!atomic_read(&bio->__bi_cnt));
 201
 202                 /*
 203                  * last put frees it
 204                  */
 205                 if (atomic_dec_and_test(&bio->__bi_cnt))
 206                         bio_free(bio);
 207         }
 208 }
 209
 210 static inline bool bio_remaining_done(struct bio *bio)
 211 {
 212         /*
 213          * If we're not chaining, then ->__bi_remaining is always 1 and
 214          * we always end io on the first invocation.
 215          */
 216         if (!bio_flagged(bio, BIO_CHAIN))
 217                 return true;
 218
 219         BUG_ON(atomic_read(&bio->__bi_remaining) <= 0);
 220
 221         if (atomic_dec_and_test(&bio->__bi_remaining)) {
 222                 bio_clear_flag(bio, BIO_CHAIN);
 223                 return true;
 224         }
 225
 226         return false;
 227 }
 228
 229 static struct bio *__bio_chain_endio(struct bio *bio)
 230 {
 231         struct bio *parent = bio->bi_private;
 232
 233         if (!parent->bi_status)
 234                 parent->bi_status = bio->bi_status;
 235         bio_put(bio);
 236         return parent;
 237 }
 238
 239 static void bio_chain_endio(struct bio *bio)
 240 {
 241         bio_endio(__bio_chain_endio(bio));
 242 }
 243
 244 void bio_endio(struct bio *bio)
 245 {
 246 again:
 247         if (!bio_remaining_done(bio))
 248                 return;
 249
 250         /*
 251          * Need to have a real endio function for chained bios, otherwise
 252          * various corner cases will break (like stacking block devices that
 253          * save/restore bi_end_io) - however, we want to avoid unbounded
 254          * recursion and blowing the stack. Tail call optimization would
 255          * handle this, but compiling with frame pointers also disables
 256          * gcc's sibling call optimization.
 257          */
 258         if (bio->bi_end_io == bio_chain_endio) {
 259                 bio = __bio_chain_endio(bio);
 260                 goto again;
 261         }
 262
 263         if (bio->bi_end_io)
 264                 bio->bi_end_io(bio);
 265 }
 266
 267 void bio_reset(struct bio *bio)
 268 {
 269         unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
 270
 271         memset(bio, 0, BIO_RESET_BYTES);
 272         bio->bi_flags = flags;
 273         atomic_set(&bio->__bi_remaining, 1);
 274 }
 275
 276 struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 277 {
 278         unsigned front_pad = bs ? bs->front_pad : 0;
 279         struct bio *bio;
 280         void *p;
 281
 282         p = kmalloc(front_pad +
 283                     sizeof(struct bio) +
 284                     nr_iovecs * sizeof(struct bio_vec),
 285                     gfp_mask);
 286
 287         if (unlikely(!p))
 288                 return NULL;
 289
 290         bio = p + front_pad;
 291         bio_init(bio, bio->bi_inline_vecs, nr_iovecs);
 292         bio->bi_pool = bs;
 293
 294         return bio;
 295 }
 296
 297 struct bio *bio_clone_bioset(struct bio *bio_src, gfp_t gfp_mask,
 298                              struct bio_set *bs)
 299 {
 300         struct bvec_iter iter;
 301         struct bio_vec bv;
 302         struct bio *bio;
 303
 304         bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs);
 305         if (!bio)
 306                 return NULL;
 307
 308         bio->bi_bdev            = bio_src->bi_bdev;
 309         bio->bi_opf             = bio_src->bi_opf;
 310         bio->bi_iter.bi_sector  = bio_src->bi_iter.bi_sector;
 311         bio->bi_iter.bi_size    = bio_src->bi_iter.bi_size;
 312
 313         switch (bio_op(bio)) {
 314         case REQ_OP_DISCARD:
 315         case REQ_OP_SECURE_ERASE:
 316                 break;
 317         case REQ_OP_WRITE_SAME:
 318                 bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0];
 319                 break;
 320         default:
 321                 bio_for_each_segment(bv, bio_src, iter)
 322                         bio->bi_io_vec[bio->bi_vcnt++] = bv;
 323                 break;
 324         }
 325
 326         return bio;
 327 }