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