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 #include <linux/export.h>
  23
  24 void bio_copy_data_iter(struct bio *dst, struct bvec_iter dst_iter,
  25                         struct bio *src, struct bvec_iter src_iter)
  26 {
  27         struct bio_vec src_bv, dst_bv;
  28         void *src_p, *dst_p;
  29         unsigned bytes;
  30
  31         while (1) {
  32                 if (!src_iter.bi_size) {
  33                         src = src->bi_next;
  34                         if (!src)
  35                                 break;
  36
  37                         src_iter = src->bi_iter;
  38                 }
  39
  40                 if (!dst_iter.bi_size) {
  41                         dst = dst->bi_next;
  42                         if (!dst)
  43                                 break;
  44
  45                         dst_iter = dst->bi_iter;
  46                 }
  47
  48                 src_bv = bio_iter_iovec(src, src_iter);
  49                 dst_bv = bio_iter_iovec(dst, dst_iter);
  50
  51                 bytes = min(src_bv.bv_len, dst_bv.bv_len);
  52
  53                 src_p = kmap_atomic(src_bv.bv_page);
  54                 dst_p = kmap_atomic(dst_bv.bv_page);
  55
  56                 memcpy(dst_p + dst_bv.bv_offset,
  57                        src_p + src_bv.bv_offset,
  58                        bytes);
  59
  60                 kunmap_atomic(dst_p);
  61                 kunmap_atomic(src_p);
  62
  63                 bio_advance_iter(src, &src_iter, bytes);
  64                 bio_advance_iter(dst, &dst_iter, bytes);
  65         }
  66 }
  67
  68 void bio_copy_data(struct bio *dst, struct bio *src)
  69 {
  70         bio_copy_data_iter(dst, dst->bi_iter,
  71                            src, src->bi_iter);
  72 }
  73
  74 void zero_fill_bio_iter(struct bio *bio, struct bvec_iter start)
  75 {
  76         unsigned long flags;
  77         struct bio_vec bv;
  78         struct bvec_iter iter;
  79
  80         __bio_for_each_segment(bv, bio, iter, start) {
  81                 char *data = bvec_kmap_irq(&bv, &flags);
  82                 memset(data, 0, bv.bv_len);
  83                 bvec_kunmap_irq(data, &flags);
  84         }
  85 }
  86
  87 void __bio_clone_fast(struct bio *bio, struct bio *bio_src)
  88 {
  89         /*
  90          * most users will be overriding ->bi_bdev with a new target,
  91          * so we don't set nor calculate new physical/hw segment counts here
  92          */
  93         bio->bi_bdev = bio_src->bi_bdev;
  94         bio_set_flag(bio, BIO_CLONED);
  95         bio->bi_opf = bio_src->bi_opf;
  96         bio->bi_iter = bio_src->bi_iter;
  97         bio->bi_io_vec = bio_src->bi_io_vec;
  98 }
  99
 100 struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs)
 101 {
 102         struct bio *b;
 103
 104         b = bio_alloc_bioset(gfp_mask, 0, bs);
 105         if (!b)
 106                 return NULL;
 107
 108         __bio_clone_fast(b, bio);
 109         return b;
 110 }
 111
 112 struct bio *bio_split(struct bio *bio, int sectors,
 113                       gfp_t gfp, struct bio_set *bs)
 114 {
 115         struct bio *split = NULL;
 116
 117         BUG_ON(sectors <= 0);
 118         BUG_ON(sectors >= bio_sectors(bio));
 119
 120         /*
 121          * Discards need a mutable bio_vec to accommodate the payload
 122          * required by the DSM TRIM and UNMAP commands.
 123          */
 124         if (bio_op(bio) == REQ_OP_DISCARD || bio_op(bio) == REQ_OP_SECURE_ERASE)
 125                 split = bio_clone_bioset(bio, gfp, bs);
 126         else
 127                 split = bio_clone_fast(bio, gfp, bs);
 128
 129         if (!split)
 130                 return NULL;
 131
 132         split->bi_iter.bi_size = sectors << 9;
 133
 134         bio_advance(bio, split->bi_iter.bi_size);
 135
 136         return split;
 137 }
 138
 139 int bio_alloc_pages(struct bio *bio, gfp_t gfp_mask)
 140 {
 141         int i;
 142         struct bio_vec *bv;
 143
 144         bio_for_each_segment_all(bv, bio, i) {
 145                 bv->bv_page = alloc_page(gfp_mask);
 146                 if (!bv->bv_page) {
 147                         while (--bv >= bio->bi_io_vec)
 148                                 __free_page(bv->bv_page);
 149                         return -ENOMEM;
 150                 }
 151         }
 152
 153         return 0;
 154 }
 155
 156 void bio_advance(struct bio *bio, unsigned bytes)
 157 {
 158         bio_advance_iter(bio, &bio->bi_iter, bytes);
 159 }
 160
 161 static void bio_free(struct bio *bio)
 162 {
 163         unsigned front_pad = bio->bi_pool ? bio->bi_pool->front_pad : 0;
 164
 165         kfree((void *) bio - front_pad);
 166 }
 167
 168 void bio_put(struct bio *bio)
 169 {
 170         if (!bio_flagged(bio, BIO_REFFED))
 171                 bio_free(bio);
 172         else {
 173                 BUG_ON(!atomic_read(&bio->__bi_cnt));
 174
 175                 /*
 176                  * last put frees it
 177                  */
 178                 if (atomic_dec_and_test(&bio->__bi_cnt))
 179                         bio_free(bio);
 180         }
 181 }
 182
 183 static inline bool bio_remaining_done(struct bio *bio)
 184 {
 185         /*
 186          * If we're not chaining, then ->__bi_remaining is always 1 and
 187          * we always end io on the first invocation.
 188          */
 189         if (!bio_flagged(bio, BIO_CHAIN))
 190                 return true;
 191
 192         BUG_ON(atomic_read(&bio->__bi_remaining) <= 0);
 193
 194         if (atomic_dec_and_test(&bio->__bi_remaining)) {
 195                 bio_clear_flag(bio, BIO_CHAIN);
 196                 return true;
 197         }
 198
 199         return false;
 200 }
 201
 202 static struct bio *__bio_chain_endio(struct bio *bio)
 203 {
 204         struct bio *parent = bio->bi_private;
 205
 206         if (!parent->bi_error)
 207                 parent->bi_error = bio->bi_error;
 208         bio_put(bio);
 209         return parent;
 210 }
 211
 212 static void bio_chain_endio(struct bio *bio)
 213 {
 214         bio_endio(__bio_chain_endio(bio));
 215 }
 216
 217 void bio_endio(struct bio *bio)
 218 {
 219 again:
 220         if (!bio_remaining_done(bio))
 221                 return;
 222
 223         /*
 224          * Need to have a real endio function for chained bios, otherwise
 225          * various corner cases will break (like stacking block devices that
 226          * save/restore bi_end_io) - however, we want to avoid unbounded
 227          * recursion and blowing the stack. Tail call optimization would
 228          * handle this, but compiling with frame pointers also disables
 229          * gcc's sibling call optimization.
 230          */
 231         if (bio->bi_end_io == bio_chain_endio) {
 232                 bio = __bio_chain_endio(bio);
 233                 goto again;
 234         }
 235
 236         if (bio->bi_end_io)
 237                 bio->bi_end_io(bio);
 238 }
 239
 240 void bio_endio_nodec(struct bio *bio)
 241 {
 242         goto nodec;
 243
 244         while (bio) {
 245                 if (unlikely(!bio_remaining_done(bio)))
 246                         break;
 247 nodec:
 248                 if (bio->bi_end_io == bio_chain_endio) {
 249                         struct bio *parent = bio->bi_private;
 250                         parent->bi_error = bio->bi_error;
 251                         bio_put(bio);
 252                         bio = parent;
 253                 } else {
 254                         if (bio->bi_end_io)
 255                                 bio->bi_end_io(bio);
 256                         bio = NULL;
 257                 }
 258         }
 259 }
 260
 261 void bio_reset(struct bio *bio)
 262 {
 263         unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
 264
 265         memset(bio, 0, BIO_RESET_BYTES);
 266         bio->bi_flags = flags;
 267         atomic_set(&bio->__bi_remaining, 1);
 268 }
 269
 270 struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 271 {
 272         unsigned front_pad = bs ? bs->front_pad : 0;
 273         struct bio *bio;
 274         void *p;
 275
 276         p = kmalloc(front_pad +
 277                     sizeof(struct bio) +
 278                     nr_iovecs * sizeof(struct bio_vec),
 279                     gfp_mask);
 280
 281         if (unlikely(!p))
 282                 return NULL;
 283
 284         bio = p + front_pad;
 285         bio_init(bio);
 286         bio->bi_pool            = bs;
 287         bio->bi_max_vecs        = nr_iovecs;
 288         bio->bi_io_vec          = bio->bi_inline_vecs;
 289
 290         return bio;
 291 }
 292
 293 struct bio *bio_clone_bioset(struct bio *bio_src, gfp_t gfp_mask,
 294                              struct bio_set *bs)
 295 {
 296         struct bvec_iter iter;
 297         struct bio_vec bv;
 298         struct bio *bio;
 299
 300         bio = bio_alloc_bioset(gfp_mask, bio_segments(bio_src), bs);
 301         if (!bio)
 302                 return NULL;
 303
 304         bio->bi_bdev            = bio_src->bi_bdev;
 305         bio->bi_opf             = bio_src->bi_opf;
 306         bio->bi_iter.bi_sector  = bio_src->bi_iter.bi_sector;
 307         bio->bi_iter.bi_size    = bio_src->bi_iter.bi_size;
 308
 309         switch (bio_op(bio)) {
 310         case REQ_OP_DISCARD:
 311         case REQ_OP_SECURE_ERASE:
 312                 break;
 313         case REQ_OP_WRITE_SAME:
 314                 bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0];
 315                 break;
 316         default:
 317                 bio_for_each_segment(bv, bio_src, iter)
 318                         bio->bi_io_vec[bio->bi_vcnt++] = bv;
 319                 break;
 320         }
 321
 322         return bio;
 323 }