2 * Copyright (c) 2010 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Alex Hornung <ahornung@gmail.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
40 #include <sys/event.h>
41 #include <sys/vnode.h>
42 #include <sys/malloc.h>
43 #include <sys/objcache.h>
44 #include <sys/ctype.h>
45 #include <sys/syslog.h>
47 #include <sys/devfs.h>
48 #include <libprop/proplib.h>
50 #include <sys/thread2.h>
52 MALLOC_DEFINE(M_UDEV, "udev", "udev allocs");
53 static struct objcache *udev_event_kernel_cache;
55 /* XXX: use UUIDs for identification; would need help from devfs */
57 static cdev_t udev_dev;
58 static d_open_t udev_dev_open;
59 static d_close_t udev_dev_close;
60 static d_read_t udev_dev_read;
61 static d_kqfilter_t udev_dev_kqfilter;
62 static d_ioctl_t udev_dev_ioctl;
63 static d_clone_t udev_dev_clone;
65 struct udev_prop_ctx {
70 struct udev_event_kernel {
72 TAILQ_ENTRY(udev_event_kernel) link;
76 TAILQ_ENTRY(udev_softc) entry;
82 struct udev_event_kernel marker; /* udev_evq marker */
87 int (*fn)(struct udev_softc *, struct plistref *,
88 u_long, prop_dictionary_t);
92 static int _udev_dict_set_cstr(prop_dictionary_t, const char *, char *);
93 static int _udev_dict_set_int(prop_dictionary_t, const char *, int64_t);
94 static int _udev_dict_set_uint(prop_dictionary_t, const char *, uint64_t);
95 static int _udev_dict_delete_key(prop_dictionary_t, const char *);
96 static prop_dictionary_t udev_init_dict_event(cdev_t, const char *);
97 static int udev_init_dict(cdev_t);
98 static int udev_destroy_dict(cdev_t);
99 static void udev_event_insert(int, prop_dictionary_t);
100 static void udev_clean_events_locked(void);
101 static char *udev_event_externalize(struct udev_event_kernel *);
102 static void udev_getdevs_scan_callback(char *, cdev_t, bool, void *);
103 static int udev_getdevs_ioctl(struct udev_softc *, struct plistref *,
104 u_long, prop_dictionary_t);
105 static void udev_dev_filter_detach(struct knote *);
106 static int udev_dev_filter_read(struct knote *, long);
108 static struct dev_ops udev_dev_ops = {
110 .d_open = udev_dev_open,
111 .d_close = udev_dev_close,
112 .d_read = udev_dev_read,
113 .d_kqfilter = udev_dev_kqfilter,
114 .d_ioctl = udev_dev_ioctl
117 static struct cmd_function cmd_fn[] = {
118 { .cmd = "getdevs", .fn = udev_getdevs_ioctl},
122 DEVFS_DEFINE_CLONE_BITMAP(udev);
124 static TAILQ_HEAD(, udev_softc) udevq;
125 static TAILQ_HEAD(, udev_event_kernel) udev_evq;
126 static struct kqinfo udev_kq;
127 static struct lock udev_lk;
128 static int udev_evqlen;
129 static int udev_initiated_count;
130 static int udev_open_count;
131 static int udev_seqwait;
135 _udev_dict_set_cstr(prop_dictionary_t dict, const char *key, char *str)
139 KKASSERT(dict != NULL);
141 ps = prop_string_create_cstring(str);
146 if (prop_dictionary_set(dict, key, ps) == false) {
147 prop_object_release(ps);
151 prop_object_release(ps);
156 _udev_dict_set_int(prop_dictionary_t dict, const char *key, int64_t val)
160 KKASSERT(dict != NULL);
162 pn = prop_number_create_integer(val);
166 if (prop_dictionary_set(dict, key, pn) == false) {
167 prop_object_release(pn);
171 prop_object_release(pn);
176 _udev_dict_set_uint(prop_dictionary_t dict, const char *key, uint64_t val)
180 KKASSERT(dict != NULL);
182 pn = prop_number_create_unsigned_integer(val);
186 if (prop_dictionary_set(dict, key, pn) == false) {
187 prop_object_release(pn);
191 prop_object_release(pn);
196 _udev_dict_delete_key(prop_dictionary_t dict, const char *key)
198 KKASSERT(dict != NULL);
200 prop_dictionary_remove(dict, key);
206 * Initialize an event dictionary, which contains three parameters to
207 * identify the device referred to (name, devnum, kptr) and the affected key.
209 static prop_dictionary_t
210 udev_init_dict_event(cdev_t dev, const char *key)
212 prop_dictionary_t dict;
216 kptr = (uint64_t)(uintptr_t)dev;
217 KKASSERT(dev != NULL);
219 dict = prop_dictionary_create();
221 log(LOG_DEBUG, "udev_init_dict_event: prop_dictionary_create() failed\n");
225 if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
227 if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
229 if ((error = _udev_dict_set_uint(dict, "devtype", (dev_dflags(dev) & D_TYPEMASK))))
231 if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
233 if ((error = _udev_dict_set_cstr(dict, "key", __DECONST(char *, key))))
239 prop_object_release(dict);
244 udev_dict_set_cstr(cdev_t dev, const char *key, char *str)
246 prop_dictionary_t dict;
249 KKASSERT(dev != NULL);
251 if (dev->si_dict == NULL) {
252 error = udev_init_dict(dev);
257 /* Queue a key update event */
258 dict = udev_init_dict_event(dev, key);
262 if ((error = _udev_dict_set_cstr(dict, "value", str))) {
263 prop_object_release(dict);
266 udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
267 prop_object_release(dict);
269 error = _udev_dict_set_cstr(dev->si_dict, key, str);
274 udev_dict_set_int(cdev_t dev, const char *key, int64_t val)
276 prop_dictionary_t dict;
279 KKASSERT(dev != NULL);
281 if (dev->si_dict == NULL) {
282 error = udev_init_dict(dev);
287 /* Queue a key update event */
288 dict = udev_init_dict_event(dev, key);
291 if ((error = _udev_dict_set_int(dict, "value", val))) {
292 prop_object_release(dict);
295 udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
296 prop_object_release(dict);
298 return _udev_dict_set_int(dev->si_dict, key, val);
302 udev_dict_set_uint(cdev_t dev, const char *key, uint64_t val)
304 prop_dictionary_t dict;
307 KKASSERT(dev != NULL);
309 if (dev->si_dict == NULL) {
310 error = udev_init_dict(dev);
315 /* Queue a key update event */
316 dict = udev_init_dict_event(dev, key);
319 if ((error = _udev_dict_set_uint(dict, "value", val))) {
320 prop_object_release(dict);
323 udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
324 prop_object_release(dict);
326 return _udev_dict_set_uint(dev->si_dict, key, val);
330 udev_dict_delete_key(cdev_t dev, const char *key)
332 prop_dictionary_t dict;
334 KKASSERT(dev != NULL);
336 /* Queue a key removal event */
337 dict = udev_init_dict_event(dev, key);
340 udev_event_insert(UDEV_EV_KEY_REMOVE, dict);
341 prop_object_release(dict);
343 return _udev_dict_delete_key(dev->si_dict, key);
347 udev_init_dict(cdev_t dev)
349 prop_dictionary_t dict;
353 kptr = (uint64_t)(uintptr_t)dev;
355 KKASSERT(dev != NULL);
357 if (dev->si_dict != NULL) {
360 "udev_init_dict: new dict for %s, but has dict already (%p)!\n",
361 dev->si_name, dev->si_dict);
366 dict = prop_dictionary_create();
368 log(LOG_DEBUG, "udev_init_dict: prop_dictionary_create() failed\n");
372 if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
374 if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
376 if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
378 if ((error = _udev_dict_set_uint(dict, "devtype", (dev_dflags(dev) & D_TYPEMASK))))
381 /* XXX: The next 3 are marginallly useful, if at all */
382 if ((error = _udev_dict_set_uint(dict, "uid", dev->si_uid)))
384 if ((error = _udev_dict_set_uint(dict, "gid", dev->si_gid)))
386 if ((error = _udev_dict_set_int(dict, "mode", dev->si_perms)))
389 if ((error = _udev_dict_set_int(dict, "major", dev->si_umajor)))
391 if ((error = _udev_dict_set_int(dict, "minor", dev->si_uminor)))
393 if (dev->si_ops->head.name != NULL) {
394 if ((error = _udev_dict_set_cstr(dict, "driver",
395 __DECONST(char *, dev->si_ops->head.name))))
404 prop_object_release(dict);
409 udev_destroy_dict(cdev_t dev)
411 KKASSERT(dev != NULL);
413 if (dev->si_dict != NULL) {
414 prop_object_release(dev->si_dict);
422 udev_event_insert(int ev_type, prop_dictionary_t dict)
424 struct udev_event_kernel *ev;
425 prop_dictionary_t dict_copy;
427 /* Only start queing events after client has initiated properly */
428 if (udev_initiated_count) {
429 dict_copy = prop_dictionary_copy(dict);
430 if (dict_copy == NULL)
432 ev = objcache_get(udev_event_kernel_cache, M_WAITOK);
433 ev->ev.ev_dict = dict_copy;
434 ev->ev.ev_type = ev_type;
436 lockmgr(&udev_lk, LK_EXCLUSIVE);
437 TAILQ_INSERT_TAIL(&udev_evq, ev, link);
441 wakeup(&udev_seqwait);
442 lockmgr(&udev_lk, LK_RELEASE);
444 KNOTE(&udev_kq.ki_note, 0);
445 } else if (udev_open_count) {
446 lockmgr(&udev_lk, LK_EXCLUSIVE);
449 wakeup(&udev_seqwait);
450 lockmgr(&udev_lk, LK_RELEASE);
451 KNOTE(&udev_kq.ki_note, 0);
456 udev_clean_events_locked(void)
458 struct udev_event_kernel *ev;
460 while ((ev = TAILQ_FIRST(&udev_evq)) &&
461 ev->ev.ev_dict != NULL) {
462 TAILQ_REMOVE(&udev_evq, ev, link);
463 objcache_put(udev_event_kernel_cache, ev);
469 udev_event_externalize(struct udev_event_kernel *ev)
471 prop_dictionary_t dict;
475 dict = prop_dictionary_create();
478 "udev_event_externalize: prop_dictionary_create() failed\n");
482 if ((error = _udev_dict_set_int(dict, "evtype", ev->ev.ev_type))) {
483 prop_object_release(dict);
487 if (prop_dictionary_set(dict, "evdict", ev->ev.ev_dict) == false) {
488 prop_object_release(dict);
492 prop_object_release(ev->ev.ev_dict);
494 xml = prop_dictionary_externalize(dict);
496 prop_object_release(dict);
502 udev_event_attach(cdev_t dev, char *name, int alias)
504 prop_dictionary_t dict;
507 KKASSERT(dev != NULL);
512 dict = prop_dictionary_copy(dev->si_dict);
516 if ((error = _udev_dict_set_cstr(dict, "name", name))) {
517 prop_object_release(dict);
521 _udev_dict_set_int(dict, "alias", 1);
523 udev_event_insert(UDEV_EVENT_ATTACH, dict);
524 prop_object_release(dict);
526 error = udev_init_dict(dev);
530 _udev_dict_set_int(dev->si_dict, "alias", 0);
531 udev_event_insert(UDEV_EVENT_ATTACH, dev->si_dict);
539 udev_event_detach(cdev_t dev, char *name, int alias)
541 prop_dictionary_t dict;
543 KKASSERT(dev != NULL);
546 dict = prop_dictionary_copy(dev->si_dict);
550 if (_udev_dict_set_cstr(dict, "name", name)) {
551 prop_object_release(dict);
555 _udev_dict_set_int(dict, "alias", 1);
557 udev_event_insert(UDEV_EVENT_DETACH, dict);
558 prop_object_release(dict);
560 udev_event_insert(UDEV_EVENT_DETACH, dev->si_dict);
564 udev_destroy_dict(dev);
570 * Allow multiple opens. Each opener gets a different device.
571 * Messages are replicated to all devices using a marker system.
574 udev_dev_clone(struct dev_clone_args *ap)
576 struct udev_softc *softc;
579 unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(udev), 1000);
585 softc = kmalloc(sizeof(*softc), M_UDEV, M_WAITOK | M_ZERO);
587 lockmgr(&udev_lk, LK_EXCLUSIVE);
588 TAILQ_INSERT_TAIL(&udevq, softc, entry);
589 lockmgr(&udev_lk, LK_RELEASE);
591 softc->dev = make_only_dev(&udev_dev_ops, unit, ap->a_cred->cr_ruid,
592 0, 0600, "udev/%d", unit);
593 softc->dev->si_drv1 = softc;
594 ap->a_dev = softc->dev;
602 udev_dev_open(struct dev_open_args *ap)
604 struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
606 lockmgr(&udev_lk, LK_EXCLUSIVE);
607 if (softc == NULL || softc->opened) {
608 lockmgr(&udev_lk, LK_RELEASE);
613 lockmgr(&udev_lk, LK_RELEASE);
619 udev_dev_close(struct dev_close_args *ap)
621 struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
623 KKASSERT(softc->dev == ap->a_head.a_dev);
624 KKASSERT(softc->opened == 1);
626 lockmgr(&udev_lk, LK_EXCLUSIVE);
627 TAILQ_REMOVE(&udevq, softc, entry);
628 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(udev), softc->unit);
630 if (softc->initiated) {
631 TAILQ_REMOVE(&udev_evq, &softc->marker, link);
632 softc->initiated = 0;
633 --udev_initiated_count;
634 udev_clean_events_locked();
638 ap->a_head.a_dev->si_drv1 = NULL;
640 lockmgr(&udev_lk, LK_RELEASE);
642 destroy_dev(ap->a_head.a_dev);
645 kfree(softc, M_UDEV);
650 static struct filterops udev_dev_read_filtops =
651 { FILTEROP_ISFD | FILTEROP_MPSAFE, NULL,
652 udev_dev_filter_detach, udev_dev_filter_read };
655 udev_dev_kqfilter(struct dev_kqfilter_args *ap)
657 struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
658 struct knote *kn = ap->a_kn;
662 lockmgr(&udev_lk, LK_EXCLUSIVE);
664 switch (kn->kn_filter) {
666 kn->kn_fop = &udev_dev_read_filtops;
667 kn->kn_hook = (caddr_t)softc;
670 ap->a_result = EOPNOTSUPP;
671 lockmgr(&udev_lk, LK_RELEASE);
675 klist = &udev_kq.ki_note;
676 knote_insert(klist, kn);
678 lockmgr(&udev_lk, LK_RELEASE);
684 udev_dev_filter_detach(struct knote *kn)
688 lockmgr(&udev_lk, LK_EXCLUSIVE);
689 klist = &udev_kq.ki_note;
690 knote_remove(klist, kn);
691 lockmgr(&udev_lk, LK_RELEASE);
695 udev_dev_filter_read(struct knote *kn, long hint)
697 struct udev_softc *softc = (void *)kn->kn_hook;
698 struct udev_event_kernel *ev;
701 lockmgr(&udev_lk, LK_EXCLUSIVE);
702 if (softc->initiated) {
703 ev = TAILQ_NEXT(&softc->marker, link);
704 while (ev && ev->ev.ev_dict == NULL)
705 ev = TAILQ_NEXT(ev, link);
709 lockmgr(&udev_lk, LK_RELEASE);
715 udev_dev_read(struct dev_read_args *ap)
717 struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
718 struct udev_event_kernel *ev;
719 struct uio *uio = ap->a_uio;
724 lockmgr(&udev_lk, LK_EXCLUSIVE);
727 * Automatically enable message collection if it has not already
730 if (softc->initiated == 0) {
731 softc->initiated = 1;
732 ++udev_initiated_count;
733 TAILQ_INSERT_HEAD(&udev_evq, &softc->marker, link);
737 * Loop, sleep interruptably until we get an event or signal.
741 if (softc->initiated) {
742 ev = TAILQ_NEXT(&softc->marker, link);
743 while (ev && ev->ev.ev_dict == NULL)
744 ev = TAILQ_NEXT(ev, link);
746 if ((xml = udev_event_externalize(ev)) == NULL) {
750 len = strlen(xml) + 1; /* include terminator */
751 if (uio->uio_resid < len)
754 error = uiomove((caddr_t)xml, len, uio);
760 TAILQ_REMOVE(&udev_evq, &softc->marker, link);
761 TAILQ_INSERT_AFTER(&udev_evq,
762 ev, &softc->marker, link);
763 udev_clean_events_locked();
767 if (ap->a_ioflag & IO_NDELAY) {
771 if ((error = lksleep(&udev_evq, &udev_lk, PCATCH, "udevq", 0)))
775 lockmgr(&udev_lk, LK_RELEASE);
780 udev_dev_ioctl(struct dev_ioctl_args *ap)
782 struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
783 prop_dictionary_t dict;
786 struct plistref *pref;
794 /* Use proplib(3) for userspace/kernel communication */
795 pref = (struct plistref *)ap->a_data;
796 error = prop_dictionary_copyin_ioctl(pref, ap->a_cmd, &dict);
800 po = prop_dictionary_get(dict, "command");
801 if (po == NULL || prop_object_type(po) != PROP_TYPE_STRING) {
802 log(LOG_DEBUG, "udev: prop_dictionary_get() failed\n");
803 prop_object_release(dict);
809 for(i = 0; cmd_fn[i].cmd != NULL; i++) {
810 if (prop_string_equals_cstring(ps, cmd_fn[i].cmd))
814 if (cmd_fn[i].cmd != NULL) {
815 error = cmd_fn[i].fn(softc, pref, ap->a_cmd, dict);
820 //prop_object_release(po);
821 prop_object_release(dict);
825 * Wait for events based on sequence number. Updates
826 * sequence number for loop.
828 lockmgr(&udev_lk, LK_EXCLUSIVE);
829 seq = *(int *)ap->a_data;
831 while (seq == udev_seq) {
832 error = lksleep(&udev_seqwait, &udev_lk,
838 *(int *)ap->a_data = udev_seq;
839 lockmgr(&udev_lk, LK_RELEASE);
842 error = ENOTTY; /* Inappropriate ioctl for device */
850 udev_getdevs_scan_callback(char *name, cdev_t cdev, bool is_alias, void *arg)
852 struct udev_prop_ctx *ctx = arg;
854 KKASSERT(arg != NULL);
856 if (cdev->si_dict == NULL)
859 if (prop_array_add(ctx->cdevs, cdev->si_dict) == false) {
866 udev_getdevs_ioctl(struct udev_softc *softc, struct plistref *pref,
867 u_long cmd, prop_dictionary_t dict)
869 prop_dictionary_t odict;
870 struct udev_prop_ctx ctx;
874 * Ensure event notification is enabled before doing the devfs
875 * scan so nothing gets missed.
877 lockmgr(&udev_lk, LK_EXCLUSIVE);
878 if (softc->initiated == 0) {
879 softc->initiated = 1;
880 ++udev_initiated_count;
881 TAILQ_INSERT_HEAD(&udev_evq, &softc->marker, link);
883 lockmgr(&udev_lk, LK_RELEASE);
886 * Devfs scan to build full dictionary.
889 ctx.cdevs = prop_array_create();
890 if (ctx.cdevs == NULL) {
892 "udev_getdevs_ioctl: prop_array_create() failed\n");
896 devfs_scan_callback(udev_getdevs_scan_callback, &ctx);
898 if (ctx.error != 0) {
899 prop_object_release(ctx.cdevs);
903 odict = prop_dictionary_create();
908 if ((prop_dictionary_set(odict, "array", ctx.cdevs)) == 0) {
910 "udev_getdevs_ioctl: prop_dictionary_set failed\n");
911 prop_object_release(odict);
915 error = prop_dictionary_copyout_ioctl(pref, cmd, odict);
917 prop_object_release(odict);
928 lockinit(&udev_lk, "udevlk", 0, LK_CANRECURSE);
930 TAILQ_INIT(&udev_evq);
931 udev_event_kernel_cache = objcache_create_simple(M_UDEV, sizeof(struct udev_event_kernel));
937 objcache_destroy(udev_event_kernel_cache);
943 udev_dev = make_autoclone_dev(&udev_dev_ops, &DEVFS_CLONE_BITMAP(udev),
945 UID_ROOT, GID_WHEEL, 0600, "udev");
949 udev_dev_uninit(void)
951 destroy_dev(udev_dev);
954 SYSINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY,
956 SYSUNINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY,
958 SYSINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY,
959 udev_dev_init, NULL);
960 SYSUNINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY,
961 udev_dev_uninit, NULL);