1 /* This file contains the device independent block driver interface.
2 *
3 * Block drivers support the following requests. Message format m10 is used.
4 * Field names are prefixed with BDEV_. Separate field names are used for the
5 * "access", "request", and "user" fields.
6 *
7 * m_type MINOR COUNT GRANT FLAGS ID REQUEST POS
8 * +--------------+--------+----------+-------+-------+------+---------+------+
9 * | BDEV_OPEN | minor | access | | | id | | |
10 * |--------------+--------+----------+-------+-------+------+---------+------|
11 * | BDEV_CLOSE | minor | | | | id | | |
12 * |--------------+--------+----------+-------+-------+------+---------+------|
13 * | BDEV_READ | minor | bytes | grant | flags | id | | pos. |
14 * |--------------+--------+----------+-------+-------+------+---------+------|
15 * | BDEV_WRITE | minor | bytes | grant | flags | id | | pos. |
16 * |--------------+--------+----------+-------+-------+------+---------+------|
17 * | BDEV_GATHER | minor | elements | grant | flags | id | | pos. |
18 * |--------------+--------+----------+-------+-------+------+---------+------|
19 * | BDEV_SCATTER | minor | elements | grant | flags | id | | pos. |
20 * |--------------+--------+----------+-------+-------+------+---------+------|
21 * | BDEV_IOCTL | minor | | grant | user | id | request | |
22 * ----------------------------------------------------------------------------
23 *
24 * The following reply message is used for all requests.
25 *
26 * m_type STATUS ID
27 * +--------------+--------+----------+-------+-------+------+---------+------+
28 * | BDEV_REPLY | status | | | | id | | |
29 * ----------------------------------------------------------------------------
30 *
31 * Changes:
32 * Oct 16, 2011 split character and block protocol (D.C. van Moolenbroek)
33 * Aug 27, 2011 move common functions into driver.c (A. Welzel)
34 * Jul 25, 2005 added SYS_SIG type for signals (Jorrit N. Herder)
35 * Sep 15, 2004 added SYN_ALARM type for timeouts (Jorrit N. Herder)
36 * Jul 23, 2004 removed kernel dependencies (Jorrit N. Herder)
37 * Apr 02, 1992 constructed from AT wini and floppy driver (Kees J. Bot)
38 */
39
40 #include <minix/drivers.h>
41 #include <minix/blockdriver.h>
42 #include <minix/ds.h>
43 #include <sys/ioc_block.h>
44 #include <sys/ioc_disk.h>
45
46 #include "driver.h"
47 #include "mq.h"
48 #include "trace.h"
49
50 /* Management data for opened devices. */
51 static int open_devs[MAX_NR_OPEN_DEVICES];
52 static int next_open_devs_slot = 0;
53
54 /*===========================================================================*
55 * clear_open_devs *
56 *===========================================================================*/
clear_open_devs(void)57 static void clear_open_devs(void)
58 {
59 /* Reset the set of previously opened minor devices. */
60 next_open_devs_slot = 0;
61 }
62
63 /*===========================================================================*
64 * is_open_dev *
65 *===========================================================================*/
is_open_dev(int device)66 static int is_open_dev(int device)
67 {
68 /* Check whether the given minor device has previously been opened. */
69 int i;
70
71 for (i = 0; i < next_open_devs_slot; i++)
72 if (open_devs[i] == device)
73 return TRUE;
74
75 return FALSE;
76 }
77
78 /*===========================================================================*
79 * set_open_dev *
80 *===========================================================================*/
set_open_dev(int device)81 static void set_open_dev(int device)
82 {
83 /* Mark the given minor device as having been opened. */
84
85 if (next_open_devs_slot >= MAX_NR_OPEN_DEVICES)
86 panic("out of slots for open devices");
87
88 open_devs[next_open_devs_slot] = device;
89 next_open_devs_slot++;
90 }
91
92 /*===========================================================================*
93 * blockdriver_announce *
94 *===========================================================================*/
blockdriver_announce(int type)95 void blockdriver_announce(int type)
96 {
97 /* Announce we are up after a fresh start or a restart. */
98 int r;
99 char key[DS_MAX_KEYLEN];
100 char label[DS_MAX_KEYLEN];
101 const char *driver_prefix = "drv.blk.";
102
103 /* Callers are allowed to use ipc_sendrec to communicate with drivers.
104 * For this reason, there may blocked callers when a driver restarts.
105 * Ask the kernel to unblock them (if any). Note that most block drivers
106 * will not restart statefully, and thus will skip this code.
107 */
108 if (type == SEF_INIT_RESTART) {
109 if ((r = sys_statectl(SYS_STATE_CLEAR_IPC_REFS, 0, 0)) != OK)
110 panic("blockdriver_init: sys_statectl failed: %d", r);
111 }
112
113 /* Publish a driver up event. */
114 if ((r = ds_retrieve_label_name(label, sef_self())) != OK)
115 panic("blockdriver_init: unable to get own label: %d", r);
116
117 snprintf(key, DS_MAX_KEYLEN, "%s%s", driver_prefix, label);
118 if ((r = ds_publish_u32(key, DS_DRIVER_UP, DSF_OVERWRITE)) != OK)
119 panic("blockdriver_init: unable to publish driver up event: %d", r);
120
121 /* Expect an open for any device before serving regular driver requests. */
122 clear_open_devs();
123
124 /* Initialize or reset the message queue. */
125 mq_init();
126 }
127
128 /*===========================================================================*
129 * send_reply *
130 *===========================================================================*/
send_reply(endpoint_t endpt,message * m_ptr,int ipc_status)131 static void send_reply(endpoint_t endpt, message *m_ptr, int ipc_status)
132 {
133 /* Send a reply message to a request. */
134 int r;
135
136 /* If we would block sending the message, send it asynchronously. The NOREPLY
137 * flag is set because the caller may also issue a SENDREC (mixing sync and
138 * async comm), and the asynchronous reply could otherwise end up satisfying
139 * the SENDREC's receive part, after which our next SENDNB call would fail.
140 */
141 if (IPC_STATUS_CALL(ipc_status) == SENDREC)
142 r = ipc_sendnb(endpt, m_ptr);
143 else
144 r = asynsend3(endpt, m_ptr, AMF_NOREPLY);
145
146 if (r != OK)
147 printf("blockdriver: unable to send reply to %d: %d\n", endpt, r);
148 }
149
150 /*===========================================================================*
151 * blockdriver_reply *
152 *===========================================================================*/
blockdriver_reply(message * m_ptr,int ipc_status,int reply)153 void blockdriver_reply(message *m_ptr, int ipc_status, int reply)
154 {
155 /* Reply to a block request sent to the driver. */
156 message m_reply;
157
158 if (reply == EDONTREPLY)
159 return;
160
161 memset(&m_reply, 0, sizeof(m_reply));
162
163 m_reply.m_type = BDEV_REPLY;
164 m_reply.m_lblockdriver_lbdev_reply.status = reply;
165 m_reply.m_lblockdriver_lbdev_reply.id = m_ptr->m_lbdev_lblockdriver_msg.id;
166
167 send_reply(m_ptr->m_source, &m_reply, ipc_status);
168 }
169
170 /*===========================================================================*
171 * do_open *
172 *===========================================================================*/
do_open(struct blockdriver * bdp,message * mp)173 static int do_open(struct blockdriver *bdp, message *mp)
174 {
175 /* Open a minor device. */
176
177 return (*bdp->bdr_open)(mp->m_lbdev_lblockdriver_msg.minor, mp->m_lbdev_lblockdriver_msg.access);
178 }
179
180 /*===========================================================================*
181 * do_close *
182 *===========================================================================*/
do_close(struct blockdriver * bdp,message * mp)183 static int do_close(struct blockdriver *bdp, message *mp)
184 {
185 /* Close a minor device. */
186
187 return (*bdp->bdr_close)(mp->m_lbdev_lblockdriver_msg.minor);
188 }
189
190 /*===========================================================================*
191 * do_rdwt *
192 *===========================================================================*/
do_rdwt(struct blockdriver * bdp,message * mp)193 static int do_rdwt(struct blockdriver *bdp, message *mp)
194 {
195 /* Carry out a single read or write request. */
196 iovec_t iovec1;
197 u64_t position;
198 int do_write;
199 ssize_t r;
200
201 /* Disk address? Address and length of the user buffer? */
202 if (mp->m_lbdev_lblockdriver_msg.count < 0) return EINVAL;
203
204 /* Create a one element scatter/gather vector for the buffer. */
205 iovec1.iov_addr = mp->m_lbdev_lblockdriver_msg.grant;
206 iovec1.iov_size = mp->m_lbdev_lblockdriver_msg.count;
207
208 /* Transfer bytes from/to the device. */
209 do_write = (mp->m_type == BDEV_WRITE);
210 position = mp->m_lbdev_lblockdriver_msg.pos;
211
212 r = (*bdp->bdr_transfer)(mp->m_lbdev_lblockdriver_msg.minor, do_write, position, mp->m_source,
213 &iovec1, 1, mp->m_lbdev_lblockdriver_msg.flags);
214
215 /* Return the number of bytes transferred or an error code. */
216 return r;
217 }
218
219 /*===========================================================================*
220 * do_vrdwt *
221 *===========================================================================*/
do_vrdwt(struct blockdriver * bdp,message * mp,thread_id_t id)222 static int do_vrdwt(struct blockdriver *bdp, message *mp, thread_id_t id)
223 {
224 /* Carry out an device read or write to/from a vector of buffers. */
225 iovec_t iovec[NR_IOREQS];
226 unsigned int i, nr_req;
227 u64_t position;
228 int do_write;
229 ssize_t r, size;
230
231 /* Copy the vector from the caller to kernel space. */
232 nr_req = mp->m_lbdev_lblockdriver_msg.count; /* Length of I/O vector */
233 if (nr_req > NR_IOREQS) nr_req = NR_IOREQS;
234
235 if (OK != sys_safecopyfrom(mp->m_source, (vir_bytes) mp->m_lbdev_lblockdriver_msg.grant,
236 0, (vir_bytes) iovec, nr_req * sizeof(iovec[0]))) {
237 printf("blockdriver: bad I/O vector by: %d\n", mp->m_source);
238 return EINVAL;
239 }
240
241 /* Check for overflow condition, and update the size for block tracing. */
242 for (i = size = 0; i < nr_req; i++) {
243 if ((ssize_t) (size + iovec[i].iov_size) < size) return EINVAL;
244 size += iovec[i].iov_size;
245 }
246
247 trace_setsize(id, size);
248
249 /* Transfer bytes from/to the device. */
250 do_write = (mp->m_type == BDEV_SCATTER);
251 position = mp->m_lbdev_lblockdriver_msg.pos;
252
253 r = (*bdp->bdr_transfer)(mp->m_lbdev_lblockdriver_msg.minor, do_write, position, mp->m_source,
254 iovec, nr_req, mp->m_lbdev_lblockdriver_msg.flags);
255
256 /* Return the number of bytes transferred or an error code. */
257 return r;
258 }
259
260 /*===========================================================================*
261 * do_dioctl *
262 *===========================================================================*/
do_dioctl(struct blockdriver * bdp,devminor_t minor,unsigned long request,endpoint_t endpt,cp_grant_id_t grant)263 static int do_dioctl(struct blockdriver *bdp, devminor_t minor,
264 unsigned long request, endpoint_t endpt, cp_grant_id_t grant)
265 {
266 /* Carry out a disk-specific I/O control request. */
267 struct device *dv;
268 struct part_geom entry;
269 int r = EINVAL;
270
271 switch (request) {
272 case DIOCSETP:
273 /* Copy just this one partition table entry. */
274 r = sys_safecopyfrom(endpt, grant, 0, (vir_bytes) &entry,
275 sizeof(entry));
276 if (r != OK)
277 return r;
278
279 if ((dv = (*bdp->bdr_part)(minor)) == NULL)
280 return ENXIO;
281 dv->dv_base = entry.base;
282 dv->dv_size = entry.size;
283
284 break;
285
286 case DIOCGETP:
287 /* Return a partition table entry and the geometry of the drive. */
288 if ((dv = (*bdp->bdr_part)(minor)) == NULL)
289 return ENXIO;
290 entry.base = dv->dv_base;
291 entry.size = dv->dv_size;
292 if (bdp->bdr_geometry) {
293 (*bdp->bdr_geometry)(minor, &entry);
294 } else {
295 /* The driver doesn't care -- make up fake geometry. */
296 entry.cylinders = (unsigned long)(entry.size / SECTOR_SIZE) /
297 (64 * 32);
298 entry.heads = 64;
299 entry.sectors = 32;
300 }
301
302 r = sys_safecopyto(endpt, grant, 0, (vir_bytes) &entry, sizeof(entry));
303
304 break;
305 }
306
307 return r;
308 }
309
310 /*===========================================================================*
311 * do_ioctl *
312 *===========================================================================*/
do_ioctl(struct blockdriver * bdp,message * mp)313 static int do_ioctl(struct blockdriver *bdp, message *mp)
314 {
315 /* Carry out an I/O control request. We forward block trace control requests
316 * to the tracing module, and handle setting/getting partitions when the driver
317 * has specified that it is a disk driver.
318 */
319 devminor_t minor;
320 unsigned long request;
321 cp_grant_id_t grant;
322 endpoint_t user_endpt;
323 int r;
324
325 minor = mp->m_lbdev_lblockdriver_msg.minor;
326 request = mp->m_lbdev_lblockdriver_msg.request;
327 grant = mp->m_lbdev_lblockdriver_msg.grant;
328 user_endpt = mp->m_lbdev_lblockdriver_msg.user;
329
330 switch (request) {
331 case BIOCTRACEBUF:
332 case BIOCTRACECTL:
333 case BIOCTRACEGET:
334 /* Block trace control. */
335 r = trace_ctl(minor, request, mp->m_source, grant);
336
337 break;
338
339 case DIOCSETP:
340 case DIOCGETP:
341 /* Handle disk-specific IOCTLs only for disk-type drivers. */
342 if (bdp->bdr_type == BLOCKDRIVER_TYPE_DISK) {
343 /* Disk partition control. */
344 r = do_dioctl(bdp, minor, request, mp->m_source, grant);
345
346 break;
347 }
348
349 /* fall-through */
350 default:
351 if (bdp->bdr_ioctl)
352 r = (*bdp->bdr_ioctl)(minor, request, mp->m_source, grant,
353 user_endpt);
354 else
355 r = ENOTTY;
356 }
357
358 return r;
359 }
360
361 /*===========================================================================*
362 * do_char_open *
363 *===========================================================================*/
do_char_open(message * m_ptr,int ipc_status)364 static void do_char_open(message *m_ptr, int ipc_status)
365 {
366 /* Reply to a character driver open request stating there is no such device. */
367 message m_reply;
368
369 memset(&m_reply, 0, sizeof(m_reply));
370
371 m_reply.m_type = CDEV_REPLY;
372 m_reply.m_lchardriver_vfs_reply.status = ENXIO;
373 m_reply.m_lchardriver_vfs_reply.id = m_ptr->m_vfs_lchardriver_openclose.id;
374
375 send_reply(m_ptr->m_source, &m_reply, ipc_status);
376 }
377
378 /*===========================================================================*
379 * blockdriver_process_on_thread *
380 *===========================================================================*/
blockdriver_process_on_thread(struct blockdriver * bdp,message * m_ptr,int ipc_status,thread_id_t id)381 void blockdriver_process_on_thread(struct blockdriver *bdp, message *m_ptr,
382 int ipc_status, thread_id_t id)
383 {
384 /* Call the appropiate driver function, based on the type of request. Send
385 * a result code to the caller. The call is processed in the context of the
386 * given thread ID, which may be SINGLE_THREAD for single-threaded callers.
387 */
388 int r;
389
390 /* Check for notifications first. We never reply to notifications. */
391 if (is_ipc_notify(ipc_status)) {
392 switch (_ENDPOINT_P(m_ptr->m_source)) {
393 case HARDWARE:
394 if (bdp->bdr_intr)
395 (*bdp->bdr_intr)(m_ptr->m_notify.interrupts);
396 break;
397
398 case CLOCK:
399 if (bdp->bdr_alarm)
400 (*bdp->bdr_alarm)(m_ptr->m_notify.timestamp);
401 break;
402
403 default:
404 if (bdp->bdr_other)
405 (*bdp->bdr_other)(m_ptr, ipc_status);
406 }
407
408 return; /* do not send a reply */
409 }
410
411 /* Reply to character driver open requests with an error code. Otherwise, if
412 * someone creates a character device node for a block driver, opening that
413 * device node will cause the corresponding VFS thread to block forever.
414 */
415 if (m_ptr->m_type == CDEV_OPEN) {
416 do_char_open(m_ptr, ipc_status);
417
418 return;
419 }
420
421 /* We might get spurious requests if the driver has been restarted. Deny any
422 * requests on devices that have not previously been opened, signaling the
423 * caller that something went wrong.
424 */
425 if (IS_BDEV_RQ(m_ptr->m_type) && !is_open_dev(m_ptr->m_lbdev_lblockdriver_msg.minor)) {
426 /* Reply ERESTART to spurious requests for unopened devices. */
427 if (m_ptr->m_type != BDEV_OPEN) {
428 blockdriver_reply(m_ptr, ipc_status, ERESTART);
429
430 return;
431 }
432
433 /* Mark the device as opened otherwise. */
434 set_open_dev(m_ptr->m_lbdev_lblockdriver_msg.minor);
435 }
436
437 trace_start(id, m_ptr);
438
439 /* Call the appropriate function(s) for this request. */
440 switch (m_ptr->m_type) {
441 case BDEV_OPEN: r = do_open(bdp, m_ptr); break;
442 case BDEV_CLOSE: r = do_close(bdp, m_ptr); break;
443 case BDEV_READ:
444 case BDEV_WRITE: r = do_rdwt(bdp, m_ptr); break;
445 case BDEV_GATHER:
446 case BDEV_SCATTER: r = do_vrdwt(bdp, m_ptr, id); break;
447 case BDEV_IOCTL: r = do_ioctl(bdp, m_ptr); break;
448 default:
449 if (bdp->bdr_other != NULL)
450 (*bdp->bdr_other)(m_ptr, ipc_status);
451
452 return; /* do not send a reply */
453 }
454
455 /* Let the driver perform any cleanup. */
456 if (bdp->bdr_cleanup != NULL)
457 (*bdp->bdr_cleanup)();
458
459 trace_finish(id, r);
460
461 blockdriver_reply(m_ptr, ipc_status, r);
462 }
463