Merge branch 'vendor/BINUTILS221'
[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/ioccom.h>
42 #include <sys/malloc.h>
43 #include <sys/ctype.h>
44 #include <sys/syslog.h>
45 #include <sys/udev.h>
46 #include <sys/devfs.h>
47 #include <libprop/proplib.h>
48
49 #include <sys/thread2.h>
50
51 MALLOC_DEFINE(M_UDEV, "udev", "udev allocs");
52
53 /* XXX: use UUIDs for identification; would need help from devfs */
54
55 static cdev_t           udev_dev;
56 static d_open_t         udev_dev_open;
57 static d_close_t        udev_dev_close;
58 static d_read_t         udev_dev_read;
59 static d_kqfilter_t     udev_dev_kqfilter;
60 static d_ioctl_t        udev_dev_ioctl;
61
62 static int _udev_dict_set_cstr(prop_dictionary_t, const char *, char *);
63 static int _udev_dict_set_int(prop_dictionary_t, const char *, int64_t);
64 static int _udev_dict_set_uint(prop_dictionary_t, const char *, uint64_t);
65 static int _udev_dict_delete_key(prop_dictionary_t, const char *);
66 static prop_dictionary_t udev_init_dict_event(cdev_t, const char *);
67 static int udev_init_dict(cdev_t);
68 static int udev_destroy_dict(cdev_t);
69 static void udev_event_insert(int, prop_dictionary_t);
70 static struct udev_event_kernel *udev_event_remove(void);
71 static void udev_event_free(struct udev_event_kernel *);
72 static char *udev_event_externalize(struct udev_event_kernel *);
73 static void udev_getdevs_scan_callback(cdev_t, void *);
74 static int udev_getdevs_ioctl(struct plistref *, u_long, prop_dictionary_t);
75 static void udev_dev_filter_detach(struct knote *);
76 static int udev_dev_filter_read(struct knote *, long);
77
78 struct cmd_function {
79         const char *cmd;
80         int  (*fn)(struct plistref *, u_long, prop_dictionary_t);
81 };
82
83 struct udev_prop_ctx {
84         prop_array_t cdevs;
85         int error;
86 };
87
88 struct udev_event_kernel {
89         struct udev_event ev;
90         TAILQ_ENTRY(udev_event_kernel)  link;
91 };
92
93 struct udev_softc {
94         int opened;
95         int initiated;
96
97         struct kqinfo kq;
98
99         int qlen;
100         struct lock lock;
101         TAILQ_HEAD(, udev_event_kernel) ev_queue;       /* list of thread_io */
102 } udevctx;
103
104 static struct dev_ops udev_dev_ops = {
105         { "udev", 0, 0 },
106         .d_open = udev_dev_open,
107         .d_close = udev_dev_close,
108         .d_read = udev_dev_read,
109         .d_kqfilter = udev_dev_kqfilter,
110         .d_ioctl = udev_dev_ioctl
111 };
112
113 static struct cmd_function cmd_fn[] = {
114                 { .cmd = "getdevs", .fn = udev_getdevs_ioctl},
115                 {NULL, NULL}
116 };
117
118 static int
119 _udev_dict_set_cstr(prop_dictionary_t dict, const char *key, char *str)
120 {
121         prop_string_t   ps;
122
123         KKASSERT(dict != NULL);
124
125         ps = prop_string_create_cstring(str);
126         if (ps == NULL) {
127                 return ENOMEM;
128         }
129
130         if (prop_dictionary_set(dict, key, ps) == false) {
131                 prop_object_release(ps);
132                 return ENOMEM;
133         }
134
135         prop_object_release(ps);
136         return 0;
137 }
138
139 static int
140 _udev_dict_set_int(prop_dictionary_t dict, const char *key, int64_t val)
141 {
142         prop_number_t   pn;
143
144         KKASSERT(dict != NULL);
145
146         pn = prop_number_create_integer(val);
147         if (pn == NULL)
148                 return ENOMEM;
149
150         if (prop_dictionary_set(dict, key, pn) == false) {
151                 prop_object_release(pn);
152                 return ENOMEM;
153         }
154
155         prop_object_release(pn);
156         return 0;
157 }
158
159 static int
160 _udev_dict_set_uint(prop_dictionary_t dict, const char *key, uint64_t val)
161 {
162         prop_number_t   pn;
163
164         KKASSERT(dict != NULL);
165
166         pn = prop_number_create_unsigned_integer(val);
167         if (pn == NULL)
168                 return ENOMEM;
169
170         if (prop_dictionary_set(dict, key, pn) == false) {
171                 prop_object_release(pn);
172                 return ENOMEM;
173         }
174
175         prop_object_release(pn);
176         return 0;
177 }
178
179 static int
180 _udev_dict_delete_key(prop_dictionary_t dict, const char *key)
181 {
182         KKASSERT(dict != NULL);
183
184         prop_dictionary_remove(dict, key);
185
186         return 0;
187 }
188
189 /*
190  * Initialize an event dictionary, which contains three parameters to
191  * identify the device referred to (name, devnum, kptr) and the affected key.
192  */
193 static prop_dictionary_t
194 udev_init_dict_event(cdev_t dev, const char *key)
195 {
196         prop_dictionary_t       dict;
197         uint64_t        kptr;
198         int error;
199
200         kptr = (uint64_t)(uintptr_t)dev;
201         KKASSERT(dev != NULL);
202
203         dict = prop_dictionary_create();
204         if (dict == NULL) {
205                 log(LOG_DEBUG, "udev_init_dict_event: prop_dictionary_create() failed\n");
206                 return NULL;
207         }
208
209         if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
210                 goto error_out;
211         if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
212                 goto error_out;
213         if ((error = _udev_dict_set_uint(dict, "devtype", (dev_dflags(dev) & D_TYPEMASK))))
214                 goto error_out;
215         if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
216                 goto error_out;
217         if ((error = _udev_dict_set_cstr(dict, "key", __DECONST(char *, key))))
218                 goto error_out;
219
220         return dict;
221
222 error_out:
223         prop_object_release(dict);
224         return NULL;
225 }
226
227 int
228 udev_dict_set_cstr(cdev_t dev, const char *key, char *str)
229 {
230         prop_dictionary_t       dict;
231         int error;
232
233         KKASSERT(dev != NULL);
234
235         if (dev->si_dict == NULL) {
236                 error = udev_init_dict(dev);
237                 if (error)
238                         return -1;
239         }
240
241         /* Queue a key update event */
242         dict = udev_init_dict_event(dev, key);
243         if (dict == NULL)
244                 return ENOMEM;
245
246         if ((error = _udev_dict_set_cstr(dict, "value", str))) {
247                 prop_object_release(dict);
248                 return error;
249         }
250         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
251         prop_object_release(dict);
252
253         error = _udev_dict_set_cstr(dev->si_dict, key, str);
254         return error;
255 }
256
257 int
258 udev_dict_set_int(cdev_t dev, const char *key, int64_t val)
259 {
260         prop_dictionary_t       dict;
261         int error;
262
263         KKASSERT(dev != NULL);
264
265         if (dev->si_dict == NULL) {
266                 error = udev_init_dict(dev);
267                 if (error)
268                         return -1;
269         }
270
271         /* Queue a key update event */
272         dict = udev_init_dict_event(dev, key);
273         if (dict == NULL)
274                 return ENOMEM;
275         if ((error = _udev_dict_set_int(dict, "value", val))) {
276                 prop_object_release(dict);
277                 return error;
278         }
279         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
280         prop_object_release(dict);
281
282         return _udev_dict_set_int(dev->si_dict, key, val);
283 }
284
285 int
286 udev_dict_set_uint(cdev_t dev, const char *key, uint64_t val)
287 {
288         prop_dictionary_t       dict;
289         int error;
290
291         KKASSERT(dev != NULL);
292
293         if (dev->si_dict == NULL) {
294                 error = udev_init_dict(dev);
295                 if (error)
296                         return -1;
297         }
298
299         /* Queue a key update event */
300         dict = udev_init_dict_event(dev, key);
301         if (dict == NULL)
302                 return ENOMEM;
303         if ((error = _udev_dict_set_uint(dict, "value", val))) {
304                 prop_object_release(dict);
305                 return error;
306         }
307         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
308         prop_object_release(dict);
309
310         return _udev_dict_set_uint(dev->si_dict, key, val);
311 }
312
313 int
314 udev_dict_delete_key(cdev_t dev, const char *key)
315 {
316         prop_dictionary_t       dict;
317
318         KKASSERT(dev != NULL);
319
320         /* Queue a key removal event */
321         dict = udev_init_dict_event(dev, key);
322         if (dict == NULL)
323                 return ENOMEM;
324         udev_event_insert(UDEV_EV_KEY_REMOVE, dict);
325         prop_object_release(dict);
326
327         return _udev_dict_delete_key(dev->si_dict, key);
328 }
329
330 static int
331 udev_init_dict(cdev_t dev)
332 {
333         prop_dictionary_t dict;
334         uint64_t        kptr;
335         int error;
336
337         kptr = (uint64_t)(uintptr_t)dev;
338
339         KKASSERT(dev != NULL);
340
341         if (dev->si_dict != NULL) {
342 #if 0
343                 log(LOG_DEBUG,
344                     "udev_init_dict: new dict for %s, but has dict already (%p)!\n",
345                     dev->si_name, dev->si_dict);
346 #endif
347                 return 0;
348         }
349
350         dict = prop_dictionary_create();
351         if (dict == NULL) {
352                 log(LOG_DEBUG, "udev_init_dict: prop_dictionary_create() failed\n");
353                 return ENOMEM;
354         }
355
356         if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
357                 goto error_out;
358         if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
359                 goto error_out;
360         if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
361                 goto error_out;
362         if ((error = _udev_dict_set_uint(dict, "devtype", (dev_dflags(dev) & D_TYPEMASK))))
363                 goto error_out;
364
365         /* XXX: The next 3 are marginallly useful, if at all */
366         if ((error = _udev_dict_set_uint(dict, "uid", dev->si_uid)))
367                 goto error_out;
368         if ((error = _udev_dict_set_uint(dict, "gid", dev->si_gid)))
369                 goto error_out;
370         if ((error = _udev_dict_set_int(dict, "mode", dev->si_perms)))
371                 goto error_out;
372
373         if ((error = _udev_dict_set_int(dict, "major", umajor(dev->si_inode))))
374                 goto error_out;
375         if ((error = _udev_dict_set_int(dict, "minor", dev->si_uminor)))
376                 goto error_out;
377         if (dev->si_ops->head.name != NULL) {
378                 if ((error = _udev_dict_set_cstr(dict, "driver",
379                     __DECONST(char *, dev->si_ops->head.name))))
380                         goto error_out;
381         }
382
383         dev->si_dict = dict;
384         return 0;
385
386 error_out:
387         dev->si_dict = NULL;
388         prop_object_release(dict);
389         return error;
390 }
391
392 static int
393 udev_destroy_dict(cdev_t dev)
394 {
395         KKASSERT(dev != NULL);
396
397         if (dev->si_dict != NULL) {
398                 prop_object_release(dev->si_dict);
399                 dev->si_dict = NULL;
400         }
401
402         return 0;
403 }
404
405 static void
406 udev_event_insert(int ev_type, prop_dictionary_t dict)
407 {
408         struct udev_event_kernel *ev;
409
410         /* Only start queing events after client has initiated properly */
411         if (!udevctx.initiated)
412                 return;
413
414         /* XXX: use objcache eventually */
415         ev = kmalloc(sizeof(*ev), M_UDEV, M_WAITOK);
416         ev->ev.ev_dict = prop_dictionary_copy(dict);
417         if (ev->ev.ev_dict == NULL) {
418                 kfree(ev, M_UDEV);
419                 return;
420         }
421         ev->ev.ev_type = ev_type;
422
423         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
424         TAILQ_INSERT_TAIL(&udevctx.ev_queue, ev, link);
425         ++udevctx.qlen;
426         lockmgr(&udevctx.lock, LK_RELEASE);
427
428         wakeup(&udevctx);
429         KNOTE(&udevctx.kq.ki_note, 0);
430 }
431
432 static struct udev_event_kernel *
433 udev_event_remove(void)
434 {
435         struct udev_event_kernel *ev;
436
437         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
438         if (TAILQ_EMPTY(&udevctx.ev_queue)) {
439                 lockmgr(&udevctx.lock, LK_RELEASE);
440                 return NULL;
441         }
442
443         ev = TAILQ_FIRST(&udevctx.ev_queue);
444         TAILQ_REMOVE(&udevctx.ev_queue, ev, link);
445         --udevctx.qlen;
446         lockmgr(&udevctx.lock, LK_RELEASE);
447
448         return ev;
449 }
450
451 static void
452 udev_event_free(struct udev_event_kernel *ev)
453 {
454         /* XXX: use objcache eventually */
455         kfree(ev, M_UDEV);
456 }
457
458 static char *
459 udev_event_externalize(struct udev_event_kernel *ev)
460 {
461         prop_dictionary_t       dict;
462         char *xml;
463         int error;
464
465
466         dict = prop_dictionary_create();
467         if (dict == NULL) {
468                 log(LOG_DEBUG, "udev_event_externalize: prop_dictionary_create() failed\n");
469                 return NULL;
470         }
471
472         if ((error = _udev_dict_set_int(dict, "evtype", ev->ev.ev_type))) {
473                 prop_object_release(dict);
474                 return NULL;
475         }
476
477         if (prop_dictionary_set(dict, "evdict", ev->ev.ev_dict) == false) {
478                 prop_object_release(dict);
479                 return NULL;
480         }
481
482         prop_object_release(ev->ev.ev_dict);
483
484         xml = prop_dictionary_externalize(dict);
485
486         prop_object_release(dict);
487
488         return xml;
489 }
490
491 int
492 udev_event_attach(cdev_t dev, char *name, int alias)
493 {
494         prop_dictionary_t       dict;
495         int error;
496
497         KKASSERT(dev != NULL);
498
499         error = ENOMEM;
500
501         if (alias) {
502                 dict = prop_dictionary_copy(dev->si_dict);
503                 if (dict == NULL)
504                         goto error_out;
505
506                 if ((error = _udev_dict_set_cstr(dict, "name", name))) {
507                         prop_object_release(dict);
508                         goto error_out;
509                 }
510
511                 _udev_dict_set_int(dict, "alias", 1);
512
513                 udev_event_insert(UDEV_EVENT_ATTACH, dict);
514                 prop_object_release(dict);
515         } else {
516                 error = udev_init_dict(dev);
517                 if (error)
518                         goto error_out;
519
520                 _udev_dict_set_int(dev->si_dict, "alias", 0);
521                 udev_event_insert(UDEV_EVENT_ATTACH, dev->si_dict);
522         }
523
524 error_out:
525         return error;
526 }
527
528 int
529 udev_event_detach(cdev_t dev, char *name, int alias)
530 {
531         prop_dictionary_t       dict;
532
533         KKASSERT(dev != NULL);
534
535         if (alias) {
536                 dict = prop_dictionary_copy(dev->si_dict);
537                 if (dict == NULL)
538                         goto error_out;
539
540                 if (_udev_dict_set_cstr(dict, "name", name)) {
541                         prop_object_release(dict);
542                         goto error_out;
543                 }
544
545                 _udev_dict_set_int(dict, "alias", 1);
546
547                 udev_event_insert(UDEV_EVENT_DETACH, dict);
548                 prop_object_release(dict);
549         } else {
550                 udev_event_insert(UDEV_EVENT_DETACH, dev->si_dict);
551         }
552
553 error_out:
554         udev_destroy_dict(dev);
555
556         return 0;
557 }
558
559 /*
560  * dev stuff
561  */
562 static int
563 udev_dev_open(struct dev_open_args *ap)
564 {
565         if (udevctx.opened)
566                 return EBUSY;
567
568         udevctx.opened = 1;
569
570         return 0;
571 }
572
573 static int
574 udev_dev_close(struct dev_close_args *ap)
575 {
576         udevctx.opened = 0;
577         udevctx.initiated = 0;
578         wakeup(&udevctx);
579
580         return 0;
581 }
582
583 static struct filterops udev_dev_read_filtops =
584         { FILTEROP_ISFD, NULL, udev_dev_filter_detach, udev_dev_filter_read };
585
586 static int
587 udev_dev_kqfilter(struct dev_kqfilter_args *ap)
588 {
589         struct knote *kn = ap->a_kn;
590         struct klist *klist;
591
592         ap->a_result = 0;
593         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
594
595         switch (kn->kn_filter) {
596         case EVFILT_READ:
597                 kn->kn_fop = &udev_dev_read_filtops;
598                 break;
599         default:
600                 ap->a_result = EOPNOTSUPP;
601                 lockmgr(&udevctx.lock, LK_RELEASE);
602                 return (0);
603         }
604
605         klist = &udevctx.kq.ki_note;
606         knote_insert(klist, kn);
607
608         lockmgr(&udevctx.lock, LK_RELEASE);
609
610         return (0);
611 }
612
613 static void
614 udev_dev_filter_detach(struct knote *kn)
615 {
616         struct klist *klist;
617
618         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
619         klist = &udevctx.kq.ki_note;
620         knote_remove(klist, kn);
621         lockmgr(&udevctx.lock, LK_RELEASE);
622 }
623
624 static int
625 udev_dev_filter_read(struct knote *kn, long hint)
626 {
627         int ready = 0;
628
629         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
630         if (!TAILQ_EMPTY(&udevctx.ev_queue))
631                 ready = 1;
632         lockmgr(&udevctx.lock, LK_RELEASE);
633
634         return (ready);
635 }
636
637 static int
638 udev_dev_read(struct dev_read_args *ap)
639 {
640         struct udev_event_kernel *ev;
641         struct uio *uio = ap->a_uio;
642         char    *xml;
643         size_t  len;
644         int     error;
645
646
647         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
648
649         for (;;) {
650                 if ((ev = udev_event_remove()) != NULL) {
651                         if ((xml = udev_event_externalize(ev)) == NULL) {
652                                 lockmgr(&udevctx.lock, LK_RELEASE);
653                                 return ENOMEM;
654                         }
655
656                         len = strlen(xml) + 1; /* account for NULL-termination */
657                         if (uio->uio_resid < len) {
658                                 error = ENOMEM;
659                         } else {
660                                 error = uiomove((caddr_t)xml, len, uio);
661                         }
662
663                         kfree(xml, M_TEMP);
664                         udev_event_free(ev);
665                         lockmgr(&udevctx.lock, LK_RELEASE);
666                         return error;
667                 }
668
669                 if ((error = lksleep(&udevctx, &udevctx.lock, 0, "udevq", 0))) {
670                         lockmgr(&udevctx.lock, LK_RELEASE);
671                         return error;
672                 }
673         }
674
675         lockmgr(&udevctx.lock, LK_RELEASE);
676
677 }
678
679 static int
680 udev_dev_ioctl(struct dev_ioctl_args *ap)
681 {
682         prop_dictionary_t dict;
683         prop_object_t   po;
684         prop_string_t   ps;
685         struct plistref *pref;
686         int i, error;
687
688         error = 0;
689
690         switch(ap->a_cmd) {
691         case UDEVPROP:
692                 /* Use proplib(3) for userspace/kernel communication */
693                 pref = (struct plistref *)ap->a_data;
694                 error = prop_dictionary_copyin_ioctl(pref, ap->a_cmd, &dict);
695                 if (error)
696                         return error;
697
698                 po = prop_dictionary_get(dict, "command");
699                 if (po == NULL || prop_object_type(po) != PROP_TYPE_STRING) {
700                         log(LOG_DEBUG, "udev: prop_dictionary_get() failed\n");
701                         prop_object_release(dict);
702                         return EINVAL;
703                 }
704
705                 ps = po;
706                 /* Handle cmd */
707                 for(i = 0; cmd_fn[i].cmd != NULL; i++) {
708                         if (prop_string_equals_cstring(ps, cmd_fn[i].cmd))
709                                 break;
710                 }
711
712                 if (cmd_fn[i].cmd != NULL) {
713                         error = cmd_fn[i].fn(pref, ap->a_cmd, dict);
714                 } else {
715                         error = EINVAL;
716                 }
717
718                 //prop_object_release(po);
719                 prop_object_release(dict);
720                 break;
721         default:
722                 error = ENOTTY; /* Inappropriate ioctl for device */
723                 break;
724         }
725
726         return(error);
727 }
728
729 static void
730 udev_getdevs_scan_callback(cdev_t cdev, void *arg)
731 {
732         struct udev_prop_ctx *ctx = arg;
733
734         KKASSERT(arg != NULL);
735
736         if (cdev->si_dict == NULL)
737                 return;
738
739         if (prop_array_add(ctx->cdevs, cdev->si_dict) == false) {
740                 ctx->error = EINVAL;
741                 return;
742         }
743 }
744
745 static int
746 udev_getdevs_ioctl(struct plistref *pref, u_long cmd, prop_dictionary_t dict)
747 {
748         prop_dictionary_t odict;
749         struct udev_prop_ctx ctx;
750         int error;
751
752         ctx.error = 0;
753         ctx.cdevs = prop_array_create();
754         if (ctx.cdevs == NULL) {
755                 log(LOG_DEBUG, "udev_getdevs_ioctl: prop_array_create() failed\n");
756                 return EINVAL;
757         }
758
759         /* XXX: need devfs_scan_alias_callback() */
760         devfs_scan_callback(udev_getdevs_scan_callback, &ctx);
761
762         if (ctx.error != 0) {
763                 prop_object_release(ctx.cdevs);
764                 return (ctx.error);
765         }
766         udevctx.initiated = 1;
767
768         odict = prop_dictionary_create();
769         if (odict == NULL) {
770                 return ENOMEM;
771         }
772
773         if ((prop_dictionary_set(odict, "array", ctx.cdevs)) == 0) {
774                 log(LOG_DEBUG, "udev_getdevs_ioctl: prop_dictionary_set failed\n");
775                 prop_object_release(odict);
776                 return ENOMEM;
777         }
778
779         error = prop_dictionary_copyout_ioctl(pref, cmd, odict);
780
781         prop_object_release(odict);
782         return error;
783 }
784
785
786 /*
787  * SYSINIT stuff
788  */
789 static void
790 udev_init(void)
791 {
792         lockinit(&udevctx.lock, "udevevq", 0, LK_CANRECURSE);
793         TAILQ_INIT(&udevctx.ev_queue);
794 }
795
796 static void
797 udev_uninit(void)
798 {
799 }
800
801 static void
802 udev_dev_init(void)
803 {
804         udev_dev = make_dev(&udev_dev_ops,
805             0,
806             UID_ROOT,
807             GID_WHEEL,
808             0600,
809             "udev");
810 }
811
812 static void
813 udev_dev_uninit(void)
814 {
815         destroy_dev(udev_dev);
816 }
817
818 SYSINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY, udev_init, NULL);
819 SYSUNINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY, udev_uninit, NULL);
820 SYSINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY, udev_dev_init, NULL);
821 SYSUNINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY, udev_dev_uninit, NULL);