git.sesse.net Git - bcachefs-tools-debian/blob - include/linux/blk_types.h

   1 /*
   2  * Block data types and constants.  Directly include this file only to
   3  * break include dependency loop.
   4  */
   5 #ifndef __LINUX_BLK_TYPES_H
   6 #define __LINUX_BLK_TYPES_H
   7
   8 #include <linux/atomic.h>
   9 #include <linux/types.h>
  10 #include <linux/bvec.h>
  11 #include <linux/kobject.h>
  12
  13 struct bio_set;
  14 struct bio;
  15 typedef void (bio_end_io_t) (struct bio *);
  16
  17 #define BDEVNAME_SIZE   32
  18
  19 struct request_queue {
  20         struct backing_dev_info *backing_dev_info;
  21 };
  22
  23 struct gendisk {
  24         struct backing_dev_info *bdi;
  25         struct backing_dev_info __bdi;
  26 };
  27
  28 struct hd_struct {
  29         struct kobject          kobj;
  30 };
  31
  32 struct block_device {
  33         struct kobject          kobj;
  34         dev_t                   bd_dev;
  35         char                    name[BDEVNAME_SIZE];
  36         struct inode            *bd_inode;
  37         struct request_queue    queue;
  38         void                    *bd_holder;
  39         struct gendisk *        bd_disk;
  40         struct gendisk          __bd_disk;
  41         int                     bd_fd;
  42         int                     bd_sync_fd;
  43 };
  44
  45 #define bdev_kobj(_bdev) (&((_bdev)->kobj))
  46
  47 /*
  48  * Block error status values.  See block/blk-core:blk_errors for the details.
  49  */
  50 typedef u8 __bitwise blk_status_t;
  51 #define BLK_STS_OK 0
  52 #define BLK_STS_NOTSUPP         ((__force blk_status_t)1)
  53 #define BLK_STS_TIMEOUT         ((__force blk_status_t)2)
  54 #define BLK_STS_NOSPC           ((__force blk_status_t)3)
  55 #define BLK_STS_TRANSPORT       ((__force blk_status_t)4)
  56 #define BLK_STS_TARGET          ((__force blk_status_t)5)
  57 #define BLK_STS_NEXUS           ((__force blk_status_t)6)
  58 #define BLK_STS_MEDIUM          ((__force blk_status_t)7)
  59 #define BLK_STS_PROTECTION      ((__force blk_status_t)8)
  60 #define BLK_STS_RESOURCE        ((__force blk_status_t)9)
  61 #define BLK_STS_IOERR           ((__force blk_status_t)10)
  62
  63 /* hack for device mapper, don't use elsewhere: */
  64 #define BLK_STS_DM_REQUEUE    ((__force blk_status_t)11)
  65
  66 #define BLK_STS_AGAIN           ((__force blk_status_t)12)
  67
  68 /*
  69  * main unit of I/O for the block layer and lower layers (ie drivers and
  70  * stacking drivers)
  71  */
  72 struct bio {
  73         struct bio              *bi_next;       /* request queue link */
  74         struct block_device     *bi_bdev;
  75         blk_status_t            bi_status;
  76         unsigned int            bi_opf;         /* bottom bits req flags,
  77                                                  * top bits REQ_OP. Use
  78                                                  * accessors.
  79                                                  */
  80         unsigned short          bi_flags;       /* status, command, etc */
  81         unsigned short          bi_ioprio;
  82
  83         struct bvec_iter        bi_iter;
  84
  85         atomic_t                __bi_remaining;
  86
  87         bio_end_io_t            *bi_end_io;
  88         void                    *bi_private;
  89
  90         unsigned short          bi_vcnt;        /* how many bio_vec's */
  91
  92         /*
  93          * Everything starting with bi_max_vecs will be preserved by bio_reset()
  94          */
  95
  96         unsigned short          bi_max_vecs;    /* max bvl_vecs we can hold */
  97
  98         atomic_t                __bi_cnt;       /* pin count */
  99
 100         struct bio_vec          *bi_io_vec;     /* the actual vec list */
 101
 102         struct bio_set          *bi_pool;
 103
 104         /*
 105          * We can inline a number of vecs at the end of the bio, to avoid
 106          * double allocations for a small number of bio_vecs. This member
 107          * MUST obviously be kept at the very end of the bio.
 108          */
 109         struct bio_vec          bi_inline_vecs[0];
 110 };
 111
 112 #define BIO_RESET_BYTES         offsetof(struct bio, bi_max_vecs)
 113
 114 /*
 115  * bio flags
 116  */
 117 #define BIO_SEG_VALID   1       /* bi_phys_segments valid */
 118 #define BIO_CLONED      2       /* doesn't own data */
 119 #define BIO_BOUNCED     3       /* bio is a bounce bio */
 120 #define BIO_USER_MAPPED 4       /* contains user pages */
 121 #define BIO_NULL_MAPPED 5       /* contains invalid user pages */
 122 #define BIO_QUIET       6       /* Make BIO Quiet */
 123 #define BIO_CHAIN       7       /* chained bio, ->bi_remaining in effect */
 124 #define BIO_REFFED      8       /* bio has elevated ->bi_cnt */
 125
 126 /*
 127  * Flags starting here get preserved by bio_reset() - this includes
 128  * BVEC_POOL_IDX()
 129  */
 130 #define BIO_RESET_BITS  10
 131
 132 /*
 133  * We support 6 different bvec pools, the last one is magic in that it
 134  * is backed by a mempool.
 135  */
 136 #define BVEC_POOL_NR            6
 137 #define BVEC_POOL_MAX           (BVEC_POOL_NR - 1)
 138
 139 /*
 140  * Top 4 bits of bio flags indicate the pool the bvecs came from.  We add
 141  * 1 to the actual index so that 0 indicates that there are no bvecs to be
 142  * freed.
 143  */
 144 #define BVEC_POOL_BITS          (4)
 145 #define BVEC_POOL_OFFSET        (16 - BVEC_POOL_BITS)
 146 #define BVEC_POOL_IDX(bio)      ((bio)->bi_flags >> BVEC_POOL_OFFSET)
 147
 148 /*
 149  * Operations and flags common to the bio and request structures.
 150  * We use 8 bits for encoding the operation, and the remaining 24 for flags.
 151  *
 152  * The least significant bit of the operation number indicates the data
 153  * transfer direction:
 154  *
 155  *   - if the least significant bit is set transfers are TO the device
 156  *   - if the least significant bit is not set transfers are FROM the device
 157  *
 158  * If a operation does not transfer data the least significant bit has no
 159  * meaning.
 160  */
 161 #define REQ_OP_BITS     8
 162 #define REQ_OP_MASK     ((1 << REQ_OP_BITS) - 1)
 163 #define REQ_FLAG_BITS   24
 164
 165 enum req_opf {
 166         /* read sectors from the device */
 167         REQ_OP_READ             = 0,
 168         /* write sectors to the device */
 169         REQ_OP_WRITE            = 1,
 170         /* flush the volatile write cache */
 171         REQ_OP_FLUSH            = 2,
 172         /* discard sectors */
 173         REQ_OP_DISCARD          = 3,
 174         /* get zone information */
 175         REQ_OP_ZONE_REPORT      = 4,
 176         /* securely erase sectors */
 177         REQ_OP_SECURE_ERASE     = 5,
 178         /* seset a zone write pointer */
 179         REQ_OP_ZONE_RESET       = 6,
 180         /* write the same sector many times */
 181         REQ_OP_WRITE_SAME       = 7,
 182         /* write the zero filled sector many times */
 183         REQ_OP_WRITE_ZEROES     = 8,
 184
 185         /* SCSI passthrough using struct scsi_request */
 186         REQ_OP_SCSI_IN          = 32,
 187         REQ_OP_SCSI_OUT         = 33,
 188         /* Driver private requests */
 189         REQ_OP_DRV_IN           = 34,
 190         REQ_OP_DRV_OUT          = 35,
 191
 192         REQ_OP_LAST,
 193 };
 194
 195 enum req_flag_bits {
 196         __REQ_FAILFAST_DEV =    /* no driver retries of device errors */
 197                 REQ_OP_BITS,
 198         __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
 199         __REQ_FAILFAST_DRIVER,  /* no driver retries of driver errors */
 200         __REQ_SYNC,             /* request is sync (sync write or read) */
 201         __REQ_META,             /* metadata io request */
 202         __REQ_PRIO,             /* boost priority in cfq */
 203         __REQ_NOMERGE,          /* don't touch this for merging */
 204         __REQ_IDLE,             /* anticipate more IO after this one */
 205         __REQ_INTEGRITY,        /* I/O includes block integrity payload */
 206         __REQ_FUA,              /* forced unit access */
 207         __REQ_PREFLUSH,         /* request for cache flush */
 208         __REQ_RAHEAD,           /* read ahead, can fail anytime */
 209         __REQ_BACKGROUND,       /* background IO */
 210         __REQ_NR_BITS,          /* stops here */
 211 };
 212
 213 #define REQ_SYNC                (1ULL << __REQ_SYNC)
 214 #define REQ_META                (1ULL << __REQ_META)
 215 #define REQ_PRIO                (1ULL << __REQ_PRIO)
 216
 217 #define REQ_NOMERGE_FLAGS       (REQ_PREFLUSH | REQ_FUA)
 218
 219 #define bio_op(bio) \
 220         ((bio)->bi_opf & REQ_OP_MASK)
 221
 222 static inline void bio_set_op_attrs(struct bio *bio, unsigned op,
 223                 unsigned op_flags)
 224 {
 225         bio->bi_opf = op | op_flags;
 226 }
 227
 228 #define REQ_RAHEAD              (1ULL << __REQ_RAHEAD)
 229 #define REQ_THROTTLED           (1ULL << __REQ_THROTTLED)
 230
 231 #define REQ_FUA                 (1ULL << __REQ_FUA)
 232 #define REQ_PREFLUSH            (1ULL << __REQ_PREFLUSH)
 233
 234 #define RW_MASK                 REQ_OP_WRITE
 235
 236 #define READ                    REQ_OP_READ
 237 #define WRITE                   REQ_OP_WRITE
 238
 239 #define READ_SYNC               REQ_SYNC
 240 #define WRITE_SYNC              (REQ_SYNC)
 241 #define WRITE_ODIRECT           REQ_SYNC
 242 #define WRITE_FLUSH             (REQ_SYNC | REQ_PREFLUSH)
 243 #define WRITE_FUA               (REQ_SYNC | REQ_FUA)
 244 #define WRITE_FLUSH_FUA         (REQ_SYNC | REQ_PREFLUSH | REQ_FUA)
 245
 246 #endif /* __LINUX_BLK_TYPES_H */