File: /usr/src/linux/include/linux/blkdev.h
1 #ifndef _LINUX_BLKDEV_H
2 #define _LINUX_BLKDEV_H
3
4 #include <linux/major.h>
5 #include <linux/sched.h>
6 #include <linux/genhd.h>
7 #include <linux/tqueue.h>
8 #include <linux/list.h>
9
10 struct request_queue;
11 typedef struct request_queue request_queue_t;
12 struct elevator_s;
13 typedef struct elevator_s elevator_t;
14
15 /*
16 * Ok, this is an expanded form so that we can use the same
17 * request for paging requests.
18 */
19 struct request {
20 struct list_head queue;
21 int elevator_sequence;
22 struct list_head table;
23
24 volatile int rq_status; /* should split this into a few status bits */
25 #define RQ_INACTIVE (-1)
26 #define RQ_ACTIVE 1
27 #define RQ_SCSI_BUSY 0xffff
28 #define RQ_SCSI_DONE 0xfffe
29 #define RQ_SCSI_DISCONNECTING 0xffe0
30
31 kdev_t rq_dev;
32 int cmd; /* READ or WRITE */
33 int errors;
34 unsigned long sector;
35 unsigned long nr_sectors;
36 unsigned long hard_sector, hard_nr_sectors;
37 unsigned int nr_segments;
38 unsigned int nr_hw_segments;
39 unsigned long current_nr_sectors;
40 void * special;
41 char * buffer;
42 struct completion * waiting;
43 struct buffer_head * bh;
44 struct buffer_head * bhtail;
45 request_queue_t *q;
46 };
47
48 #include <linux/elevator.h>
49
50 typedef int (merge_request_fn) (request_queue_t *q,
51 struct request *req,
52 struct buffer_head *bh,
53 int);
54 typedef int (merge_requests_fn) (request_queue_t *q,
55 struct request *req,
56 struct request *req2,
57 int);
58 typedef void (request_fn_proc) (request_queue_t *q);
59 typedef request_queue_t * (queue_proc) (kdev_t dev);
60 typedef int (make_request_fn) (request_queue_t *q, int rw, struct buffer_head *bh);
61 typedef void (plug_device_fn) (request_queue_t *q, kdev_t device);
62 typedef void (unplug_device_fn) (void *q);
63
64 /*
65 * Default nr free requests per queue, ll_rw_blk will scale it down
66 * according to available RAM at init time
67 */
68 #define QUEUE_NR_REQUESTS 8192
69
70 struct request_queue
71 {
72 /*
73 * the queue request freelist, one for reads and one for writes
74 */
75 struct list_head request_freelist[2];
76 struct list_head pending_freelist[2];
77 int pending_free[2];
78
79 /*
80 * Together with queue_head for cacheline sharing
81 */
82 struct list_head queue_head;
83 elevator_t elevator;
84
85 request_fn_proc * request_fn;
86 merge_request_fn * back_merge_fn;
87 merge_request_fn * front_merge_fn;
88 merge_requests_fn * merge_requests_fn;
89 make_request_fn * make_request_fn;
90 plug_device_fn * plug_device_fn;
91 /*
92 * The queue owner gets to use this for whatever they like.
93 * ll_rw_blk doesn't touch it.
94 */
95 void * queuedata;
96
97 /*
98 * This is used to remove the plug when tq_disk runs.
99 */
100 struct tq_struct plug_tq;
101
102 /*
103 * Boolean that indicates whether this queue is plugged or not.
104 */
105 char plugged;
106
107 /*
108 * Boolean that indicates whether current_request is active or
109 * not.
110 */
111 char head_active;
112
113 /*
114 * Is meant to protect the queue in the future instead of
115 * io_request_lock
116 */
117 spinlock_t queue_lock;
118
119 /*
120 * Tasks wait here for free request
121 */
122 wait_queue_head_t wait_for_request;
123 };
124
125 struct blk_dev_struct {
126 /*
127 * queue_proc has to be atomic
128 */
129 request_queue_t request_queue;
130 queue_proc *queue;
131 void *data;
132 };
133
134 struct sec_size {
135 unsigned block_size;
136 unsigned block_size_bits;
137 };
138
139 /*
140 * Used to indicate the default queue for drivers that don't bother
141 * to implement multiple queues. We have this access macro here
142 * so as to eliminate the need for each and every block device
143 * driver to know about the internal structure of blk_dev[].
144 */
145 #define BLK_DEFAULT_QUEUE(_MAJOR) &blk_dev[_MAJOR].request_queue
146
147 extern struct sec_size * blk_sec[MAX_BLKDEV];
148 extern struct blk_dev_struct blk_dev[MAX_BLKDEV];
149 extern void grok_partitions(struct gendisk *dev, int drive, unsigned minors, long size);
150 extern void register_disk(struct gendisk *dev, kdev_t first, unsigned minors, struct block_device_operations *ops, long size);
151 extern void generic_make_request(int rw, struct buffer_head * bh);
152 extern inline request_queue_t *blk_get_queue(kdev_t dev);
153 extern void blkdev_release_request(struct request *);
154
155 /*
156 * Access functions for manipulating queue properties
157 */
158 extern void blk_init_queue(request_queue_t *, request_fn_proc *);
159 extern void blk_cleanup_queue(request_queue_t *);
160 extern void blk_queue_headactive(request_queue_t *, int);
161 extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
162 extern void generic_unplug_device(void *);
163
164 extern int * blk_size[MAX_BLKDEV];
165
166 extern int * blksize_size[MAX_BLKDEV];
167
168 extern int * hardsect_size[MAX_BLKDEV];
169
170 extern int * max_readahead[MAX_BLKDEV];
171
172 extern int * max_sectors[MAX_BLKDEV];
173
174 extern int * max_segments[MAX_BLKDEV];
175
176 #define MAX_SEGMENTS 128
177 #define MAX_SECTORS 255
178
179 #define PageAlignSize(size) (((size) + PAGE_SIZE -1) & PAGE_MASK)
180
181 /* read-ahead in pages.. */
182 #define MAX_READAHEAD 31
183 #define MIN_READAHEAD 3
184
185 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queue)
186 #define blkdev_entry_next_request(entry) blkdev_entry_to_request((entry)->next)
187 #define blkdev_entry_prev_request(entry) blkdev_entry_to_request((entry)->prev)
188 #define blkdev_next_request(req) blkdev_entry_to_request((req)->queue.next)
189 #define blkdev_prev_request(req) blkdev_entry_to_request((req)->queue.prev)
190
191 extern void drive_stat_acct (kdev_t dev, int rw,
192 unsigned long nr_sectors, int new_io);
193
194 static inline int get_hardsect_size(kdev_t dev)
195 {
196 extern int *hardsect_size[];
197 if (hardsect_size[MAJOR(dev)] != NULL)
198 return hardsect_size[MAJOR(dev)][MINOR(dev)];
199 else
200 return 512;
201 }
202
203 #define blk_finished_io(nsects) do { } while (0)
204 #define blk_started_io(nsects) do { } while (0)
205
206 static inline int buffered_blk_size(kdev_t dev)
207 {
208 int ret = INT_MAX;
209 int major = MAJOR(dev);
210
211 if (blk_size[major])
212 ret = blk_size[major][MINOR(dev)] + ((BUFFERED_BLOCKSIZE-1) >> BLOCK_SIZE_BITS);
213
214 return ret;
215 }
216
217 #endif
218