Merge from vendor branch LIBARCHIVE:
[dragonfly.git] / sys / kern / kern_device.c
1 /*
2  * Copyright (c) 2003 Matthew Dillon <dillon@backplane.com> All rights reserved.
3  * cdevsw from kern/kern_conf.c Copyright (c) 1995 Terrence R. Lambert
4  * cdevsw from kern/kern_conf.c Copyright (c) 1995 Julian R. Elishcer,
5  *                                                      All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * $DragonFly: src/sys/kern/kern_device.c,v 1.15 2005/03/23 02:50:53 dillon Exp $
29  */
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/sysctl.h>
33 #include <sys/systm.h>
34 #include <sys/module.h>
35 #include <sys/malloc.h>
36 #include <sys/conf.h>
37 #include <sys/vnode.h>
38 #include <sys/queue.h>
39 #include <sys/msgport.h>
40 #include <sys/device.h>
41 #include <machine/stdarg.h>
42 #include <sys/proc.h>
43 #include <sys/thread2.h>
44 #include <sys/msgport2.h>
45
46 static struct cdevlink  *cdevbase[NUMCDEVSW];
47
48 static int cdevsw_putport(lwkt_port_t port, lwkt_msg_t msg);
49
50 struct cdevsw dead_cdevsw;
51
52 /*
53  * Initialize a message port to serve as the default message-handling port
54  * for device operations.  This message port provides compatibility with
55  * traditional cdevsw dispatch functions by running them synchronously.
56  *
57  * YYY NOTE: ms_cmd can now hold a function pointer, should this code be
58  * converted from an integer op to a function pointer with a flag to
59  * indicate legacy operation?
60  */
61 static void
62 init_default_cdevsw_port(lwkt_port_t port)
63 {
64     lwkt_initport(port, NULL);
65     port->mp_putport = cdevsw_putport;
66 }
67
68 static
69 int
70 cdevsw_putport(lwkt_port_t port, lwkt_msg_t lmsg)
71 {
72     cdevallmsg_t msg = (cdevallmsg_t)lmsg;
73     struct cdevsw *devsw = msg->am_msg.dev->si_devsw;
74     int error;
75
76     /*
77      * Run the device switch function synchronously in the context of the
78      * caller and return a synchronous error code (anything not EASYNC).
79      */
80     switch(msg->am_lmsg.ms_cmd.cm_op) {
81     case CDEV_CMD_OPEN:
82         error = devsw->old_open(
83                     msg->am_open.msg.dev,
84                     msg->am_open.oflags,
85                     msg->am_open.devtype,
86                     msg->am_open.td);
87         break;
88     case CDEV_CMD_CLOSE:
89         error = devsw->old_close(
90                     msg->am_close.msg.dev,
91                     msg->am_close.fflag,
92                     msg->am_close.devtype,
93                     msg->am_close.td);
94         break;
95     case CDEV_CMD_STRATEGY:
96         devsw->old_strategy(msg->am_strategy.bp);
97         error = 0;
98         break;
99     case CDEV_CMD_IOCTL:
100         error = devsw->old_ioctl(
101                     msg->am_ioctl.msg.dev,
102                     msg->am_ioctl.cmd,
103                     msg->am_ioctl.data,
104                     msg->am_ioctl.fflag,
105                     msg->am_ioctl.td);
106         break;
107     case CDEV_CMD_DUMP:
108         error = devsw->old_dump(
109                     msg->am_dump.msg.dev,
110                     msg->am_dump.count,
111                     msg->am_dump.blkno,
112                     msg->am_dump.secsize);
113         break;
114     case CDEV_CMD_PSIZE:
115         msg->am_psize.result = devsw->old_psize(msg->am_psize.msg.dev);
116         error = 0;      /* XXX */
117         break;
118     case CDEV_CMD_READ:
119         error = devsw->old_read(
120                     msg->am_read.msg.dev,
121                     msg->am_read.uio,
122                     msg->am_read.ioflag);
123         break;
124     case CDEV_CMD_WRITE:
125         error = devsw->old_write(
126                     msg->am_read.msg.dev,
127                     msg->am_read.uio,
128                     msg->am_read.ioflag);
129         break;
130     case CDEV_CMD_POLL:
131         msg->am_poll.events = devsw->old_poll(
132                                 msg->am_poll.msg.dev,
133                                 msg->am_poll.events,
134                                 msg->am_poll.td);
135         error = 0;
136         break;
137     case CDEV_CMD_KQFILTER:
138         msg->am_kqfilter.result = devsw->old_kqfilter(
139                                 msg->am_kqfilter.msg.dev,
140                                 msg->am_kqfilter.kn);
141         error = 0;
142         break;
143     case CDEV_CMD_MMAP:
144         msg->am_mmap.result = devsw->old_mmap(
145                     msg->am_mmap.msg.dev,
146                     msg->am_mmap.offset,
147                     msg->am_mmap.nprot);
148         error = 0;      /* XXX */
149         break;
150     default:
151         error = ENOSYS;
152         break;
153     }
154     KKASSERT(error != EASYNC);
155     return(error);
156 }
157
158 static __inline
159 lwkt_port_t
160 _init_cdevmsg(dev_t dev, cdevmsg_t msg, int cmd)
161 {
162     lwkt_initmsg_simple(&msg->msg, cmd);
163     msg->dev = dev;
164     return(dev->si_port);
165 }
166
167 int
168 dev_dopen(dev_t dev, int oflags, int devtype, thread_t td)
169 {
170     struct cdevmsg_open msg;
171     lwkt_port_t port;
172
173     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_OPEN);
174     if (port == NULL)
175         return(ENXIO);
176     msg.oflags = oflags;
177     msg.devtype = devtype;
178     msg.td = td;
179     return(lwkt_domsg(port, &msg.msg.msg));
180 }
181
182 int
183 dev_dclose(dev_t dev, int fflag, int devtype, thread_t td)
184 {
185     struct cdevmsg_close msg;
186     lwkt_port_t port;
187
188     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_CLOSE);
189     if (port == NULL)
190         return(ENXIO);
191     msg.fflag = fflag;
192     msg.devtype = devtype;
193     msg.td = td;
194     return(lwkt_domsg(port, &msg.msg.msg));
195 }
196
197 void
198 dev_dstrategy(dev_t dev, struct buf *bp)
199 {
200     struct cdevmsg_strategy msg;
201     lwkt_port_t port;
202
203     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_STRATEGY);
204     KKASSERT(port);     /* 'nostrategy' function is NULL YYY */
205     msg.bp = bp;
206     lwkt_domsg(port, &msg.msg.msg);
207 }
208
209 int
210 dev_dioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, thread_t td)
211 {
212     struct cdevmsg_ioctl msg;
213     lwkt_port_t port;
214
215     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_IOCTL);
216     if (port == NULL)
217         return(ENXIO);
218     msg.cmd = cmd;
219     msg.data = data;
220     msg.fflag = fflag;
221     msg.td = td;
222     return(lwkt_domsg(port, &msg.msg.msg));
223 }
224
225 /*
226  * note: the disk layer is expected to set count, blkno, and secsize before
227  * forwarding the message.
228  */
229 int
230 dev_ddump(dev_t dev)
231 {
232     struct cdevmsg_dump msg;
233     lwkt_port_t port;
234
235     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_DUMP);
236     if (port == NULL)
237         return(ENXIO);
238     msg.count = 0;
239     msg.blkno = 0;
240     msg.secsize = 0;
241     return(lwkt_domsg(port, &msg.msg.msg));
242 }
243
244 int
245 dev_dpsize(dev_t dev)
246 {
247     struct cdevmsg_psize msg;
248     lwkt_port_t port;
249     int error;
250
251     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_PSIZE);
252     if (port == NULL)
253         return(-1);
254     error = lwkt_domsg(port, &msg.msg.msg);
255     if (error == 0)
256         return(msg.result);
257     return(-1);
258 }
259
260 int
261 dev_dread(dev_t dev, struct uio *uio, int ioflag)
262 {
263     struct cdevmsg_read msg;
264     lwkt_port_t port;
265     int error;
266
267     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_READ);
268     if (port == NULL)
269         return(ENXIO);
270     msg.uio = uio;
271     msg.ioflag = ioflag;
272     error = lwkt_domsg(port, &msg.msg.msg);
273     if (error == 0)
274         dev->si_lastread = time_second;
275     return (error);
276 }
277
278 int
279 dev_dwrite(dev_t dev, struct uio *uio, int ioflag)
280 {
281     struct cdevmsg_write msg;
282     lwkt_port_t port;
283
284     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_WRITE);
285     if (port == NULL)
286         return(ENXIO);
287     dev->si_lastwrite = time_second;
288     msg.uio = uio;
289     msg.ioflag = ioflag;
290     return(lwkt_domsg(port, &msg.msg.msg));
291 }
292
293 int
294 dev_dpoll(dev_t dev, int events, thread_t td)
295 {
296     struct cdevmsg_poll msg;
297     lwkt_port_t port;
298     int error;
299
300     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_POLL);
301     if (port == NULL)
302         return(ENXIO);
303     msg.events = events;
304     msg.td = td;
305     error = lwkt_domsg(port, &msg.msg.msg);
306     if (error == 0)
307         return(msg.events);
308     return(seltrue(dev, msg.events, td));
309 }
310
311 int
312 dev_dkqfilter(dev_t dev, struct knote *kn)
313 {
314     struct cdevmsg_kqfilter msg;
315     lwkt_port_t port;
316     int error;
317
318     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_KQFILTER);
319     if (port == NULL)
320         return(ENXIO);
321     msg.kn = kn;
322     error = lwkt_domsg(port, &msg.msg.msg);
323     if (error == 0)
324         return(msg.result);
325     return(ENODEV);
326 }
327
328 int
329 dev_dmmap(dev_t dev, vm_offset_t offset, int nprot)
330 {
331     struct cdevmsg_mmap msg;
332     lwkt_port_t port;
333     int error;
334
335     port = _init_cdevmsg(dev, &msg.msg, CDEV_CMD_MMAP);
336     if (port == NULL)
337         return(-1);
338     msg.offset = offset;
339     msg.nprot = nprot;
340     error = lwkt_domsg(port, &msg.msg.msg);
341     if (error == 0)
342         return(msg.result);
343     return(-1);
344 }
345
346 const char *
347 dev_dname(dev_t dev)
348 {
349     return(dev->si_devsw->d_name);
350 }
351
352 int
353 dev_dflags(dev_t dev)
354 {
355     return(dev->si_devsw->d_flags);
356 }
357
358 int
359 dev_dmaj(dev_t dev)
360 {
361     return(dev->si_devsw->d_maj);
362 }
363
364 lwkt_port_t
365 dev_dport(dev_t dev)
366 {
367     return(dev->si_port);
368 }
369
370 /*
371  * Convert a cdevsw template into the real thing, filling in fields the
372  * device left empty with appropriate defaults.
373  */
374 void
375 compile_devsw(struct cdevsw *devsw)
376 {
377     static lwkt_port devsw_compat_port;
378
379     if (devsw_compat_port.mp_putport == NULL)
380         init_default_cdevsw_port(&devsw_compat_port);
381     
382     if (devsw->old_open == NULL)
383         devsw->old_open = noopen;
384     if (devsw->old_close == NULL)
385         devsw->old_close = noclose;
386     if (devsw->old_read == NULL)
387         devsw->old_read = noread;
388     if (devsw->old_write == NULL)
389         devsw->old_write = nowrite;
390     if (devsw->old_ioctl == NULL)
391         devsw->old_ioctl = noioctl;
392     if (devsw->old_poll == NULL)
393         devsw->old_poll = nopoll;
394     if (devsw->old_mmap == NULL)
395         devsw->old_mmap = nommap;
396     if (devsw->old_strategy == NULL)
397         devsw->old_strategy = nostrategy;
398     if (devsw->old_dump == NULL)
399         devsw->old_dump = nodump;
400     if (devsw->old_psize == NULL)
401         devsw->old_psize = nopsize;
402     if (devsw->old_kqfilter == NULL)
403         devsw->old_kqfilter = nokqfilter;
404
405     if (devsw->d_port == NULL)
406         devsw->d_port = &devsw_compat_port;
407     if (devsw->d_clone == NULL)
408         devsw->d_clone = noclone;
409 }
410
411 /*
412  * This makes a cdevsw entry visible to userland (e.g /dev/<blah>).
413  *
414  * The kernel can overload a major number by making multiple cdevsw_add()
415  * calls, but only the most recent one (the first one in the cdevbase[] list
416  * matching the mask/match) will be visible to userland.  make_dev() does
417  * not automatically call cdevsw_add() (nor do we want it to, since 
418  * partition-managed disk devices are overloaded on top of the raw device).
419  *
420  * Disk devices typically register their major, e.g. 'ad0', and then call
421  * into the disk label management code which overloads its own onto e.g. 'ad0'
422  * to support all the various slice and partition combinations.
423  *
424  * The mask/match supplied in this call are a full 32 bits and the same
425  * mask and match must be specified in a later cdevsw_remove() call to
426  * match this add.  However, the match value for the minor number should never
427  * have any bits set in the major number's bit range (8-15).  The mask value
428  * may be conveniently specified as -1 without creating any major number
429  * interference.
430  */
431 int
432 cdevsw_add(struct cdevsw *devsw, u_int mask, u_int match)
433 {
434     int maj;
435     struct cdevlink *link;
436
437     compile_devsw(devsw);
438     maj = devsw->d_maj;
439     if (maj < 0 || maj >= NUMCDEVSW) {
440         printf("%s: ERROR: driver has bogus cdevsw->d_maj = %d\n",
441             devsw->d_name, maj);
442         return (EINVAL);
443     }
444     for (link = cdevbase[maj]; link; link = link->next) {
445         /*
446          * If we get an exact match we usurp the target, but we only print
447          * a warning message if a different device switch is installed.
448          */
449         if (link->mask == mask && link->match == match) {
450             if (link->devsw != devsw) {
451                     printf("WARNING: \"%s\" (%p) is usurping \"%s\"'s (%p)"
452                         " cdevsw[]\n",
453                         devsw->d_name, devsw, 
454                         link->devsw->d_name, link->devsw);
455                     link->devsw = devsw;
456                     ++devsw->d_refs;
457             }
458             return(0);
459         }
460         /*
461          * XXX add additional warnings for overlaps
462          */
463     }
464
465     link = malloc(sizeof(struct cdevlink), M_DEVBUF, M_INTWAIT|M_ZERO);
466     link->mask = mask;
467     link->match = match;
468     link->devsw = devsw;
469     link->next = cdevbase[maj];
470     cdevbase[maj] = link;
471     ++devsw->d_refs;
472     return(0);
473 }
474
475 /*
476  * Should only be used by udev2dev().
477  *
478  * If the minor number is -1, we match the first cdevsw we find for this
479  * major.   If the mask is not -1 then multiple minor numbers can match
480  * the same devsw.
481  *
482  * Note that this function will return NULL if the minor number is not within
483  * the bounds of the installed mask(s).
484  *
485  * The specified minor number should NOT include any major bits.
486  */
487 struct cdevsw *
488 cdevsw_get(int x, int y)
489 {
490     struct cdevlink *link;
491
492     if (x < 0 || x >= NUMCDEVSW)
493         return(NULL);
494     for (link = cdevbase[x]; link; link = link->next) {
495         if (y == -1 || (link->mask & y) == link->match)
496             return(link->devsw);
497     }
498     return(NULL);
499 }
500
501 /*
502  * Use the passed cdevsw as a template to create our intercept cdevsw,
503  * and install and return ours.
504  */
505 struct cdevsw *
506 cdevsw_add_override(dev_t backing_dev, u_int mask, u_int match)
507 {
508     struct cdevsw *devsw;
509     struct cdevsw *bsw = backing_dev->si_devsw;
510
511     devsw = malloc(sizeof(struct cdevsw), M_DEVBUF, M_INTWAIT|M_ZERO);
512     devsw->d_name = bsw->d_name;
513     devsw->d_maj = bsw->d_maj;
514     devsw->d_flags = bsw->d_flags;
515     compile_devsw(devsw);
516     cdevsw_add(devsw, mask, match);
517
518     return(devsw);
519 }
520
521 /*
522  * Override a device's port, returning the previously installed port.  This
523  * is XXX very dangerous.
524  */
525 lwkt_port_t
526 cdevsw_dev_override(dev_t dev, lwkt_port_t port)
527 {
528     lwkt_port_t oport;
529
530     oport = dev->si_port;
531     dev->si_port = port;
532     return(oport);
533 }
534
535 /*
536  * Remove a cdevsw entry from the cdevbase[] major array so no new user opens
537  * can be performed, and destroy all devices installed in the hash table
538  * which are associated with this cdevsw.  (see destroy_all_dev()).
539  */
540 int
541 cdevsw_remove(struct cdevsw *devsw, u_int mask, u_int match)
542 {
543     int maj = devsw->d_maj;
544     struct cdevlink *link;
545     struct cdevlink **plink;
546  
547     if (maj < 0 || maj >= NUMCDEVSW) {
548         printf("%s: ERROR: driver has bogus cdevsw->d_maj = %d\n",
549             devsw->d_name, maj);
550         return EINVAL;
551     }
552     if (devsw != &dead_cdevsw)
553         destroy_all_dev(devsw, mask, match);
554     for (plink = &cdevbase[maj]; (link = *plink) != NULL; plink = &link->next) {
555         if (link->mask == mask && link->match == match) {
556             if (link->devsw == devsw)
557                 break;
558             printf("%s: ERROR: cannot remove from cdevsw[], its major"
559                     " number %d was stolen by %s\n",
560                     devsw->d_name, maj,
561                     link->devsw->d_name
562             );
563         }
564     }
565     if (link == NULL) {
566         printf("%s(%d)[%08x/%08x]: WARNING: cdevsw removed multiple times!\n",
567                 devsw->d_name, maj, mask, match);
568     } else {
569         *plink = link->next;
570         --devsw->d_refs; /* XXX cdevsw_release() / record refs */
571         free(link, M_DEVBUF);
572     }
573     if (cdevbase[maj] == NULL && devsw->d_refs != 0) {
574         printf("%s(%d)[%08x/%08x]: Warning: cdevsw_remove() called while "
575                 "%d device refs still exist!\n", 
576                 devsw->d_name, maj, mask, match, devsw->d_refs);
577     } else {
578         printf("%s: cdevsw removed\n", devsw->d_name);
579     }
580     return 0;
581 }
582
583 /*
584  * Release a cdevsw entry.  When the ref count reaches zero, recurse
585  * through the stack.
586  */
587 void
588 cdevsw_release(struct cdevsw *devsw)
589 {
590     --devsw->d_refs;
591     if (devsw->d_refs == 0) {
592         /* XXX */
593     }
594 }
595