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