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