blkdev.h 39 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290
  1. #ifndef _LINUX_BLKDEV_H
  2. #define _LINUX_BLKDEV_H
  3. #ifdef CONFIG_BLOCK
  4. #include <linux/sched.h>
  5. #include <linux/major.h>
  6. #include <linux/genhd.h>
  7. #include <linux/list.h>
  8. #include <linux/timer.h>
  9. #include <linux/workqueue.h>
  10. #include <linux/pagemap.h>
  11. #include <linux/backing-dev.h>
  12. #include <linux/wait.h>
  13. #include <linux/mempool.h>
  14. #include <linux/bio.h>
  15. #include <linux/module.h>
  16. #include <linux/stringify.h>
  17. #include <linux/gfp.h>
  18. #include <linux/bsg.h>
  19. #include <linux/smp.h>
  20. #include <asm/scatterlist.h>
  21. struct scsi_ioctl_command;
  22. struct request_queue;
  23. struct elevator_queue;
  24. struct request_pm_state;
  25. struct blk_trace;
  26. struct request;
  27. struct sg_io_hdr;
  28. #define BLKDEV_MIN_RQ 4
  29. #define BLKDEV_MAX_RQ 128 /* Default maximum */
  30. struct request;
  31. typedef void (rq_end_io_fn)(struct request *, int);
  32. struct request_list {
  33. /*
  34. * count[], starved[], and wait[] are indexed by
  35. * BLK_RW_SYNC/BLK_RW_ASYNC
  36. */
  37. int count[2];
  38. int starved[2];
  39. int elvpriv;
  40. mempool_t *rq_pool;
  41. wait_queue_head_t wait[2];
  42. };
  43. /*
  44. * request command types
  45. */
  46. enum rq_cmd_type_bits {
  47. REQ_TYPE_FS = 1, /* fs request */
  48. REQ_TYPE_BLOCK_PC, /* scsi command */
  49. REQ_TYPE_SENSE, /* sense request */
  50. REQ_TYPE_PM_SUSPEND, /* suspend request */
  51. REQ_TYPE_PM_RESUME, /* resume request */
  52. REQ_TYPE_PM_SHUTDOWN, /* shutdown request */
  53. REQ_TYPE_SPECIAL, /* driver defined type */
  54. REQ_TYPE_LINUX_BLOCK, /* generic block layer message */
  55. /*
  56. * for ATA/ATAPI devices. this really doesn't belong here, ide should
  57. * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
  58. * private REQ_LB opcodes to differentiate what type of request this is
  59. */
  60. REQ_TYPE_ATA_TASKFILE,
  61. REQ_TYPE_ATA_PC,
  62. };
  63. /*
  64. * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
  65. * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
  66. * SCSI cdb.
  67. *
  68. * 0x00 -> 0x3f are driver private, to be used for whatever purpose they need,
  69. * typically to differentiate REQ_TYPE_SPECIAL requests.
  70. *
  71. */
  72. enum {
  73. REQ_LB_OP_EJECT = 0x40, /* eject request */
  74. REQ_LB_OP_FLUSH = 0x41, /* flush request */
  75. };
  76. /*
  77. * request type modified bits. first four bits match BIO_RW* bits, important
  78. */
  79. enum rq_flag_bits {
  80. __REQ_RW, /* not set, read. set, write */
  81. __REQ_FAILFAST_DEV, /* no driver retries of device errors */
  82. __REQ_FAILFAST_TRANSPORT, /* no driver retries of transport errors */
  83. __REQ_FAILFAST_DRIVER, /* no driver retries of driver errors */
  84. /* above flags must match BIO_RW_* */
  85. __REQ_DISCARD, /* request to discard sectors */
  86. __REQ_SORTED, /* elevator knows about this request */
  87. __REQ_SOFTBARRIER, /* may not be passed by ioscheduler */
  88. __REQ_HARDBARRIER, /* may not be passed by drive either */
  89. __REQ_FUA, /* forced unit access */
  90. __REQ_NOMERGE, /* don't touch this for merging */
  91. __REQ_STARTED, /* drive already may have started this one */
  92. __REQ_DONTPREP, /* don't call prep for this one */
  93. __REQ_QUEUED, /* uses queueing */
  94. __REQ_ELVPRIV, /* elevator private data attached */
  95. __REQ_FAILED, /* set if the request failed */
  96. __REQ_QUIET, /* don't worry about errors */
  97. __REQ_PREEMPT, /* set for "ide_preempt" requests */
  98. __REQ_ORDERED_COLOR, /* is before or after barrier */
  99. __REQ_RW_SYNC, /* request is sync (sync write or read) */
  100. __REQ_ALLOCED, /* request came from our alloc pool */
  101. __REQ_RW_META, /* metadata io request */
  102. __REQ_COPY_USER, /* contains copies of user pages */
  103. __REQ_INTEGRITY, /* integrity metadata has been remapped */
  104. __REQ_NOIDLE, /* Don't anticipate more IO after this one */
  105. __REQ_IO_STAT, /* account I/O stat */
  106. __REQ_MIXED_MERGE, /* merge of different types, fail separately */
  107. __REQ_NR_BITS, /* stops here */
  108. };
  109. #define REQ_RW (1 << __REQ_RW)
  110. #define REQ_FAILFAST_DEV (1 << __REQ_FAILFAST_DEV)
  111. #define REQ_FAILFAST_TRANSPORT (1 << __REQ_FAILFAST_TRANSPORT)
  112. #define REQ_FAILFAST_DRIVER (1 << __REQ_FAILFAST_DRIVER)
  113. #define REQ_DISCARD (1 << __REQ_DISCARD)
  114. #define REQ_SORTED (1 << __REQ_SORTED)
  115. #define REQ_SOFTBARRIER (1 << __REQ_SOFTBARRIER)
  116. #define REQ_HARDBARRIER (1 << __REQ_HARDBARRIER)
  117. #define REQ_FUA (1 << __REQ_FUA)
  118. #define REQ_NOMERGE (1 << __REQ_NOMERGE)
  119. #define REQ_STARTED (1 << __REQ_STARTED)
  120. #define REQ_DONTPREP (1 << __REQ_DONTPREP)
  121. #define REQ_QUEUED (1 << __REQ_QUEUED)
  122. #define REQ_ELVPRIV (1 << __REQ_ELVPRIV)
  123. #define REQ_FAILED (1 << __REQ_FAILED)
  124. #define REQ_QUIET (1 << __REQ_QUIET)
  125. #define REQ_PREEMPT (1 << __REQ_PREEMPT)
  126. #define REQ_ORDERED_COLOR (1 << __REQ_ORDERED_COLOR)
  127. #define REQ_RW_SYNC (1 << __REQ_RW_SYNC)
  128. #define REQ_ALLOCED (1 << __REQ_ALLOCED)
  129. #define REQ_RW_META (1 << __REQ_RW_META)
  130. #define REQ_COPY_USER (1 << __REQ_COPY_USER)
  131. #define REQ_INTEGRITY (1 << __REQ_INTEGRITY)
  132. #define REQ_NOIDLE (1 << __REQ_NOIDLE)
  133. #define REQ_IO_STAT (1 << __REQ_IO_STAT)
  134. #define REQ_MIXED_MERGE (1 << __REQ_MIXED_MERGE)
  135. #define REQ_FAILFAST_MASK (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | \
  136. REQ_FAILFAST_DRIVER)
  137. #define BLK_MAX_CDB 16
  138. /*
  139. * try to put the fields that are referenced together in the same cacheline.
  140. * if you modify this structure, be sure to check block/blk-core.c:rq_init()
  141. * as well!
  142. */
  143. struct request {
  144. struct list_head queuelist;
  145. struct call_single_data csd;
  146. int cpu;
  147. struct request_queue *q;
  148. unsigned int cmd_flags;
  149. enum rq_cmd_type_bits cmd_type;
  150. unsigned long atomic_flags;
  151. /* the following two fields are internal, NEVER access directly */
  152. sector_t __sector; /* sector cursor */
  153. unsigned int __data_len; /* total data len */
  154. struct bio *bio;
  155. struct bio *biotail;
  156. struct hlist_node hash; /* merge hash */
  157. /*
  158. * The rb_node is only used inside the io scheduler, requests
  159. * are pruned when moved to the dispatch queue. So let the
  160. * completion_data share space with the rb_node.
  161. */
  162. union {
  163. struct rb_node rb_node; /* sort/lookup */
  164. void *completion_data;
  165. };
  166. /*
  167. * two pointers are available for the IO schedulers, if they need
  168. * more they have to dynamically allocate it.
  169. */
  170. void *elevator_private;
  171. void *elevator_private2;
  172. struct gendisk *rq_disk;
  173. unsigned long start_time;
  174. /* Number of scatter-gather DMA addr+len pairs after
  175. * physical address coalescing is performed.
  176. */
  177. unsigned short nr_phys_segments;
  178. unsigned short ioprio;
  179. void *special; /* opaque pointer available for LLD use */
  180. char *buffer; /* kaddr of the current segment if available */
  181. int tag;
  182. int errors;
  183. int ref_count;
  184. /*
  185. * when request is used as a packet command carrier
  186. */
  187. unsigned short cmd_len;
  188. unsigned char __cmd[BLK_MAX_CDB];
  189. unsigned char *cmd;
  190. unsigned int extra_len; /* length of alignment and padding */
  191. unsigned int sense_len;
  192. unsigned int resid_len; /* residual count */
  193. void *sense;
  194. unsigned long deadline;
  195. struct list_head timeout_list;
  196. unsigned int timeout;
  197. int retries;
  198. /*
  199. * completion callback.
  200. */
  201. rq_end_io_fn *end_io;
  202. void *end_io_data;
  203. /* for bidi */
  204. struct request *next_rq;
  205. };
  206. static inline unsigned short req_get_ioprio(struct request *req)
  207. {
  208. return req->ioprio;
  209. }
  210. /*
  211. * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
  212. * requests. Some step values could eventually be made generic.
  213. */
  214. struct request_pm_state
  215. {
  216. /* PM state machine step value, currently driver specific */
  217. int pm_step;
  218. /* requested PM state value (S1, S2, S3, S4, ...) */
  219. u32 pm_state;
  220. void* data; /* for driver use */
  221. };
  222. #include <linux/elevator.h>
  223. typedef void (request_fn_proc) (struct request_queue *q);
  224. typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
  225. typedef int (prep_rq_fn) (struct request_queue *, struct request *);
  226. typedef void (unplug_fn) (struct request_queue *);
  227. struct bio_vec;
  228. struct bvec_merge_data {
  229. struct block_device *bi_bdev;
  230. sector_t bi_sector;
  231. unsigned bi_size;
  232. unsigned long bi_rw;
  233. };
  234. typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
  235. struct bio_vec *);
  236. typedef void (prepare_flush_fn) (struct request_queue *, struct request *);
  237. typedef void (softirq_done_fn)(struct request *);
  238. typedef int (dma_drain_needed_fn)(struct request *);
  239. typedef int (lld_busy_fn) (struct request_queue *q);
  240. enum blk_eh_timer_return {
  241. BLK_EH_NOT_HANDLED,
  242. BLK_EH_HANDLED,
  243. BLK_EH_RESET_TIMER,
  244. };
  245. typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
  246. enum blk_queue_state {
  247. Queue_down,
  248. Queue_up,
  249. };
  250. struct blk_queue_tag {
  251. struct request **tag_index; /* map of busy tags */
  252. unsigned long *tag_map; /* bit map of free/busy tags */
  253. int busy; /* current depth */
  254. int max_depth; /* what we will send to device */
  255. int real_max_depth; /* what the array can hold */
  256. atomic_t refcnt; /* map can be shared */
  257. };
  258. #define BLK_SCSI_MAX_CMDS (256)
  259. #define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
  260. struct queue_limits {
  261. unsigned long bounce_pfn;
  262. unsigned long seg_boundary_mask;
  263. unsigned int max_hw_sectors;
  264. unsigned int max_sectors;
  265. unsigned int max_segment_size;
  266. unsigned int physical_block_size;
  267. unsigned int alignment_offset;
  268. unsigned int io_min;
  269. unsigned int io_opt;
  270. unsigned int max_discard_sectors;
  271. unsigned short logical_block_size;
  272. unsigned short max_hw_segments;
  273. unsigned short max_phys_segments;
  274. unsigned char misaligned;
  275. unsigned char no_cluster;
  276. };
  277. struct request_queue
  278. {
  279. /*
  280. * Together with queue_head for cacheline sharing
  281. */
  282. struct list_head queue_head;
  283. struct request *last_merge;
  284. struct elevator_queue *elevator;
  285. /*
  286. * the queue request freelist, one for reads and one for writes
  287. */
  288. struct request_list rq;
  289. request_fn_proc *request_fn;
  290. make_request_fn *make_request_fn;
  291. prep_rq_fn *prep_rq_fn;
  292. unplug_fn *unplug_fn;
  293. merge_bvec_fn *merge_bvec_fn;
  294. prepare_flush_fn *prepare_flush_fn;
  295. softirq_done_fn *softirq_done_fn;
  296. rq_timed_out_fn *rq_timed_out_fn;
  297. dma_drain_needed_fn *dma_drain_needed;
  298. lld_busy_fn *lld_busy_fn;
  299. /*
  300. * Dispatch queue sorting
  301. */
  302. sector_t end_sector;
  303. struct request *boundary_rq;
  304. /*
  305. * Auto-unplugging state
  306. */
  307. struct timer_list unplug_timer;
  308. int unplug_thresh; /* After this many requests */
  309. unsigned long unplug_delay; /* After this many jiffies */
  310. struct work_struct unplug_work;
  311. struct backing_dev_info backing_dev_info;
  312. /*
  313. * The queue owner gets to use this for whatever they like.
  314. * ll_rw_blk doesn't touch it.
  315. */
  316. void *queuedata;
  317. /*
  318. * queue needs bounce pages for pages above this limit
  319. */
  320. gfp_t bounce_gfp;
  321. /*
  322. * various queue flags, see QUEUE_* below
  323. */
  324. unsigned long queue_flags;
  325. /*
  326. * protects queue structures from reentrancy. ->__queue_lock should
  327. * _never_ be used directly, it is queue private. always use
  328. * ->queue_lock.
  329. */
  330. spinlock_t __queue_lock;
  331. spinlock_t *queue_lock;
  332. /*
  333. * queue kobject
  334. */
  335. struct kobject kobj;
  336. /*
  337. * queue settings
  338. */
  339. unsigned long nr_requests; /* Max # of requests */
  340. unsigned int nr_congestion_on;
  341. unsigned int nr_congestion_off;
  342. unsigned int nr_batching;
  343. void *dma_drain_buffer;
  344. unsigned int dma_drain_size;
  345. unsigned int dma_pad_mask;
  346. unsigned int dma_alignment;
  347. struct blk_queue_tag *queue_tags;
  348. struct list_head tag_busy_list;
  349. unsigned int nr_sorted;
  350. unsigned int in_flight[2];
  351. unsigned int rq_timeout;
  352. struct timer_list timeout;
  353. struct list_head timeout_list;
  354. struct queue_limits limits;
  355. /*
  356. * sg stuff
  357. */
  358. unsigned int sg_timeout;
  359. unsigned int sg_reserved_size;
  360. int node;
  361. #ifdef CONFIG_BLK_DEV_IO_TRACE
  362. struct blk_trace *blk_trace;
  363. #endif
  364. /*
  365. * reserved for flush operations
  366. */
  367. unsigned int ordered, next_ordered, ordseq;
  368. int orderr, ordcolor;
  369. struct request pre_flush_rq, bar_rq, post_flush_rq;
  370. struct request *orig_bar_rq;
  371. struct mutex sysfs_lock;
  372. #if defined(CONFIG_BLK_DEV_BSG)
  373. struct bsg_class_device bsg_dev;
  374. #endif
  375. };
  376. #define QUEUE_FLAG_CLUSTER 0 /* cluster several segments into 1 */
  377. #define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */
  378. #define QUEUE_FLAG_STOPPED 2 /* queue is stopped */
  379. #define QUEUE_FLAG_SYNCFULL 3 /* read queue has been filled */
  380. #define QUEUE_FLAG_ASYNCFULL 4 /* write queue has been filled */
  381. #define QUEUE_FLAG_DEAD 5 /* queue being torn down */
  382. #define QUEUE_FLAG_REENTER 6 /* Re-entrancy avoidance */
  383. #define QUEUE_FLAG_PLUGGED 7 /* queue is plugged */
  384. #define QUEUE_FLAG_ELVSWITCH 8 /* don't use elevator, just do FIFO */
  385. #define QUEUE_FLAG_BIDI 9 /* queue supports bidi requests */
  386. #define QUEUE_FLAG_NOMERGES 10 /* disable merge attempts */
  387. #define QUEUE_FLAG_SAME_COMP 11 /* force complete on same CPU */
  388. #define QUEUE_FLAG_FAIL_IO 12 /* fake timeout */
  389. #define QUEUE_FLAG_STACKABLE 13 /* supports request stacking */
  390. #define QUEUE_FLAG_NONROT 14 /* non-rotational device (SSD) */
  391. #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */
  392. #define QUEUE_FLAG_IO_STAT 15 /* do IO stats */
  393. #define QUEUE_FLAG_CQ 16 /* hardware does queuing */
  394. #define QUEUE_FLAG_DISCARD 17 /* supports DISCARD */
  395. #define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
  396. (1 << QUEUE_FLAG_CLUSTER) | \
  397. (1 << QUEUE_FLAG_STACKABLE) | \
  398. (1 << QUEUE_FLAG_SAME_COMP))
  399. static inline int queue_is_locked(struct request_queue *q)
  400. {
  401. #ifdef CONFIG_SMP
  402. spinlock_t *lock = q->queue_lock;
  403. return lock && spin_is_locked(lock);
  404. #else
  405. return 1;
  406. #endif
  407. }
  408. static inline void queue_flag_set_unlocked(unsigned int flag,
  409. struct request_queue *q)
  410. {
  411. __set_bit(flag, &q->queue_flags);
  412. }
  413. static inline int queue_flag_test_and_clear(unsigned int flag,
  414. struct request_queue *q)
  415. {
  416. WARN_ON_ONCE(!queue_is_locked(q));
  417. if (test_bit(flag, &q->queue_flags)) {
  418. __clear_bit(flag, &q->queue_flags);
  419. return 1;
  420. }
  421. return 0;
  422. }
  423. static inline int queue_flag_test_and_set(unsigned int flag,
  424. struct request_queue *q)
  425. {
  426. WARN_ON_ONCE(!queue_is_locked(q));
  427. if (!test_bit(flag, &q->queue_flags)) {
  428. __set_bit(flag, &q->queue_flags);
  429. return 0;
  430. }
  431. return 1;
  432. }
  433. static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
  434. {
  435. WARN_ON_ONCE(!queue_is_locked(q));
  436. __set_bit(flag, &q->queue_flags);
  437. }
  438. static inline void queue_flag_clear_unlocked(unsigned int flag,
  439. struct request_queue *q)
  440. {
  441. __clear_bit(flag, &q->queue_flags);
  442. }
  443. static inline int queue_in_flight(struct request_queue *q)
  444. {
  445. return q->in_flight[0] + q->in_flight[1];
  446. }
  447. static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
  448. {
  449. WARN_ON_ONCE(!queue_is_locked(q));
  450. __clear_bit(flag, &q->queue_flags);
  451. }
  452. enum {
  453. /*
  454. * Hardbarrier is supported with one of the following methods.
  455. *
  456. * NONE : hardbarrier unsupported
  457. * DRAIN : ordering by draining is enough
  458. * DRAIN_FLUSH : ordering by draining w/ pre and post flushes
  459. * DRAIN_FUA : ordering by draining w/ pre flush and FUA write
  460. * TAG : ordering by tag is enough
  461. * TAG_FLUSH : ordering by tag w/ pre and post flushes
  462. * TAG_FUA : ordering by tag w/ pre flush and FUA write
  463. */
  464. QUEUE_ORDERED_BY_DRAIN = 0x01,
  465. QUEUE_ORDERED_BY_TAG = 0x02,
  466. QUEUE_ORDERED_DO_PREFLUSH = 0x10,
  467. QUEUE_ORDERED_DO_BAR = 0x20,
  468. QUEUE_ORDERED_DO_POSTFLUSH = 0x40,
  469. QUEUE_ORDERED_DO_FUA = 0x80,
  470. QUEUE_ORDERED_NONE = 0x00,
  471. QUEUE_ORDERED_DRAIN = QUEUE_ORDERED_BY_DRAIN |
  472. QUEUE_ORDERED_DO_BAR,
  473. QUEUE_ORDERED_DRAIN_FLUSH = QUEUE_ORDERED_DRAIN |
  474. QUEUE_ORDERED_DO_PREFLUSH |
  475. QUEUE_ORDERED_DO_POSTFLUSH,
  476. QUEUE_ORDERED_DRAIN_FUA = QUEUE_ORDERED_DRAIN |
  477. QUEUE_ORDERED_DO_PREFLUSH |
  478. QUEUE_ORDERED_DO_FUA,
  479. QUEUE_ORDERED_TAG = QUEUE_ORDERED_BY_TAG |
  480. QUEUE_ORDERED_DO_BAR,
  481. QUEUE_ORDERED_TAG_FLUSH = QUEUE_ORDERED_TAG |
  482. QUEUE_ORDERED_DO_PREFLUSH |
  483. QUEUE_ORDERED_DO_POSTFLUSH,
  484. QUEUE_ORDERED_TAG_FUA = QUEUE_ORDERED_TAG |
  485. QUEUE_ORDERED_DO_PREFLUSH |
  486. QUEUE_ORDERED_DO_FUA,
  487. /*
  488. * Ordered operation sequence
  489. */
  490. QUEUE_ORDSEQ_STARTED = 0x01, /* flushing in progress */
  491. QUEUE_ORDSEQ_DRAIN = 0x02, /* waiting for the queue to be drained */
  492. QUEUE_ORDSEQ_PREFLUSH = 0x04, /* pre-flushing in progress */
  493. QUEUE_ORDSEQ_BAR = 0x08, /* original barrier req in progress */
  494. QUEUE_ORDSEQ_POSTFLUSH = 0x10, /* post-flushing in progress */
  495. QUEUE_ORDSEQ_DONE = 0x20,
  496. };
  497. #define blk_queue_plugged(q) test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
  498. #define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
  499. #define blk_queue_queuing(q) test_bit(QUEUE_FLAG_CQ, &(q)->queue_flags)
  500. #define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
  501. #define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
  502. #define blk_queue_nonrot(q) test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
  503. #define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
  504. #define blk_queue_flushing(q) ((q)->ordseq)
  505. #define blk_queue_stackable(q) \
  506. test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
  507. #define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
  508. #define blk_fs_request(rq) ((rq)->cmd_type == REQ_TYPE_FS)
  509. #define blk_pc_request(rq) ((rq)->cmd_type == REQ_TYPE_BLOCK_PC)
  510. #define blk_special_request(rq) ((rq)->cmd_type == REQ_TYPE_SPECIAL)
  511. #define blk_sense_request(rq) ((rq)->cmd_type == REQ_TYPE_SENSE)
  512. #define blk_failfast_dev(rq) ((rq)->cmd_flags & REQ_FAILFAST_DEV)
  513. #define blk_failfast_transport(rq) ((rq)->cmd_flags & REQ_FAILFAST_TRANSPORT)
  514. #define blk_failfast_driver(rq) ((rq)->cmd_flags & REQ_FAILFAST_DRIVER)
  515. #define blk_noretry_request(rq) (blk_failfast_dev(rq) || \
  516. blk_failfast_transport(rq) || \
  517. blk_failfast_driver(rq))
  518. #define blk_rq_started(rq) ((rq)->cmd_flags & REQ_STARTED)
  519. #define blk_rq_io_stat(rq) ((rq)->cmd_flags & REQ_IO_STAT)
  520. #define blk_rq_quiet(rq) ((rq)->cmd_flags & REQ_QUIET)
  521. #define blk_account_rq(rq) (blk_rq_started(rq) && (blk_fs_request(rq) || blk_discard_rq(rq)))
  522. #define blk_pm_suspend_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND)
  523. #define blk_pm_resume_request(rq) ((rq)->cmd_type == REQ_TYPE_PM_RESUME)
  524. #define blk_pm_request(rq) \
  525. (blk_pm_suspend_request(rq) || blk_pm_resume_request(rq))
  526. #define blk_rq_cpu_valid(rq) ((rq)->cpu != -1)
  527. #define blk_sorted_rq(rq) ((rq)->cmd_flags & REQ_SORTED)
  528. #define blk_barrier_rq(rq) ((rq)->cmd_flags & REQ_HARDBARRIER)
  529. #define blk_fua_rq(rq) ((rq)->cmd_flags & REQ_FUA)
  530. #define blk_discard_rq(rq) ((rq)->cmd_flags & REQ_DISCARD)
  531. #define blk_bidi_rq(rq) ((rq)->next_rq != NULL)
  532. /* rq->queuelist of dequeued request must be list_empty() */
  533. #define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist))
  534. #define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
  535. #define rq_data_dir(rq) ((rq)->cmd_flags & 1)
  536. /*
  537. * We regard a request as sync, if either a read or a sync write
  538. */
  539. static inline bool rw_is_sync(unsigned int rw_flags)
  540. {
  541. return !(rw_flags & REQ_RW) || (rw_flags & REQ_RW_SYNC);
  542. }
  543. static inline bool rq_is_sync(struct request *rq)
  544. {
  545. return rw_is_sync(rq->cmd_flags);
  546. }
  547. #define rq_is_meta(rq) ((rq)->cmd_flags & REQ_RW_META)
  548. #define rq_noidle(rq) ((rq)->cmd_flags & REQ_NOIDLE)
  549. static inline int blk_queue_full(struct request_queue *q, int sync)
  550. {
  551. if (sync)
  552. return test_bit(QUEUE_FLAG_SYNCFULL, &q->queue_flags);
  553. return test_bit(QUEUE_FLAG_ASYNCFULL, &q->queue_flags);
  554. }
  555. static inline void blk_set_queue_full(struct request_queue *q, int sync)
  556. {
  557. if (sync)
  558. queue_flag_set(QUEUE_FLAG_SYNCFULL, q);
  559. else
  560. queue_flag_set(QUEUE_FLAG_ASYNCFULL, q);
  561. }
  562. static inline void blk_clear_queue_full(struct request_queue *q, int sync)
  563. {
  564. if (sync)
  565. queue_flag_clear(QUEUE_FLAG_SYNCFULL, q);
  566. else
  567. queue_flag_clear(QUEUE_FLAG_ASYNCFULL, q);
  568. }
  569. /*
  570. * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
  571. * it already be started by driver.
  572. */
  573. #define RQ_NOMERGE_FLAGS \
  574. (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
  575. #define rq_mergeable(rq) \
  576. (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
  577. (blk_discard_rq(rq) || blk_fs_request((rq))))
  578. /*
  579. * q->prep_rq_fn return values
  580. */
  581. #define BLKPREP_OK 0 /* serve it */
  582. #define BLKPREP_KILL 1 /* fatal error, kill */
  583. #define BLKPREP_DEFER 2 /* leave on queue */
  584. extern unsigned long blk_max_low_pfn, blk_max_pfn;
  585. /*
  586. * standard bounce addresses:
  587. *
  588. * BLK_BOUNCE_HIGH : bounce all highmem pages
  589. * BLK_BOUNCE_ANY : don't bounce anything
  590. * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary
  591. */
  592. #if BITS_PER_LONG == 32
  593. #define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
  594. #else
  595. #define BLK_BOUNCE_HIGH -1ULL
  596. #endif
  597. #define BLK_BOUNCE_ANY (-1ULL)
  598. #define BLK_BOUNCE_ISA (ISA_DMA_THRESHOLD)
  599. /*
  600. * default timeout for SG_IO if none specified
  601. */
  602. #define BLK_DEFAULT_SG_TIMEOUT (60 * HZ)
  603. #define BLK_MIN_SG_TIMEOUT (7 * HZ)
  604. #ifdef CONFIG_BOUNCE
  605. extern int init_emergency_isa_pool(void);
  606. extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
  607. #else
  608. static inline int init_emergency_isa_pool(void)
  609. {
  610. return 0;
  611. }
  612. static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
  613. {
  614. }
  615. #endif /* CONFIG_MMU */
  616. struct rq_map_data {
  617. struct page **pages;
  618. int page_order;
  619. int nr_entries;
  620. unsigned long offset;
  621. int null_mapped;
  622. int from_user;
  623. };
  624. struct req_iterator {
  625. int i;
  626. struct bio *bio;
  627. };
  628. /* This should not be used directly - use rq_for_each_segment */
  629. #define for_each_bio(_bio) \
  630. for (; _bio; _bio = _bio->bi_next)
  631. #define __rq_for_each_bio(_bio, rq) \
  632. if ((rq->bio)) \
  633. for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
  634. #define rq_for_each_segment(bvl, _rq, _iter) \
  635. __rq_for_each_bio(_iter.bio, _rq) \
  636. bio_for_each_segment(bvl, _iter.bio, _iter.i)
  637. #define rq_iter_last(rq, _iter) \
  638. (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1)
  639. extern int blk_register_queue(struct gendisk *disk);
  640. extern void blk_unregister_queue(struct gendisk *disk);
  641. extern void register_disk(struct gendisk *dev);
  642. extern void generic_make_request(struct bio *bio);
  643. extern void blk_rq_init(struct request_queue *q, struct request *rq);
  644. extern void blk_put_request(struct request *);
  645. extern void __blk_put_request(struct request_queue *, struct request *);
  646. extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
  647. extern struct request *blk_make_request(struct request_queue *, struct bio *,
  648. gfp_t);
  649. extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
  650. extern void blk_requeue_request(struct request_queue *, struct request *);
  651. extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
  652. extern int blk_lld_busy(struct request_queue *q);
  653. extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
  654. struct bio_set *bs, gfp_t gfp_mask,
  655. int (*bio_ctr)(struct bio *, struct bio *, void *),
  656. void *data);
  657. extern void blk_rq_unprep_clone(struct request *rq);
  658. extern int blk_insert_cloned_request(struct request_queue *q,
  659. struct request *rq);
  660. extern void blk_plug_device(struct request_queue *);
  661. extern void blk_plug_device_unlocked(struct request_queue *);
  662. extern int blk_remove_plug(struct request_queue *);
  663. extern void blk_recount_segments(struct request_queue *, struct bio *);
  664. extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
  665. unsigned int, void __user *);
  666. extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
  667. struct scsi_ioctl_command __user *);
  668. /*
  669. * A queue has just exitted congestion. Note this in the global counter of
  670. * congested queues, and wake up anyone who was waiting for requests to be
  671. * put back.
  672. */
  673. static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
  674. {
  675. clear_bdi_congested(&q->backing_dev_info, sync);
  676. }
  677. /*
  678. * A queue has just entered congestion. Flag that in the queue's VM-visible
  679. * state flags and increment the global gounter of congested queues.
  680. */
  681. static inline void blk_set_queue_congested(struct request_queue *q, int sync)
  682. {
  683. set_bdi_congested(&q->backing_dev_info, sync);
  684. }
  685. extern void blk_start_queue(struct request_queue *q);
  686. extern void blk_stop_queue(struct request_queue *q);
  687. extern void blk_sync_queue(struct request_queue *q);
  688. extern void __blk_stop_queue(struct request_queue *q);
  689. extern void __blk_run_queue(struct request_queue *);
  690. extern void blk_run_queue(struct request_queue *);
  691. extern int blk_rq_map_user(struct request_queue *, struct request *,
  692. struct rq_map_data *, void __user *, unsigned long,
  693. gfp_t);
  694. extern int blk_rq_unmap_user(struct bio *);
  695. extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
  696. extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
  697. struct rq_map_data *, struct sg_iovec *, int,
  698. unsigned int, gfp_t);
  699. extern int blk_execute_rq(struct request_queue *, struct gendisk *,
  700. struct request *, int);
  701. extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
  702. struct request *, int, rq_end_io_fn *);
  703. extern void blk_unplug(struct request_queue *q);
  704. static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
  705. {
  706. return bdev->bd_disk->queue;
  707. }
  708. static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
  709. struct page *page)
  710. {
  711. if (bdi && bdi->unplug_io_fn)
  712. bdi->unplug_io_fn(bdi, page);
  713. }
  714. static inline void blk_run_address_space(struct address_space *mapping)
  715. {
  716. if (mapping)
  717. blk_run_backing_dev(mapping->backing_dev_info, NULL);
  718. }
  719. /*
  720. * blk_rq_pos() : the current sector
  721. * blk_rq_bytes() : bytes left in the entire request
  722. * blk_rq_cur_bytes() : bytes left in the current segment
  723. * blk_rq_err_bytes() : bytes left till the next error boundary
  724. * blk_rq_sectors() : sectors left in the entire request
  725. * blk_rq_cur_sectors() : sectors left in the current segment
  726. * blk_rq_err_sectors() : sectors left till the next error boundary
  727. */
  728. static inline sector_t blk_rq_pos(const struct request *rq)
  729. {
  730. return rq->__sector;
  731. }
  732. static inline unsigned int blk_rq_bytes(const struct request *rq)
  733. {
  734. return rq->__data_len;
  735. }
  736. static inline int blk_rq_cur_bytes(const struct request *rq)
  737. {
  738. return rq->bio ? bio_cur_bytes(rq->bio) : 0;
  739. }
  740. extern unsigned int blk_rq_err_bytes(const struct request *rq);
  741. static inline unsigned int blk_rq_sectors(const struct request *rq)
  742. {
  743. return blk_rq_bytes(rq) >> 9;
  744. }
  745. static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
  746. {
  747. return blk_rq_cur_bytes(rq) >> 9;
  748. }
  749. static inline unsigned int blk_rq_err_sectors(const struct request *rq)
  750. {
  751. return blk_rq_err_bytes(rq) >> 9;
  752. }
  753. /*
  754. * Request issue related functions.
  755. */
  756. extern struct request *blk_peek_request(struct request_queue *q);
  757. extern void blk_start_request(struct request *rq);
  758. extern struct request *blk_fetch_request(struct request_queue *q);
  759. /*
  760. * Request completion related functions.
  761. *
  762. * blk_update_request() completes given number of bytes and updates
  763. * the request without completing it.
  764. *
  765. * blk_end_request() and friends. __blk_end_request() must be called
  766. * with the request queue spinlock acquired.
  767. *
  768. * Several drivers define their own end_request and call
  769. * blk_end_request() for parts of the original function.
  770. * This prevents code duplication in drivers.
  771. */
  772. extern bool blk_update_request(struct request *rq, int error,
  773. unsigned int nr_bytes);
  774. extern bool blk_end_request(struct request *rq, int error,
  775. unsigned int nr_bytes);
  776. extern void blk_end_request_all(struct request *rq, int error);
  777. extern bool blk_end_request_cur(struct request *rq, int error);
  778. extern bool blk_end_request_err(struct request *rq, int error);
  779. extern bool __blk_end_request(struct request *rq, int error,
  780. unsigned int nr_bytes);
  781. extern void __blk_end_request_all(struct request *rq, int error);
  782. extern bool __blk_end_request_cur(struct request *rq, int error);
  783. extern bool __blk_end_request_err(struct request *rq, int error);
  784. extern void blk_complete_request(struct request *);
  785. extern void __blk_complete_request(struct request *);
  786. extern void blk_abort_request(struct request *);
  787. extern void blk_abort_queue(struct request_queue *);
  788. /*
  789. * Access functions for manipulating queue properties
  790. */
  791. extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
  792. spinlock_t *lock, int node_id);
  793. extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
  794. extern void blk_cleanup_queue(struct request_queue *);
  795. extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
  796. extern void blk_queue_bounce_limit(struct request_queue *, u64);
  797. extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
  798. extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
  799. extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
  800. extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
  801. extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
  802. extern void blk_queue_max_discard_sectors(struct request_queue *q,
  803. unsigned int max_discard_sectors);
  804. extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
  805. extern void blk_queue_physical_block_size(struct request_queue *, unsigned short);
  806. extern void blk_queue_alignment_offset(struct request_queue *q,
  807. unsigned int alignment);
  808. extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
  809. extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
  810. extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
  811. extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
  812. extern void blk_set_default_limits(struct queue_limits *lim);
  813. extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
  814. sector_t offset);
  815. extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
  816. sector_t offset);
  817. extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
  818. extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
  819. extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
  820. extern int blk_queue_dma_drain(struct request_queue *q,
  821. dma_drain_needed_fn *dma_drain_needed,
  822. void *buf, unsigned int size);
  823. extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
  824. extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
  825. extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
  826. extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
  827. extern void blk_queue_dma_alignment(struct request_queue *, int);
  828. extern void blk_queue_update_dma_alignment(struct request_queue *, int);
  829. extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
  830. extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
  831. extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
  832. extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
  833. extern int blk_queue_ordered(struct request_queue *, unsigned, prepare_flush_fn *);
  834. extern bool blk_do_ordered(struct request_queue *, struct request **);
  835. extern unsigned blk_ordered_cur_seq(struct request_queue *);
  836. extern unsigned blk_ordered_req_seq(struct request *);
  837. extern bool blk_ordered_complete_seq(struct request_queue *, unsigned, int);
  838. extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
  839. extern void blk_dump_rq_flags(struct request *, char *);
  840. extern void generic_unplug_device(struct request_queue *);
  841. extern long nr_blockdev_pages(void);
  842. int blk_get_queue(struct request_queue *);
  843. struct request_queue *blk_alloc_queue(gfp_t);
  844. struct request_queue *blk_alloc_queue_node(gfp_t, int);
  845. extern void blk_put_queue(struct request_queue *);
  846. /*
  847. * tag stuff
  848. */
  849. #define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED)
  850. extern int blk_queue_start_tag(struct request_queue *, struct request *);
  851. extern struct request *blk_queue_find_tag(struct request_queue *, int);
  852. extern void blk_queue_end_tag(struct request_queue *, struct request *);
  853. extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
  854. extern void blk_queue_free_tags(struct request_queue *);
  855. extern int blk_queue_resize_tags(struct request_queue *, int);
  856. extern void blk_queue_invalidate_tags(struct request_queue *);
  857. extern struct blk_queue_tag *blk_init_tags(int);
  858. extern void blk_free_tags(struct blk_queue_tag *);
  859. static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
  860. int tag)
  861. {
  862. if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
  863. return NULL;
  864. return bqt->tag_index[tag];
  865. }
  866. extern int blkdev_issue_flush(struct block_device *, sector_t *);
  867. #define DISCARD_FL_WAIT 0x01 /* wait for completion */
  868. #define DISCARD_FL_BARRIER 0x02 /* issue DISCARD_BARRIER request */
  869. extern int blkdev_issue_discard(struct block_device *, sector_t sector,
  870. sector_t nr_sects, gfp_t, int flags);
  871. static inline int sb_issue_discard(struct super_block *sb,
  872. sector_t block, sector_t nr_blocks)
  873. {
  874. block <<= (sb->s_blocksize_bits - 9);
  875. nr_blocks <<= (sb->s_blocksize_bits - 9);
  876. return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL,
  877. DISCARD_FL_BARRIER);
  878. }
  879. extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
  880. #define MAX_PHYS_SEGMENTS 128
  881. #define MAX_HW_SEGMENTS 128
  882. #define SAFE_MAX_SECTORS 255
  883. #define BLK_DEF_MAX_SECTORS 1024
  884. #define MAX_SEGMENT_SIZE 65536
  885. #define BLK_SEG_BOUNDARY_MASK 0xFFFFFFFFUL
  886. #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
  887. static inline unsigned long queue_bounce_pfn(struct request_queue *q)
  888. {
  889. return q->limits.bounce_pfn;
  890. }
  891. static inline unsigned long queue_segment_boundary(struct request_queue *q)
  892. {
  893. return q->limits.seg_boundary_mask;
  894. }
  895. static inline unsigned int queue_max_sectors(struct request_queue *q)
  896. {
  897. return q->limits.max_sectors;
  898. }
  899. static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
  900. {
  901. return q->limits.max_hw_sectors;
  902. }
  903. static inline unsigned short queue_max_hw_segments(struct request_queue *q)
  904. {
  905. return q->limits.max_hw_segments;
  906. }
  907. static inline unsigned short queue_max_phys_segments(struct request_queue *q)
  908. {
  909. return q->limits.max_phys_segments;
  910. }
  911. static inline unsigned int queue_max_segment_size(struct request_queue *q)
  912. {
  913. return q->limits.max_segment_size;
  914. }
  915. static inline unsigned short queue_logical_block_size(struct request_queue *q)
  916. {
  917. int retval = 512;
  918. if (q && q->limits.logical_block_size)
  919. retval = q->limits.logical_block_size;
  920. return retval;
  921. }
  922. static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
  923. {
  924. return queue_logical_block_size(bdev_get_queue(bdev));
  925. }
  926. static inline unsigned int queue_physical_block_size(struct request_queue *q)
  927. {
  928. return q->limits.physical_block_size;
  929. }
  930. static inline int bdev_physical_block_size(struct block_device *bdev)
  931. {
  932. return queue_physical_block_size(bdev_get_queue(bdev));
  933. }
  934. static inline unsigned int queue_io_min(struct request_queue *q)
  935. {
  936. return q->limits.io_min;
  937. }
  938. static inline int bdev_io_min(struct block_device *bdev)
  939. {
  940. return queue_io_min(bdev_get_queue(bdev));
  941. }
  942. static inline unsigned int queue_io_opt(struct request_queue *q)
  943. {
  944. return q->limits.io_opt;
  945. }
  946. static inline int bdev_io_opt(struct block_device *bdev)
  947. {
  948. return queue_io_opt(bdev_get_queue(bdev));
  949. }
  950. static inline int queue_alignment_offset(struct request_queue *q)
  951. {
  952. if (q->limits.misaligned)
  953. return -1;
  954. return q->limits.alignment_offset;
  955. }
  956. static inline int queue_sector_alignment_offset(struct request_queue *q,
  957. sector_t sector)
  958. {
  959. return ((sector << 9) - q->limits.alignment_offset)
  960. & (q->limits.io_min - 1);
  961. }
  962. static inline int bdev_alignment_offset(struct block_device *bdev)
  963. {
  964. struct request_queue *q = bdev_get_queue(bdev);
  965. if (q->limits.misaligned)
  966. return -1;
  967. if (bdev != bdev->bd_contains)
  968. return bdev->bd_part->alignment_offset;
  969. return q->limits.alignment_offset;
  970. }
  971. static inline int queue_dma_alignment(struct request_queue *q)
  972. {
  973. return q ? q->dma_alignment : 511;
  974. }
  975. static inline int blk_rq_aligned(struct request_queue *q, void *addr,
  976. unsigned int len)
  977. {
  978. unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
  979. return !((unsigned long)addr & alignment) && !(len & alignment);
  980. }
  981. /* assumes size > 256 */
  982. static inline unsigned int blksize_bits(unsigned int size)
  983. {
  984. unsigned int bits = 8;
  985. do {
  986. bits++;
  987. size >>= 1;
  988. } while (size > 256);
  989. return bits;
  990. }
  991. static inline unsigned int block_size(struct block_device *bdev)
  992. {
  993. return bdev->bd_block_size;
  994. }
  995. typedef struct {struct page *v;} Sector;
  996. unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
  997. static inline void put_dev_sector(Sector p)
  998. {
  999. page_cache_release(p.v);
  1000. }
  1001. struct work_struct;
  1002. struct delayed_work;
  1003. int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
  1004. int kblockd_schedule_delayed_work(struct request_queue *q,
  1005. struct delayed_work *work,
  1006. unsigned long delay);
  1007. #define MODULE_ALIAS_BLOCKDEV(major,minor) \
  1008. MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
  1009. #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
  1010. MODULE_ALIAS("block-major-" __stringify(major) "-*")
  1011. #if defined(CONFIG_BLK_DEV_INTEGRITY)
  1012. #define INTEGRITY_FLAG_READ 2 /* verify data integrity on read */
  1013. #define INTEGRITY_FLAG_WRITE 4 /* generate data integrity on write */
  1014. struct blk_integrity_exchg {
  1015. void *prot_buf;
  1016. void *data_buf;
  1017. sector_t sector;
  1018. unsigned int data_size;
  1019. unsigned short sector_size;
  1020. const char *disk_name;
  1021. };
  1022. typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
  1023. typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
  1024. typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
  1025. typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
  1026. struct blk_integrity {
  1027. integrity_gen_fn *generate_fn;
  1028. integrity_vrfy_fn *verify_fn;
  1029. integrity_set_tag_fn *set_tag_fn;
  1030. integrity_get_tag_fn *get_tag_fn;
  1031. unsigned short flags;
  1032. unsigned short tuple_size;
  1033. unsigned short sector_size;
  1034. unsigned short tag_size;
  1035. const char *name;
  1036. struct kobject kobj;
  1037. };
  1038. extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
  1039. extern void blk_integrity_unregister(struct gendisk *);
  1040. extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
  1041. extern int blk_rq_map_integrity_sg(struct request *, struct scatterlist *);
  1042. extern int blk_rq_count_integrity_sg(struct request *);
  1043. static inline
  1044. struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
  1045. {
  1046. return bdev->bd_disk->integrity;
  1047. }
  1048. static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
  1049. {
  1050. return disk->integrity;
  1051. }
  1052. static inline int blk_integrity_rq(struct request *rq)
  1053. {
  1054. if (rq->bio == NULL)
  1055. return 0;
  1056. return bio_integrity(rq->bio);
  1057. }
  1058. #else /* CONFIG_BLK_DEV_INTEGRITY */
  1059. #define blk_integrity_rq(rq) (0)
  1060. #define blk_rq_count_integrity_sg(a) (0)
  1061. #define blk_rq_map_integrity_sg(a, b) (0)
  1062. #define bdev_get_integrity(a) (0)
  1063. #define blk_get_integrity(a) (0)
  1064. #define blk_integrity_compare(a, b) (0)
  1065. #define blk_integrity_register(a, b) (0)
  1066. #define blk_integrity_unregister(a) do { } while (0);
  1067. #endif /* CONFIG_BLK_DEV_INTEGRITY */
  1068. struct block_device_operations {
  1069. int (*open) (struct block_device *, fmode_t);
  1070. int (*release) (struct gendisk *, fmode_t);
  1071. int (*locked_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1072. int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1073. int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1074. int (*direct_access) (struct block_device *, sector_t,
  1075. void **, unsigned long *);
  1076. int (*media_changed) (struct gendisk *);
  1077. unsigned long long (*set_capacity) (struct gendisk *,
  1078. unsigned long long);
  1079. int (*revalidate_disk) (struct gendisk *);
  1080. int (*getgeo)(struct block_device *, struct hd_geometry *);
  1081. struct module *owner;
  1082. };
  1083. extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
  1084. unsigned long);
  1085. #else /* CONFIG_BLOCK */
  1086. /*
  1087. * stubs for when the block layer is configured out
  1088. */
  1089. #define buffer_heads_over_limit 0
  1090. static inline long nr_blockdev_pages(void)
  1091. {
  1092. return 0;
  1093. }
  1094. #endif /* CONFIG_BLOCK */
  1095. #endif