e5c5797699636332640f7412d82b9f2cb5e07c83
[linux-2.6.git] / block / blk.h
1 #ifndef BLK_INTERNAL_H
2 #define BLK_INTERNAL_H
3
4 /* Amount of time in which a process may batch requests */
5 #define BLK_BATCH_TIME  (HZ/50UL)
6
7 /* Number of requests a "batching" process may submit */
8 #define BLK_BATCH_REQ   32
9
10 extern struct kmem_cache *blk_requestq_cachep;
11 extern struct kobj_type blk_queue_ktype;
12
13 void init_request_from_bio(struct request *req, struct bio *bio);
14 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
15                         struct bio *bio);
16 void __blk_queue_free_tags(struct request_queue *q);
17
18 void blk_unplug_work(struct work_struct *work);
19 void blk_unplug_timeout(unsigned long data);
20 void blk_rq_timed_out_timer(unsigned long data);
21 void blk_delete_timer(struct request *);
22 void blk_add_timer(struct request *);
23
24 /*
25  * Internal atomic flags for request handling
26  */
27 enum rq_atomic_flags {
28         REQ_ATOM_COMPLETE = 0,
29 };
30
31 /*
32  * EH timer and IO completion will both attempt to 'grab' the request, make
33  * sure that only one of them suceeds
34  */
35 static inline int blk_mark_rq_complete(struct request *rq)
36 {
37         return test_and_set_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags);
38 }
39
40 static inline void blk_clear_rq_complete(struct request *rq)
41 {
42         clear_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags);
43 }
44
45 #ifdef CONFIG_FAIL_IO_TIMEOUT
46 int blk_should_fake_timeout(struct request_queue *);
47 ssize_t part_timeout_show(struct device *, struct device_attribute *, char *);
48 ssize_t part_timeout_store(struct device *, struct device_attribute *,
49                                 const char *, size_t);
50 #else
51 static inline int blk_should_fake_timeout(struct request_queue *q)
52 {
53         return 0;
54 }
55 #endif
56
57 struct io_context *current_io_context(gfp_t gfp_flags, int node);
58
59 int ll_back_merge_fn(struct request_queue *q, struct request *req,
60                      struct bio *bio);
61 int ll_front_merge_fn(struct request_queue *q, struct request *req, 
62                       struct bio *bio);
63 int attempt_back_merge(struct request_queue *q, struct request *rq);
64 int attempt_front_merge(struct request_queue *q, struct request *rq);
65 void blk_recalc_rq_segments(struct request *rq);
66 void blk_recalc_rq_sectors(struct request *rq, int nsect);
67
68 void blk_queue_congestion_threshold(struct request_queue *q);
69
70 int blk_dev_init(void);
71
72 /*
73  * Return the threshold (number of used requests) at which the queue is
74  * considered to be congested.  It include a little hysteresis to keep the
75  * context switch rate down.
76  */
77 static inline int queue_congestion_on_threshold(struct request_queue *q)
78 {
79         return q->nr_congestion_on;
80 }
81
82 /*
83  * The threshold at which a queue is considered to be uncongested
84  */
85 static inline int queue_congestion_off_threshold(struct request_queue *q)
86 {
87         return q->nr_congestion_off;
88 }
89
90 #if defined(CONFIG_BLK_DEV_INTEGRITY)
91
92 #define rq_for_each_integrity_segment(bvl, _rq, _iter)          \
93         __rq_for_each_bio(_iter.bio, _rq)                       \
94                 bip_for_each_vec(bvl, _iter.bio->bi_integrity, _iter.i)
95
96 #endif /* BLK_DEV_INTEGRITY */
97
98 static inline int blk_cpu_to_group(int cpu)
99 {
100 #ifdef CONFIG_SCHED_MC
101         cpumask_t mask = cpu_coregroup_map(cpu);
102         return first_cpu(mask);
103 #elif defined(CONFIG_SCHED_SMT)
104         return first_cpu(per_cpu(cpu_sibling_map, cpu));
105 #else
106         return cpu;
107 #endif
108 }
109
110 #endif