1#ifndef _LINUX_BLKDEV_H
2#define _LINUX_BLKDEV_H
3
4#ifdef CONFIG_BLOCK
5
6#include <linux/sched.h>
7#include <linux/major.h>
8#include <linux/genhd.h>
9#include <linux/list.h>
10#include <linux/timer.h>
11#include <linux/workqueue.h>
12#include <linux/pagemap.h>
13#include <linux/backing-dev.h>
14#include <linux/wait.h>
15#include <linux/mempool.h>
16#include <linux/bio.h>
17#include <linux/module.h>
18#include <linux/stringify.h>
19#include <linux/gfp.h>
20#include <linux/bsg.h>
21#include <linux/smp.h>
22
23#include <asm/scatterlist.h>
24
25struct scsi_ioctl_command;
26
27struct request_queue;
28struct elevator_queue;
29struct request_pm_state;
30struct blk_trace;
31struct request;
32struct sg_io_hdr;
33
34#define BLKDEV_MIN_RQ 4
35#define BLKDEV_MAX_RQ 128
36
37struct request;
38typedef void (rq_end_io_fn)(struct request *, int);
39
40struct request_list {
41
42
43
44
45 int count[2];
46 int starved[2];
47 int elvpriv;
48 mempool_t *rq_pool;
49 wait_queue_head_t wait[2];
50};
51
52
53
54
55enum rq_cmd_type_bits {
56 REQ_TYPE_FS = 1,
57 REQ_TYPE_BLOCK_PC,
58 REQ_TYPE_SENSE,
59 REQ_TYPE_PM_SUSPEND,
60 REQ_TYPE_PM_RESUME,
61 REQ_TYPE_PM_SHUTDOWN,
62 REQ_TYPE_SPECIAL,
63
64
65
66
67
68 REQ_TYPE_ATA_TASKFILE,
69 REQ_TYPE_ATA_PC,
70};
71
72#define BLK_MAX_CDB 16
73
74
75
76
77
78
79struct request {
80 struct list_head queuelist;
81 struct call_single_data csd;
82
83 struct request_queue *q;
84
85 unsigned int cmd_flags;
86 enum rq_cmd_type_bits cmd_type;
87 unsigned long atomic_flags;
88
89 int cpu;
90
91
92 unsigned int __data_len;
93 sector_t __sector;
94
95 struct bio *bio;
96 struct bio *biotail;
97
98 struct hlist_node hash;
99
100
101
102
103
104 union {
105 struct rb_node rb_node;
106 void *completion_data;
107 };
108
109
110
111
112
113 void *elevator_private;
114 void *elevator_private2;
115 void *elevator_private3;
116
117 struct gendisk *rq_disk;
118 struct hd_struct *part;
119 unsigned long start_time;
120#ifdef CONFIG_BLK_CGROUP
121 unsigned long long start_time_ns;
122 unsigned long long io_start_time_ns;
123#endif
124
125
126
127 unsigned short nr_phys_segments;
128#if defined(CONFIG_BLK_DEV_INTEGRITY)
129 unsigned short nr_integrity_segments;
130#endif
131
132 unsigned short ioprio;
133
134 int ref_count;
135
136 void *special;
137 char *buffer;
138
139 int tag;
140 int errors;
141
142
143
144
145 unsigned char __cmd[BLK_MAX_CDB];
146 unsigned char *cmd;
147 unsigned short cmd_len;
148
149 unsigned int extra_len;
150 unsigned int sense_len;
151 unsigned int resid_len;
152 void *sense;
153
154 unsigned long deadline;
155 struct list_head timeout_list;
156 unsigned int timeout;
157 int retries;
158
159
160
161
162 rq_end_io_fn *end_io;
163 void *end_io_data;
164
165
166 struct request *next_rq;
167};
168
169static inline unsigned short req_get_ioprio(struct request *req)
170{
171 return req->ioprio;
172}
173
174
175
176
177
178struct request_pm_state
179{
180
181 int pm_step;
182
183 u32 pm_state;
184 void* data;
185};
186
187#include <linux/elevator.h>
188
189typedef void (request_fn_proc) (struct request_queue *q);
190typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
191typedef int (prep_rq_fn) (struct request_queue *, struct request *);
192typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
193typedef void (unplug_fn) (struct request_queue *);
194
195struct bio_vec;
196struct bvec_merge_data {
197 struct block_device *bi_bdev;
198 sector_t bi_sector;
199 unsigned bi_size;
200 unsigned long bi_rw;
201};
202typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
203 struct bio_vec *);
204typedef void (softirq_done_fn)(struct request *);
205typedef int (dma_drain_needed_fn)(struct request *);
206typedef int (lld_busy_fn) (struct request_queue *q);
207
208enum blk_eh_timer_return {
209 BLK_EH_NOT_HANDLED,
210 BLK_EH_HANDLED,
211 BLK_EH_RESET_TIMER,
212};
213
214typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
215
216enum blk_queue_state {
217 Queue_down,
218 Queue_up,
219};
220
221struct blk_queue_tag {
222 struct request **tag_index;
223 unsigned long *tag_map;
224 int busy;
225 int max_depth;
226 int real_max_depth;
227 atomic_t refcnt;
228};
229
230#define BLK_SCSI_MAX_CMDS (256)
231#define BLK_SCSI_CMD_PER_LONG (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
232
233struct queue_limits {
234 unsigned long bounce_pfn;
235 unsigned long seg_boundary_mask;
236
237 unsigned int max_hw_sectors;
238 unsigned int max_sectors;
239 unsigned int max_segment_size;
240 unsigned int physical_block_size;
241 unsigned int alignment_offset;
242 unsigned int io_min;
243 unsigned int io_opt;
244 unsigned int max_discard_sectors;
245 unsigned int discard_granularity;
246 unsigned int discard_alignment;
247
248 unsigned short logical_block_size;
249 unsigned short max_segments;
250 unsigned short max_integrity_segments;
251
252 unsigned char misaligned;
253 unsigned char discard_misaligned;
254 unsigned char cluster;
255 signed char discard_zeroes_data;
256};
257
258struct request_queue
259{
260
261
262
263 struct list_head queue_head;
264 struct request *last_merge;
265 struct elevator_queue *elevator;
266
267
268
269
270 struct request_list rq;
271
272 request_fn_proc *request_fn;
273 make_request_fn *make_request_fn;
274 prep_rq_fn *prep_rq_fn;
275 unprep_rq_fn *unprep_rq_fn;
276 unplug_fn *unplug_fn;
277 merge_bvec_fn *merge_bvec_fn;
278 softirq_done_fn *softirq_done_fn;
279 rq_timed_out_fn *rq_timed_out_fn;
280 dma_drain_needed_fn *dma_drain_needed;
281 lld_busy_fn *lld_busy_fn;
282
283
284
285
286 sector_t end_sector;
287 struct request *boundary_rq;
288
289
290
291
292 struct timer_list unplug_timer;
293 int unplug_thresh;
294 unsigned long unplug_delay;
295 struct work_struct unplug_work;
296
297 struct backing_dev_info backing_dev_info;
298
299
300
301
302
303 void *queuedata;
304
305
306
307
308 gfp_t bounce_gfp;
309
310
311
312
313 unsigned long queue_flags;
314
315
316
317
318
319
320 spinlock_t __queue_lock;
321 spinlock_t *queue_lock;
322
323
324
325
326 struct kobject kobj;
327
328
329
330
331 unsigned long nr_requests;
332 unsigned int nr_congestion_on;
333 unsigned int nr_congestion_off;
334 unsigned int nr_batching;
335
336 void *dma_drain_buffer;
337 unsigned int dma_drain_size;
338 unsigned int dma_pad_mask;
339 unsigned int dma_alignment;
340
341 struct blk_queue_tag *queue_tags;
342 struct list_head tag_busy_list;
343
344 unsigned int nr_sorted;
345 unsigned int in_flight[2];
346
347 unsigned int rq_timeout;
348 struct timer_list timeout;
349 struct list_head timeout_list;
350
351 struct queue_limits limits;
352
353
354
355
356 unsigned int sg_timeout;
357 unsigned int sg_reserved_size;
358 int node;
359#ifdef CONFIG_BLK_DEV_IO_TRACE
360 struct blk_trace *blk_trace;
361#endif
362
363
364
365 unsigned int flush_flags;
366 unsigned int flush_seq;
367 int flush_err;
368 struct request flush_rq;
369 struct request *orig_flush_rq;
370 struct list_head pending_flushes;
371
372 struct mutex sysfs_lock;
373
374#if defined(CONFIG_BLK_DEV_BSG)
375 struct bsg_class_device bsg_dev;
376#endif
377
378#ifdef CONFIG_BLK_DEV_THROTTLING
379
380 struct throtl_data *td;
381#endif
382};
383
384#define QUEUE_FLAG_QUEUED 1
385#define QUEUE_FLAG_STOPPED 2
386#define QUEUE_FLAG_SYNCFULL 3
387#define QUEUE_FLAG_ASYNCFULL 4
388#define QUEUE_FLAG_DEAD 5
389#define QUEUE_FLAG_REENTER 6
390#define QUEUE_FLAG_PLUGGED 7
391#define QUEUE_FLAG_ELVSWITCH 8
392#define QUEUE_FLAG_BIDI 9
393#define QUEUE_FLAG_NOMERGES 10
394#define QUEUE_FLAG_SAME_COMP 11
395#define QUEUE_FLAG_FAIL_IO 12
396#define QUEUE_FLAG_STACKABLE 13
397#define QUEUE_FLAG_NONROT 14
398#define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT
399#define QUEUE_FLAG_IO_STAT 15
400#define QUEUE_FLAG_DISCARD 16
401#define QUEUE_FLAG_NOXMERGES 17
402#define QUEUE_FLAG_ADD_RANDOM 18
403#define QUEUE_FLAG_SECDISCARD 19
404
405#define QUEUE_FLAG_DEFAULT ((1 << QUEUE_FLAG_IO_STAT) | \
406 (1 << QUEUE_FLAG_STACKABLE) | \
407 (1 << QUEUE_FLAG_SAME_COMP) | \
408 (1 << QUEUE_FLAG_ADD_RANDOM))
409
410static inline int queue_is_locked(struct request_queue *q)
411{
412#ifdef CONFIG_SMP
413 spinlock_t *lock = q->queue_lock;
414 return lock && spin_is_locked(lock);
415#else
416 return 1;
417#endif
418}
419
420static inline void queue_flag_set_unlocked(unsigned int flag,
421 struct request_queue *q)
422{
423 __set_bit(flag, &q->queue_flags);
424}
425
426static inline int queue_flag_test_and_clear(unsigned int flag,
427 struct request_queue *q)
428{
429 WARN_ON_ONCE(!queue_is_locked(q));
430
431 if (test_bit(flag, &q->queue_flags)) {
432 __clear_bit(flag, &q->queue_flags);
433 return 1;
434 }
435
436 return 0;
437}
438
439static inline int queue_flag_test_and_set(unsigned int flag,
440 struct request_queue *q)
441{
442 WARN_ON_ONCE(!queue_is_locked(q));
443
444 if (!test_bit(flag, &q->queue_flags)) {
445 __set_bit(flag, &q->queue_flags);
446 return 0;
447 }
448
449 return 1;
450}
451
452static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
453{
454 WARN_ON_ONCE(!queue_is_locked(q));
455 __set_bit(flag, &q->queue_flags);
456}
457
458static inline void queue_flag_clear_unlocked(unsigned int flag,
459 struct request_queue *q)
460{
461 __clear_bit(flag, &q->queue_flags);
462}
463
464static inline int queue_in_flight(struct request_queue *q)
465{
466 return q->in_flight[0] + q->in_flight[1];
467}
468
469static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
470{
471 WARN_ON_ONCE(!queue_is_locked(q));
472 __clear_bit(flag, &q->queue_flags);
473}
474
475#define blk_queue_plugged(q) test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
476#define blk_queue_tagged(q) test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
477#define blk_queue_stopped(q) test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
478#define blk_queue_nomerges(q) test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
479#define blk_queue_noxmerges(q) \
480 test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
481#define blk_queue_nonrot(q) test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
482#define blk_queue_io_stat(q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
483#define blk_queue_add_random(q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
484#define blk_queue_stackable(q) \
485 test_bit(QUEUE_FLAG_STACKABLE, &(q)->queue_flags)
486#define blk_queue_discard(q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)
487#define blk_queue_secdiscard(q) (blk_queue_discard(q) && \
488 test_bit(QUEUE_FLAG_SECDISCARD, &(q)->queue_flags))
489
490#define blk_noretry_request(rq) \
491 ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
492 REQ_FAILFAST_DRIVER))
493
494#define blk_account_rq(rq) \
495 (((rq)->cmd_flags & REQ_STARTED) && \
496 ((rq)->cmd_type == REQ_TYPE_FS || \
497 ((rq)->cmd_flags & REQ_DISCARD)))
498
499#define blk_pm_request(rq) \
500 ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
501 (rq)->cmd_type == REQ_TYPE_PM_RESUME)
502
503#define blk_rq_cpu_valid(rq) ((rq)->cpu != -1)
504#define blk_bidi_rq(rq) ((rq)->next_rq != NULL)
505
506#define blk_queued_rq(rq) (!list_empty(&(rq)->queuelist))
507
508#define list_entry_rq(ptr) list_entry((ptr), struct request, queuelist)
509
510#define rq_data_dir(rq) ((rq)->cmd_flags & 1)
511
512static inline unsigned int blk_queue_cluster(struct request_queue *q)
513{
514 return q->limits.cluster;
515}
516
517
518
519
520static inline bool rw_is_sync(unsigned int rw_flags)
521{
522 return !(rw_flags & REQ_WRITE) || (rw_flags & REQ_SYNC);
523}
524
525static inline bool rq_is_sync(struct request *rq)
526{
527 return rw_is_sync(rq->cmd_flags);
528}
529
530static inline int blk_queue_full(struct request_queue *q, int sync)
531{
532 if (sync)
533 return test_bit(QUEUE_FLAG_SYNCFULL, &q->queue_flags);
534 return test_bit(QUEUE_FLAG_ASYNCFULL, &q->queue_flags);
535}
536
537static inline void blk_set_queue_full(struct request_queue *q, int sync)
538{
539 if (sync)
540 queue_flag_set(QUEUE_FLAG_SYNCFULL, q);
541 else
542 queue_flag_set(QUEUE_FLAG_ASYNCFULL, q);
543}
544
545static inline void blk_clear_queue_full(struct request_queue *q, int sync)
546{
547 if (sync)
548 queue_flag_clear(QUEUE_FLAG_SYNCFULL, q);
549 else
550 queue_flag_clear(QUEUE_FLAG_ASYNCFULL, q);
551}
552
553
554
555
556
557
558#define RQ_NOMERGE_FLAGS \
559 (REQ_NOMERGE | REQ_STARTED | REQ_SOFTBARRIER | REQ_FLUSH | REQ_FUA)
560#define rq_mergeable(rq) \
561 (!((rq)->cmd_flags & RQ_NOMERGE_FLAGS) && \
562 (((rq)->cmd_flags & REQ_DISCARD) || \
563 (rq)->cmd_type == REQ_TYPE_FS))
564
565
566
567
568#define BLKPREP_OK 0
569#define BLKPREP_KILL 1
570#define BLKPREP_DEFER 2
571
572extern unsigned long blk_max_low_pfn, blk_max_pfn;
573
574
575
576
577
578
579
580
581
582#if BITS_PER_LONG == 32
583#define BLK_BOUNCE_HIGH ((u64)blk_max_low_pfn << PAGE_SHIFT)
584#else
585#define BLK_BOUNCE_HIGH -1ULL
586#endif
587#define BLK_BOUNCE_ANY (-1ULL)
588#define BLK_BOUNCE_ISA (DMA_BIT_MASK(24))
589
590
591
592
593#define BLK_DEFAULT_SG_TIMEOUT (60 * HZ)
594#define BLK_MIN_SG_TIMEOUT (7 * HZ)
595
596#ifdef CONFIG_BOUNCE
597extern int init_emergency_isa_pool(void);
598extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
599#else
600static inline int init_emergency_isa_pool(void)
601{
602 return 0;
603}
604static inline void blk_queue_bounce(struct request_queue *q, struct bio **bio)
605{
606}
607#endif
608
609struct rq_map_data {
610 struct page **pages;
611 int page_order;
612 int nr_entries;
613 unsigned long offset;
614 int null_mapped;
615 int from_user;
616};
617
618struct req_iterator {
619 int i;
620 struct bio *bio;
621};
622
623
624#define for_each_bio(_bio) \
625 for (; _bio; _bio = _bio->bi_next)
626#define __rq_for_each_bio(_bio, rq) \
627 if ((rq->bio)) \
628 for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
629
630#define rq_for_each_segment(bvl, _rq, _iter) \
631 __rq_for_each_bio(_iter.bio, _rq) \
632 bio_for_each_segment(bvl, _iter.bio, _iter.i)
633
634#define rq_iter_last(rq, _iter) \
635 (_iter.bio->bi_next == NULL && _iter.i == _iter.bio->bi_vcnt-1)
636
637#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
638# error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
639#endif
640#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
641extern void rq_flush_dcache_pages(struct request *rq);
642#else
643static inline void rq_flush_dcache_pages(struct request *rq)
644{
645}
646#endif
647
648extern int blk_register_queue(struct gendisk *disk);
649extern void blk_unregister_queue(struct gendisk *disk);
650extern void generic_make_request(struct bio *bio);
651extern void blk_rq_init(struct request_queue *q, struct request *rq);
652extern void blk_put_request(struct request *);
653extern void __blk_put_request(struct request_queue *, struct request *);
654extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
655extern struct request *blk_make_request(struct request_queue *, struct bio *,
656 gfp_t);
657extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
658extern void blk_requeue_request(struct request_queue *, struct request *);
659extern void blk_add_request_payload(struct request *rq, struct page *page,
660 unsigned int len);
661extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
662extern int blk_lld_busy(struct request_queue *q);
663extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
664 struct bio_set *bs, gfp_t gfp_mask,
665 int (*bio_ctr)(struct bio *, struct bio *, void *),
666 void *data);
667extern void blk_rq_unprep_clone(struct request *rq);
668extern int blk_insert_cloned_request(struct request_queue *q,
669 struct request *rq);
670extern void blk_plug_device(struct request_queue *);
671extern void blk_plug_device_unlocked(struct request_queue *);
672extern int blk_remove_plug(struct request_queue *);
673extern void blk_recount_segments(struct request_queue *, struct bio *);
674extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
675 unsigned int, void __user *);
676extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
677 struct scsi_ioctl_command __user *);
678
679
680
681
682
683
684static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
685{
686 clear_bdi_congested(&q->backing_dev_info, sync);
687}
688
689
690
691
692
693static inline void blk_set_queue_congested(struct request_queue *q, int sync)
694{
695 set_bdi_congested(&q->backing_dev_info, sync);
696}
697
698extern void blk_start_queue(struct request_queue *q);
699extern void blk_stop_queue(struct request_queue *q);
700extern void blk_sync_queue(struct request_queue *q);
701extern void __blk_stop_queue(struct request_queue *q);
702extern void __blk_run_queue(struct request_queue *q, bool force_kblockd);
703extern void blk_run_queue(struct request_queue *);
704extern int blk_rq_map_user(struct request_queue *, struct request *,
705 struct rq_map_data *, void __user *, unsigned long,
706 gfp_t);
707extern int blk_rq_unmap_user(struct bio *);
708extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
709extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
710 struct rq_map_data *, struct sg_iovec *, int,
711 unsigned int, gfp_t);
712extern int blk_execute_rq(struct request_queue *, struct gendisk *,
713 struct request *, int);
714extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
715 struct request *, int, rq_end_io_fn *);
716extern void blk_unplug(struct request_queue *q);
717
718static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
719{
720 return bdev->bd_disk->queue;
721}
722
723
724
725
726
727
728
729
730
731static inline sector_t blk_rq_pos(const struct request *rq)
732{
733 return rq->__sector;
734}
735
736static inline unsigned int blk_rq_bytes(const struct request *rq)
737{
738 return rq->__data_len;
739}
740
741static inline int blk_rq_cur_bytes(const struct request *rq)
742{
743 return rq->bio ? bio_cur_bytes(rq->bio) : 0;
744}
745
746extern unsigned int blk_rq_err_bytes(const struct request *rq);
747
748static inline unsigned int blk_rq_sectors(const struct request *rq)
749{
750 return blk_rq_bytes(rq) >> 9;
751}
752
753static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
754{
755 return blk_rq_cur_bytes(rq) >> 9;
756}
757
758
759
760
761extern struct request *blk_peek_request(struct request_queue *q);
762extern void blk_start_request(struct request *rq);
763extern struct request *blk_fetch_request(struct request_queue *q);
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778extern bool blk_update_request(struct request *rq, int error,
779 unsigned int nr_bytes);
780extern bool blk_end_request(struct request *rq, int error,
781 unsigned int nr_bytes);
782extern void blk_end_request_all(struct request *rq, int error);
783extern bool blk_end_request_cur(struct request *rq, int error);
784extern bool blk_end_request_err(struct request *rq, int error);
785extern bool __blk_end_request(struct request *rq, int error,
786 unsigned int nr_bytes);
787extern void __blk_end_request_all(struct request *rq, int error);
788extern bool __blk_end_request_cur(struct request *rq, int error);
789extern bool __blk_end_request_err(struct request *rq, int error);
790
791extern void blk_complete_request(struct request *);
792extern void __blk_complete_request(struct request *);
793extern void blk_abort_request(struct request *);
794extern void blk_abort_queue(struct request_queue *);
795extern void blk_unprep_request(struct request *);
796
797
798
799
800extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
801 spinlock_t *lock, int node_id);
802extern struct request_queue *blk_init_allocated_queue_node(struct request_queue *,
803 request_fn_proc *,
804 spinlock_t *, int node_id);
805extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
806extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
807 request_fn_proc *, spinlock_t *);
808extern void blk_cleanup_queue(struct request_queue *);
809extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
810extern void blk_queue_bounce_limit(struct request_queue *, u64);
811extern void blk_limits_max_hw_sectors(struct queue_limits *, unsigned int);
812extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
813extern void blk_queue_max_segments(struct request_queue *, unsigned short);
814extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
815extern void blk_queue_max_discard_sectors(struct request_queue *q,
816 unsigned int max_discard_sectors);
817extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
818extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
819extern void blk_queue_alignment_offset(struct request_queue *q,
820 unsigned int alignment);
821extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
822extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
823extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
824extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
825extern void blk_set_default_limits(struct queue_limits *lim);
826extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
827 sector_t offset);
828extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
829 sector_t offset);
830extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
831 sector_t offset);
832extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
833extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
834extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
835extern int blk_queue_dma_drain(struct request_queue *q,
836 dma_drain_needed_fn *dma_drain_needed,
837 void *buf, unsigned int size);
838extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
839extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
840extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
841extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
842extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
843extern void blk_queue_dma_alignment(struct request_queue *, int);
844extern void blk_queue_update_dma_alignment(struct request_queue *, int);
845extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
846extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
847extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
848extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
849extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
850
851extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
852extern void blk_dump_rq_flags(struct request *, char *);
853extern void generic_unplug_device(struct request_queue *);
854extern long nr_blockdev_pages(void);
855
856int blk_get_queue(struct request_queue *);
857struct request_queue *blk_alloc_queue(gfp_t);
858struct request_queue *blk_alloc_queue_node(gfp_t, int);
859extern void blk_put_queue(struct request_queue *);
860
861
862
863
864#define blk_rq_tagged(rq) ((rq)->cmd_flags & REQ_QUEUED)
865extern int blk_queue_start_tag(struct request_queue *, struct request *);
866extern struct request *blk_queue_find_tag(struct request_queue *, int);
867extern void blk_queue_end_tag(struct request_queue *, struct request *);
868extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
869extern void blk_queue_free_tags(struct request_queue *);
870extern int blk_queue_resize_tags(struct request_queue *, int);
871extern void blk_queue_invalidate_tags(struct request_queue *);
872extern struct blk_queue_tag *blk_init_tags(int);
873extern void blk_free_tags(struct blk_queue_tag *);
874
875static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
876 int tag)
877{
878 if (unlikely(bqt == NULL || tag >= bqt->real_max_depth))
879 return NULL;
880 return bqt->tag_index[tag];
881}
882
883#define BLKDEV_DISCARD_SECURE 0x01
884
885extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
886extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
887 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
888extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
889 sector_t nr_sects, gfp_t gfp_mask);
890static inline int sb_issue_discard(struct super_block *sb, sector_t block,
891 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
892{
893 return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
894 nr_blocks << (sb->s_blocksize_bits - 9),
895 gfp_mask, flags);
896}
897static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
898 sector_t nr_blocks, gfp_t gfp_mask)
899{
900 return blkdev_issue_zeroout(sb->s_bdev,
901 block << (sb->s_blocksize_bits - 9),
902 nr_blocks << (sb->s_blocksize_bits - 9),
903 gfp_mask);
904}
905
906extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
907
908enum blk_default_limits {
909 BLK_MAX_SEGMENTS = 128,
910 BLK_SAFE_MAX_SECTORS = 255,
911 BLK_DEF_MAX_SECTORS = 1024,
912 BLK_MAX_SEGMENT_SIZE = 65536,
913 BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL,
914};
915
916#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
917
918static inline unsigned long queue_bounce_pfn(struct request_queue *q)
919{
920 return q->limits.bounce_pfn;
921}
922
923static inline unsigned long queue_segment_boundary(struct request_queue *q)
924{
925 return q->limits.seg_boundary_mask;
926}
927
928static inline unsigned int queue_max_sectors(struct request_queue *q)
929{
930 return q->limits.max_sectors;
931}
932
933static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
934{
935 return q->limits.max_hw_sectors;
936}
937
938static inline unsigned short queue_max_segments(struct request_queue *q)
939{
940 return q->limits.max_segments;
941}
942
943static inline unsigned int queue_max_segment_size(struct request_queue *q)
944{
945 return q->limits.max_segment_size;
946}
947
948static inline unsigned short queue_logical_block_size(struct request_queue *q)
949{
950 int retval = 512;
951
952 if (q && q->limits.logical_block_size)
953 retval = q->limits.logical_block_size;
954
955 return retval;
956}
957
958static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
959{
960 return queue_logical_block_size(bdev_get_queue(bdev));
961}
962
963static inline unsigned int queue_physical_block_size(struct request_queue *q)
964{
965 return q->limits.physical_block_size;
966}
967
968static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
969{
970 return queue_physical_block_size(bdev_get_queue(bdev));
971}
972
973static inline unsigned int queue_io_min(struct request_queue *q)
974{
975 return q->limits.io_min;
976}
977
978static inline int bdev_io_min(struct block_device *bdev)
979{
980 return queue_io_min(bdev_get_queue(bdev));
981}
982
983static inline unsigned int queue_io_opt(struct request_queue *q)
984{
985 return q->limits.io_opt;
986}
987
988static inline int bdev_io_opt(struct block_device *bdev)
989{
990 return queue_io_opt(bdev_get_queue(bdev));
991}
992
993static inline int queue_alignment_offset(struct request_queue *q)
994{
995 if (q->limits.misaligned)
996 return -1;
997
998 return q->limits.alignment_offset;
999}
1000
1001static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
1002{
1003 unsigned int granularity = max(lim->physical_block_size, lim->io_min);
1004 unsigned int alignment = (sector << 9) & (granularity - 1);
1005
1006 return (granularity + lim->alignment_offset - alignment)
1007 & (granularity - 1);
1008}
1009
1010static inline int bdev_alignment_offset(struct block_device *bdev)
1011{
1012 struct request_queue *q = bdev_get_queue(bdev);
1013
1014 if (q->limits.misaligned)
1015 return -1;
1016
1017 if (bdev != bdev->bd_contains)
1018 return bdev->bd_part->alignment_offset;
1019
1020 return q->limits.alignment_offset;
1021}
1022
1023static inline int queue_discard_alignment(struct request_queue *q)
1024{
1025 if (q->limits.discard_misaligned)
1026 return -1;
1027
1028 return q->limits.discard_alignment;
1029}
1030
1031static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
1032{
1033 unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1);
1034
1035 return (lim->discard_granularity + lim->discard_alignment - alignment)
1036 & (lim->discard_granularity - 1);
1037}
1038
1039static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
1040{
1041 if (q->limits.discard_zeroes_data == 1)
1042 return 1;
1043
1044 return 0;
1045}
1046
1047static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
1048{
1049 return queue_discard_zeroes_data(bdev_get_queue(bdev));
1050}
1051
1052static inline int queue_dma_alignment(struct request_queue *q)
1053{
1054 return q ? q->dma_alignment : 511;
1055}
1056
1057static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
1058 unsigned int len)
1059{
1060 unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
1061 return !(addr & alignment) && !(len & alignment);
1062}
1063
1064
1065static inline unsigned int blksize_bits(unsigned int size)
1066{
1067 unsigned int bits = 8;
1068 do {
1069 bits++;
1070 size >>= 1;
1071 } while (size > 256);
1072 return bits;
1073}
1074
1075static inline unsigned int block_size(struct block_device *bdev)
1076{
1077 return bdev->bd_block_size;
1078}
1079
1080typedef struct {struct page *v;} Sector;
1081
1082unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
1083
1084static inline void put_dev_sector(Sector p)
1085{
1086 page_cache_release(p.v);
1087}
1088
1089struct work_struct;
1090int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
1091
1092#ifdef CONFIG_BLK_CGROUP
1093
1094
1095
1096
1097
1098static inline void set_start_time_ns(struct request *req)
1099{
1100 preempt_disable();
1101 req->start_time_ns = sched_clock();
1102 preempt_enable();
1103}
1104
1105static inline void set_io_start_time_ns(struct request *req)
1106{
1107 preempt_disable();
1108 req->io_start_time_ns = sched_clock();
1109 preempt_enable();
1110}
1111
1112static inline uint64_t rq_start_time_ns(struct request *req)
1113{
1114 return req->start_time_ns;
1115}
1116
1117static inline uint64_t rq_io_start_time_ns(struct request *req)
1118{
1119 return req->io_start_time_ns;
1120}
1121#else
1122static inline void set_start_time_ns(struct request *req) {}
1123static inline void set_io_start_time_ns(struct request *req) {}
1124static inline uint64_t rq_start_time_ns(struct request *req)
1125{
1126 return 0;
1127}
1128static inline uint64_t rq_io_start_time_ns(struct request *req)
1129{
1130 return 0;
1131}
1132#endif
1133
1134#ifdef CONFIG_BLK_DEV_THROTTLING
1135extern int blk_throtl_init(struct request_queue *q);
1136extern void blk_throtl_exit(struct request_queue *q);
1137extern int blk_throtl_bio(struct request_queue *q, struct bio **bio);
1138extern void throtl_shutdown_timer_wq(struct request_queue *q);
1139#else
1140static inline int blk_throtl_bio(struct request_queue *q, struct bio **bio)
1141{
1142 return 0;
1143}
1144
1145static inline int blk_throtl_init(struct request_queue *q) { return 0; }
1146static inline int blk_throtl_exit(struct request_queue *q) { return 0; }
1147static inline void throtl_shutdown_timer_wq(struct request_queue *q) {}
1148#endif
1149
1150#define MODULE_ALIAS_BLOCKDEV(major,minor) \
1151 MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
1152#define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
1153 MODULE_ALIAS("block-major-" __stringify(major) "-*")
1154
1155#if defined(CONFIG_BLK_DEV_INTEGRITY)
1156
1157#define INTEGRITY_FLAG_READ 2
1158#define INTEGRITY_FLAG_WRITE 4
1159
1160struct blk_integrity_exchg {
1161 void *prot_buf;
1162 void *data_buf;
1163 sector_t sector;
1164 unsigned int data_size;
1165 unsigned short sector_size;
1166 const char *disk_name;
1167};
1168
1169typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
1170typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
1171typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
1172typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
1173
1174struct blk_integrity {
1175 integrity_gen_fn *generate_fn;
1176 integrity_vrfy_fn *verify_fn;
1177 integrity_set_tag_fn *set_tag_fn;
1178 integrity_get_tag_fn *get_tag_fn;
1179
1180 unsigned short flags;
1181 unsigned short tuple_size;
1182 unsigned short sector_size;
1183 unsigned short tag_size;
1184
1185 const char *name;
1186
1187 struct kobject kobj;
1188};
1189
1190extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
1191extern void blk_integrity_unregister(struct gendisk *);
1192extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
1193extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
1194 struct scatterlist *);
1195extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
1196extern int blk_integrity_merge_rq(struct request_queue *, struct request *,
1197 struct request *);
1198extern int blk_integrity_merge_bio(struct request_queue *, struct request *,
1199 struct bio *);
1200
1201static inline
1202struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
1203{
1204 return bdev->bd_disk->integrity;
1205}
1206
1207static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
1208{
1209 return disk->integrity;
1210}
1211
1212static inline int blk_integrity_rq(struct request *rq)
1213{
1214 if (rq->bio == NULL)
1215 return 0;
1216
1217 return bio_integrity(rq->bio);
1218}
1219
1220static inline void blk_queue_max_integrity_segments(struct request_queue *q,
1221 unsigned int segs)
1222{
1223 q->limits.max_integrity_segments = segs;
1224}
1225
1226static inline unsigned short
1227queue_max_integrity_segments(struct request_queue *q)
1228{
1229 return q->limits.max_integrity_segments;
1230}
1231
1232#else
1233
1234#define blk_integrity_rq(rq) (0)
1235#define blk_rq_count_integrity_sg(a, b) (0)
1236#define blk_rq_map_integrity_sg(a, b, c) (0)
1237#define bdev_get_integrity(a) (0)
1238#define blk_get_integrity(a) (0)
1239#define blk_integrity_compare(a, b) (0)
1240#define blk_integrity_register(a, b) (0)
1241#define blk_integrity_unregister(a) do { } while (0);
1242#define blk_queue_max_integrity_segments(a, b) do { } while (0);
1243#define queue_max_integrity_segments(a) (0)
1244#define blk_integrity_merge_rq(a, b, c) (0)
1245#define blk_integrity_merge_bio(a, b, c) (0)
1246
1247#endif
1248
1249struct block_device_operations {
1250 int (*open) (struct block_device *, fmode_t);
1251 int (*release) (struct gendisk *, fmode_t);
1252 int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1253 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
1254 int (*direct_access) (struct block_device *, sector_t,
1255 void **, unsigned long *);
1256 unsigned int (*check_events) (struct gendisk *disk,
1257 unsigned int clearing);
1258
1259 int (*media_changed) (struct gendisk *);
1260 void (*unlock_native_capacity) (struct gendisk *);
1261 int (*revalidate_disk) (struct gendisk *);
1262 int (*getgeo)(struct block_device *, struct hd_geometry *);
1263
1264 void (*swap_slot_free_notify) (struct block_device *, unsigned long);
1265 struct module *owner;
1266};
1267
1268extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
1269 unsigned long);
1270#else
1271
1272
1273
1274#define buffer_heads_over_limit 0
1275
1276static inline long nr_blockdev_pages(void)
1277{
1278 return 0;
1279}
1280
1281#endif
1282
1283#endif
1284