This source file includes following definitions.
- end_request
1 #ifndef _BLK_H
2 #define _BLK_H
3
4 #include <linux/sched.h>
5 #include <linux/locks.h>
6 #include <linux/genhd.h>
7
8
9
10
11
12
13
14
15
16
17
18 #define NR_REQUEST 32
19
20
21
22
23
24
25
26 struct request {
27 int dev;
28 int cmd;
29 int errors;
30 unsigned long sector;
31 unsigned long nr_sectors;
32 unsigned long current_nr_sectors;
33 char * buffer;
34 struct task_struct * waiting;
35 struct buffer_head * bh;
36 struct buffer_head * bhtail;
37 struct request * next;
38 };
39
40
41
42
43
44
45 #define IN_ORDER(s1,s2) \
46 ((s1)->cmd < (s2)->cmd || ((s1)->cmd == (s2)->cmd && \
47 ((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \
48 (s1)->sector < (s2)->sector)))))
49
50 struct blk_dev_struct {
51 void (*request_fn)(void);
52 struct request * current_request;
53 };
54
55
56 struct sec_size {
57 unsigned block_size;
58 unsigned block_size_bits;
59 };
60
61
62
63
64
65 #define SECTOR_MASK (blksize_size[MAJOR_NR] && \
66 blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] ? \
67 ((blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] >> 9) - 1) : \
68 ((BLOCK_SIZE >> 9) - 1))
69
70 #define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)
71
72 extern struct sec_size * blk_sec[MAX_BLKDEV];
73 extern struct blk_dev_struct blk_dev[MAX_BLKDEV];
74 extern struct request request[NR_REQUEST];
75 extern struct wait_queue * wait_for_request;
76 extern void resetup_one_dev(struct gendisk *dev, int drive);
77
78 extern int * blk_size[MAX_BLKDEV];
79
80 extern int * blksize_size[MAX_BLKDEV];
81
82 extern unsigned long hd_init(unsigned long mem_start, unsigned long mem_end);
83 extern unsigned long cdu31a_init(unsigned long mem_start, unsigned long mem_end);
84 extern unsigned long mcd_init(unsigned long mem_start, unsigned long mem_end);
85 extern int is_read_only(int dev);
86 extern void set_device_ro(int dev,int flag);
87
88 extern void rd_load(void);
89 extern long rd_init(long mem_start, int length);
90 extern int ramdisk_size;
91
92 extern unsigned long xd_init(unsigned long mem_start, unsigned long mem_end);
93
94 #define RO_IOCTLS(dev,where) \
95 case BLKROSET: if (!suser()) return -EPERM; \
96 set_device_ro((dev),get_fs_long((long *) (where))); return 0; \
97 case BLKROGET: { int __err = verify_area(VERIFY_WRITE, (void *) (where), sizeof(long)); \
98 if (!__err) put_fs_long(is_read_only(dev),(long *) (where)); return __err; }
99
100 #ifdef MAJOR_NR
101
102
103
104
105
106
107 #if (MAJOR_NR == 1)
108
109 #define DEVICE_NAME "ramdisk"
110 #define DEVICE_REQUEST do_rd_request
111 #define DEVICE_NR(device) ((device) & 7)
112 #define DEVICE_ON(device)
113 #define DEVICE_OFF(device)
114
115 #elif (MAJOR_NR == 2)
116
117 static void floppy_on(unsigned int nr);
118 static void floppy_off(unsigned int nr);
119
120 #define DEVICE_NAME "floppy"
121 #define DEVICE_INTR do_floppy
122 #define DEVICE_REQUEST do_fd_request
123 #define DEVICE_NR(device) ((device) & 3)
124 #define DEVICE_ON(device) floppy_on(DEVICE_NR(device))
125 #define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
126
127 #elif (MAJOR_NR == 3)
128
129 #define DEVICE_NAME "harddisk"
130 #define DEVICE_INTR do_hd
131 #define DEVICE_TIMEOUT HD_TIMER
132 #define TIMEOUT_VALUE 600
133 #define DEVICE_REQUEST do_hd_request
134 #define DEVICE_NR(device) (MINOR(device)>>6)
135 #define DEVICE_ON(device)
136 #define DEVICE_OFF(device)
137
138 #elif (MAJOR_NR == 8)
139
140 #define DEVICE_NAME "scsidisk"
141 #define DEVICE_INTR do_sd
142 #define TIMEOUT_VALUE 200
143 #define DEVICE_REQUEST do_sd_request
144 #define DEVICE_NR(device) (MINOR(device) >> 4)
145 #define DEVICE_ON(device)
146 #define DEVICE_OFF(device)
147
148 #elif (MAJOR_NR == 9)
149
150 #define DEVICE_NAME "scsitape"
151 #define DEVICE_INTR do_st
152 #define DEVICE_REQUEST do_st_request
153 #define DEVICE_NR(device) (MINOR(device))
154 #define DEVICE_ON(device)
155 #define DEVICE_OFF(device)
156
157 #elif (MAJOR_NR == 11)
158
159 #define DEVICE_NAME "CD-ROM"
160 #define DEVICE_INTR do_sr
161 #define DEVICE_REQUEST do_sr_request
162 #define DEVICE_NR(device) (MINOR(device))
163 #define DEVICE_ON(device)
164 #define DEVICE_OFF(device)
165
166 #elif (MAJOR_NR == 13)
167
168 #define DEVICE_NAME "xt disk"
169 #define DEVICE_REQUEST do_xd_request
170 #define DEVICE_NR(device) (MINOR(device) >> 6)
171 #define DEVICE_ON(device)
172 #define DEVICE_OFF(device)
173
174 #elif (MAJOR_NR == 15)
175
176 #define DEVICE_NAME "CDU31A"
177 #define DEVICE_REQUEST do_cdu31a_request
178 #define DEVICE_NR(device) (MINOR(device))
179 #define DEVICE_ON(device)
180 #define DEVICE_OFF(device)
181
182 #elif (MAJOR_NR == 23)
183
184 #define DEVICE_NAME "Mitsumi CD-ROM"
185
186 #define DEVICE_REQUEST do_mcd_request
187 #define DEVICE_NR(device) (MINOR(device))
188 #define DEVICE_ON(device)
189 #define DEVICE_OFF(device)
190
191 #else
192
193 #error "unknown blk device"
194
195 #endif
196
197 #if (MAJOR_NR != 9)
198
199 #ifndef CURRENT
200 #define CURRENT (blk_dev[MAJOR_NR].current_request)
201 #endif
202
203 #define CURRENT_DEV DEVICE_NR(CURRENT->dev)
204
205 #ifdef DEVICE_INTR
206 void (*DEVICE_INTR)(void) = NULL;
207 #endif
208 #ifdef DEVICE_TIMEOUT
209
210 #define SET_TIMER \
211 ((timer_table[DEVICE_TIMEOUT].expires = jiffies + TIMEOUT_VALUE), \
212 (timer_active |= 1<<DEVICE_TIMEOUT))
213
214 #define CLEAR_TIMER \
215 timer_active &= ~(1<<DEVICE_TIMEOUT)
216
217 #define SET_INTR(x) \
218 if ((DEVICE_INTR = (x)) != NULL) \
219 SET_TIMER; \
220 else \
221 CLEAR_TIMER;
222
223 #else
224
225 #define SET_INTR(x) (DEVICE_INTR = (x))
226
227 #endif
228 static void (DEVICE_REQUEST)(void);
229
230
231 #if (MAJOR_NR != 8 && MAJOR_NR != 9 && MAJOR_NR != 11)
232 static void end_request(int uptodate)
233 {
234 struct request * req;
235 struct buffer_head * bh;
236 struct task_struct * p;
237
238 req = CURRENT;
239 req->errors = 0;
240 if (!uptodate) {
241 printk(DEVICE_NAME " I/O error\n");
242 printk("dev %04x, sector %d\n",req->dev,req->sector);
243 req->nr_sectors--;
244 req->nr_sectors &= ~SECTOR_MASK;
245 req->sector += (BLOCK_SIZE / 512);
246 req->sector &= ~SECTOR_MASK;
247 }
248
249 if ((bh = req->bh) != NULL) {
250 req->bh = bh->b_reqnext;
251 bh->b_reqnext = NULL;
252 bh->b_uptodate = uptodate;
253 unlock_buffer(bh);
254 if ((bh = req->bh) != NULL) {
255 req->current_nr_sectors = bh->b_size >> 9;
256 if (req->nr_sectors < req->current_nr_sectors) {
257 req->nr_sectors = req->current_nr_sectors;
258 printk("end_request: buffer-list destroyed\n");
259 }
260 req->buffer = bh->b_data;
261 return;
262 }
263 }
264 DEVICE_OFF(req->dev);
265 CURRENT = req->next;
266 if ((p = req->waiting) != NULL) {
267 req->waiting = NULL;
268 p->state = TASK_RUNNING;
269 if (p->counter > current->counter)
270 need_resched = 1;
271 }
272 req->dev = -1;
273 wake_up(&wait_for_request);
274 }
275 #endif
276
277 #ifdef DEVICE_INTR
278 #define CLEAR_INTR SET_INTR(NULL)
279 #else
280 #define CLEAR_INTR
281 #endif
282
283 #define INIT_REQUEST \
284 if (!CURRENT) {\
285 CLEAR_INTR; \
286 return; \
287 } \
288 if (MAJOR(CURRENT->dev) != MAJOR_NR) \
289 panic(DEVICE_NAME ": request list destroyed"); \
290 if (CURRENT->bh) { \
291 if (!CURRENT->bh->b_lock) \
292 panic(DEVICE_NAME ": block not locked"); \
293 }
294
295 #endif
296
297 #endif
298 #endif