udev - use objcache for struct udev_event_kernel
[dragonfly.git] / sys / kern / kern_udev.c
1 /*
2  * Copyright (c) 2010 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Alex Hornung <ahornung@gmail.com>
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  *
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
16  *    distribution.
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.
20  *
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
32  * SUCH DAMAGE.
33  */
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/proc.h>
38 #include <sys/buf.h>
39 #include <sys/conf.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>
46 #include <sys/udev.h>
47 #include <sys/devfs.h>
48 #include <libprop/proplib.h>
49
50 #include <sys/thread2.h>
51
52 MALLOC_DEFINE(M_UDEV, "udev", "udev allocs");
53 static struct objcache *udev_event_kernel_cache;
54
55 /* XXX: use UUIDs for identification; would need help from devfs */
56
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;
64
65 struct udev_prop_ctx {
66         prop_array_t cdevs;
67         int error;
68 };
69
70 struct udev_event_kernel {
71         struct udev_event ev;
72         TAILQ_ENTRY(udev_event_kernel)  link;
73 };
74
75 struct udev_softc {
76         TAILQ_ENTRY(udev_softc) entry;
77         int opened;
78         int initiated;
79         int unit;
80         cdev_t dev;
81
82         struct udev_event_kernel marker;        /* udev_evq marker */
83 };
84
85 struct cmd_function {
86         const char *cmd;
87         int  (*fn)(struct udev_softc *, struct plistref *,
88                    u_long, prop_dictionary_t);
89 };
90
91
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);
107
108 static struct dev_ops udev_dev_ops = {
109         { "udev", 0, 0 },
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
115 };
116
117 static struct cmd_function cmd_fn[] = {
118                 { .cmd = "getdevs", .fn = udev_getdevs_ioctl},
119                 {NULL, NULL}
120 };
121
122 DEVFS_DECLARE_CLONE_BITMAP(udev);
123
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;
132 static int udev_seq;
133
134 static int
135 _udev_dict_set_cstr(prop_dictionary_t dict, const char *key, char *str)
136 {
137         prop_string_t   ps;
138
139         KKASSERT(dict != NULL);
140
141         ps = prop_string_create_cstring(str);
142         if (ps == NULL) {
143                 return ENOMEM;
144         }
145
146         if (prop_dictionary_set(dict, key, ps) == false) {
147                 prop_object_release(ps);
148                 return ENOMEM;
149         }
150
151         prop_object_release(ps);
152         return 0;
153 }
154
155 static int
156 _udev_dict_set_int(prop_dictionary_t dict, const char *key, int64_t val)
157 {
158         prop_number_t   pn;
159
160         KKASSERT(dict != NULL);
161
162         pn = prop_number_create_integer(val);
163         if (pn == NULL)
164                 return ENOMEM;
165
166         if (prop_dictionary_set(dict, key, pn) == false) {
167                 prop_object_release(pn);
168                 return ENOMEM;
169         }
170
171         prop_object_release(pn);
172         return 0;
173 }
174
175 static int
176 _udev_dict_set_uint(prop_dictionary_t dict, const char *key, uint64_t val)
177 {
178         prop_number_t   pn;
179
180         KKASSERT(dict != NULL);
181
182         pn = prop_number_create_unsigned_integer(val);
183         if (pn == NULL)
184                 return ENOMEM;
185
186         if (prop_dictionary_set(dict, key, pn) == false) {
187                 prop_object_release(pn);
188                 return ENOMEM;
189         }
190
191         prop_object_release(pn);
192         return 0;
193 }
194
195 static int
196 _udev_dict_delete_key(prop_dictionary_t dict, const char *key)
197 {
198         KKASSERT(dict != NULL);
199
200         prop_dictionary_remove(dict, key);
201
202         return 0;
203 }
204
205 /*
206  * Initialize an event dictionary, which contains three parameters to
207  * identify the device referred to (name, devnum, kptr) and the affected key.
208  */
209 static prop_dictionary_t
210 udev_init_dict_event(cdev_t dev, const char *key)
211 {
212         prop_dictionary_t       dict;
213         uint64_t        kptr;
214         int error;
215
216         kptr = (uint64_t)(uintptr_t)dev;
217         KKASSERT(dev != NULL);
218
219         dict = prop_dictionary_create();
220         if (dict == NULL) {
221                 log(LOG_DEBUG, "udev_init_dict_event: prop_dictionary_create() failed\n");
222                 return NULL;
223         }
224
225         if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
226                 goto error_out;
227         if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
228                 goto error_out;
229         if ((error = _udev_dict_set_uint(dict, "devtype", (dev_dflags(dev) & D_TYPEMASK))))
230                 goto error_out;
231         if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
232                 goto error_out;
233         if ((error = _udev_dict_set_cstr(dict, "key", __DECONST(char *, key))))
234                 goto error_out;
235
236         return dict;
237
238 error_out:
239         prop_object_release(dict);
240         return NULL;
241 }
242
243 int
244 udev_dict_set_cstr(cdev_t dev, const char *key, char *str)
245 {
246         prop_dictionary_t       dict;
247         int error;
248
249         KKASSERT(dev != NULL);
250
251         if (dev->si_dict == NULL) {
252                 error = udev_init_dict(dev);
253                 if (error)
254                         return -1;
255         }
256
257         /* Queue a key update event */
258         dict = udev_init_dict_event(dev, key);
259         if (dict == NULL)
260                 return ENOMEM;
261
262         if ((error = _udev_dict_set_cstr(dict, "value", str))) {
263                 prop_object_release(dict);
264                 return error;
265         }
266         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
267         prop_object_release(dict);
268
269         error = _udev_dict_set_cstr(dev->si_dict, key, str);
270         return error;
271 }
272
273 int
274 udev_dict_set_int(cdev_t dev, const char *key, int64_t val)
275 {
276         prop_dictionary_t       dict;
277         int error;
278
279         KKASSERT(dev != NULL);
280
281         if (dev->si_dict == NULL) {
282                 error = udev_init_dict(dev);
283                 if (error)
284                         return -1;
285         }
286
287         /* Queue a key update event */
288         dict = udev_init_dict_event(dev, key);
289         if (dict == NULL)
290                 return ENOMEM;
291         if ((error = _udev_dict_set_int(dict, "value", val))) {
292                 prop_object_release(dict);
293                 return error;
294         }
295         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
296         prop_object_release(dict);
297
298         return _udev_dict_set_int(dev->si_dict, key, val);
299 }
300
301 int
302 udev_dict_set_uint(cdev_t dev, const char *key, uint64_t val)
303 {
304         prop_dictionary_t       dict;
305         int error;
306
307         KKASSERT(dev != NULL);
308
309         if (dev->si_dict == NULL) {
310                 error = udev_init_dict(dev);
311                 if (error)
312                         return -1;
313         }
314
315         /* Queue a key update event */
316         dict = udev_init_dict_event(dev, key);
317         if (dict == NULL)
318                 return ENOMEM;
319         if ((error = _udev_dict_set_uint(dict, "value", val))) {
320                 prop_object_release(dict);
321                 return error;
322         }
323         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
324         prop_object_release(dict);
325
326         return _udev_dict_set_uint(dev->si_dict, key, val);
327 }
328
329 int
330 udev_dict_delete_key(cdev_t dev, const char *key)
331 {
332         prop_dictionary_t       dict;
333
334         KKASSERT(dev != NULL);
335
336         /* Queue a key removal event */
337         dict = udev_init_dict_event(dev, key);
338         if (dict == NULL)
339                 return ENOMEM;
340         udev_event_insert(UDEV_EV_KEY_REMOVE, dict);
341         prop_object_release(dict);
342
343         return _udev_dict_delete_key(dev->si_dict, key);
344 }
345
346 static int
347 udev_init_dict(cdev_t dev)
348 {
349         prop_dictionary_t dict;
350         uint64_t        kptr;
351         int error;
352
353         kptr = (uint64_t)(uintptr_t)dev;
354
355         KKASSERT(dev != NULL);
356
357         if (dev->si_dict != NULL) {
358 #if 0
359                 log(LOG_DEBUG,
360                     "udev_init_dict: new dict for %s, but has dict already (%p)!\n",
361                     dev->si_name, dev->si_dict);
362 #endif
363                 return 0;
364         }
365
366         dict = prop_dictionary_create();
367         if (dict == NULL) {
368                 log(LOG_DEBUG, "udev_init_dict: prop_dictionary_create() failed\n");
369                 return ENOMEM;
370         }
371
372         if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
373                 goto error_out;
374         if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
375                 goto error_out;
376         if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
377                 goto error_out;
378         if ((error = _udev_dict_set_uint(dict, "devtype", (dev_dflags(dev) & D_TYPEMASK))))
379                 goto error_out;
380
381         /* XXX: The next 3 are marginallly useful, if at all */
382         if ((error = _udev_dict_set_uint(dict, "uid", dev->si_uid)))
383                 goto error_out;
384         if ((error = _udev_dict_set_uint(dict, "gid", dev->si_gid)))
385                 goto error_out;
386         if ((error = _udev_dict_set_int(dict, "mode", dev->si_perms)))
387                 goto error_out;
388
389         if ((error = _udev_dict_set_int(dict, "major", dev->si_umajor)))
390                 goto error_out;
391         if ((error = _udev_dict_set_int(dict, "minor", dev->si_uminor)))
392                 goto error_out;
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))))
396                         goto error_out;
397         }
398
399         dev->si_dict = dict;
400         return 0;
401
402 error_out:
403         dev->si_dict = NULL;
404         prop_object_release(dict);
405         return error;
406 }
407
408 static int
409 udev_destroy_dict(cdev_t dev)
410 {
411         KKASSERT(dev != NULL);
412
413         if (dev->si_dict != NULL) {
414                 prop_object_release(dev->si_dict);
415                 dev->si_dict = NULL;
416         }
417
418         return 0;
419 }
420
421 static void
422 udev_event_insert(int ev_type, prop_dictionary_t dict)
423 {
424         struct udev_event_kernel *ev;
425         prop_dictionary_t dict_copy;
426
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)
431                         return;
432                 ev = objcache_get(udev_event_kernel_cache, M_WAITOK);
433                 ev->ev.ev_dict = dict_copy;
434                 ev->ev.ev_type = ev_type;
435
436                 lockmgr(&udev_lk, LK_EXCLUSIVE);
437                 TAILQ_INSERT_TAIL(&udev_evq, ev, link);
438                 ++udev_evqlen;
439                 ++udev_seq;
440                 if (udev_seqwait)
441                         wakeup(&udev_seqwait);
442                 lockmgr(&udev_lk, LK_RELEASE);
443                 wakeup(&udev_evq);
444                 KNOTE(&udev_kq.ki_note, 0);
445         } else if (udev_open_count) {
446                 lockmgr(&udev_lk, LK_EXCLUSIVE);
447                 ++udev_seq;
448                 if (udev_seqwait)
449                         wakeup(&udev_seqwait);
450                 lockmgr(&udev_lk, LK_RELEASE);
451                 KNOTE(&udev_kq.ki_note, 0);
452         }
453 }
454
455 static void
456 udev_clean_events_locked(void)
457 {
458         struct udev_event_kernel *ev;
459
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);
464                 --udev_evqlen;
465         }
466 }
467
468 static char *
469 udev_event_externalize(struct udev_event_kernel *ev)
470 {
471         prop_dictionary_t       dict;
472         char *xml;
473         int error;
474
475         dict = prop_dictionary_create();
476         if (dict == NULL) {
477                 log(LOG_DEBUG,
478                     "udev_event_externalize: prop_dictionary_create() failed\n");
479                 return NULL;
480         }
481
482         if ((error = _udev_dict_set_int(dict, "evtype", ev->ev.ev_type))) {
483                 prop_object_release(dict);
484                 return NULL;
485         }
486
487         if (prop_dictionary_set(dict, "evdict", ev->ev.ev_dict) == false) {
488                 prop_object_release(dict);
489                 return NULL;
490         }
491
492         prop_object_release(ev->ev.ev_dict);
493
494         xml = prop_dictionary_externalize(dict);
495
496         prop_object_release(dict);
497
498         return xml;
499 }
500
501 int
502 udev_event_attach(cdev_t dev, char *name, int alias)
503 {
504         prop_dictionary_t       dict;
505         int error;
506
507         KKASSERT(dev != NULL);
508
509         error = ENOMEM;
510
511         if (alias) {
512                 dict = prop_dictionary_copy(dev->si_dict);
513                 if (dict == NULL)
514                         goto error_out;
515
516                 if ((error = _udev_dict_set_cstr(dict, "name", name))) {
517                         prop_object_release(dict);
518                         goto error_out;
519                 }
520
521                 _udev_dict_set_int(dict, "alias", 1);
522
523                 udev_event_insert(UDEV_EVENT_ATTACH, dict);
524                 prop_object_release(dict);
525         } else {
526                 error = udev_init_dict(dev);
527                 if (error)
528                         goto error_out;
529
530                 _udev_dict_set_int(dev->si_dict, "alias", 0);
531                 udev_event_insert(UDEV_EVENT_ATTACH, dev->si_dict);
532         }
533
534 error_out:
535         return error;
536 }
537
538 int
539 udev_event_detach(cdev_t dev, char *name, int alias)
540 {
541         prop_dictionary_t       dict;
542
543         KKASSERT(dev != NULL);
544
545         if (alias) {
546                 dict = prop_dictionary_copy(dev->si_dict);
547                 if (dict == NULL)
548                         goto error_out;
549
550                 if (_udev_dict_set_cstr(dict, "name", name)) {
551                         prop_object_release(dict);
552                         goto error_out;
553                 }
554
555                 _udev_dict_set_int(dict, "alias", 1);
556
557                 udev_event_insert(UDEV_EVENT_DETACH, dict);
558                 prop_object_release(dict);
559         } else {
560                 udev_event_insert(UDEV_EVENT_DETACH, dev->si_dict);
561         }
562
563 error_out:
564         udev_destroy_dict(dev);
565
566         return 0;
567 }
568
569 /*
570  * Allow multiple opens.  Each opener gets a different device.
571  * Messages are replicated to all devices using a marker system.
572  */
573 static int
574 udev_dev_clone(struct dev_clone_args *ap)
575 {
576         struct udev_softc *softc;
577         int unit;
578
579         unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(udev), 1000);
580         if (unit < 0) {
581                 ap->a_dev = NULL;
582                 return 1;
583         }
584
585         softc = kmalloc(sizeof(*softc), M_UDEV, M_WAITOK | M_ZERO);
586         softc->unit = unit;
587         lockmgr(&udev_lk, LK_EXCLUSIVE);
588         TAILQ_INSERT_TAIL(&udevq, softc, entry);
589         lockmgr(&udev_lk, LK_RELEASE);
590
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;
595         return 0;
596 }
597
598 /*
599  * dev stuff
600  */
601 static int
602 udev_dev_open(struct dev_open_args *ap)
603 {
604         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
605
606         lockmgr(&udev_lk, LK_EXCLUSIVE);
607         if (softc == NULL || softc->opened) {
608                 lockmgr(&udev_lk, LK_RELEASE);
609                 return EBUSY;
610         }
611         softc->opened = 1;
612         ++udev_open_count;
613         lockmgr(&udev_lk, LK_RELEASE);
614
615         return 0;
616 }
617
618 static int
619 udev_dev_close(struct dev_close_args *ap)
620 {
621         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
622
623         KKASSERT(softc->dev == ap->a_head.a_dev);
624         KKASSERT(softc->opened == 1);
625
626         lockmgr(&udev_lk, LK_EXCLUSIVE);
627         TAILQ_REMOVE(&udevq, softc, entry);
628         devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(udev), softc->unit);
629
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();
635         }
636         softc->opened = 0;
637         softc->dev = NULL;
638         ap->a_head.a_dev->si_drv1 = NULL;
639         --udev_open_count;
640         lockmgr(&udev_lk, LK_RELEASE);
641
642         destroy_dev(ap->a_head.a_dev);
643         wakeup(&udev_evq);
644
645         kfree(softc, M_UDEV);
646
647         return 0;
648 }
649
650 static struct filterops udev_dev_read_filtops =
651         { FILTEROP_ISFD, NULL, udev_dev_filter_detach, udev_dev_filter_read };
652
653 static int
654 udev_dev_kqfilter(struct dev_kqfilter_args *ap)
655 {
656         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
657         struct knote *kn = ap->a_kn;
658         struct klist *klist;
659
660         ap->a_result = 0;
661         lockmgr(&udev_lk, LK_EXCLUSIVE);
662
663         switch (kn->kn_filter) {
664         case EVFILT_READ:
665                 kn->kn_fop = &udev_dev_read_filtops;
666                 kn->kn_hook = (caddr_t)softc;
667                 break;
668         default:
669                 ap->a_result = EOPNOTSUPP;
670                 lockmgr(&udev_lk, LK_RELEASE);
671                 return (0);
672         }
673
674         klist = &udev_kq.ki_note;
675         knote_insert(klist, kn);
676
677         lockmgr(&udev_lk, LK_RELEASE);
678
679         return (0);
680 }
681
682 static void
683 udev_dev_filter_detach(struct knote *kn)
684 {
685         struct klist *klist;
686
687         lockmgr(&udev_lk, LK_EXCLUSIVE);
688         klist = &udev_kq.ki_note;
689         knote_remove(klist, kn);
690         lockmgr(&udev_lk, LK_RELEASE);
691 }
692
693 static int
694 udev_dev_filter_read(struct knote *kn, long hint)
695 {
696         struct udev_softc *softc = (void *)kn->kn_hook;
697         struct udev_event_kernel *ev;
698         int ready = 0;
699
700         lockmgr(&udev_lk, LK_EXCLUSIVE);
701         if (softc->initiated) {
702                 ev = TAILQ_NEXT(&softc->marker, link);
703                 while (ev && ev->ev.ev_dict == NULL)
704                         ev = TAILQ_NEXT(ev, link);
705                 if (ev)
706                         ready = 1;
707         }
708         lockmgr(&udev_lk, LK_RELEASE);
709
710         return (ready);
711 }
712
713 static int
714 udev_dev_read(struct dev_read_args *ap)
715 {
716         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
717         struct udev_event_kernel *ev;
718         struct uio *uio = ap->a_uio;
719         char    *xml;
720         size_t  len;
721         int     error;
722
723         lockmgr(&udev_lk, LK_EXCLUSIVE);
724
725         /*
726          * Automatically enable message collection if it has not already
727          * been enabled.
728          */
729         if (softc->initiated == 0) {
730                 softc->initiated = 1;
731                 ++udev_initiated_count;
732                 TAILQ_INSERT_HEAD(&udev_evq, &softc->marker, link);
733         }
734
735         /*
736          * Loop, sleep interruptably until we get an event or signal.
737          */
738         error = 0;
739         for (;;) {
740                 if (softc->initiated) {
741                         ev = TAILQ_NEXT(&softc->marker, link);
742                         while (ev && ev->ev.ev_dict == NULL)
743                                 ev = TAILQ_NEXT(ev, link);
744                         if (ev) {
745                                 if ((xml = udev_event_externalize(ev)) == NULL) {
746                                         error = ENOMEM;
747                                         break;
748                                 }
749                                 len = strlen(xml) + 1; /* include terminator */
750                                 if (uio->uio_resid < len)
751                                         error = ENOMEM;
752                                 else
753                                         error = uiomove((caddr_t)xml, len, uio);
754                                 kfree(xml, M_TEMP);
755
756                                 /*
757                                  * Move the marker
758                                  */
759                                 TAILQ_REMOVE(&udev_evq, &softc->marker, link);
760                                 TAILQ_INSERT_AFTER(&udev_evq,
761                                                    ev, &softc->marker, link);
762                                 udev_clean_events_locked();
763                                 break;
764                         }
765                 }
766                 if (ap->a_ioflag & IO_NDELAY) {
767                         error = EWOULDBLOCK;
768                         break;
769                 }
770                 if ((error = lksleep(&udev_evq, &udev_lk, PCATCH, "udevq", 0)))
771                         break;
772         }
773
774         lockmgr(&udev_lk, LK_RELEASE);
775         return error;
776 }
777
778 static int
779 udev_dev_ioctl(struct dev_ioctl_args *ap)
780 {
781         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
782         prop_dictionary_t dict;
783         prop_object_t   po;
784         prop_string_t   ps;
785         struct plistref *pref;
786         int i, error;
787         int seq;
788
789         error = 0;
790
791         switch(ap->a_cmd) {
792         case UDEVPROP:
793                 /* Use proplib(3) for userspace/kernel communication */
794                 pref = (struct plistref *)ap->a_data;
795                 error = prop_dictionary_copyin_ioctl(pref, ap->a_cmd, &dict);
796                 if (error)
797                         return error;
798
799                 po = prop_dictionary_get(dict, "command");
800                 if (po == NULL || prop_object_type(po) != PROP_TYPE_STRING) {
801                         log(LOG_DEBUG, "udev: prop_dictionary_get() failed\n");
802                         prop_object_release(dict);
803                         return EINVAL;
804                 }
805
806                 ps = po;
807                 /* Handle cmd */
808                 for(i = 0; cmd_fn[i].cmd != NULL; i++) {
809                         if (prop_string_equals_cstring(ps, cmd_fn[i].cmd))
810                                 break;
811                 }
812
813                 if (cmd_fn[i].cmd != NULL) {
814                         error = cmd_fn[i].fn(softc, pref, ap->a_cmd, dict);
815                 } else {
816                         error = EINVAL;
817                 }
818
819                 //prop_object_release(po);
820                 prop_object_release(dict);
821                 break;
822         case UDEVWAIT:
823                 /*
824                  * Wait for events based on sequence number.  Updates
825                  * sequence number for loop.
826                  */
827                 lockmgr(&udev_lk, LK_EXCLUSIVE);
828                 seq = *(int *)ap->a_data;
829                 ++udev_seqwait;
830                 while (seq == udev_seq) {
831                         error = lksleep(&udev_seqwait, &udev_lk,
832                                         PCATCH, "udevw", 0);
833                         if (error)
834                                 break;
835                 }
836                 --udev_seqwait;
837                 *(int *)ap->a_data = udev_seq;
838                 lockmgr(&udev_lk, LK_RELEASE);
839                 break;
840         default:
841                 error = ENOTTY; /* Inappropriate ioctl for device */
842                 break;
843         }
844
845         return(error);
846 }
847
848 static void
849 udev_getdevs_scan_callback(char *name, cdev_t cdev, bool is_alias, void *arg)
850 {
851         struct udev_prop_ctx *ctx = arg;
852
853         KKASSERT(arg != NULL);
854
855         if (cdev->si_dict == NULL)
856                 return;
857
858         if (prop_array_add(ctx->cdevs, cdev->si_dict) == false) {
859                 ctx->error = EINVAL;
860                 return;
861         }
862 }
863
864 static int
865 udev_getdevs_ioctl(struct udev_softc *softc, struct plistref *pref,
866                    u_long cmd, prop_dictionary_t dict)
867 {
868         prop_dictionary_t odict;
869         struct udev_prop_ctx ctx;
870         int error;
871
872         /*
873          * Ensure event notification is enabled before doing the devfs
874          * scan so nothing gets missed.
875          */
876         lockmgr(&udev_lk, LK_EXCLUSIVE);
877         if (softc->initiated == 0) {
878                 softc->initiated = 1;
879                 ++udev_initiated_count;
880                 TAILQ_INSERT_HEAD(&udev_evq, &softc->marker, link);
881         }
882         lockmgr(&udev_lk, LK_RELEASE);
883
884         /*
885          * Devfs scan to build full dictionary.
886          */
887         ctx.error = 0;
888         ctx.cdevs = prop_array_create();
889         if (ctx.cdevs == NULL) {
890                 log(LOG_DEBUG,
891                     "udev_getdevs_ioctl: prop_array_create() failed\n");
892                 return EINVAL;
893         }
894
895         devfs_scan_callback(udev_getdevs_scan_callback, &ctx);
896
897         if (ctx.error != 0) {
898                 prop_object_release(ctx.cdevs);
899                 return (ctx.error);
900         }
901
902         odict = prop_dictionary_create();
903         if (odict == NULL) {
904                 return ENOMEM;
905         }
906
907         if ((prop_dictionary_set(odict, "array", ctx.cdevs)) == 0) {
908                 log(LOG_DEBUG,
909                     "udev_getdevs_ioctl: prop_dictionary_set failed\n");
910                 prop_object_release(odict);
911                 return ENOMEM;
912         }
913
914         error = prop_dictionary_copyout_ioctl(pref, cmd, odict);
915
916         prop_object_release(odict);
917         return error;
918 }
919
920
921 /*
922  * SYSINIT stuff
923  */
924 static void
925 udev_init(void)
926 {
927         lockinit(&udev_lk, "udevlk", 0, LK_CANRECURSE);
928         TAILQ_INIT(&udevq);
929         TAILQ_INIT(&udev_evq);
930         udev_event_kernel_cache = objcache_create_simple(M_UDEV, sizeof(struct udev_event_kernel));
931 }
932
933 static void
934 udev_uninit(void)
935 {
936         objcache_destroy(udev_event_kernel_cache);
937 }
938
939 static void
940 udev_dev_init(void)
941 {
942         udev_dev = make_autoclone_dev(&udev_dev_ops, &DEVFS_CLONE_BITMAP(udev),
943                                       udev_dev_clone,
944                                       UID_ROOT, GID_WHEEL, 0600, "udev");
945 }
946
947 static void
948 udev_dev_uninit(void)
949 {
950         destroy_dev(udev_dev);
951 }
952
953 SYSINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY,
954         udev_init, NULL);
955 SYSUNINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY,
956         udev_uninit, NULL);
957 SYSINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY,
958         udev_dev_init, NULL);
959 SYSUNINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY,
960         udev_dev_uninit, NULL);