1#ifndef _LINUX_BLKDEV_H
2#define _LINUX_BLKDEV_H
3
4#include <linux/sched.h>
5
6#ifdef CONFIG_BLOCK
7
8#include <linux/major.h>
9#include <linux/genhd.h>
10#include <linux/list.h>
11#include <linux/llist.h>
12#include <linux/timer.h>
13#include <linux/workqueue.h>
14#include <linux/pagemap.h>
15#include <linux/backing-dev.h>
16#include <linux/wait.h>
17#include <linux/mempool.h>
18#include <linux/bio.h>
19#include <linux/stringify.h>
20#include <linux/gfp.h>
21#include <linux/bsg.h>
22#include <linux/smp.h>
23#include <linux/rcupdate.h>
24#include <linux/percpu-refcount.h>
25
26#include <asm/scatterlist.h>
27
28struct module;
29struct scsi_ioctl_command;
30
31struct request_queue;
32struct elevator_queue;
33struct request_pm_state;
34struct blk_trace;
35struct request;
36struct sg_io_hdr;
37struct bsg_job;
38struct blkcg_gq;
39struct blk_flush_queue;
40
41#define BLKDEV_MIN_RQ 4
42#define BLKDEV_MAX_RQ 128
43
44
45
46
47
48#define BLKCG_MAX_POLS 2
49
50struct request;
51typedef void (rq_end_io_fn)(struct request *, int);
52
53#define BLK_RL_SYNCFULL (1U << 0)
54#define BLK_RL_ASYNCFULL (1U << 1)
55
56struct request_list {
57 struct request_queue *q;
58#ifdef CONFIG_BLK_CGROUP
59 struct blkcg_gq *blkg;
60#endif
61
62
63
64
65 int count[2];
66 int starved[2];
67 mempool_t *rq_pool;
68 wait_queue_head_t wait[2];
69 unsigned int flags;
70};
71
72
73
74
75enum rq_cmd_type_bits {
76 REQ_TYPE_FS = 1,
77 REQ_TYPE_BLOCK_PC,
78 REQ_TYPE_SENSE,
79 REQ_TYPE_PM_SUSPEND,
80 REQ_TYPE_PM_RESUME,
81 REQ_TYPE_PM_SHUTDOWN,
82 REQ_TYPE_SPECIAL,
83
84
85
86
87
88 REQ_TYPE_ATA_TASKFILE,
89 REQ_TYPE_ATA_PC,
90};
91
92#define BLK_MAX_CDB 16
93
94
95
96
97
98
99
100struct request {
101 struct list_head queuelist;
102 union {
103 struct call_single_data csd;
104 unsigned long fifo_time;
105 };
106
107 struct request_queue *q;
108 struct blk_mq_ctx *mq_ctx;
109
110 u64 cmd_flags;
111 enum rq_cmd_type_bits cmd_type;
112 unsigned long atomic_flags;
113
114 int cpu;
115
116
117 unsigned int __data_len;
118 sector_t __sector;
119
120 struct bio *bio;
121 struct bio *biotail;
122
123
124
125
126
127
128
129
130 union {
131 struct hlist_node hash;
132 struct list_head ipi_list;
133 };
134
135
136
137
138
139
140 union {
141 struct rb_node rb_node;
142 void *completion_data;
143 };
144
145
146
147
148
149
150
151 union {
152 struct {
153 struct io_cq *icq;
154 void *priv[2];
155 } elv;
156
157 struct {
158 unsigned int seq;
159 struct list_head list;
160 rq_end_io_fn *saved_end_io;
161 } flush;
162 };
163
164 struct gendisk *rq_disk;
165 struct hd_struct *part;
166 unsigned long start_time;
167#ifdef CONFIG_BLK_CGROUP
168 struct request_list *rl;
169 unsigned long long start_time_ns;
170 unsigned long long io_start_time_ns;
171#endif
172
173
174
175 unsigned short nr_phys_segments;
176#if defined(CONFIG_BLK_DEV_INTEGRITY)
177 unsigned short nr_integrity_segments;
178#endif
179
180 unsigned short ioprio;
181
182 void *special;
183
184 int tag;
185 int errors;
186
187
188
189
190 unsigned char __cmd[BLK_MAX_CDB];
191 unsigned char *cmd;
192 unsigned short cmd_len;
193
194 unsigned int extra_len;
195 unsigned int sense_len;
196 unsigned int resid_len;
197 void *sense;
198
199 unsigned long deadline;
200 struct list_head timeout_list;
201 unsigned int timeout;
202 int retries;
203
204
205
206
207 rq_end_io_fn *end_io;
208 void *end_io_data;
209
210
211 struct request *next_rq;
212};
213
214static inline unsigned short req_get_ioprio(struct request *req)
215{
216 return req->ioprio;
217}
218
219
220
221
222
223struct request_pm_state
224{
225
226 int pm_step;
227
228 u32 pm_state;
229 void* data;
230};
231
232#include <linux/elevator.h>
233
234struct blk_queue_ctx;
235
236typedef void (request_fn_proc) (struct request_queue *q);
237typedef void (make_request_fn) (struct request_queue *q, struct bio *bio);
238typedef int (prep_rq_fn) (struct request_queue *, struct request *);
239typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
240
241struct bio_vec;
242struct bvec_merge_data {
243 struct block_device *bi_bdev;
244 sector_t bi_sector;
245 unsigned bi_size;
246 unsigned long bi_rw;
247};
248typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
249 struct bio_vec *);
250typedef void (softirq_done_fn)(struct request *);
251typedef int (dma_drain_needed_fn)(struct request *);
252typedef int (lld_busy_fn) (struct request_queue *q);
253typedef int (bsg_job_fn) (struct bsg_job *);
254
255enum blk_eh_timer_return {
256 BLK_EH_NOT_HANDLED,
257 BLK_EH_HANDLED,
258 BLK_EH_RESET_TIMER,
259};
260
261typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
262
263enum blk_queue_state {
264 Queue_down,
265 Queue_up,
266};
267
268struct blk_queue_tag {
269 struct request **tag_index;
270 unsigned long *tag_map;
271 int busy;
272 int max_depth;
273 int real_max_depth;
274 atomic_t refcnt;
275};
276
277#define BLK_SCSI_MAX_CMDS (256)
278#define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
279
280struct queue_limits {
281 unsigned long bounce_pfn;
282 unsigned long seg_boundary_mask;
283
284 unsigned int max_hw_sectors;
285 unsigned int chunk_sectors;
286 unsigned int max_sectors;
287 unsigned int max_segment_size;
288 unsigned int physical_block_size;
289 unsigned int alignment_offset;
290 unsigned int io_min;
291 unsigned int io_opt;
292 unsigned int max_discard_sectors;
293 unsigned int max_write_same_sectors;
294 unsigned int discard_granularity;
295 unsigned int discard_alignment;
296
297 unsigned short logical_block_size;
298 unsigned short max_segments;
299 unsigned short max_integrity_segments;
300
301 unsigned char misaligned;
302 unsigned char discard_misaligned;
303 unsigned char cluster;
304 unsigned char discard_zeroes_data;
305 unsigned char raid_partial_stripes_expensive;
306};
307
308struct request_queue {
309
310
311
312 struct list_head queue_head;
313 struct request *last_merge;
314 struct elevator_queue *elevator;
315 int nr_rqs[2];
316 int nr_rqs_elvpriv;
317
318
319
320
321
322
323
324 struct request_list root_rl;
325
326 request_fn_proc *request_fn;
327 make_request_fn *make_request_fn;
328 prep_rq_fn *prep_rq_fn;
329 unprep_rq_fn *unprep_rq_fn;
330 merge_bvec_fn *merge_bvec_fn;
331 softirq_done_fn *softirq_done_fn;
332 rq_timed_out_fn *rq_timed_out_fn;
333 dma_drain_needed_fn *dma_drain_needed;
334 lld_busy_fn *lld_busy_fn;
335
336 struct blk_mq_ops *mq_ops;
337
338 unsigned int *mq_map;
339
340
341 struct blk_mq_ctx __percpu *queue_ctx;
342 unsigned int nr_queues;
343
344
345 struct blk_mq_hw_ctx **queue_hw_ctx;
346 unsigned int nr_hw_queues;
347
348
349
350
351 sector_t end_sector;
352 struct request *boundary_rq;
353
354
355
356
357 struct delayed_work delay_work;
358
359 struct backing_dev_info backing_dev_info;
360
361
362
363
364
365 void *queuedata;
366
367
368
369
370 unsigned long queue_flags;
371
372
373
374
375
376 int id;
377
378
379
380
381 gfp_t bounce_gfp;
382
383
384
385
386
387
388 spinlock_t __queue_lock;
389 spinlock_t *queue_lock;
390
391
392
393
394 struct kobject kobj;
395
396
397
398
399 struct kobject mq_kobj;
400
401#ifdef CONFIG_PM_RUNTIME
402 struct device *dev;
403 int rpm_status;
404 unsigned int nr_pending;
405#endif
406
407
408
409
410 unsigned long nr_requests;
411 unsigned int nr_congestion_on;
412 unsigned int nr_congestion_off;
413 unsigned int nr_batching;
414
415 unsigned int dma_drain_size;
416 void *dma_drain_buffer;
417 unsigned int dma_pad_mask;
418 unsigned int dma_alignment;
419
420 struct blk_queue_tag *queue_tags;
421 struct list_head tag_busy_list;
422
423 unsigned int nr_sorted;
424 unsigned int in_flight[2];
425
426
427
428
429
430 unsigned int request_fn_active;
431
432 unsigned int rq_timeout;
433 struct timer_list timeout;
434 struct list_head timeout_list;
435
436 struct list_head icq_list;
437#ifdef CONFIG_BLK_CGROUP
438 DECLARE_BITMAP (blkcg_pols, BLKCG_MAX_POLS);
439 struct blkcg_gq *root_blkg;
440 struct list_head blkg_list;
441#endif
442
443 struct queue_limits limits;
444
445
446
447
448 unsigned int sg_timeout;
449 unsigned int sg_reserved_size;
450 int node;
451#ifdef CONFIG_BLK_DEV_IO_TRACE
452 struct blk_trace *blk_trace;
453#endif
454
455
456
457 unsigned int flush_flags;
458 unsigned int flush_not_queueable:1;
459 struct blk_flush_queue *fq;
460
461 struct list_head requeue_list;
462 spinlock_t requeue_lock;
463 struct work_struct requeue_work;
464
465 struct mutex sysfs_lock;
466
467 int bypass_depth;
468 int mq_freeze_depth;
469
470#if defined(CONFIG_BLK_DEV_BSG)
471 bsg_job_fn *bsg_job_fn;
472 int bsg_job_size;
473 struct bsg_class_device bsg_dev;
474#endif
475
476#ifdef CONFIG_BLK_DEV_THROTTLING
477
478 struct throtl_data *td;
479#endif
480 struct rcu_head rcu_head;
481 wait_queue_head_t mq_freeze_wq;
482 struct percpu_ref mq_usage_counter;
483 struct list_head all_q_node;
484
485 struct blk_mq_tag_set *tag_set;
486 struct list_head tag_set_list;
487};
488
489#define QUEUE_FLAG_QUEUED 1
490#define QUEUE_FLAG_STOPPED 2
491#define QUEUE_FLAG_SYNCFULL 3
492#define QUEUE_FLAG_ASYNCFULL 4
493#define QUEUE_FLAG_DYING 5
494#define QUEUE_FLAG_BYPASS 6
495#define QUEUE_FLAG_BIDI 7
496#define QUEUE_FLAG_NOMERGES 8
497#define QUEUE_FLAG_SAME_COMP 9
498#define QUEUE_FLAG_FAIL_IO 10
499#define QUEUE_FLAG_STACKABLE 11
500#define QUEUE_FLAG_NONROT 12
501#define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT
502#define QUEUE_FLAG_IO_STAT 13
503#define QUEUE_FLAG_DISCARD 14
504#define QUEUE_FLAG_NOXMERGES 15
505#define QUEUE_FLAG_ADD_RANDOM 16
506#define QUEUE_FLAG_SECDISCARD 17
507#define QUEUE_FLAG_SAME_FORCE 18
508#define QUEUE_FLAG_DEAD 19
509#define QUEUE_FLAG_INIT_DONE 20
510#define QUEUE_FLAG_NO_SG_MERGE 21
511#define QUEUE_FLAG_SG_GAPS 22
512
513#define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
514 (1 << QUEUE_FLAG_STACKABLE) | \
515 (1 << QUEUE_FLAG_SAME_COMP) | \
516 (1 << QUEUE_FLAG_ADD_RANDOM))
517
518#define QUEUE_FLAG_MQ_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
519 (1 << QUEUE_FLAG_SAME_COMP))
520
521static inline void queue_lockdep_assert_held(struct request_queue *q)
522{
523 if (q->queue_lock)
524 lockdep_assert_held(q->queue_lock);
525}
526
527static inline void queue_flag_set_unlocked(unsigned int flag,
528 struct request_queue *q)
529{
530 __set_bit(flag, &q->queue_flags);
531}
532
533static inline int queue_flag_test_and_clear(unsigned int flag,
534 struct request_queue *q)
535{
536 queue_lockdep_assert_held(q);
537
538 if (test_bit(flag, &q->queue_flags)) {
539 __clear_bit(flag, &q->queue_flags);
540 return 1;
541 }
542
543 return 0;
544}
545
546static inline int queue_flag_test_and_set(unsigned int flag,
547 struct request_queue *q)
548{
549 queue_lockdep_assert_held(q);
550
551 if (!test_bit(flag, &q->queue_flags)) {
552 __set_bit(flag, &q->queue_flags);
553 return 0;
554 }
555
556 return 1;
557}
558
559static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
560{
561 queue_lockdep_assert_held(q);
562 __set_bit(flag, &q->queue_flags);
563}
564
565static inline void queue_flag_clear_unlocked(unsigned int flag,
566 struct request_queue *q)
567{
568 __clear_bit(flag, &q->queue_flags);
569}
570
571static inline int queue_in_flight(struct request_queue *q)
572{
573 return q->in_flight[0] + q->in_flight[1];
574}
575
576static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
577{
578 queue_lockdep_assert_held(q);
579 __clear_bit(flag, &q->queue_flags);
580}
581
582#define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
583#define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
584#define blk_queue_dying(q) test_bit(QUEUE_FLAG_DYING, &(q)->queue_flags)
585#define blk_queue_dead(q) test_bit(QUEUE_FLAG_DEAD, &(q)->queue_flags)
586#define blk_queue_bypass(q) test_bit(QUEUE_FLAG_BYPASS, &(q)->queue_flags)
587#define blk_queue_init_done(q) test_bit(QUEUE_FLAG_INIT_DONE, &(q)->queue_flags)
588#define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
589#define blk_queue_noxmerges(q) \
590 test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
591#define blk_queue_nonrot(q) test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
592#define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
593#define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
594#define blk_queue_stackable(q) \
595 test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
596#define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
597#define blk_queue_secdiscard(q) (blk_queue_discard(q) && \
598 test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
599
600#define blk_noretry_request(rq) \
601 ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
602 REQ_FAILFAST_DRIVER))
603
604#define blk_account_rq(rq) \
605 (((rq)->cmd_flags & REQ_STARTED) && \
606 ((rq)->cmd_type == REQ_TYPE_FS))
607
608#define blk_pm_request(rq) \
609 ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
610 (rq)->cmd_type == REQ_TYPE_PM_RESUME)
611
612#define blk_rq_cpu_valid(rq) ((rq)->cpu != -1)
613#define blk_bidi_rq(rq) ((rq)->next_rq != NULL)
614
615#define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist))
616
617#define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
618
619#define rq_data_dir(rq) (((rq)->cmd_flags & 1) != 0)
620
621
622
623
624
625static inline bool queue_is_rq_based(struct request_queue *q)
626{
627 return q->request_fn || q->mq_ops;
628}
629
630static inline unsigned int blk_queue_cluster(struct request_queue *q)
631{
632 return q->limits.cluster;
633}
634
635
636
637
638static inline bool rw_is_sync(unsigned int rw_flags)
639{
640 return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
641}
642
643static inline bool rq_is_sync(struct request *rq)
644{
645 return rw_is_sync(rq->cmd_flags);
646}
647
648static inline bool blk_rl_full(struct request_list *rl, bool sync)
649{
650 unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
651
652 return rl->flags & flag;
653}
654
655static inline void blk_set_rl_full(struct request_list *rl, bool sync)
656{
657 unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
658
659 rl->flags |= flag;
660}
661
662static inline void blk_clear_rl_full(struct request_list *rl, bool sync)
663{
664 unsigned int flag = sync ? BLK_RL_SYNCFULL : BLK_RL_ASYNCFULL;
665
666 rl->flags &= ~flag;
667}
668
669static inline bool rq_mergeable(struct request *rq)
670{
671 if (rq->cmd_type != REQ_TYPE_FS)
672 return false;
673
674 if (rq->cmd_flags & REQ_NOMERGE_FLAGS)
675 return false;
676
677 return true;
678}
679
680static inline bool blk_check_merge_flags(unsigned int flags1,
681 unsigned int flags2)
682{
683 if ((flags1 & REQ_DISCARD) != (flags2 & REQ_DISCARD))
684 return false;
685
686 if ((flags1 & REQ_SECURE) != (flags2 & REQ_SECURE))
687 return false;
688
689 if ((flags1 & REQ_WRITE_SAME) != (flags2 & REQ_WRITE_SAME))
690 return false;
691
692 return true;
693}
694
695static inline bool blk_write_same_mergeable(struct bio *a, struct bio *b)
696{
697 if (bio_data(a) == bio_data(b))
698 return true;
699
700 return false;
701}
702
703
704
705
706#define BLKPREP_OK 0
707#define BLKPREP_KILL 1
708#define BLKPREP_DEFER 2
709
710extern unsigned long blk_max_low_pfn, blk_max_pfn;
711
712
713
714
715
716
717
718
719
720#if BITS_PER_LONG == 32
721#define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
722#else
723#define BLK_BOUNCE_HIGH -1ULL
724#endif
725#define BLK_BOUNCE_ANY (-1ULL)
726#define BLK_BOUNCE_ISA (DMA_BIT_MASK(24))
727
728
729
730
731#define BLK_DEFAULT_SG_TIMEOUT (60 * HZ)
732#define BLK_MIN_SG_TIMEOUT (7 * HZ)
733
734#ifdef CONFIG_BOUNCE
735extern int init_emergency_isa_pool(void);
736extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
737#else
738static inline int init_emergency_isa_pool(void)
739{
740 return 0;
741}
742static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
743{
744}
745#endif
746
747struct rq_map_data {
748 struct page **pages;
749 int page_order;
750 int nr_entries;
751 unsigned long offset;
752 int null_mapped;
753 int from_user;
754};
755
756struct req_iterator {
757 struct bvec_iter iter;
758 struct bio *bio;
759};
760
761
762#define for_each_bio(_bio) \
763 for (; _bio; _bio = _bio->bi_next)
764#define __rq_for_each_bio(_bio, rq) \
765 if ((rq->bio)) \
766 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
767
768#define rq_for_each_segment(bvl, _rq, _iter) \
769 __rq_for_each_bio(_iter.bio, _rq) \
770 bio_for_each_segment(bvl, _iter.bio, _iter.iter)
771
772#define rq_iter_last(bvec, _iter) \
773 (_iter.bio->bi_next == NULL && \
774 bio_iter_last(bvec, _iter.iter))
775
776#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
777# error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
778#endif
779#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
780extern void rq_flush_dcache_pages(struct request *rq);
781#else
782static inline void rq_flush_dcache_pages(struct request *rq)
783{
784}
785#endif
786
787extern int blk_register_queue(struct gendisk *disk);
788extern void blk_unregister_queue(struct gendisk *disk);
789extern void generic_make_request(struct bio *bio);
790extern void blk_rq_init(struct request_queue *q, struct request *rq);
791extern void blk_put_request(struct request *);
792extern void __blk_put_request(struct request_queue *, struct request *);
793extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
794extern struct request *blk_make_request(struct request_queue *, struct bio *,
795 gfp_t);
796extern void blk_rq_set_block_pc(struct request *);
797extern void blk_requeue_request(struct request_queue *, struct request *);
798extern void blk_add_request_payload(struct request *rq, struct page *page,
799 unsigned int len);
800extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
801extern int blk_lld_busy(struct request_queue *q);
802extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
803 struct bio_set *bs, gfp_t gfp_mask,
804 int (*bio_ctr)(struct bio *, struct bio *, void *),
805 void *data);
806extern void blk_rq_unprep_clone(struct request *rq);
807extern int blk_insert_cloned_request(struct request_queue *q,
808 struct request *rq);
809extern void blk_delay_queue(struct request_queue *, unsigned long);
810extern void blk_recount_segments(struct request_queue *, struct bio *);
811extern int scsi_verify_blk_ioctl(struct block_device *, unsigned int);
812extern int scsi_cmd_blk_ioctl(struct block_device *, fmode_t,
813 unsigned int, void __user *);
814extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
815 unsigned int, void __user *);
816extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
817 struct scsi_ioctl_command __user *);
818
819extern void blk_queue_bio(struct request_queue *q, struct bio *bio);
820
821
822
823
824
825
826static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
827{
828 clear_bdi_congested(&q->backing_dev_info, sync);
829}
830
831
832
833
834
835static inline void blk_set_queue_congested(struct request_queue *q, int sync)
836{
837 set_bdi_congested(&q->backing_dev_info, sync);
838}
839
840extern void blk_start_queue(struct request_queue *q);
841extern void blk_stop_queue(struct request_queue *q);
842extern void blk_sync_queue(struct request_queue *q);
843extern void __blk_stop_queue(struct request_queue *q);
844extern void __blk_run_queue(struct request_queue *q);
845extern void blk_run_queue(struct request_queue *);
846extern void blk_run_queue_async(struct request_queue *q);
847extern int blk_rq_map_user(struct request_queue *, struct request *,
848 struct rq_map_data *, void __user *, unsigned long,
849 gfp_t);
850extern int blk_rq_unmap_user(struct bio *);
851extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
852extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
853 struct rq_map_data *, const struct sg_iovec *,
854 int, unsigned int, gfp_t);
855extern int blk_execute_rq(struct request_queue *, struct gendisk *,
856 struct request *, int);
857extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
858 struct request *, int, rq_end_io_fn *);
859
860static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
861{
862 return bdev->bd_disk->queue;
863}
864
865
866
867
868
869
870
871
872
873static inline sector_t blk_rq_pos(const struct request *rq)
874{
875 return rq->__sector;
876}
877
878static inline unsigned int blk_rq_bytes(const struct request *rq)
879{
880 return rq->__data_len;
881}
882
883static inline int blk_rq_cur_bytes(const struct request *rq)
884{
885 return rq->bio ? bio_cur_bytes(rq->bio) : 0;
886}
887
888extern unsigned int blk_rq_err_bytes(const struct request *rq);
889
890static inline unsigned int blk_rq_sectors(const struct request *rq)
891{
892 return blk_rq_bytes(rq) >> 9;
893}
894
895static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
896{
897 return blk_rq_cur_bytes(rq) >> 9;
898}
899
900static inline unsigned int blk_queue_get_max_sectors(struct request_queue *q,
901 unsigned int cmd_flags)
902{
903 if (unlikely(cmd_flags & REQ_DISCARD))
904 return min(q->limits.max_discard_sectors, UINT_MAX >> 9);
905
906 if (unlikely(cmd_flags & REQ_WRITE_SAME))
907 return q->limits.max_write_same_sectors;
908
909 return q->limits.max_sectors;
910}
911
912
913
914
915
916static inline unsigned int blk_max_size_offset(struct request_queue *q,
917 sector_t offset)
918{
919 if (!q->limits.chunk_sectors)
920 return q->limits.max_sectors;
921
922 return q->limits.chunk_sectors -
923 (offset & (q->limits.chunk_sectors - 1));
924}
925
926static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
927{
928 struct request_queue *q = rq->q;
929
930 if (unlikely(rq->cmd_type == REQ_TYPE_BLOCK_PC))
931 return q->limits.max_hw_sectors;
932
933 if (!q->limits.chunk_sectors)
934 return blk_queue_get_max_sectors(q, rq->cmd_flags);
935
936 return min(blk_max_size_offset(q, blk_rq_pos(rq)),
937 blk_queue_get_max_sectors(q, rq->cmd_flags));
938}
939
940static inline unsigned int blk_rq_count_bios(struct request *rq)
941{
942 unsigned int nr_bios = 0;
943 struct bio *bio;
944
945 __rq_for_each_bio(bio, rq)
946 nr_bios++;
947
948 return nr_bios;
949}
950
951
952
953
954extern struct request *blk_peek_request(struct request_queue *q);
955extern void blk_start_request(struct request *rq);
956extern struct request *blk_fetch_request(struct request_queue *q);
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971extern bool blk_update_request(struct request *rq, int error,
972 unsigned int nr_bytes);
973extern void blk_finish_request(struct request *rq, int error);
974extern bool blk_end_request(struct request *rq, int error,
975 unsigned int nr_bytes);
976extern void blk_end_request_all(struct request *rq, int error);
977extern bool blk_end_request_cur(struct request *rq, int error);
978extern bool blk_end_request_err(struct request *rq, int error);
979extern bool __blk_end_request(struct request *rq, int error,
980 unsigned int nr_bytes);
981extern void __blk_end_request_all(struct request *rq, int error);
982extern bool __blk_end_request_cur(struct request *rq, int error);
983extern bool __blk_end_request_err(struct request *rq, int error);
984
985extern void blk_complete_request(struct request *);
986extern void __blk_complete_request(struct request *);
987extern void blk_abort_request(struct request *);
988extern void blk_unprep_request(struct request *);
989
990
991
992
993extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
994 spinlock_t *lock, int node_id);
995extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
996extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
997 request_fn_proc *, spinlock_t *);
998extern void blk_cleanup_queue(struct request_queue *);
999extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
1000extern void blk_queue_bounce_limit(struct request_queue *, u64);
1001extern void blk_limits_max_hw_sectors(struct queue_limits *, unsigned int);
1002extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
1003extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);
1004extern void blk_queue_max_segments(struct request_queue *, unsigned short);
1005extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
1006extern void blk_queue_max_discard_sectors(struct request_queue *q,
1007 unsigned int max_discard_sectors);
1008extern void blk_queue_max_write_same_sectors(struct request_queue *q,
1009 unsigned int max_write_same_sectors);
1010extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
1011extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
1012extern void blk_queue_alignment_offset(struct request_queue *q,
1013 unsigned int alignment);
1014extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
1015extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
1016extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
1017extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
1018extern void blk_set_default_limits(struct queue_limits *lim);
1019extern void blk_set_stacking_limits(struct queue_limits *lim);
1020extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
1021 sector_t offset);
1022extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
1023 sector_t offset);
1024extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
1025 sector_t offset);
1026extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
1027extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
1028extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
1029extern int blk_queue_dma_drain(struct request_queue *q,
1030 dma_drain_needed_fn *dma_drain_needed,
1031 void *buf, unsigned int size);
1032extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
1033extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
1034extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
1035extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
1036extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
1037extern void blk_queue_dma_alignment(struct request_queue *, int);
1038extern void blk_queue_update_dma_alignment(struct request_queue *, int);
1039extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
1040extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
1041extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
1042extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
1043extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
1044extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
1045
1046extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
1047extern int blk_bio_map_sg(struct request_queue *q, struct bio *bio,
1048 struct scatterlist *sglist);
1049extern void blk_dump_rq_flags(struct request *, char *);
1050extern long nr_blockdev_pages(void);
1051
1052bool __must_check blk_get_queue(struct request_queue *);
1053struct request_queue *blk_alloc_queue(gfp_t);
1054struct request_queue *blk_alloc_queue_node(gfp_t, int);
1055extern void blk_put_queue(struct request_queue *);
1056
1057
1058
1059
1060#ifdef CONFIG_PM_RUNTIME
1061extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
1062extern int blk_pre_runtime_suspend(struct request_queue *q);
1063extern void blk_post_runtime_suspend(struct request_queue *q, int err);
1064extern void blk_pre_runtime_resume(struct request_queue *q);
1065extern void blk_post_runtime_resume(struct request_queue *q, int err);
1066#else
1067static inline void blk_pm_runtime_init(struct request_queue *q,
1068 struct device *dev) {}
1069static inline int blk_pre_runtime_suspend(struct request_queue *q)
1070{
1071 return -ENOSYS;
1072}
1073static inline void blk_post_runtime_suspend(struct request_queue *q, int err) {}
1074static inline void blk_pre_runtime_resume(struct request_queue *q) {}
1075static inline void blk_post_runtime_resume(struct request_queue *q, int err) {}
1076#endif
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090struct blk_plug {
1091 struct list_head list;
1092 struct list_head mq_list;
1093 struct list_head cb_list;
1094};
1095#define BLK_MAX_REQUEST_COUNT 16
1096
1097struct blk_plug_cb;
1098typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);
1099struct blk_plug_cb {
1100 struct list_head list;
1101 blk_plug_cb_fn callback;
1102 void *data;
1103};
1104extern struct blk_plug_cb *blk_check_plugged(blk_plug_cb_fn unplug,
1105 void *data, int size);
1106extern void blk_start_plug(struct blk_plug *);
1107extern void blk_finish_plug(struct blk_plug *);
1108extern void blk_flush_plug_list(struct blk_plug *, bool);
1109
1110static inline void blk_flush_plug(struct task_struct *tsk)
1111{
1112 struct blk_plug *plug = tsk->plug;
1113
1114 if (plug)
1115 blk_flush_plug_list(plug, false);
1116}
1117
1118static inline void blk_schedule_flush_plug(struct task_struct *tsk)
1119{
1120 struct blk_plug *plug = tsk->plug;
1121
1122 if (plug)
1123 blk_flush_plug_list(plug, true);
1124}
1125
1126static inline bool blk_needs_flush_plug(struct task_struct *tsk)
1127{
1128 struct blk_plug *plug = tsk->plug;
1129
1130 return plug &&
1131 (!list_empty(&plug->list) ||
1132 !list_empty(&plug->mq_list) ||
1133 !list_empty(&plug->cb_list));
1134}
1135
1136
1137
1138
1139#define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED)
1140extern int blk_queue_start_tag(struct request_queue *, struct request *);
1141extern struct request *blk_queue_find_tag(struct request_queue *, int);
1142extern void blk_queue_end_tag(struct request_queue *, struct request *);
1143extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
1144extern void blk_queue_free_tags(struct request_queue *);
1145extern int blk_queue_resize_tags(struct request_queue *, int);
1146extern void blk_queue_invalidate_tags(struct request_queue *);
1147extern struct blk_queue_tag *blk_init_tags(int);
1148extern void blk_free_tags(struct blk_queue_tag *);
1149
1150static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
1151 int tag)
1152{
1153 if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
1154 return NULL;
1155 return bqt->tag_index[tag];
1156}
1157
1158#define BLKDEV_DISCARD_SECURE 0x01
1159
1160extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
1161extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
1162 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
1163extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
1164 sector_t nr_sects, gfp_t gfp_mask, struct page *page);
1165extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
1166 sector_t nr_sects, gfp_t gfp_mask);
1167static inline int sb_issue_discard(struct super_block *sb, sector_t block,
1168 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
1169{
1170 return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
1171 nr_blocks << (sb->s_blocksize_bits - 9),
1172 gfp_mask, flags);
1173}
1174static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
1175 sector_t nr_blocks, gfp_t gfp_mask)
1176{
1177 return blkdev_issue_zeroout(sb->s_bdev,
1178 block << (sb->s_blocksize_bits - 9),
1179 nr_blocks << (sb->s_blocksize_bits - 9),
1180 gfp_mask);
1181}
1182
1183extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
1184
1185enum blk_default_limits {
1186 BLK_MAX_SEGMENTS = 128,
1187 BLK_SAFE_MAX_SECTORS = 255,
1188 BLK_DEF_MAX_SECTORS = 1024,
1189 BLK_MAX_SEGMENT_SIZE = 65536,
1190 BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL,
1191};
1192
1193#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
1194
1195static inline unsigned long queue_bounce_pfn(struct request_queue *q)
1196{
1197 return q->limits.bounce_pfn;
1198}
1199
1200static inline unsigned long queue_segment_boundary(struct request_queue *q)
1201{
1202 return q->limits.seg_boundary_mask;
1203}
1204
1205static inline unsigned int queue_max_sectors(struct request_queue *q)
1206{
1207 return q->limits.max_sectors;
1208}
1209
1210static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
1211{
1212 return q->limits.max_hw_sectors;
1213}
1214
1215static inline unsigned short queue_max_segments(struct request_queue *q)
1216{
1217 return q->limits.max_segments;
1218}
1219
1220static inline unsigned int queue_max_segment_size(struct request_queue *q)
1221{
1222 return q->limits.max_segment_size;
1223}
1224
1225static inline unsigned short queue_logical_block_size(struct request_queue *q)
1226{
1227 int retval = 512;
1228
1229 if (q && q->limits.logical_block_size)
1230 retval = q->limits.logical_block_size;
1231
1232 return retval;
1233}
1234
1235static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
1236{
1237 return queue_logical_block_size(bdev_get_queue(bdev));
1238}
1239
1240static inline unsigned int queue_physical_block_size(struct request_queue *q)
1241{
1242 return q->limits.physical_block_size;
1243}
1244
1245static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
1246{
1247 return queue_physical_block_size(bdev_get_queue(bdev));
1248}
1249
1250static inline unsigned int queue_io_min(struct request_queue *q)
1251{
1252 return q->limits.io_min;
1253}
1254
1255static inline int bdev_io_min(struct block_device *bdev)
1256{
1257 return queue_io_min(bdev_get_queue(bdev));
1258}
1259
1260static inline unsigned int queue_io_opt(struct request_queue *q)
1261{
1262 return q->limits.io_opt;
1263}
1264
1265static inline int bdev_io_opt(struct block_device *bdev)
1266{
1267 return queue_io_opt(bdev_get_queue(bdev));
1268}
1269
1270static inline int queue_alignment_offset(struct request_queue *q)
1271{
1272 if (q->limits.misaligned)
1273 return -1;
1274
1275 return q->limits.alignment_offset;
1276}
1277
1278static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
1279{
1280 unsigned int granularity = max(lim->physical_block_size, lim->io_min);
1281 unsigned int alignment = sector_div(sector, granularity >> 9) << 9;
1282
1283 return (granularity + lim->alignment_offset - alignment) % granularity;
1284}
1285
1286static inline int bdev_alignment_offset(struct block_device *bdev)
1287{
1288 struct request_queue *q = bdev_get_queue(bdev);
1289
1290 if (q->limits.misaligned)
1291 return -1;
1292
1293 if (bdev != bdev->bd_contains)
1294 return bdev->bd_part->alignment_offset;
1295
1296 return q->limits.alignment_offset;
1297}
1298
1299static inline int queue_discard_alignment(struct request_queue *q)
1300{
1301 if (q->limits.discard_misaligned)
1302 return -1;
1303
1304 return q->limits.discard_alignment;
1305}
1306
1307static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
1308{
1309 unsigned int alignment, granularity, offset;
1310
1311 if (!lim->max_discard_sectors)
1312 return 0;
1313
1314
1315 alignment = lim->discard_alignment >> 9;
1316 granularity = lim->discard_granularity >> 9;
1317 if (!granularity)
1318 return 0;
1319
1320
1321 offset = sector_div(sector, granularity);
1322
1323
1324 offset = (granularity + alignment - offset) % granularity;
1325
1326
1327 return offset << 9;
1328}
1329
1330static inline int bdev_discard_alignment(struct block_device *bdev)
1331{
1332 struct request_queue *q = bdev_get_queue(bdev);
1333
1334 if (bdev != bdev->bd_contains)
1335 return bdev->bd_part->discard_alignment;
1336
1337 return q->limits.discard_alignment;
1338}
1339
1340static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
1341{
1342 if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
1343 return 1;
1344
1345 return 0;
1346}
1347
1348static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
1349{
1350 return queue_discard_zeroes_data(bdev_get_queue(bdev));
1351}
1352
1353static inline unsigned int bdev_write_same(struct block_device *bdev)
1354{
1355 struct request_queue *q = bdev_get_queue(bdev);
1356
1357 if (q)
1358 return q->limits.max_write_same_sectors;
1359
1360 return 0;
1361}
1362
1363static inline int queue_dma_alignment(struct request_queue *q)
1364{
1365 return q ? q->dma_alignment : 511;
1366}
1367
1368static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
1369 unsigned int len)
1370{
1371 unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1372 return !(addr & alignment) && !(len & alignment);
1373}
1374
1375
1376static inline unsigned int blksize_bits(unsigned int size)
1377{
1378 unsigned int bits = 8;
1379 do {
1380 bits++;
1381 size >>= 1;
1382 } while (size > 256);
1383 return bits;
1384}
1385
1386static inline unsigned int block_size(struct block_device *bdev)
1387{
1388 return bdev->bd_block_size;
1389}
1390
1391static inline bool queue_flush_queueable(struct request_queue *q)
1392{
1393 return !q->flush_not_queueable;
1394}
1395
1396typedef struct {struct page *v;} Sector;
1397
1398unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
1399
1400static inline void put_dev_sector(Sector p)
1401{
1402 page_cache_release(p.v);
1403}
1404
1405struct work_struct;
1406int kblockd_schedule_work(struct work_struct *work);
1407int kblockd_schedule_delayed_work(struct delayed_work *dwork, unsigned long delay);
1408int kblockd_schedule_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
1409
1410#ifdef CONFIG_BLK_CGROUP
1411
1412
1413
1414
1415
1416static inline void set_start_time_ns(struct request *req)
1417{
1418 preempt_disable();
1419 req->start_time_ns = sched_clock();
1420 preempt_enable();
1421}
1422
1423static inline void set_io_start_time_ns(struct request *req)
1424{
1425 preempt_disable();
1426 req->io_start_time_ns = sched_clock();
1427 preempt_enable();
1428}
1429
1430static inline uint64_t rq_start_time_ns(struct request *req)
1431{
1432 return req->start_time_ns;
1433}
1434
1435static inline uint64_t rq_io_start_time_ns(struct request *req)
1436{
1437 return req->io_start_time_ns;
1438}
1439#else
1440static inline void set_start_time_ns(struct request *req) {}
1441static inline void set_io_start_time_ns(struct request *req) {}
1442static inline uint64_t rq_start_time_ns(struct request *req)
1443{
1444 return 0;
1445}
1446static inline uint64_t rq_io_start_time_ns(struct request *req)
1447{
1448 return 0;
1449}
1450#endif
1451
1452#define MODULE_ALIAS_BLOCKDEV(major,minor) \
1453 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
1454#define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
1455 MODULE_ALIAS("block-major-" __stringify(major) "-*")
1456
1457#if defined(CONFIG_BLK_DEV_INTEGRITY)
1458
1459enum blk_integrity_flags {
1460 BLK_INTEGRITY_VERIFY = 1 << 0,
1461 BLK_INTEGRITY_GENERATE = 1 << 1,
1462 BLK_INTEGRITY_DEVICE_CAPABLE = 1 << 2,
1463 BLK_INTEGRITY_IP_CHECKSUM = 1 << 3,
1464};
1465
1466struct blk_integrity_iter {
1467 void *prot_buf;
1468 void *data_buf;
1469 sector_t seed;
1470 unsigned int data_size;
1471 unsigned short interval;
1472 const char *disk_name;
1473};
1474
1475typedef int (integrity_processing_fn) (struct blk_integrity_iter *);
1476
1477struct blk_integrity {
1478 integrity_processing_fn *generate_fn;
1479 integrity_processing_fn *verify_fn;
1480
1481 unsigned short flags;
1482 unsigned short tuple_size;
1483 unsigned short interval;
1484 unsigned short tag_size;
1485
1486 const char *name;
1487
1488 struct kobject kobj;
1489};
1490
1491extern bool blk_integrity_is_initialized(struct gendisk *);
1492extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
1493extern void blk_integrity_unregister(struct gendisk *);
1494extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
1495extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
1496 struct scatterlist *);
1497extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
1498extern bool blk_integrity_merge_rq(struct request_queue *, struct request *,
1499 struct request *);
1500extern bool blk_integrity_merge_bio(struct request_queue *, struct request *,
1501 struct bio *);
1502
1503static inline
1504struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
1505{
1506 return bdev->bd_disk->integrity;
1507}
1508
1509static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1510{
1511 return disk->integrity;
1512}
1513
1514static inline bool blk_integrity_rq(struct request *rq)
1515{
1516 return rq->cmd_flags & REQ_INTEGRITY;
1517}
1518
1519static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1520 unsigned int segs)
1521{
1522 q->limits.max_integrity_segments = segs;
1523}
1524
1525static inline unsigned short
1526queue_max_integrity_segments(struct request_queue *q)
1527{
1528 return q->limits.max_integrity_segments;
1529}
1530
1531#else
1532
1533struct bio;
1534struct block_device;
1535struct gendisk;
1536struct blk_integrity;
1537
1538static inline int blk_integrity_rq(struct request *rq)
1539{
1540 return 0;
1541}
1542static inline int blk_rq_count_integrity_sg(struct request_queue *q,
1543 struct bio *b)
1544{
1545 return 0;
1546}
1547static inline int blk_rq_map_integrity_sg(struct request_queue *q,
1548 struct bio *b,
1549 struct scatterlist *s)
1550{
1551 return 0;
1552}
1553static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
1554{
1555 return NULL;
1556}
1557static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1558{
1559 return NULL;
1560}
1561static inline int blk_integrity_compare(struct gendisk *a, struct gendisk *b)
1562{
1563 return 0;
1564}
1565static inline int blk_integrity_register(struct gendisk *d,
1566 struct blk_integrity *b)
1567{
1568 return 0;
1569}
1570static inline void blk_integrity_unregister(struct gendisk *d)
1571{
1572}
1573static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1574 unsigned int segs)
1575{
1576}
1577static inline unsigned short queue_max_integrity_segments(struct request_queue *q)
1578{
1579 return 0;
1580}
1581static inline bool blk_integrity_merge_rq(struct request_queue *rq,
1582 struct request *r1,
1583 struct request *r2)
1584{
1585 return true;
1586}
1587static inline bool blk_integrity_merge_bio(struct request_queue *rq,
1588 struct request *r,
1589 struct bio *b)
1590{
1591 return true;
1592}
1593static inline bool blk_integrity_is_initialized(struct gendisk *g)
1594{
1595 return 0;
1596}
1597
1598#endif
1599
1600struct block_device_operations {
1601 int (*open) (struct block_device *, fmode_t);
1602 void (*release) (struct gendisk *, fmode_t);
1603 int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
1604 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1605 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1606 int (*direct_access) (struct block_device *, sector_t,
1607 void **, unsigned long *);
1608 unsigned int (*check_events) (struct gendisk *disk,
1609 unsigned int clearing);
1610
1611 int (*media_changed) (struct gendisk *);
1612 void (*unlock_native_capacity) (struct gendisk *);
1613 int (*revalidate_disk) (struct gendisk *);
1614 int (*getgeo)(struct block_device *, struct hd_geometry *);
1615
1616 void (*swap_slot_free_notify) (struct block_device *, unsigned long);
1617 struct module *owner;
1618};
1619
1620extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
1621 unsigned long);
1622extern int bdev_read_page(struct block_device *, sector_t, struct page *);
1623extern int bdev_write_page(struct block_device *, sector_t, struct page *,
1624 struct writeback_control *);
1625#else
1626
1627struct block_device;
1628
1629
1630
1631
1632#define buffer_heads_over_limit 0
1633
1634static inline long nr_blockdev_pages(void)
1635{
1636 return 0;
1637}
1638
1639struct blk_plug {
1640};
1641
1642static inline void blk_start_plug(struct blk_plug *plug)
1643{
1644}
1645
1646static inline void blk_finish_plug(struct blk_plug *plug)
1647{
1648}
1649
1650static inline void blk_flush_plug(struct task_struct *task)
1651{
1652}
1653
1654static inline void blk_schedule_flush_plug(struct task_struct *task)
1655{
1656}
1657
1658
1659static inline bool blk_needs_flush_plug(struct task_struct *tsk)
1660{
1661 return false;
1662}
1663
1664static inline int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
1665 sector_t *error_sector)
1666{
1667 return 0;
1668}
1669
1670#endif
1671
1672#endif
1673