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 void bio_free_pages(struct bio *bio)
 167 {
 168         struct bio_vec *bvec;
 169         int i;
 170
 171         bio_for_each_segment_all(bvec, bio, i)
 172                 __free_page(bvec->bv_page);
 173 }
 174
 175 void bio_advance(struct bio *bio, unsigned bytes)
 176 {
 177         bio_advance_iter(bio, &bio->bi_iter, bytes);
 178 }
 179
 180 static void bio_free(struct bio *bio)
 181 {
 182         unsigned front_pad = bio->bi_pool ? bio->bi_pool->front_pad : 0;
 183
 184         kfree((void *) bio - front_pad);
 185 }
 186
 187 void bio_put(struct bio *bio)
 188 {
 189         if (!bio_flagged(bio, BIO_REFFED))
 190                 bio_free(bio);
 191         else {
 192                 BUG_ON(!atomic_read(&bio->__bi_cnt));
 193
 194                 /*
 195                  * last put frees it
 196                  */
 197                 if (atomic_dec_and_test(&bio->__bi_cnt))
 198                         bio_free(bio);
 199         }
 200 }
 201
 202 static inline bool bio_remaining_done(struct bio *bio)
 203 {
 204         /*
 205          * If we're not chaining, then ->__bi_remaining is always 1 and
 206          * we always end io on the first invocation.
 207          */
 208         if (!bio_flagged(bio, BIO_CHAIN))
 209                 return true;
 210
 211         BUG_ON(atomic_read(&bio->__bi_remaining) <= 0);
 212
 213         if (atomic_dec_and_test(&bio->__bi_remaining)) {
 214                 bio_clear_flag(bio, BIO_CHAIN);
 215                 return true;
 216         }
 217
 218         return false;
 219 }
 220
 221 static struct bio *__bio_chain_endio(struct bio *bio)
 222 {
 223         struct bio *parent = bio->bi_private;
 224
 225         if (!parent->bi_status)
 226                 parent->bi_status = bio->bi_status;
 227         bio_put(bio);
 228         return parent;
 229 }
 230
 231 static void bio_chain_endio(struct bio *bio)
 232 {
 233         bio_endio(__bio_chain_endio(bio));
 234 }
 235
 236 void bio_endio(struct bio *bio)
 237 {
 238 again:
 239         if (!bio_remaining_done(bio))
 240                 return;
 241
 242         /*
 243          * Need to have a real endio function for chained bios, otherwise
 244          * various corner cases will break (like stacking block devices that
 245          * save/restore bi_end_io) - however, we want to avoid unbounded
 246          * recursion and blowing the stack. Tail call optimization would
 247          * handle this, but compiling with frame pointers also disables
 248          * gcc's sibling call optimization.
 249          */
 250         if (bio->bi_end_io == bio_chain_endio) {
 251                 bio = __bio_chain_endio(bio);
 252                 goto again;
 253         }
 254
 255         if (bio->bi_end_io)
 256                 bio->bi_end_io(bio);
 257 }
 258
 259 void bio_reset(struct bio *bio)
 260 {
 261         unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
 262
 263         memset(bio, 0, BIO_RESET_BYTES);
 264         bio->bi_flags = flags;
 265         atomic_set(&bio->__bi_remaining, 1);
 266 }
 267
 268 struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 269 {
 270         unsigned front_pad = bs ? bs->front_pad : 0;
 271         struct bio *bio;
 272         void *p;
 273
 274         p = kmalloc(front_pad +
 275                     sizeof(struct bio) +
 276                     nr_iovecs * sizeof(struct bio_vec),
 277                     gfp_mask);
 278
 279         if (unlikely(!p))
 280                 return NULL;
 281
 282         bio = p + front_pad;
 283         bio_init(bio, bio->bi_inline_vecs, nr_iovecs);
 284         bio->bi_pool = bs;
 285
 286         return bio;
 287 }
 288
 289 struct bio *bio_clone_bioset(struct bio *bio_src, gfp_t gfp_mask,
 290                              struct bio_set *bs)
 291 {
 292         struct bvec_iter iter;
 293         struct bio_vec bv;
 294         struct bio *bio;
 295
 296         bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs);
 297         if (!bio)
 298                 return NULL;
 299
 300         bio->bi_bdev            = bio_src->bi_bdev;
 301         bio->bi_opf             = bio_src->bi_opf;
 302         bio->bi_iter.bi_sector  = bio_src->bi_iter.bi_sector;
 303         bio->bi_iter.bi_size    = bio_src->bi_iter.bi_size;
 304
 305         switch (bio_op(bio)) {
 306         case REQ_OP_DISCARD:
 307         case REQ_OP_SECURE_ERASE:
 308                 break;
 309         case REQ_OP_WRITE_SAME:
 310                 bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0];
 311                 break;
 312         default:
 313                 bio_for_each_segment(bv, bio_src, iter)
 314                         bio->bi_io_vec[bio->bi_vcnt++] = bv;
 315                 break;
 316         }
 317
 318         return bio;
 319 }