blkdev.h 48 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684
  1. #ifndef _LINUX_BLKDEV_H
  2. #define _LINUX_BLKDEV_H
  3. #include <linux/sched.h>
  4. #ifdef CONFIG_BLOCK
  5. #include <linux/major.h>
  6. #include <linux/genhd.h>
  7. #include <linux/list.h>
  8. #include <linux/llist.h>
  9. #include <linux/timer.h>
  10. #include <linux/workqueue.h>
  11. #include <linux/pagemap.h>
  12. #include <linux/backing-dev.h>
  13. #include <linux/wait.h>
  14. #include <linux/mempool.h>
  15. #include <linux/bio.h>
  16. #include <linux/stringify.h>
  17. #include <linux/gfp.h>
  18. #include <linux/bsg.h>
  19. #include <linux/smp.h>
  20. #include <linux/rcupdate.h>
  21. #include <linux/percpu-refcount.h>
  22. #include <asm/scatterlist.h>
  23. struct module;
  24. struct scsi_ioctl_command;
  25. struct request_queue;
  26. struct elevator_queue;
  27. struct request_pm_state;
  28. struct blk_trace;
  29. struct request;
  30. struct sg_io_hdr;
  31. struct bsg_job;
  32. struct blkcg_gq;
  33. #define BLKDEV_MIN_RQ 4
  34. #define BLKDEV_MAX_RQ 128 /* Default maximum */
  35. /*
  36. * Maximum number of blkcg policies allowed to be registered concurrently.
  37. * Defined here to simplify include dependency.
  38. */
  39. #define BLKCG_MAX_POLS 2
  40. struct request;
  41. typedef void (rq_end_io_fn)(struct request *, int);
  42. #define BLK_RL_SYNCFULL (1U << 0)
  43. #define BLK_RL_ASYNCFULL (1U << 1)
  44. struct request_list {
  45. struct request_queue *q; /* the queue this rl belongs to */
  46. #ifdef CONFIG_BLK_CGROUP
  47. struct blkcg_gq *blkg; /* blkg this request pool belongs to */
  48. #endif
  49. /*
  50. * count[], starved[], and wait[] are indexed by
  51. * BLK_RW_SYNC/BLK_RW_ASYNC
  52. */
  53. int count[2];
  54. int starved[2];
  55. mempool_t *rq_pool;
  56. wait_queue_head_t wait[2];
  57. unsigned int flags;
  58. };
  59. /*
  60. * request command types
  61. */
  62. enum rq_cmd_type_bits {
  63. REQ_TYPE_FS = 1, /* fs request */
  64. REQ_TYPE_BLOCK_PC, /* scsi command */
  65. REQ_TYPE_SENSE, /* sense request */
  66. REQ_TYPE_PM_SUSPEND, /* suspend request */
  67. REQ_TYPE_PM_RESUME, /* resume request */
  68. REQ_TYPE_PM_SHUTDOWN, /* shutdown request */
  69. REQ_TYPE_SPECIAL, /* driver defined type */
  70. /*
  71. * for ATA/ATAPI devices. this really doesn't belong here, ide should
  72. * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
  73. * private REQ_LB opcodes to differentiate what type of request this is
  74. */
  75. REQ_TYPE_ATA_TASKFILE,
  76. REQ_TYPE_ATA_PC,
  77. };
  78. #define BLK_MAX_CDB 16
  79. /*
  80. * Try to put the fields that are referenced together in the same cacheline.
  81. *
  82. * If you modify this structure, make sure to update blk_rq_init() and
  83. * especially blk_mq_rq_ctx_init() to take care of the added fields.
  84. */
  85. struct request {
  86. struct list_head queuelist;
  87. union {
  88. struct call_single_data csd;
  89. unsigned long fifo_time;
  90. };
  91. struct request_queue *q;
  92. struct blk_mq_ctx *mq_ctx;
  93. u64 cmd_flags;
  94. enum rq_cmd_type_bits cmd_type;
  95. unsigned long atomic_flags;
  96. int cpu;
  97. /* the following two fields are internal, NEVER access directly */
  98. unsigned int __data_len; /* total data len */
  99. sector_t __sector; /* sector cursor */
  100. struct bio *bio;
  101. struct bio *biotail;
  102. /*
  103. * The hash is used inside the scheduler, and killed once the
  104. * request reaches the dispatch list. The ipi_list is only used
  105. * to queue the request for softirq completion, which is long
  106. * after the request has been unhashed (and even removed from
  107. * the dispatch list).
  108. */
  109. union {
  110. struct hlist_node hash; /* merge hash */
  111. struct list_head ipi_list;
  112. };
  113. /*
  114. * The rb_node is only used inside the io scheduler, requests
  115. * are pruned when moved to the dispatch queue. So let the
  116. * completion_data share space with the rb_node.
  117. */
  118. union {
  119. struct rb_node rb_node; /* sort/lookup */
  120. void *completion_data;
  121. };
  122. /*
  123. * Three pointers are available for the IO schedulers, if they need
  124. * more they have to dynamically allocate it. Flush requests are
  125. * never put on the IO scheduler. So let the flush fields share
  126. * space with the elevator data.
  127. */
  128. union {
  129. struct {
  130. struct io_cq *icq;
  131. void *priv[2];
  132. } elv;
  133. struct {
  134. unsigned int seq;
  135. struct list_head list;
  136. rq_end_io_fn *saved_end_io;
  137. } flush;
  138. };
  139. struct gendisk *rq_disk;
  140. struct hd_struct *part;
  141. unsigned long start_time;
  142. #ifdef CONFIG_BLK_CGROUP
  143. struct request_list *rl; /* rl this rq is alloced from */
  144. unsigned long long start_time_ns;
  145. unsigned long long io_start_time_ns; /* when passed to hardware */
  146. #endif
  147. /* Number of scatter-gather DMA addr+len pairs after
  148. * physical address coalescing is performed.
  149. */
  150. unsigned short nr_phys_segments;
  151. #if defined(CONFIG_BLK_DEV_INTEGRITY)
  152. unsigned short nr_integrity_segments;
  153. #endif
  154. unsigned short ioprio;
  155. void *special; /* opaque pointer available for LLD use */
  156. int tag;
  157. int errors;
  158. /*
  159. * when request is used as a packet command carrier
  160. */
  161. unsigned char __cmd[BLK_MAX_CDB];
  162. unsigned char *cmd;
  163. unsigned short cmd_len;
  164. unsigned int extra_len; /* length of alignment and padding */
  165. unsigned int sense_len;
  166. unsigned int resid_len; /* residual count */
  167. void *sense;
  168. unsigned long deadline;
  169. struct list_head timeout_list;
  170. unsigned int timeout;
  171. int retries;
  172. /*
  173. * completion callback.
  174. */
  175. rq_end_io_fn *end_io;
  176. void *end_io_data;
  177. /* for bidi */
  178. struct request *next_rq;
  179. };
  180. static inline unsigned short req_get_ioprio(struct request *req)
  181. {
  182. return req->ioprio;
  183. }
  184. /*
  185. * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
  186. * requests. Some step values could eventually be made generic.
  187. */
  188. struct request_pm_state
  189. {
  190. /* PM state machine step value, currently driver specific */
  191. int pm_step;
  192. /* requested PM state value (S1, S2, S3, S4, ...) */
  193. u32 pm_state;
  194. void* data; /* for driver use */
  195. };
  196. #include <linux/elevator.h>
  197. struct blk_queue_ctx;
  198. typedef void (request_fn_proc) (struct request_queue *q);
  199. typedef void (make_request_fn) (struct request_queue *q, struct bio *bio);
  200. typedef int (prep_rq_fn) (struct request_queue *, struct request *);
  201. typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
  202. struct bio_vec;
  203. struct bvec_merge_data {
  204. struct block_device *bi_bdev;
  205. sector_t bi_sector;
  206. unsigned bi_size;
  207. unsigned long bi_rw;
  208. };
  209. typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
  210. struct bio_vec *);
  211. typedef void (softirq_done_fn)(struct request *);
  212. typedef int (dma_drain_needed_fn)(struct request *);
  213. typedef int (lld_busy_fn) (struct request_queue *q);
  214. typedef int (bsg_job_fn) (struct bsg_job *);
  215. enum blk_eh_timer_return {
  216. BLK_EH_NOT_HANDLED,
  217. BLK_EH_HANDLED,
  218. BLK_EH_RESET_TIMER,
  219. };
  220. typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
  221. enum blk_queue_state {
  222. Queue_down,
  223. Queue_up,
  224. };
  225. struct blk_queue_tag {
  226. struct request **tag_index; /* map of busy tags */
  227. unsigned long *tag_map; /* bit map of free/busy tags */
  228. int busy; /* current depth */
  229. int max_depth; /* what we will send to device */
  230. int real_max_depth; /* what the array can hold */
  231. atomic_t refcnt; /* map can be shared */
  232. };
  233. #define BLK_SCSI_MAX_CMDS (256)
  234. #define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
  235. struct queue_limits {
  236. unsigned long bounce_pfn;
  237. unsigned long seg_boundary_mask;
  238. unsigned int max_hw_sectors;
  239. unsigned int chunk_sectors;
  240. unsigned int max_sectors;
  241. unsigned int max_segment_size;
  242. unsigned int physical_block_size;
  243. unsigned int alignment_offset;
  244. unsigned int io_min;
  245. unsigned int io_opt;
  246. unsigned int max_discard_sectors;
  247. unsigned int max_write_same_sectors;
  248. unsigned int discard_granularity;
  249. unsigned int discard_alignment;
  250. unsigned short logical_block_size;
  251. unsigned short max_segments;
  252. unsigned short max_integrity_segments;
  253. unsigned char misaligned;
  254. unsigned char discard_misaligned;
  255. unsigned char cluster;
  256. unsigned char discard_zeroes_data;
  257. unsigned char raid_partial_stripes_expensive;
  258. };
  259. struct request_queue {
  260. /*
  261. * Together with queue_head for cacheline sharing
  262. */
  263. struct list_head queue_head;
  264. struct request *last_merge;
  265. struct elevator_queue *elevator;
  266. int nr_rqs[2]; /* # allocated [a]sync rqs */
  267. int nr_rqs_elvpriv; /* # allocated rqs w/ elvpriv */
  268. /*
  269. * If blkcg is not used, @q->root_rl serves all requests. If blkcg
  270. * is used, root blkg allocates from @q->root_rl and all other
  271. * blkgs from their own blkg->rl. Which one to use should be
  272. * determined using bio_request_list().
  273. */
  274. struct request_list root_rl;
  275. request_fn_proc *request_fn;
  276. make_request_fn *make_request_fn;
  277. prep_rq_fn *prep_rq_fn;
  278. unprep_rq_fn *unprep_rq_fn;
  279. merge_bvec_fn *merge_bvec_fn;
  280. softirq_done_fn *softirq_done_fn;
  281. rq_timed_out_fn *rq_timed_out_fn;
  282. dma_drain_needed_fn *dma_drain_needed;
  283. lld_busy_fn *lld_busy_fn;
  284. struct blk_mq_ops *mq_ops;
  285. unsigned int *mq_map;
  286. /* sw queues */
  287. struct blk_mq_ctx __percpu *queue_ctx;
  288. unsigned int nr_queues;
  289. /* hw dispatch queues */
  290. struct blk_mq_hw_ctx **queue_hw_ctx;
  291. unsigned int nr_hw_queues;
  292. /*
  293. * Dispatch queue sorting
  294. */
  295. sector_t end_sector;
  296. struct request *boundary_rq;
  297. /*
  298. * Delayed queue handling
  299. */
  300. struct delayed_work delay_work;
  301. struct backing_dev_info backing_dev_info;
  302. /*
  303. * The queue owner gets to use this for whatever they like.
  304. * ll_rw_blk doesn't touch it.
  305. */
  306. void *queuedata;
  307. /*
  308. * various queue flags, see QUEUE_* below
  309. */
  310. unsigned long queue_flags;
  311. /*
  312. * ida allocated id for this queue. Used to index queues from
  313. * ioctx.
  314. */
  315. int id;
  316. /*
  317. * queue needs bounce pages for pages above this limit
  318. */
  319. gfp_t bounce_gfp;
  320. /*
  321. * protects queue structures from reentrancy. ->__queue_lock should
  322. * _never_ be used directly, it is queue private. always use
  323. * ->queue_lock.
  324. */
  325. spinlock_t __queue_lock;
  326. spinlock_t *queue_lock;
  327. /*
  328. * queue kobject
  329. */
  330. struct kobject kobj;
  331. /*
  332. * mq queue kobject
  333. */
  334. struct kobject mq_kobj;
  335. #ifdef CONFIG_PM_RUNTIME
  336. struct device *dev;
  337. int rpm_status;
  338. unsigned int nr_pending;
  339. #endif
  340. /*
  341. * queue settings
  342. */
  343. unsigned long nr_requests; /* Max # of requests */
  344. unsigned int nr_congestion_on;
  345. unsigned int nr_congestion_off;
  346. unsigned int nr_batching;
  347. unsigned int dma_drain_size;
  348. void *dma_drain_buffer;
  349. unsigned int dma_pad_mask;
  350. unsigned int dma_alignment;
  351. struct blk_queue_tag *queue_tags;
  352. struct list_head tag_busy_list;
  353. unsigned int nr_sorted;
  354. unsigned int in_flight[2];
  355. /*
  356. * Number of active block driver functions for which blk_drain_queue()
  357. * must wait. Must be incremented around functions that unlock the
  358. * queue_lock internally, e.g. scsi_request_fn().
  359. */
  360. unsigned int request_fn_active;
  361. unsigned int rq_timeout;
  362. struct timer_list timeout;
  363. struct list_head timeout_list;
  364. struct list_head icq_list;
  365. #ifdef CONFIG_BLK_CGROUP
  366. DECLARE_BITMAP (blkcg_pols, BLKCG_MAX_POLS);
  367. struct blkcg_gq *root_blkg;
  368. struct list_head blkg_list;
  369. #endif
  370. struct queue_limits limits;
  371. /*
  372. * sg stuff
  373. */
  374. unsigned int sg_timeout;
  375. unsigned int sg_reserved_size;
  376. int node;
  377. #ifdef CONFIG_BLK_DEV_IO_TRACE
  378. struct blk_trace *blk_trace;
  379. #endif
  380. /*
  381. * for flush operations
  382. */
  383. unsigned int flush_flags;
  384. unsigned int flush_not_queueable:1;
  385. unsigned int flush_queue_delayed:1;
  386. unsigned int flush_pending_idx:1;
  387. unsigned int flush_running_idx:1;
  388. unsigned long flush_pending_since;
  389. struct list_head flush_queue[2];
  390. struct list_head flush_data_in_flight;
  391. struct request *flush_rq;
  392. spinlock_t mq_flush_lock;
  393. struct list_head requeue_list;
  394. spinlock_t requeue_lock;
  395. struct work_struct requeue_work;
  396. struct mutex sysfs_lock;
  397. int bypass_depth;
  398. int mq_freeze_depth;
  399. #if defined(CONFIG_BLK_DEV_BSG)
  400. bsg_job_fn *bsg_job_fn;
  401. int bsg_job_size;
  402. struct bsg_class_device bsg_dev;
  403. #endif
  404. #ifdef CONFIG_BLK_DEV_THROTTLING
  405. /* Throttle data */
  406. struct throtl_data *td;
  407. #endif
  408. struct rcu_head rcu_head;
  409. wait_queue_head_t mq_freeze_wq;
  410. struct percpu_ref mq_usage_counter;
  411. struct list_head all_q_node;
  412. struct blk_mq_tag_set *tag_set;
  413. struct list_head tag_set_list;
  414. };
  415. #define QUEUE_FLAG_QUEUED 1 /* uses generic tag queueing */
  416. #define QUEUE_FLAG_STOPPED 2 /* queue is stopped */
  417. #define QUEUE_FLAG_SYNCFULL 3 /* read queue has been filled */
  418. #define QUEUE_FLAG_ASYNCFULL 4 /* write queue has been filled */
  419. #define QUEUE_FLAG_DYING 5 /* queue being torn down */
  420. #define QUEUE_FLAG_BYPASS 6 /* act as dumb FIFO queue */
  421. #define QUEUE_FLAG_BIDI 7 /* queue supports bidi requests */
  422. #define QUEUE_FLAG_NOMERGES 8 /* disable merge attempts */
  423. #define QUEUE_FLAG_SAME_COMP 9 /* complete on same CPU-group */
  424. #define QUEUE_FLAG_FAIL_IO 10 /* fake timeout */
  425. #define QUEUE_FLAG_STACKABLE 11 /* supports request stacking */
  426. #define QUEUE_FLAG_NONROT 12 /* non-rotational device (SSD) */
  427. #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT /* paravirt device */
  428. #define QUEUE_FLAG_IO_STAT 13 /* do IO stats */
  429. #define QUEUE_FLAG_DISCARD 14 /* supports DISCARD */
  430. #define QUEUE_FLAG_NOXMERGES 15 /* No extended merges */
  431. #define QUEUE_FLAG_ADD_RANDOM 16 /* Contributes to random pool */
  432. #define QUEUE_FLAG_SECDISCARD 17 /* supports SECDISCARD */
  433. #define QUEUE_FLAG_SAME_FORCE 18 /* force complete on same CPU */
  434. #define QUEUE_FLAG_DEAD 19 /* queue tear-down finished */
  435. #define QUEUE_FLAG_INIT_DONE 20 /* queue is initialized */
  436. #define QUEUE_FLAG_NO_SG_MERGE 21 /* don't attempt to merge SG segments*/
  437. #define QUEUE_FLAG_SG_GAPS 22 /* queue doesn't support SG gaps */
  438. #define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
  439. (1 << QUEUE_FLAG_STACKABLE) | \
  440. (1 << QUEUE_FLAG_SAME_COMP) | \
  441. (1 << QUEUE_FLAG_ADD_RANDOM))
  442. #define QUEUE_FLAG_MQ_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
  443. (1 << QUEUE_FLAG_SAME_COMP))
  444. static inline void queue_lockdep_assert_held(struct request_queue *q)
  445. {
  446. if (q->queue_lock)
  447. lockdep_assert_held(q->queue_lock);
  448. }
  449. static inline void queue_flag_set_unlocked(unsigned int flag,
  450. struct request_queue *q)
  451. {
  452. __set_bit(flag, &q->queue_flags);
  453. }
  454. static inline int queue_flag_test_and_clear(unsigned int flag,
  455. struct request_queue *q)
  456. {
  457. queue_lockdep_assert_held(q);
  458. if (test_bit(flag, &q->queue_flags)) {
  459. __clear_bit(flag, &q->queue_flags);
  460. return 1;
  461. }
  462. return 0;
  463. }
  464. static inline int queue_flag_test_and_set(unsigned int flag,
  465. struct request_queue *q)
  466. {
  467. queue_lockdep_assert_held(q);
  468. if (!test_bit(flag, &q->queue_flags)) {
  469. __set_bit(flag, &q->queue_flags);
  470. return 0;
  471. }
  472. return 1;
  473. }
  474. static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
  475. {
  476. queue_lockdep_assert_held(q);
  477. __set_bit(flag, &q->queue_flags);
  478. }
  479. static inline void queue_flag_clear_unlocked(unsigned int flag,
  480. struct request_queue *q)
  481. {
  482. __clear_bit(flag, &q->queue_flags);
  483. }
  484. static inline int queue_in_flight(struct request_queue *q)
  485. {
  486. return q->in_flight[0] + q->in_flight[1];
  487. }
  488. static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
  489. {
  490. queue_lockdep_assert_held(q);
  491. __clear_bit(flag, &q->queue_flags);
  492. }
  493. #define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
  494. #define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
  495. #define blk_queue_dying(q) test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
  496. #define blk_queue_dead(q) test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
  497. #define blk_queue_bypass(q) test_bit(QUEUE_FLAG_BYPASS, &(q)->queue_flags)
  498. #define blk_queue_init_done(q) test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
  499. #define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
  500. #define blk_queue_noxmerges(q) \
  501. test_bit(QUEUE_FLAG_NOXMERGES, &(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_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
  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_queue_secdiscard(q) (blk_queue_discard(q) && \
  509. test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
  510. #define blk_noretry_request(rq) \
  511. ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
  512. REQ_FAILFAST_DRIVER))
  513. #define blk_account_rq(rq) \
  514. (((rq)->cmd_flags & REQ_STARTED) && \
  515. ((rq)->cmd_type == REQ_TYPE_FS))
  516. #define blk_pm_request(rq) \
  517. ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
  518. (rq)->cmd_type == REQ_TYPE_PM_RESUME)
  519. #define blk_rq_cpu_valid(rq) ((rq)->cpu != -1)
  520. #define blk_bidi_rq(rq) ((rq)->next_rq != NULL)
  521. /* rq->queuelist of dequeued request must be list_empty() */
  522. #define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist))
  523. #define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
  524. #define rq_data_dir(rq) (((rq)->cmd_flags & 1) != 0)
  525. /*
  526. * Driver can handle struct request, if it either has an old style
  527. * request_fn defined, or is blk-mq based.
  528. */
  529. static inline bool queue_is_rq_based(struct request_queue *q)
  530. {
  531. return q->request_fn || q->mq_ops;
  532. }
  533. static inline unsigned int blk_queue_cluster(struct request_queue *q)
  534. {
  535. return q->limits.cluster;
  536. }
  537. /*
  538. * We regard a request as sync, if either a read or a sync write
  539. */
  540. static inline bool rw_is_sync(unsigned int rw_flags)
  541. {
  542. return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
  543. }
  544. static inline bool rq_is_sync(struct request *rq)
  545. {
  546. return rw_is_sync(rq->cmd_flags);
  547. }
  548. static inline bool blk_rl_full(struct request_list *rl, bool sync)
  549. {
  550. unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
  551. return rl->flags & flag;
  552. }
  553. static inline void blk_set_rl_full(struct request_list *rl, bool sync)
  554. {
  555. unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
  556. rl->flags |= flag;
  557. }
  558. static inline void blk_clear_rl_full(struct request_list *rl, bool sync)
  559. {
  560. unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
  561. rl->flags &= ~flag;
  562. }
  563. static inline bool rq_mergeable(struct request *rq)
  564. {
  565. if (rq->cmd_type != REQ_TYPE_FS)
  566. return false;
  567. if (rq->cmd_flags & REQ_NOMERGE_FLAGS)
  568. return false;
  569. return true;
  570. }
  571. static inline bool blk_check_merge_flags(unsigned int flags1,
  572. unsigned int flags2)
  573. {
  574. if ((flags1 & REQ_DISCARD) != (flags2 & REQ_DISCARD))
  575. return false;
  576. if ((flags1 & REQ_SECURE) != (flags2 & REQ_SECURE))
  577. return false;
  578. if ((flags1 & REQ_WRITE_SAME) != (flags2 & REQ_WRITE_SAME))
  579. return false;
  580. return true;
  581. }
  582. static inline bool blk_write_same_mergeable(struct bio *a, struct bio *b)
  583. {
  584. if (bio_data(a) == bio_data(b))
  585. return true;
  586. return false;
  587. }
  588. /*
  589. * q->prep_rq_fn return values
  590. */
  591. #define BLKPREP_OK 0 /* serve it */
  592. #define BLKPREP_KILL 1 /* fatal error, kill */
  593. #define BLKPREP_DEFER 2 /* leave on queue */
  594. extern unsigned long blk_max_low_pfn, blk_max_pfn;
  595. /*
  596. * standard bounce addresses:
  597. *
  598. * BLK_BOUNCE_HIGH : bounce all highmem pages
  599. * BLK_BOUNCE_ANY : don't bounce anything
  600. * BLK_BOUNCE_ISA : bounce pages above ISA DMA boundary
  601. */
  602. #if BITS_PER_LONG == 32
  603. #define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
  604. #else
  605. #define BLK_BOUNCE_HIGH -1ULL
  606. #endif
  607. #define BLK_BOUNCE_ANY (-1ULL)
  608. #define BLK_BOUNCE_ISA (DMA_BIT_MASK(24))
  609. /*
  610. * default timeout for SG_IO if none specified
  611. */
  612. #define BLK_DEFAULT_SG_TIMEOUT (60 * HZ)
  613. #define BLK_MIN_SG_TIMEOUT (7 * HZ)
  614. #ifdef CONFIG_BOUNCE
  615. extern int init_emergency_isa_pool(void);
  616. extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
  617. #else
  618. static inline int init_emergency_isa_pool(void)
  619. {
  620. return 0;
  621. }
  622. static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
  623. {
  624. }
  625. #endif /* CONFIG_MMU */
  626. struct rq_map_data {
  627. struct page **pages;
  628. int page_order;
  629. int nr_entries;
  630. unsigned long offset;
  631. int null_mapped;
  632. int from_user;
  633. };
  634. struct req_iterator {
  635. struct bvec_iter iter;
  636. struct bio *bio;
  637. };
  638. /* This should not be used directly - use rq_for_each_segment */
  639. #define for_each_bio(_bio) \
  640. for (; _bio; _bio = _bio->bi_next)
  641. #define __rq_for_each_bio(_bio, rq) \
  642. if ((rq->bio)) \
  643. for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
  644. #define rq_for_each_segment(bvl, _rq, _iter) \
  645. __rq_for_each_bio(_iter.bio, _rq) \
  646. bio_for_each_segment(bvl, _iter.bio, _iter.iter)
  647. #define rq_iter_last(bvec, _iter) \
  648. (_iter.bio->bi_next == NULL && \
  649. bio_iter_last(bvec, _iter.iter))
  650. #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
  651. # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
  652. #endif
  653. #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
  654. extern void rq_flush_dcache_pages(struct request *rq);
  655. #else
  656. static inline void rq_flush_dcache_pages(struct request *rq)
  657. {
  658. }
  659. #endif
  660. extern int blk_register_queue(struct gendisk *disk);
  661. extern void blk_unregister_queue(struct gendisk *disk);
  662. extern void generic_make_request(struct bio *bio);
  663. extern void blk_rq_init(struct request_queue *q, struct request *rq);
  664. extern void blk_put_request(struct request *);
  665. extern void __blk_put_request(struct request_queue *, struct request *);
  666. extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
  667. extern struct request *blk_make_request(struct request_queue *, struct bio *,
  668. gfp_t);
  669. extern void blk_rq_set_block_pc(struct request *);
  670. extern void blk_requeue_request(struct request_queue *, struct request *);
  671. extern void blk_add_request_payload(struct request *rq, struct page *page,
  672. unsigned int len);
  673. extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
  674. extern int blk_lld_busy(struct request_queue *q);
  675. extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
  676. struct bio_set *bs, gfp_t gfp_mask,
  677. int (*bio_ctr)(struct bio *, struct bio *, void *),
  678. void *data);
  679. extern void blk_rq_unprep_clone(struct request *rq);
  680. extern int blk_insert_cloned_request(struct request_queue *q,
  681. struct request *rq);
  682. extern void blk_delay_queue(struct request_queue *, unsigned long);
  683. extern void blk_recount_segments(struct request_queue *, struct bio *);
  684. extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int);
  685. extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t,
  686. unsigned int, void __user *);
  687. extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
  688. unsigned int, void __user *);
  689. extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
  690. struct scsi_ioctl_command __user *);
  691. extern void blk_queue_bio(struct request_queue *q, struct bio *bio);
  692. /*
  693. * A queue has just exitted congestion. Note this in the global counter of
  694. * congested queues, and wake up anyone who was waiting for requests to be
  695. * put back.
  696. */
  697. static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
  698. {
  699. clear_bdi_congested(&q->backing_dev_info, sync);
  700. }
  701. /*
  702. * A queue has just entered congestion. Flag that in the queue's VM-visible
  703. * state flags and increment the global gounter of congested queues.
  704. */
  705. static inline void blk_set_queue_congested(struct request_queue *q, int sync)
  706. {
  707. set_bdi_congested(&q->backing_dev_info, sync);
  708. }
  709. extern void blk_start_queue(struct request_queue *q);
  710. extern void blk_stop_queue(struct request_queue *q);
  711. extern void blk_sync_queue(struct request_queue *q);
  712. extern void __blk_stop_queue(struct request_queue *q);
  713. extern void __blk_run_queue(struct request_queue *q);
  714. extern void blk_run_queue(struct request_queue *);
  715. extern void blk_run_queue_async(struct request_queue *q);
  716. extern int blk_rq_map_user(struct request_queue *, struct request *,
  717. struct rq_map_data *, void __user *, unsigned long,
  718. gfp_t);
  719. extern int blk_rq_unmap_user(struct bio *);
  720. extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
  721. extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
  722. struct rq_map_data *, const struct sg_iovec *,
  723. int, unsigned int, gfp_t);
  724. extern int blk_execute_rq(struct request_queue *, struct gendisk *,
  725. struct request *, int);
  726. extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
  727. struct request *, int, rq_end_io_fn *);
  728. static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
  729. {
  730. return bdev->bd_disk->queue;
  731. }
  732. /*
  733. * blk_rq_pos() : the current sector
  734. * blk_rq_bytes() : bytes left in the entire request
  735. * blk_rq_cur_bytes() : bytes left in the current segment
  736. * blk_rq_err_bytes() : bytes left till the next error boundary
  737. * blk_rq_sectors() : sectors left in the entire request
  738. * blk_rq_cur_sectors() : sectors left in the current segment
  739. */
  740. static inline sector_t blk_rq_pos(const struct request *rq)
  741. {
  742. return rq->__sector;
  743. }
  744. static inline unsigned int blk_rq_bytes(const struct request *rq)
  745. {
  746. return rq->__data_len;
  747. }
  748. static inline int blk_rq_cur_bytes(const struct request *rq)
  749. {
  750. return rq->bio ? bio_cur_bytes(rq->bio) : 0;
  751. }
  752. extern unsigned int blk_rq_err_bytes(const struct request *rq);
  753. static inline unsigned int blk_rq_sectors(const struct request *rq)
  754. {
  755. return blk_rq_bytes(rq) >> 9;
  756. }
  757. static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
  758. {
  759. return blk_rq_cur_bytes(rq) >> 9;
  760. }
  761. static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
  762. unsigned int cmd_flags)
  763. {
  764. if (unlikely(cmd_flags & REQ_DISCARD))
  765. return min(q->limits.max_discard_sectors, UINT_MAX >> 9);
  766. if (unlikely(cmd_flags & REQ_WRITE_SAME))
  767. return q->limits.max_write_same_sectors;
  768. return q->limits.max_sectors;
  769. }
  770. /*
  771. * Return maximum size of a request at given offset. Only valid for
  772. * file system requests.
  773. */
  774. static inline unsigned int blk_max_size_offset(struct request_queue *q,
  775. sector_t offset)
  776. {
  777. if (!q->limits.chunk_sectors)
  778. return q->limits.max_sectors;
  779. return q->limits.chunk_sectors -
  780. (offset & (q->limits.chunk_sectors - 1));
  781. }
  782. static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
  783. {
  784. struct request_queue *q = rq->q;
  785. if (unlikely(rq->cmd_type == REQ_TYPE_BLOCK_PC))
  786. return q->limits.max_hw_sectors;
  787. if (!q->limits.chunk_sectors)
  788. return blk_queue_get_max_sectors(q, rq->cmd_flags);
  789. return min(blk_max_size_offset(q, blk_rq_pos(rq)),
  790. blk_queue_get_max_sectors(q, rq->cmd_flags));
  791. }
  792. static inline unsigned int blk_rq_count_bios(struct request *rq)
  793. {
  794. unsigned int nr_bios = 0;
  795. struct bio *bio;
  796. __rq_for_each_bio(bio, rq)
  797. nr_bios++;
  798. return nr_bios;
  799. }
  800. /*
  801. * Request issue related functions.
  802. */
  803. extern struct request *blk_peek_request(struct request_queue *q);
  804. extern void blk_start_request(struct request *rq);
  805. extern struct request *blk_fetch_request(struct request_queue *q);
  806. /*
  807. * Request completion related functions.
  808. *
  809. * blk_update_request() completes given number of bytes and updates
  810. * the request without completing it.
  811. *
  812. * blk_end_request() and friends. __blk_end_request() must be called
  813. * with the request queue spinlock acquired.
  814. *
  815. * Several drivers define their own end_request and call
  816. * blk_end_request() for parts of the original function.
  817. * This prevents code duplication in drivers.
  818. */
  819. extern bool blk_update_request(struct request *rq, int error,
  820. unsigned int nr_bytes);
  821. extern void blk_finish_request(struct request *rq, int error);
  822. extern bool blk_end_request(struct request *rq, int error,
  823. unsigned int nr_bytes);
  824. extern void blk_end_request_all(struct request *rq, int error);
  825. extern bool blk_end_request_cur(struct request *rq, int error);
  826. extern bool blk_end_request_err(struct request *rq, int error);
  827. extern bool __blk_end_request(struct request *rq, int error,
  828. unsigned int nr_bytes);
  829. extern void __blk_end_request_all(struct request *rq, int error);
  830. extern bool __blk_end_request_cur(struct request *rq, int error);
  831. extern bool __blk_end_request_err(struct request *rq, int error);
  832. extern void blk_complete_request(struct request *);
  833. extern void __blk_complete_request(struct request *);
  834. extern void blk_abort_request(struct request *);
  835. extern void blk_unprep_request(struct request *);
  836. /*
  837. * Access functions for manipulating queue properties
  838. */
  839. extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
  840. spinlock_t *lock, int node_id);
  841. extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
  842. extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
  843. request_fn_proc *, spinlock_t *);
  844. extern void blk_cleanup_queue(struct request_queue *);
  845. extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
  846. extern void blk_queue_bounce_limit(struct request_queue *, u64);
  847. extern void blk_limits_max_hw_sectors(struct queue_limits *, unsigned int);
  848. extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
  849. extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
  850. extern void blk_queue_max_segments(struct request_queue *, unsigned short);
  851. extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
  852. extern void blk_queue_max_discard_sectors(struct request_queue *q,
  853. unsigned int max_discard_sectors);
  854. extern void blk_queue_max_write_same_sectors(struct request_queue *q,
  855. unsigned int max_write_same_sectors);
  856. extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
  857. extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
  858. extern void blk_queue_alignment_offset(struct request_queue *q,
  859. unsigned int alignment);
  860. extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
  861. extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
  862. extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
  863. extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
  864. extern void blk_set_default_limits(struct queue_limits *lim);
  865. extern void blk_set_stacking_limits(struct queue_limits *lim);
  866. extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
  867. sector_t offset);
  868. extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
  869. sector_t offset);
  870. extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
  871. sector_t offset);
  872. extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
  873. extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
  874. extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
  875. extern int blk_queue_dma_drain(struct request_queue *q,
  876. dma_drain_needed_fn *dma_drain_needed,
  877. void *buf, unsigned int size);
  878. extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
  879. extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
  880. extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
  881. extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
  882. extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
  883. extern void blk_queue_dma_alignment(struct request_queue *, int);
  884. extern void blk_queue_update_dma_alignment(struct request_queue *, int);
  885. extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
  886. extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
  887. extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
  888. extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
  889. extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
  890. extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
  891. extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
  892. extern int blk_bio_map_sg(struct request_queue *q, struct bio *bio,
  893. struct scatterlist *sglist);
  894. extern void blk_dump_rq_flags(struct request *, char *);
  895. extern long nr_blockdev_pages(void);
  896. bool __must_check blk_get_queue(struct request_queue *);
  897. struct request_queue *blk_alloc_queue(gfp_t);
  898. struct request_queue *blk_alloc_queue_node(gfp_t, int);
  899. extern void blk_put_queue(struct request_queue *);
  900. /*
  901. * block layer runtime pm functions
  902. */
  903. #ifdef CONFIG_PM_RUNTIME
  904. extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
  905. extern int blk_pre_runtime_suspend(struct request_queue *q);
  906. extern void blk_post_runtime_suspend(struct request_queue *q, int err);
  907. extern void blk_pre_runtime_resume(struct request_queue *q);
  908. extern void blk_post_runtime_resume(struct request_queue *q, int err);
  909. #else
  910. static inline void blk_pm_runtime_init(struct request_queue *q,
  911. struct device *dev) {}
  912. static inline int blk_pre_runtime_suspend(struct request_queue *q)
  913. {
  914. return -ENOSYS;
  915. }
  916. static inline void blk_post_runtime_suspend(struct request_queue *q, int err) {}
  917. static inline void blk_pre_runtime_resume(struct request_queue *q) {}
  918. static inline void blk_post_runtime_resume(struct request_queue *q, int err) {}
  919. #endif
  920. /*
  921. * blk_plug permits building a queue of related requests by holding the I/O
  922. * fragments for a short period. This allows merging of sequential requests
  923. * into single larger request. As the requests are moved from a per-task list to
  924. * the device's request_queue in a batch, this results in improved scalability
  925. * as the lock contention for request_queue lock is reduced.
  926. *
  927. * It is ok not to disable preemption when adding the request to the plug list
  928. * or when attempting a merge, because blk_schedule_flush_list() will only flush
  929. * the plug list when the task sleeps by itself. For details, please see
  930. * schedule() where blk_schedule_flush_plug() is called.
  931. */
  932. struct blk_plug {
  933. struct list_head list; /* requests */
  934. struct list_head mq_list; /* blk-mq requests */
  935. struct list_head cb_list; /* md requires an unplug callback */
  936. };
  937. #define BLK_MAX_REQUEST_COUNT 16
  938. struct blk_plug_cb;
  939. typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
  940. struct blk_plug_cb {
  941. struct list_head list;
  942. blk_plug_cb_fn callback;
  943. void *data;
  944. };
  945. extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
  946. void *data, int size);
  947. extern void blk_start_plug(struct blk_plug *);
  948. extern void blk_finish_plug(struct blk_plug *);
  949. extern void blk_flush_plug_list(struct blk_plug *, bool);
  950. static inline void blk_flush_plug(struct task_struct *tsk)
  951. {
  952. struct blk_plug *plug = tsk->plug;
  953. if (plug)
  954. blk_flush_plug_list(plug, false);
  955. }
  956. static inline void blk_schedule_flush_plug(struct task_struct *tsk)
  957. {
  958. struct blk_plug *plug = tsk->plug;
  959. if (plug)
  960. blk_flush_plug_list(plug, true);
  961. }
  962. static inline bool blk_needs_flush_plug(struct task_struct *tsk)
  963. {
  964. struct blk_plug *plug = tsk->plug;
  965. return plug &&
  966. (!list_empty(&plug->list) ||
  967. !list_empty(&plug->mq_list) ||
  968. !list_empty(&plug->cb_list));
  969. }
  970. /*
  971. * tag stuff
  972. */
  973. #define blk_rq_tagged(rq) \
  974. ((rq)->mq_ctx || ((rq)->cmd_flags & REQ_QUEUED))
  975. extern int blk_queue_start_tag(struct request_queue *, struct request *);
  976. extern struct request *blk_queue_find_tag(struct request_queue *, int);
  977. extern void blk_queue_end_tag(struct request_queue *, struct request *);
  978. extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
  979. extern void blk_queue_free_tags(struct request_queue *);
  980. extern int blk_queue_resize_tags(struct request_queue *, int);
  981. extern void blk_queue_invalidate_tags(struct request_queue *);
  982. extern struct blk_queue_tag *blk_init_tags(int);
  983. extern void blk_free_tags(struct blk_queue_tag *);
  984. static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
  985. int tag)
  986. {
  987. if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
  988. return NULL;
  989. return bqt->tag_index[tag];
  990. }
  991. #define BLKDEV_DISCARD_SECURE 0x01 /* secure discard */
  992. extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
  993. extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
  994. sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
  995. extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
  996. sector_t nr_sects, gfp_t gfp_mask, struct page *page);
  997. extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
  998. sector_t nr_sects, gfp_t gfp_mask);
  999. static inline int sb_issue_discard(struct super_block *sb, sector_t block,
  1000. sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
  1001. {
  1002. return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
  1003. nr_blocks << (sb->s_blocksize_bits - 9),
  1004. gfp_mask, flags);
  1005. }
  1006. static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
  1007. sector_t nr_blocks, gfp_t gfp_mask)
  1008. {
  1009. return blkdev_issue_zeroout(sb->s_bdev,
  1010. block << (sb->s_blocksize_bits - 9),
  1011. nr_blocks << (sb->s_blocksize_bits - 9),
  1012. gfp_mask);
  1013. }
  1014. extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
  1015. enum blk_default_limits {
  1016. BLK_MAX_SEGMENTS = 128,
  1017. BLK_SAFE_MAX_SECTORS = 255,
  1018. BLK_DEF_MAX_SECTORS = 1024,
  1019. BLK_MAX_SEGMENT_SIZE = 65536,
  1020. BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL,
  1021. };
  1022. #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
  1023. static inline unsigned long queue_bounce_pfn(struct request_queue *q)
  1024. {
  1025. return q->limits.bounce_pfn;
  1026. }
  1027. static inline unsigned long queue_segment_boundary(struct request_queue *q)
  1028. {
  1029. return q->limits.seg_boundary_mask;
  1030. }
  1031. static inline unsigned int queue_max_sectors(struct request_queue *q)
  1032. {
  1033. return q->limits.max_sectors;
  1034. }
  1035. static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
  1036. {
  1037. return q->limits.max_hw_sectors;
  1038. }
  1039. static inline unsigned short queue_max_segments(struct request_queue *q)
  1040. {
  1041. return q->limits.max_segments;
  1042. }
  1043. static inline unsigned int queue_max_segment_size(struct request_queue *q)
  1044. {
  1045. return q->limits.max_segment_size;
  1046. }
  1047. static inline unsigned short queue_logical_block_size(struct request_queue *q)
  1048. {
  1049. int retval = 512;
  1050. if (q && q->limits.logical_block_size)
  1051. retval = q->limits.logical_block_size;
  1052. return retval;
  1053. }
  1054. static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
  1055. {
  1056. return queue_logical_block_size(bdev_get_queue(bdev));
  1057. }
  1058. static inline unsigned int queue_physical_block_size(struct request_queue *q)
  1059. {
  1060. return q->limits.physical_block_size;
  1061. }
  1062. static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
  1063. {
  1064. return queue_physical_block_size(bdev_get_queue(bdev));
  1065. }
  1066. static inline unsigned int queue_io_min(struct request_queue *q)
  1067. {
  1068. return q->limits.io_min;
  1069. }
  1070. static inline int bdev_io_min(struct block_device *bdev)
  1071. {
  1072. return queue_io_min(bdev_get_queue(bdev));
  1073. }
  1074. static inline unsigned int queue_io_opt(struct request_queue *q)
  1075. {
  1076. return q->limits.io_opt;
  1077. }
  1078. static inline int bdev_io_opt(struct block_device *bdev)
  1079. {
  1080. return queue_io_opt(bdev_get_queue(bdev));
  1081. }
  1082. static inline int queue_alignment_offset(struct request_queue *q)
  1083. {
  1084. if (q->limits.misaligned)
  1085. return -1;
  1086. return q->limits.alignment_offset;
  1087. }
  1088. static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
  1089. {
  1090. unsigned int granularity = max(lim->physical_block_size, lim->io_min);
  1091. unsigned int alignment = (sector << 9) & (granularity - 1);
  1092. return (granularity + lim->alignment_offset - alignment)
  1093. & (granularity - 1);
  1094. }
  1095. static inline int bdev_alignment_offset(struct block_device *bdev)
  1096. {
  1097. struct request_queue *q = bdev_get_queue(bdev);
  1098. if (q->limits.misaligned)
  1099. return -1;
  1100. if (bdev != bdev->bd_contains)
  1101. return bdev->bd_part->alignment_offset;
  1102. return q->limits.alignment_offset;
  1103. }
  1104. static inline int queue_discard_alignment(struct request_queue *q)
  1105. {
  1106. if (q->limits.discard_misaligned)
  1107. return -1;
  1108. return q->limits.discard_alignment;
  1109. }
  1110. static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
  1111. {
  1112. unsigned int alignment, granularity, offset;
  1113. if (!lim->max_discard_sectors)
  1114. return 0;
  1115. /* Why are these in bytes, not sectors? */
  1116. alignment = lim->discard_alignment >> 9;
  1117. granularity = lim->discard_granularity >> 9;
  1118. if (!granularity)
  1119. return 0;
  1120. /* Offset of the partition start in 'granularity' sectors */
  1121. offset = sector_div(sector, granularity);
  1122. /* And why do we do this modulus *again* in blkdev_issue_discard()? */
  1123. offset = (granularity + alignment - offset) % granularity;
  1124. /* Turn it back into bytes, gaah */
  1125. return offset << 9;
  1126. }
  1127. static inline int bdev_discard_alignment(struct block_device *bdev)
  1128. {
  1129. struct request_queue *q = bdev_get_queue(bdev);
  1130. if (bdev != bdev->bd_contains)
  1131. return bdev->bd_part->discard_alignment;
  1132. return q->limits.discard_alignment;
  1133. }
  1134. static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
  1135. {
  1136. if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
  1137. return 1;
  1138. return 0;
  1139. }
  1140. static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
  1141. {
  1142. return queue_discard_zeroes_data(bdev_get_queue(bdev));
  1143. }
  1144. static inline unsigned int bdev_write_same(struct block_device *bdev)
  1145. {
  1146. struct request_queue *q = bdev_get_queue(bdev);
  1147. if (q)
  1148. return q->limits.max_write_same_sectors;
  1149. return 0;
  1150. }
  1151. static inline int queue_dma_alignment(struct request_queue *q)
  1152. {
  1153. return q ? q->dma_alignment : 511;
  1154. }
  1155. static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
  1156. unsigned int len)
  1157. {
  1158. unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
  1159. return !(addr & alignment) && !(len & alignment);
  1160. }
  1161. /* assumes size > 256 */
  1162. static inline unsigned int blksize_bits(unsigned int size)
  1163. {
  1164. unsigned int bits = 8;
  1165. do {
  1166. bits++;
  1167. size >>= 1;
  1168. } while (size > 256);
  1169. return bits;
  1170. }
  1171. static inline unsigned int block_size(struct block_device *bdev)
  1172. {
  1173. return bdev->bd_block_size;
  1174. }
  1175. static inline bool queue_flush_queueable(struct request_queue *q)
  1176. {
  1177. return !q->flush_not_queueable;
  1178. }
  1179. typedef struct {struct page *v;} Sector;
  1180. unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
  1181. static inline void put_dev_sector(Sector p)
  1182. {
  1183. page_cache_release(p.v);
  1184. }
  1185. struct work_struct;
  1186. int kblockd_schedule_work(struct work_struct *work);
  1187. int kblockd_schedule_delayed_work(struct delayed_work *dwork, unsigned long delay);
  1188. int kblockd_schedule_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
  1189. #ifdef CONFIG_BLK_CGROUP
  1190. /*
  1191. * This should not be using sched_clock(). A real patch is in progress
  1192. * to fix this up, until that is in place we need to disable preemption
  1193. * around sched_clock() in this function and set_io_start_time_ns().
  1194. */
  1195. static inline void set_start_time_ns(struct request *req)
  1196. {
  1197. preempt_disable();
  1198. req->start_time_ns = sched_clock();
  1199. preempt_enable();
  1200. }
  1201. static inline void set_io_start_time_ns(struct request *req)
  1202. {
  1203. preempt_disable();
  1204. req->io_start_time_ns = sched_clock();
  1205. preempt_enable();
  1206. }
  1207. static inline uint64_t rq_start_time_ns(struct request *req)
  1208. {
  1209. return req->start_time_ns;
  1210. }
  1211. static inline uint64_t rq_io_start_time_ns(struct request *req)
  1212. {
  1213. return req->io_start_time_ns;
  1214. }
  1215. #else
  1216. static inline void set_start_time_ns(struct request *req) {}
  1217. static inline void set_io_start_time_ns(struct request *req) {}
  1218. static inline uint64_t rq_start_time_ns(struct request *req)
  1219. {
  1220. return 0;
  1221. }
  1222. static inline uint64_t rq_io_start_time_ns(struct request *req)
  1223. {
  1224. return 0;
  1225. }
  1226. #endif
  1227. #define MODULE_ALIAS_BLOCKDEV(major,minor) \
  1228. MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
  1229. #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
  1230. MODULE_ALIAS("block-major-" __stringify(major) "-*")
  1231. #if defined(CONFIG_BLK_DEV_INTEGRITY)
  1232. #define INTEGRITY_FLAG_READ 2 /* verify data integrity on read */
  1233. #define INTEGRITY_FLAG_WRITE 4 /* generate data integrity on write */
  1234. struct blk_integrity_exchg {
  1235. void *prot_buf;
  1236. void *data_buf;
  1237. sector_t sector;
  1238. unsigned int data_size;
  1239. unsigned short sector_size;
  1240. const char *disk_name;
  1241. };
  1242. typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
  1243. typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
  1244. typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
  1245. typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
  1246. struct blk_integrity {
  1247. integrity_gen_fn *generate_fn;
  1248. integrity_vrfy_fn *verify_fn;
  1249. integrity_set_tag_fn *set_tag_fn;
  1250. integrity_get_tag_fn *get_tag_fn;
  1251. unsigned short flags;
  1252. unsigned short tuple_size;
  1253. unsigned short sector_size;
  1254. unsigned short tag_size;
  1255. const char *name;
  1256. struct kobject kobj;
  1257. };
  1258. extern bool blk_integrity_is_initialized(struct gendisk *);
  1259. extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
  1260. extern void blk_integrity_unregister(struct gendisk *);
  1261. extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
  1262. extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
  1263. struct scatterlist *);
  1264. extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
  1265. extern int blk_integrity_merge_rq(struct request_queue *, struct request *,
  1266. struct request *);
  1267. extern int blk_integrity_merge_bio(struct request_queue *, struct request *,
  1268. struct bio *);
  1269. static inline
  1270. struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
  1271. {
  1272. return bdev->bd_disk->integrity;
  1273. }
  1274. static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
  1275. {
  1276. return disk->integrity;
  1277. }
  1278. static inline int blk_integrity_rq(struct request *rq)
  1279. {
  1280. if (rq->bio == NULL)
  1281. return 0;
  1282. return bio_integrity(rq->bio);
  1283. }
  1284. static inline void blk_queue_max_integrity_segments(struct request_queue *q,
  1285. unsigned int segs)
  1286. {
  1287. q->limits.max_integrity_segments = segs;
  1288. }
  1289. static inline unsigned short
  1290. queue_max_integrity_segments(struct request_queue *q)
  1291. {
  1292. return q->limits.max_integrity_segments;
  1293. }
  1294. #else /* CONFIG_BLK_DEV_INTEGRITY */
  1295. struct bio;
  1296. struct block_device;
  1297. struct gendisk;
  1298. struct blk_integrity;
  1299. static inline int blk_integrity_rq(struct request *rq)
  1300. {
  1301. return 0;
  1302. }
  1303. static inline int blk_rq_count_integrity_sg(struct request_queue *q,
  1304. struct bio *b)
  1305. {
  1306. return 0;
  1307. }
  1308. static inline int blk_rq_map_integrity_sg(struct request_queue *q,
  1309. struct bio *b,
  1310. struct scatterlist *s)
  1311. {
  1312. return 0;
  1313. }
  1314. static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
  1315. {
  1316. return 0;
  1317. }
  1318. static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
  1319. {
  1320. return NULL;
  1321. }
  1322. static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
  1323. {
  1324. return 0;
  1325. }
  1326. static inline int blk_integrity_register(struct gendisk *d,
  1327. struct blk_integrity *b)
  1328. {
  1329. return 0;
  1330. }
  1331. static inline void blk_integrity_unregister(struct gendisk *d)
  1332. {
  1333. }
  1334. static inline void blk_queue_max_integrity_segments(struct request_queue *q,
  1335. unsigned int segs)
  1336. {
  1337. }
  1338. static inline unsigned short queue_max_integrity_segments(struct request_queue *q)
  1339. {
  1340. return 0;
  1341. }
  1342. static inline int blk_integrity_merge_rq(struct request_queue *rq,
  1343. struct request *r1,
  1344. struct request *r2)
  1345. {
  1346. return 0;
  1347. }
  1348. static inline int blk_integrity_merge_bio(struct request_queue *rq,
  1349. struct request *r,
  1350. struct bio *b)
  1351. {
  1352. return 0;
  1353. }
  1354. static inline bool blk_integrity_is_initialized(struct gendisk *g)
  1355. {
  1356. return 0;
  1357. }
  1358. #endif /* CONFIG_BLK_DEV_INTEGRITY */
  1359. struct block_device_operations {
  1360. int (*open) (struct block_device *, fmode_t);
  1361. void (*release) (struct gendisk *, fmode_t);
  1362. int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
  1363. int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1364. int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
  1365. int (*direct_access) (struct block_device *, sector_t,
  1366. void **, unsigned long *);
  1367. unsigned int (*check_events) (struct gendisk *disk,
  1368. unsigned int clearing);
  1369. /* ->media_changed() is DEPRECATED, use ->check_events() instead */
  1370. int (*media_changed) (struct gendisk *);
  1371. void (*unlock_native_capacity) (struct gendisk *);
  1372. int (*revalidate_disk) (struct gendisk *);
  1373. int (*getgeo)(struct block_device *, struct hd_geometry *);
  1374. /* this callback is with swap_lock and sometimes page table lock held */
  1375. void (*swap_slot_free_notify) (struct block_device *, unsigned long);
  1376. struct module *owner;
  1377. };
  1378. extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
  1379. unsigned long);
  1380. extern int bdev_read_page(struct block_device *, sector_t, struct page *);
  1381. extern int bdev_write_page(struct block_device *, sector_t, struct page *,
  1382. struct writeback_control *);
  1383. #else /* CONFIG_BLOCK */
  1384. struct block_device;
  1385. /*
  1386. * stubs for when the block layer is configured out
  1387. */
  1388. #define buffer_heads_over_limit 0
  1389. static inline long nr_blockdev_pages(void)
  1390. {
  1391. return 0;
  1392. }
  1393. struct blk_plug {
  1394. };
  1395. static inline void blk_start_plug(struct blk_plug *plug)
  1396. {
  1397. }
  1398. static inline void blk_finish_plug(struct blk_plug *plug)
  1399. {
  1400. }
  1401. static inline void blk_flush_plug(struct task_struct *task)
  1402. {
  1403. }
  1404. static inline void blk_schedule_flush_plug(struct task_struct *task)
  1405. {
  1406. }
  1407. static inline bool blk_needs_flush_plug(struct task_struct *tsk)
  1408. {
  1409. return false;
  1410. }
  1411. static inline int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
  1412. sector_t *error_sector)
  1413. {
  1414. return 0;
  1415. }
  1416. #endif /* CONFIG_BLOCK */
  1417. #endif