LCOV - code coverage report
Current view: top level - include/linux - bio.h (source / functions) Hit Total Coverage
Test: Real Lines: 41 84 48.8 %
Date: 2020-10-17 15:46:16 Functions: 0 8 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
       4                 :            :  */
       5                 :            : #ifndef __LINUX_BIO_H
       6                 :            : #define __LINUX_BIO_H
       7                 :            : 
       8                 :            : #include <linux/highmem.h>
       9                 :            : #include <linux/mempool.h>
      10                 :            : #include <linux/ioprio.h>
      11                 :            : 
      12                 :            : #ifdef CONFIG_BLOCK
      13                 :            : /* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
      14                 :            : #include <linux/blk_types.h>
      15                 :            : 
      16                 :            : #define BIO_DEBUG
      17                 :            : 
      18                 :            : #ifdef BIO_DEBUG
      19                 :            : #define BIO_BUG_ON      BUG_ON
      20                 :            : #else
      21                 :            : #define BIO_BUG_ON
      22                 :            : #endif
      23                 :            : 
      24                 :            : #define BIO_MAX_PAGES           256
      25                 :            : 
      26                 :            : #define bio_prio(bio)                   (bio)->bi_ioprio
      27                 :            : #define bio_set_prio(bio, prio)         ((bio)->bi_ioprio = prio)
      28                 :            : 
      29                 :            : #define bio_iter_iovec(bio, iter)                               \
      30                 :            :         bvec_iter_bvec((bio)->bi_io_vec, (iter))
      31                 :            : 
      32                 :            : #define bio_iter_page(bio, iter)                                \
      33                 :            :         bvec_iter_page((bio)->bi_io_vec, (iter))
      34                 :            : #define bio_iter_len(bio, iter)                                 \
      35                 :            :         bvec_iter_len((bio)->bi_io_vec, (iter))
      36                 :            : #define bio_iter_offset(bio, iter)                              \
      37                 :            :         bvec_iter_offset((bio)->bi_io_vec, (iter))
      38                 :            : 
      39                 :            : #define bio_page(bio)           bio_iter_page((bio), (bio)->bi_iter)
      40                 :            : #define bio_offset(bio)         bio_iter_offset((bio), (bio)->bi_iter)
      41                 :            : #define bio_iovec(bio)          bio_iter_iovec((bio), (bio)->bi_iter)
      42                 :            : 
      43                 :            : #define bio_multiple_segments(bio)                              \
      44                 :            :         ((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
      45                 :            : 
      46                 :            : #define bvec_iter_sectors(iter) ((iter).bi_size >> 9)
      47                 :            : #define bvec_iter_end_sector(iter) ((iter).bi_sector + bvec_iter_sectors((iter)))
      48                 :            : 
      49                 :            : #define bio_sectors(bio)        bvec_iter_sectors((bio)->bi_iter)
      50                 :            : #define bio_end_sector(bio)     bvec_iter_end_sector((bio)->bi_iter)
      51                 :            : 
      52                 :            : /*
      53                 :            :  * Return the data direction, READ or WRITE.
      54                 :            :  */
      55                 :            : #define bio_data_dir(bio) \
      56                 :            :         (op_is_write(bio_op(bio)) ? WRITE : READ)
      57                 :            : 
      58                 :            : /*
      59                 :            :  * Check whether this bio carries any data or not. A NULL bio is allowed.
      60                 :            :  */
      61                 :            : static inline bool bio_has_data(struct bio *bio)
      62                 :            : {
      63                 :          3 :         if (bio &&
      64                 :          3 :             bio->bi_iter.bi_size &&
      65                 :          3 :             bio_op(bio) != REQ_OP_DISCARD &&
      66                 :          3 :             bio_op(bio) != REQ_OP_SECURE_ERASE &&
      67                 :            :             bio_op(bio) != REQ_OP_WRITE_ZEROES)
      68                 :            :                 return true;
      69                 :            : 
      70                 :            :         return false;
      71                 :            : }
      72                 :            : 
      73                 :            : static inline bool bio_no_advance_iter(struct bio *bio)
      74                 :            : {
      75                 :          3 :         return bio_op(bio) == REQ_OP_DISCARD ||
      76                 :          3 :                bio_op(bio) == REQ_OP_SECURE_ERASE ||
      77                 :          3 :                bio_op(bio) == REQ_OP_WRITE_SAME ||
      78                 :            :                bio_op(bio) == REQ_OP_WRITE_ZEROES;
      79                 :            : }
      80                 :            : 
      81                 :            : static inline bool bio_mergeable(struct bio *bio)
      82                 :            : {
      83                 :          3 :         if (bio->bi_opf & REQ_NOMERGE_FLAGS)
      84                 :            :                 return false;
      85                 :            : 
      86                 :            :         return true;
      87                 :            : }
      88                 :            : 
      89                 :          0 : static inline unsigned int bio_cur_bytes(struct bio *bio)
      90                 :            : {
      91                 :          0 :         if (bio_has_data(bio))
      92                 :          0 :                 return bio_iovec(bio).bv_len;
      93                 :            :         else /* dataless requests such as discard */
      94                 :          0 :                 return bio->bi_iter.bi_size;
      95                 :            : }
      96                 :            : 
      97                 :            : static inline void *bio_data(struct bio *bio)
      98                 :            : {
      99                 :            :         if (bio_has_data(bio))
     100                 :            :                 return page_address(bio_page(bio)) + bio_offset(bio);
     101                 :            : 
     102                 :            :         return NULL;
     103                 :            : }
     104                 :            : 
     105                 :            : /**
     106                 :            :  * bio_full - check if the bio is full
     107                 :            :  * @bio:        bio to check
     108                 :            :  * @len:        length of one segment to be added
     109                 :            :  *
     110                 :            :  * Return true if @bio is full and one segment with @len bytes can't be
     111                 :            :  * added to the bio, otherwise return false
     112                 :            :  */
     113                 :            : static inline bool bio_full(struct bio *bio, unsigned len)
     114                 :            : {
     115                 :          3 :         if (bio->bi_vcnt >= bio->bi_max_vecs)
     116                 :            :                 return true;
     117                 :            : 
     118                 :          3 :         if (bio->bi_iter.bi_size > UINT_MAX - len)
     119                 :            :                 return true;
     120                 :            : 
     121                 :            :         return false;
     122                 :            : }
     123                 :            : 
     124                 :            : static inline bool bio_next_segment(const struct bio *bio,
     125                 :            :                                     struct bvec_iter_all *iter)
     126                 :            : {
     127                 :          3 :         if (iter->idx >= bio->bi_vcnt)
     128                 :            :                 return false;
     129                 :            : 
     130                 :          3 :         bvec_advance(&bio->bi_io_vec[iter->idx], iter);
     131                 :            :         return true;
     132                 :            : }
     133                 :            : 
     134                 :            : /*
     135                 :            :  * drivers should _never_ use the all version - the bio may have been split
     136                 :            :  * before it got to the driver and the driver won't own all of it
     137                 :            :  */
     138                 :            : #define bio_for_each_segment_all(bvl, bio, iter) \
     139                 :            :         for (bvl = bvec_init_iter_all(&iter); bio_next_segment((bio), &iter); )
     140                 :            : 
     141                 :          3 : static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
     142                 :            :                                     unsigned bytes)
     143                 :            : {
     144                 :          3 :         iter->bi_sector += bytes >> 9;
     145                 :            : 
     146                 :          3 :         if (bio_no_advance_iter(bio))
     147                 :          0 :                 iter->bi_size -= bytes;
     148                 :            :         else
     149                 :          3 :                 bvec_iter_advance(bio->bi_io_vec, iter, bytes);
     150                 :            :                 /* TODO: It is reasonable to complete bio with error here. */
     151                 :          3 : }
     152                 :            : 
     153                 :            : #define __bio_for_each_segment(bvl, bio, iter, start)                   \
     154                 :            :         for (iter = (start);                                            \
     155                 :            :              (iter).bi_size &&                                          \
     156                 :            :                 ((bvl = bio_iter_iovec((bio), (iter))), 1);             \
     157                 :            :              bio_advance_iter((bio), &(iter), (bvl).bv_len))
     158                 :            : 
     159                 :            : #define bio_for_each_segment(bvl, bio, iter)                            \
     160                 :            :         __bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
     161                 :            : 
     162                 :            : #define __bio_for_each_bvec(bvl, bio, iter, start)              \
     163                 :            :         for (iter = (start);                                            \
     164                 :            :              (iter).bi_size &&                                          \
     165                 :            :                 ((bvl = mp_bvec_iter_bvec((bio)->bi_io_vec, (iter))), 1); \
     166                 :            :              bio_advance_iter((bio), &(iter), (bvl).bv_len))
     167                 :            : 
     168                 :            : /* iterate over multi-page bvec */
     169                 :            : #define bio_for_each_bvec(bvl, bio, iter)                       \
     170                 :            :         __bio_for_each_bvec(bvl, bio, iter, (bio)->bi_iter)
     171                 :            : 
     172                 :            : #define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
     173                 :            : 
     174                 :            : static inline unsigned bio_segments(struct bio *bio)
     175                 :            : {
     176                 :            :         unsigned segs = 0;
     177                 :            :         struct bio_vec bv;
     178                 :            :         struct bvec_iter iter;
     179                 :            : 
     180                 :            :         /*
     181                 :            :          * We special case discard/write same/write zeroes, because they
     182                 :            :          * interpret bi_size differently:
     183                 :            :          */
     184                 :            : 
     185                 :            :         switch (bio_op(bio)) {
     186                 :            :         case REQ_OP_DISCARD:
     187                 :            :         case REQ_OP_SECURE_ERASE:
     188                 :            :         case REQ_OP_WRITE_ZEROES:
     189                 :            :                 return 0;
     190                 :            :         case REQ_OP_WRITE_SAME:
     191                 :            :                 return 1;
     192                 :            :         default:
     193                 :            :                 break;
     194                 :            :         }
     195                 :            : 
     196                 :            :         bio_for_each_segment(bv, bio, iter)
     197                 :            :                 segs++;
     198                 :            : 
     199                 :            :         return segs;
     200                 :            : }
     201                 :            : 
     202                 :            : /*
     203                 :            :  * get a reference to a bio, so it won't disappear. the intended use is
     204                 :            :  * something like:
     205                 :            :  *
     206                 :            :  * bio_get(bio);
     207                 :            :  * submit_bio(rw, bio);
     208                 :            :  * if (bio->bi_flags ...)
     209                 :            :  *      do_something
     210                 :            :  * bio_put(bio);
     211                 :            :  *
     212                 :            :  * without the bio_get(), it could potentially complete I/O before submit_bio
     213                 :            :  * returns. and then bio would be freed memory when if (bio->bi_flags ...)
     214                 :            :  * runs
     215                 :            :  */
     216                 :          0 : static inline void bio_get(struct bio *bio)
     217                 :            : {
     218                 :          0 :         bio->bi_flags |= (1 << BIO_REFFED);
     219                 :          0 :         smp_mb__before_atomic();
     220                 :          0 :         atomic_inc(&bio->__bi_cnt);
     221                 :          0 : }
     222                 :            : 
     223                 :            : static inline void bio_cnt_set(struct bio *bio, unsigned int count)
     224                 :            : {
     225                 :            :         if (count != 1) {
     226                 :            :                 bio->bi_flags |= (1 << BIO_REFFED);
     227                 :            :                 smp_mb();
     228                 :            :         }
     229                 :            :         atomic_set(&bio->__bi_cnt, count);
     230                 :            : }
     231                 :            : 
     232                 :            : static inline bool bio_flagged(struct bio *bio, unsigned int bit)
     233                 :            : {
     234                 :          3 :         return (bio->bi_flags & (1U << bit)) != 0;
     235                 :            : }
     236                 :            : 
     237                 :            : static inline void bio_set_flag(struct bio *bio, unsigned int bit)
     238                 :            : {
     239                 :          3 :         bio->bi_flags |= (1U << bit);
     240                 :            : }
     241                 :            : 
     242                 :            : static inline void bio_clear_flag(struct bio *bio, unsigned int bit)
     243                 :            : {
     244                 :          3 :         bio->bi_flags &= ~(1U << bit);
     245                 :            : }
     246                 :            : 
     247                 :          0 : static inline void bio_get_first_bvec(struct bio *bio, struct bio_vec *bv)
     248                 :            : {
     249                 :          0 :         *bv = bio_iovec(bio);
     250                 :          0 : }
     251                 :            : 
     252                 :          0 : static inline void bio_get_last_bvec(struct bio *bio, struct bio_vec *bv)
     253                 :            : {
     254                 :          0 :         struct bvec_iter iter = bio->bi_iter;
     255                 :            :         int idx;
     256                 :            : 
     257                 :          0 :         if (unlikely(!bio_multiple_segments(bio))) {
     258                 :          0 :                 *bv = bio_iovec(bio);
     259                 :          0 :                 return;
     260                 :            :         }
     261                 :            : 
     262                 :          0 :         bio_advance_iter(bio, &iter, iter.bi_size);
     263                 :            : 
     264                 :          0 :         if (!iter.bi_bvec_done)
     265                 :          0 :                 idx = iter.bi_idx - 1;
     266                 :            :         else    /* in the middle of bvec */
     267                 :          0 :                 idx = iter.bi_idx;
     268                 :            : 
     269                 :          0 :         *bv = bio->bi_io_vec[idx];
     270                 :            : 
     271                 :            :         /*
     272                 :            :          * iter.bi_bvec_done records actual length of the last bvec
     273                 :            :          * if this bio ends in the middle of one io vector
     274                 :            :          */
     275                 :          0 :         if (iter.bi_bvec_done)
     276                 :          0 :                 bv->bv_len = iter.bi_bvec_done;
     277                 :            : }
     278                 :            : 
     279                 :          0 : static inline struct bio_vec *bio_first_bvec_all(struct bio *bio)
     280                 :            : {
     281                 :          0 :         WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
     282                 :          0 :         return bio->bi_io_vec;
     283                 :            : }
     284                 :            : 
     285                 :            : static inline struct page *bio_first_page_all(struct bio *bio)
     286                 :            : {
     287                 :          0 :         return bio_first_bvec_all(bio)->bv_page;
     288                 :            : }
     289                 :            : 
     290                 :            : static inline struct bio_vec *bio_last_bvec_all(struct bio *bio)
     291                 :            : {
     292                 :            :         WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
     293                 :            :         return &bio->bi_io_vec[bio->bi_vcnt - 1];
     294                 :            : }
     295                 :            : 
     296                 :            : enum bip_flags {
     297                 :            :         BIP_BLOCK_INTEGRITY     = 1 << 0, /* block layer owns integrity data */
     298                 :            :         BIP_MAPPED_INTEGRITY    = 1 << 1, /* ref tag has been remapped */
     299                 :            :         BIP_CTRL_NOCHECK        = 1 << 2, /* disable HBA integrity checking */
     300                 :            :         BIP_DISK_NOCHECK        = 1 << 3, /* disable disk integrity checking */
     301                 :            :         BIP_IP_CHECKSUM         = 1 << 4, /* IP checksum */
     302                 :            : };
     303                 :            : 
     304                 :            : /*
     305                 :            :  * bio integrity payload
     306                 :            :  */
     307                 :            : struct bio_integrity_payload {
     308                 :            :         struct bio              *bip_bio;       /* parent bio */
     309                 :            : 
     310                 :            :         struct bvec_iter        bip_iter;
     311                 :            : 
     312                 :            :         unsigned short          bip_slab;       /* slab the bip came from */
     313                 :            :         unsigned short          bip_vcnt;       /* # of integrity bio_vecs */
     314                 :            :         unsigned short          bip_max_vcnt;   /* integrity bio_vec slots */
     315                 :            :         unsigned short          bip_flags;      /* control flags */
     316                 :            : 
     317                 :            :         struct bvec_iter        bio_iter;       /* for rewinding parent bio */
     318                 :            : 
     319                 :            :         struct work_struct      bip_work;       /* I/O completion */
     320                 :            : 
     321                 :            :         struct bio_vec          *bip_vec;
     322                 :            :         struct bio_vec          bip_inline_vecs[0];/* embedded bvec array */
     323                 :            : };
     324                 :            : 
     325                 :            : #if defined(CONFIG_BLK_DEV_INTEGRITY)
     326                 :            : 
     327                 :            : static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
     328                 :            : {
     329                 :            :         if (bio->bi_opf & REQ_INTEGRITY)
     330                 :            :                 return bio->bi_integrity;
     331                 :            : 
     332                 :            :         return NULL;
     333                 :            : }
     334                 :            : 
     335                 :            : static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
     336                 :            : {
     337                 :            :         struct bio_integrity_payload *bip = bio_integrity(bio);
     338                 :            : 
     339                 :            :         if (bip)
     340                 :            :                 return bip->bip_flags & flag;
     341                 :            : 
     342                 :            :         return false;
     343                 :            : }
     344                 :            : 
     345                 :            : static inline sector_t bip_get_seed(struct bio_integrity_payload *bip)
     346                 :            : {
     347                 :            :         return bip->bip_iter.bi_sector;
     348                 :            : }
     349                 :            : 
     350                 :            : static inline void bip_set_seed(struct bio_integrity_payload *bip,
     351                 :            :                                 sector_t seed)
     352                 :            : {
     353                 :            :         bip->bip_iter.bi_sector = seed;
     354                 :            : }
     355                 :            : 
     356                 :            : #endif /* CONFIG_BLK_DEV_INTEGRITY */
     357                 :            : 
     358                 :            : extern void bio_trim(struct bio *bio, int offset, int size);
     359                 :            : extern struct bio *bio_split(struct bio *bio, int sectors,
     360                 :            :                              gfp_t gfp, struct bio_set *bs);
     361                 :            : 
     362                 :            : /**
     363                 :            :  * bio_next_split - get next @sectors from a bio, splitting if necessary
     364                 :            :  * @bio:        bio to split
     365                 :            :  * @sectors:    number of sectors to split from the front of @bio
     366                 :            :  * @gfp:        gfp mask
     367                 :            :  * @bs:         bio set to allocate from
     368                 :            :  *
     369                 :            :  * Returns a bio representing the next @sectors of @bio - if the bio is smaller
     370                 :            :  * than @sectors, returns the original bio unchanged.
     371                 :            :  */
     372                 :            : static inline struct bio *bio_next_split(struct bio *bio, int sectors,
     373                 :            :                                          gfp_t gfp, struct bio_set *bs)
     374                 :            : {
     375                 :            :         if (sectors >= bio_sectors(bio))
     376                 :            :                 return bio;
     377                 :            : 
     378                 :            :         return bio_split(bio, sectors, gfp, bs);
     379                 :            : }
     380                 :            : 
     381                 :            : enum {
     382                 :            :         BIOSET_NEED_BVECS = BIT(0),
     383                 :            :         BIOSET_NEED_RESCUER = BIT(1),
     384                 :            : };
     385                 :            : extern int bioset_init(struct bio_set *, unsigned int, unsigned int, int flags);
     386                 :            : extern void bioset_exit(struct bio_set *);
     387                 :            : extern int biovec_init_pool(mempool_t *pool, int pool_entries);
     388                 :            : extern int bioset_init_from_src(struct bio_set *bs, struct bio_set *src);
     389                 :            : 
     390                 :            : extern struct bio *bio_alloc_bioset(gfp_t, unsigned int, struct bio_set *);
     391                 :            : extern void bio_put(struct bio *);
     392                 :            : 
     393                 :            : extern void __bio_clone_fast(struct bio *, struct bio *);
     394                 :            : extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
     395                 :            : 
     396                 :            : extern struct bio_set fs_bio_set;
     397                 :            : 
     398                 :            : static inline struct bio *bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
     399                 :            : {
     400                 :          3 :         return bio_alloc_bioset(gfp_mask, nr_iovecs, &fs_bio_set);
     401                 :            : }
     402                 :            : 
     403                 :            : static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs)
     404                 :            : {
     405                 :          0 :         return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
     406                 :            : }
     407                 :            : 
     408                 :            : extern blk_qc_t submit_bio(struct bio *);
     409                 :            : 
     410                 :            : extern void bio_endio(struct bio *);
     411                 :            : 
     412                 :            : static inline void bio_io_error(struct bio *bio)
     413                 :            : {
     414                 :          0 :         bio->bi_status = BLK_STS_IOERR;
     415                 :          0 :         bio_endio(bio);
     416                 :            : }
     417                 :            : 
     418                 :            : static inline void bio_wouldblock_error(struct bio *bio)
     419                 :            : {
     420                 :          0 :         bio->bi_status = BLK_STS_AGAIN;
     421                 :          0 :         bio_endio(bio);
     422                 :            : }
     423                 :            : 
     424                 :            : struct request_queue;
     425                 :            : 
     426                 :            : extern int submit_bio_wait(struct bio *bio);
     427                 :            : extern void bio_advance(struct bio *, unsigned);
     428                 :            : 
     429                 :            : extern void bio_init(struct bio *bio, struct bio_vec *table,
     430                 :            :                      unsigned short max_vecs);
     431                 :            : extern void bio_uninit(struct bio *);
     432                 :            : extern void bio_reset(struct bio *);
     433                 :            : void bio_chain(struct bio *, struct bio *);
     434                 :            : 
     435                 :            : extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
     436                 :            : extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
     437                 :            :                            unsigned int, unsigned int);
     438                 :            : bool __bio_try_merge_page(struct bio *bio, struct page *page,
     439                 :            :                 unsigned int len, unsigned int off, bool *same_page);
     440                 :            : void __bio_add_page(struct bio *bio, struct page *page,
     441                 :            :                 unsigned int len, unsigned int off);
     442                 :            : int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter);
     443                 :            : void bio_release_pages(struct bio *bio, bool mark_dirty);
     444                 :            : struct rq_map_data;
     445                 :            : extern struct bio *bio_map_user_iov(struct request_queue *,
     446                 :            :                                     struct iov_iter *, gfp_t);
     447                 :            : extern void bio_unmap_user(struct bio *);
     448                 :            : extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
     449                 :            :                                 gfp_t);
     450                 :            : extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
     451                 :            :                                  gfp_t, int);
     452                 :            : extern void bio_set_pages_dirty(struct bio *bio);
     453                 :            : extern void bio_check_pages_dirty(struct bio *bio);
     454                 :            : 
     455                 :            : void generic_start_io_acct(struct request_queue *q, int op,
     456                 :            :                                 unsigned long sectors, struct hd_struct *part);
     457                 :            : void generic_end_io_acct(struct request_queue *q, int op,
     458                 :            :                                 struct hd_struct *part,
     459                 :            :                                 unsigned long start_time);
     460                 :            : 
     461                 :            : extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
     462                 :            :                                struct bio *src, struct bvec_iter *src_iter);
     463                 :            : extern void bio_copy_data(struct bio *dst, struct bio *src);
     464                 :            : extern void bio_list_copy_data(struct bio *dst, struct bio *src);
     465                 :            : extern void bio_free_pages(struct bio *bio);
     466                 :            : 
     467                 :            : extern struct bio *bio_copy_user_iov(struct request_queue *,
     468                 :            :                                      struct rq_map_data *,
     469                 :            :                                      struct iov_iter *,
     470                 :            :                                      gfp_t);
     471                 :            : extern int bio_uncopy_user(struct bio *);
     472                 :            : void zero_fill_bio_iter(struct bio *bio, struct bvec_iter iter);
     473                 :            : void bio_truncate(struct bio *bio, unsigned new_size);
     474                 :            : 
     475                 :            : static inline void zero_fill_bio(struct bio *bio)
     476                 :            : {
     477                 :          0 :         zero_fill_bio_iter(bio, bio->bi_iter);
     478                 :            : }
     479                 :            : 
     480                 :            : extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
     481                 :            : extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
     482                 :            : extern unsigned int bvec_nr_vecs(unsigned short idx);
     483                 :            : extern const char *bio_devname(struct bio *bio, char *buffer);
     484                 :            : 
     485                 :            : #define bio_set_dev(bio, bdev)                  \
     486                 :            : do {                                            \
     487                 :            :         if ((bio)->bi_disk != (bdev)->bd_disk)    \
     488                 :            :                 bio_clear_flag(bio, BIO_THROTTLED);\
     489                 :            :         (bio)->bi_disk = (bdev)->bd_disk; \
     490                 :            :         (bio)->bi_partno = (bdev)->bd_partno;     \
     491                 :            :         bio_associate_blkg(bio);                \
     492                 :            : } while (0)
     493                 :            : 
     494                 :            : #define bio_copy_dev(dst, src)                  \
     495                 :            : do {                                            \
     496                 :            :         (dst)->bi_disk = (src)->bi_disk;  \
     497                 :            :         (dst)->bi_partno = (src)->bi_partno;      \
     498                 :            :         bio_clone_blkg_association(dst, src);   \
     499                 :            : } while (0)
     500                 :            : 
     501                 :            : #define bio_dev(bio) \
     502                 :            :         disk_devt((bio)->bi_disk)
     503                 :            : 
     504                 :            : #if defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP)
     505                 :            : void bio_associate_blkg_from_page(struct bio *bio, struct page *page);
     506                 :            : #else
     507                 :            : static inline void bio_associate_blkg_from_page(struct bio *bio,
     508                 :            :                                                 struct page *page) { }
     509                 :            : #endif
     510                 :            : 
     511                 :            : #ifdef CONFIG_BLK_CGROUP
     512                 :            : void bio_disassociate_blkg(struct bio *bio);
     513                 :            : void bio_associate_blkg(struct bio *bio);
     514                 :            : void bio_associate_blkg_from_css(struct bio *bio,
     515                 :            :                                  struct cgroup_subsys_state *css);
     516                 :            : void bio_clone_blkg_association(struct bio *dst, struct bio *src);
     517                 :            : #else   /* CONFIG_BLK_CGROUP */
     518                 :            : static inline void bio_disassociate_blkg(struct bio *bio) { }
     519                 :            : static inline void bio_associate_blkg(struct bio *bio) { }
     520                 :            : static inline void bio_associate_blkg_from_css(struct bio *bio,
     521                 :            :                                                struct cgroup_subsys_state *css)
     522                 :            : { }
     523                 :            : static inline void bio_clone_blkg_association(struct bio *dst,
     524                 :            :                                               struct bio *src) { }
     525                 :            : #endif  /* CONFIG_BLK_CGROUP */
     526                 :            : 
     527                 :            : #ifdef CONFIG_HIGHMEM
     528                 :            : /*
     529                 :            :  * remember never ever reenable interrupts between a bvec_kmap_irq and
     530                 :            :  * bvec_kunmap_irq!
     531                 :            :  */
     532                 :            : static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
     533                 :            : {
     534                 :            :         unsigned long addr;
     535                 :            : 
     536                 :            :         /*
     537                 :            :          * might not be a highmem page, but the preempt/irq count
     538                 :            :          * balancing is a lot nicer this way
     539                 :            :          */
     540                 :            :         local_irq_save(*flags);
     541                 :            :         addr = (unsigned long) kmap_atomic(bvec->bv_page);
     542                 :            : 
     543                 :            :         BUG_ON(addr & ~PAGE_MASK);
     544                 :            : 
     545                 :            :         return (char *) addr + bvec->bv_offset;
     546                 :            : }
     547                 :            : 
     548                 :            : static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
     549                 :            : {
     550                 :            :         unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
     551                 :            : 
     552                 :            :         kunmap_atomic((void *) ptr);
     553                 :            :         local_irq_restore(*flags);
     554                 :            : }
     555                 :            : 
     556                 :            : #else
     557                 :          0 : static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
     558                 :            : {
     559                 :          0 :         return page_address(bvec->bv_page) + bvec->bv_offset;
     560                 :            : }
     561                 :            : 
     562                 :            : static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
     563                 :            : {
     564                 :          0 :         *flags = 0;
     565                 :            : }
     566                 :            : #endif
     567                 :            : 
     568                 :            : /*
     569                 :            :  * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
     570                 :            :  *
     571                 :            :  * A bio_list anchors a singly-linked list of bios chained through the bi_next
     572                 :            :  * member of the bio.  The bio_list also caches the last list member to allow
     573                 :            :  * fast access to the tail.
     574                 :            :  */
     575                 :            : struct bio_list {
     576                 :            :         struct bio *head;
     577                 :            :         struct bio *tail;
     578                 :            : };
     579                 :            : 
     580                 :            : static inline int bio_list_empty(const struct bio_list *bl)
     581                 :            : {
     582                 :          3 :         return bl->head == NULL;
     583                 :            : }
     584                 :            : 
     585                 :            : static inline void bio_list_init(struct bio_list *bl)
     586                 :            : {
     587                 :          3 :         bl->head = bl->tail = NULL;
     588                 :            : }
     589                 :            : 
     590                 :            : #define BIO_EMPTY_LIST  { NULL, NULL }
     591                 :            : 
     592                 :            : #define bio_list_for_each(bio, bl) \
     593                 :            :         for (bio = (bl)->head; bio; bio = bio->bi_next)
     594                 :            : 
     595                 :            : static inline unsigned bio_list_size(const struct bio_list *bl)
     596                 :            : {
     597                 :            :         unsigned sz = 0;
     598                 :            :         struct bio *bio;
     599                 :            : 
     600                 :            :         bio_list_for_each(bio, bl)
     601                 :            :                 sz++;
     602                 :            : 
     603                 :            :         return sz;
     604                 :            : }
     605                 :            : 
     606                 :            : static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
     607                 :            : {
     608                 :          3 :         bio->bi_next = NULL;
     609                 :            : 
     610                 :          3 :         if (bl->tail)
     611                 :          0 :                 bl->tail->bi_next = bio;
     612                 :            :         else
     613                 :          3 :                 bl->head = bio;
     614                 :            : 
     615                 :          3 :         bl->tail = bio;
     616                 :            : }
     617                 :            : 
     618                 :            : static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
     619                 :            : {
     620                 :            :         bio->bi_next = bl->head;
     621                 :            : 
     622                 :            :         bl->head = bio;
     623                 :            : 
     624                 :            :         if (!bl->tail)
     625                 :            :                 bl->tail = bio;
     626                 :            : }
     627                 :            : 
     628                 :            : static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
     629                 :            : {
     630                 :          3 :         if (!bl2->head)
     631                 :            :                 return;
     632                 :            : 
     633                 :          3 :         if (bl->tail)
     634                 :          0 :                 bl->tail->bi_next = bl2->head;
     635                 :            :         else
     636                 :          3 :                 bl->head = bl2->head;
     637                 :            : 
     638                 :          3 :         bl->tail = bl2->tail;
     639                 :            : }
     640                 :            : 
     641                 :            : static inline void bio_list_merge_head(struct bio_list *bl,
     642                 :            :                                        struct bio_list *bl2)
     643                 :            : {
     644                 :            :         if (!bl2->head)
     645                 :            :                 return;
     646                 :            : 
     647                 :            :         if (bl->head)
     648                 :            :                 bl2->tail->bi_next = bl->head;
     649                 :            :         else
     650                 :            :                 bl->tail = bl2->tail;
     651                 :            : 
     652                 :            :         bl->head = bl2->head;
     653                 :            : }
     654                 :            : 
     655                 :            : static inline struct bio *bio_list_peek(struct bio_list *bl)
     656                 :            : {
     657                 :            :         return bl->head;
     658                 :            : }
     659                 :            : 
     660                 :            : static inline struct bio *bio_list_pop(struct bio_list *bl)
     661                 :            : {
     662                 :          3 :         struct bio *bio = bl->head;
     663                 :            : 
     664                 :          3 :         if (bio) {
     665                 :          3 :                 bl->head = bl->head->bi_next;
     666                 :          3 :                 if (!bl->head)
     667                 :          3 :                         bl->tail = NULL;
     668                 :            : 
     669                 :          3 :                 bio->bi_next = NULL;
     670                 :            :         }
     671                 :            : 
     672                 :            :         return bio;
     673                 :            : }
     674                 :            : 
     675                 :            : static inline struct bio *bio_list_get(struct bio_list *bl)
     676                 :            : {
     677                 :            :         struct bio *bio = bl->head;
     678                 :            : 
     679                 :            :         bl->head = bl->tail = NULL;
     680                 :            : 
     681                 :            :         return bio;
     682                 :            : }
     683                 :            : 
     684                 :            : /*
     685                 :            :  * Increment chain count for the bio. Make sure the CHAIN flag update
     686                 :            :  * is visible before the raised count.
     687                 :            :  */
     688                 :          3 : static inline void bio_inc_remaining(struct bio *bio)
     689                 :            : {
     690                 :            :         bio_set_flag(bio, BIO_CHAIN);
     691                 :          3 :         smp_mb__before_atomic();
     692                 :          3 :         atomic_inc(&bio->__bi_remaining);
     693                 :          3 : }
     694                 :            : 
     695                 :            : /*
     696                 :            :  * bio_set is used to allow other portions of the IO system to
     697                 :            :  * allocate their own private memory pools for bio and iovec structures.
     698                 :            :  * These memory pools in turn all allocate from the bio_slab
     699                 :            :  * and the bvec_slabs[].
     700                 :            :  */
     701                 :            : #define BIO_POOL_SIZE 2
     702                 :            : 
     703                 :            : struct bio_set {
     704                 :            :         struct kmem_cache *bio_slab;
     705                 :            :         unsigned int front_pad;
     706                 :            : 
     707                 :            :         mempool_t bio_pool;
     708                 :            :         mempool_t bvec_pool;
     709                 :            : #if defined(CONFIG_BLK_DEV_INTEGRITY)
     710                 :            :         mempool_t bio_integrity_pool;
     711                 :            :         mempool_t bvec_integrity_pool;
     712                 :            : #endif
     713                 :            : 
     714                 :            :         /*
     715                 :            :          * Deadlock avoidance for stacking block drivers: see comments in
     716                 :            :          * bio_alloc_bioset() for details
     717                 :            :          */
     718                 :            :         spinlock_t              rescue_lock;
     719                 :            :         struct bio_list         rescue_list;
     720                 :            :         struct work_struct      rescue_work;
     721                 :            :         struct workqueue_struct *rescue_workqueue;
     722                 :            : };
     723                 :            : 
     724                 :            : struct biovec_slab {
     725                 :            :         int nr_vecs;
     726                 :            :         char *name;
     727                 :            :         struct kmem_cache *slab;
     728                 :            : };
     729                 :            : 
     730                 :            : static inline bool bioset_initialized(struct bio_set *bs)
     731                 :            : {
     732                 :            :         return bs->bio_slab != NULL;
     733                 :            : }
     734                 :            : 
     735                 :            : /*
     736                 :            :  * a small number of entries is fine, not going to be performance critical.
     737                 :            :  * basically we just need to survive
     738                 :            :  */
     739                 :            : #define BIO_SPLIT_ENTRIES 2
     740                 :            : 
     741                 :            : #if defined(CONFIG_BLK_DEV_INTEGRITY)
     742                 :            : 
     743                 :            : #define bip_for_each_vec(bvl, bip, iter)                                \
     744                 :            :         for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
     745                 :            : 
     746                 :            : #define bio_for_each_integrity_vec(_bvl, _bio, _iter)                   \
     747                 :            :         for_each_bio(_bio)                                              \
     748                 :            :                 bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
     749                 :            : 
     750                 :            : extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
     751                 :            : extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
     752                 :            : extern bool bio_integrity_prep(struct bio *);
     753                 :            : extern void bio_integrity_advance(struct bio *, unsigned int);
     754                 :            : extern void bio_integrity_trim(struct bio *);
     755                 :            : extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
     756                 :            : extern int bioset_integrity_create(struct bio_set *, int);
     757                 :            : extern void bioset_integrity_free(struct bio_set *);
     758                 :            : extern void bio_integrity_init(void);
     759                 :            : 
     760                 :            : #else /* CONFIG_BLK_DEV_INTEGRITY */
     761                 :            : 
     762                 :            : static inline void *bio_integrity(struct bio *bio)
     763                 :            : {
     764                 :            :         return NULL;
     765                 :            : }
     766                 :            : 
     767                 :            : static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
     768                 :            : {
     769                 :            :         return 0;
     770                 :            : }
     771                 :            : 
     772                 :            : static inline void bioset_integrity_free (struct bio_set *bs)
     773                 :            : {
     774                 :            :         return;
     775                 :            : }
     776                 :            : 
     777                 :            : static inline bool bio_integrity_prep(struct bio *bio)
     778                 :            : {
     779                 :            :         return true;
     780                 :            : }
     781                 :            : 
     782                 :            : static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
     783                 :            :                                       gfp_t gfp_mask)
     784                 :            : {
     785                 :            :         return 0;
     786                 :            : }
     787                 :            : 
     788                 :            : static inline void bio_integrity_advance(struct bio *bio,
     789                 :            :                                          unsigned int bytes_done)
     790                 :            : {
     791                 :            :         return;
     792                 :            : }
     793                 :            : 
     794                 :            : static inline void bio_integrity_trim(struct bio *bio)
     795                 :            : {
     796                 :            :         return;
     797                 :            : }
     798                 :            : 
     799                 :            : static inline void bio_integrity_init(void)
     800                 :            : {
     801                 :            :         return;
     802                 :            : }
     803                 :            : 
     804                 :            : static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
     805                 :            : {
     806                 :            :         return false;
     807                 :            : }
     808                 :            : 
     809                 :            : static inline void *bio_integrity_alloc(struct bio * bio, gfp_t gfp,
     810                 :            :                                                                 unsigned int nr)
     811                 :            : {
     812                 :            :         return ERR_PTR(-EINVAL);
     813                 :            : }
     814                 :            : 
     815                 :            : static inline int bio_integrity_add_page(struct bio *bio, struct page *page,
     816                 :            :                                         unsigned int len, unsigned int offset)
     817                 :            : {
     818                 :            :         return 0;
     819                 :            : }
     820                 :            : 
     821                 :            : #endif /* CONFIG_BLK_DEV_INTEGRITY */
     822                 :            : 
     823                 :            : /*
     824                 :            :  * Mark a bio as polled. Note that for async polled IO, the caller must
     825                 :            :  * expect -EWOULDBLOCK if we cannot allocate a request (or other resources).
     826                 :            :  * We cannot block waiting for requests on polled IO, as those completions
     827                 :            :  * must be found by the caller. This is different than IRQ driven IO, where
     828                 :            :  * it's safe to wait for IO to complete.
     829                 :            :  */
     830                 :            : static inline void bio_set_polled(struct bio *bio, struct kiocb *kiocb)
     831                 :            : {
     832                 :          0 :         bio->bi_opf |= REQ_HIPRI;
     833                 :          0 :         if (!is_sync_kiocb(kiocb))
     834                 :          0 :                 bio->bi_opf |= REQ_NOWAIT;
     835                 :            : }
     836                 :            : 
     837                 :            : #endif /* CONFIG_BLOCK */
     838                 :            : #endif /* __LINUX_BIO_H */
    

Generated by: LCOV version 1.14