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, D_KQFILTER },
 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, "kptr", kptr)))
 214                 goto error_out;
 215         if ((error = _udev_dict_set_cstr(dict, "key", __DECONST(char *, key))))
 216                 goto error_out;
 217
 218         return dict;
 219
 220 error_out:
 221         prop_object_release(dict);
 222         return NULL;
 223 }
 224
 225 int
 226 udev_dict_set_cstr(cdev_t dev, const char *key, char *str)
 227 {
 228         prop_dictionary_t       dict;
 229         int error;
 230
 231         KKASSERT(dev != NULL);
 232
 233         if (dev->si_dict == NULL) {
 234                 error = udev_init_dict(dev);
 235                 if (error)
 236                         return -1;
 237         }
 238
 239         /* Queue a key update event */
 240         dict = udev_init_dict_event(dev, key);
 241         if (dict == NULL)
 242                 return ENOMEM;
 243
 244         if ((error = _udev_dict_set_cstr(dict, "value", str))) {
 245                 prop_object_release(dict);
 246                 return error;
 247         }
 248         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
 249         prop_object_release(dict);
 250
 251         error = _udev_dict_set_cstr(dev->si_dict, key, str);
 252         return error;
 253 }
 254
 255 int
 256 udev_dict_set_int(cdev_t dev, const char *key, int64_t val)
 257 {
 258         prop_dictionary_t       dict;
 259         int error;
 260
 261         KKASSERT(dev != NULL);
 262
 263         if (dev->si_dict == NULL) {
 264                 error = udev_init_dict(dev);
 265                 if (error)
 266                         return -1;
 267         }
 268
 269         /* Queue a key update event */
 270         dict = udev_init_dict_event(dev, key);
 271         if (dict == NULL)
 272                 return ENOMEM;
 273         if ((error = _udev_dict_set_int(dict, "value", val))) {
 274                 prop_object_release(dict);
 275                 return error;
 276         }
 277         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
 278         prop_object_release(dict);
 279
 280         return _udev_dict_set_int(dev->si_dict, key, val);
 281 }
 282
 283 int
 284 udev_dict_set_uint(cdev_t dev, const char *key, uint64_t val)
 285 {
 286         prop_dictionary_t       dict;
 287         int error;
 288
 289         KKASSERT(dev != NULL);
 290
 291         if (dev->si_dict == NULL) {
 292                 error = udev_init_dict(dev);
 293                 if (error)
 294                         return -1;
 295         }
 296
 297         /* Queue a key update event */
 298         dict = udev_init_dict_event(dev, key);
 299         if (dict == NULL)
 300                 return ENOMEM;
 301         if ((error = _udev_dict_set_uint(dict, "value", val))) {
 302                 prop_object_release(dict);
 303                 return error;
 304         }
 305         udev_event_insert(UDEV_EV_KEY_UPDATE, dict);
 306         prop_object_release(dict);
 307
 308         return _udev_dict_set_uint(dev->si_dict, key, val);
 309 }
 310
 311 int
 312 udev_dict_delete_key(cdev_t dev, const char *key)
 313 {
 314         prop_dictionary_t       dict;
 315
 316         KKASSERT(dev != NULL);
 317
 318         /* Queue a key removal event */
 319         dict = udev_init_dict_event(dev, key);
 320         if (dict == NULL)
 321                 return ENOMEM;
 322         udev_event_insert(UDEV_EV_KEY_REMOVE, dict);
 323         prop_object_release(dict);
 324
 325         return _udev_dict_delete_key(dev->si_dict, key);
 326 }
 327
 328 static int
 329 udev_init_dict(cdev_t dev)
 330 {
 331         prop_dictionary_t dict;
 332         uint64_t        kptr;
 333         int error;
 334
 335         kptr = (uint64_t)(uintptr_t)dev;
 336
 337         KKASSERT(dev != NULL);
 338
 339         if (dev->si_dict != NULL) {
 340 #if 0
 341                 log(LOG_DEBUG,
 342                     "udev_init_dict: new dict for %s, but has dict already (%p)!\n",
 343                     dev->si_name, dev->si_dict);
 344 #endif
 345                 return 0;
 346         }
 347
 348         dict = prop_dictionary_create();
 349         if (dict == NULL) {
 350                 log(LOG_DEBUG, "udev_init_dict: prop_dictionary_create() failed\n");
 351                 return ENOMEM;
 352         }
 353
 354         if ((error = _udev_dict_set_cstr(dict, "name", dev->si_name)))
 355                 goto error_out;
 356         if ((error = _udev_dict_set_uint(dict, "devnum", dev->si_inode)))
 357                 goto error_out;
 358         if ((error = _udev_dict_set_uint(dict, "kptr", kptr)))
 359                 goto error_out;
 360
 361         /* XXX: The next 3 are marginallly useful, if at all */
 362         if ((error = _udev_dict_set_uint(dict, "uid", dev->si_uid)))
 363                 goto error_out;
 364         if ((error = _udev_dict_set_uint(dict, "gid", dev->si_gid)))
 365                 goto error_out;
 366         if ((error = _udev_dict_set_int(dict, "mode", dev->si_perms)))
 367                 goto error_out;
 368
 369         if ((error = _udev_dict_set_int(dict, "major", umajor(dev->si_inode))))
 370                 goto error_out;
 371         if ((error = _udev_dict_set_int(dict, "minor", dev->si_uminor)))
 372                 goto error_out;
 373         if (dev->si_ops->head.name != NULL) {
 374                 if ((error = _udev_dict_set_cstr(dict, "driver",
 375                     __DECONST(char *, dev->si_ops->head.name))))
 376                         goto error_out;
 377         }
 378
 379         dev->si_dict = dict;
 380         return 0;
 381
 382 error_out:
 383         dev->si_dict = NULL;
 384         prop_object_release(dict);
 385         return error;
 386 }
 387
 388 static int
 389 udev_destroy_dict(cdev_t dev)
 390 {
 391         KKASSERT(dev != NULL);
 392
 393         if (dev->si_dict != NULL) {
 394                 prop_object_release(dev->si_dict);
 395                 dev->si_dict = NULL;
 396         }
 397
 398         return 0;
 399 }
 400
 401 static void
 402 udev_event_insert(int ev_type, prop_dictionary_t dict)
 403 {
 404         struct udev_event_kernel *ev;
 405
 406         /* Only start queing events after client has initiated properly */
 407         if (!udevctx.initiated)
 408                 return;
 409
 410         /* XXX: use objcache eventually */
 411         ev = kmalloc(sizeof(*ev), M_UDEV, M_WAITOK);
 412         ev->ev.ev_dict = prop_dictionary_copy(dict);
 413         if (ev->ev.ev_dict == NULL) {
 414                 kfree(ev, M_UDEV);
 415                 return;
 416         }
 417         ev->ev.ev_type = ev_type;
 418
 419         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
 420         TAILQ_INSERT_TAIL(&udevctx.ev_queue, ev, link);
 421         ++udevctx.qlen;
 422         lockmgr(&udevctx.lock, LK_RELEASE);
 423
 424         wakeup(&udevctx);
 425         KNOTE(&udevctx.kq.ki_note, 0);
 426 }
 427
 428 static struct udev_event_kernel *
 429 udev_event_remove(void)
 430 {
 431         struct udev_event_kernel *ev;
 432
 433         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
 434         if (TAILQ_EMPTY(&udevctx.ev_queue)) {
 435                 lockmgr(&udevctx.lock, LK_RELEASE);
 436                 return NULL;
 437         }
 438
 439         ev = TAILQ_FIRST(&udevctx.ev_queue);
 440         TAILQ_REMOVE(&udevctx.ev_queue, ev, link);
 441         --udevctx.qlen;
 442         lockmgr(&udevctx.lock, LK_RELEASE);
 443
 444         return ev;
 445 }
 446
 447 static void
 448 udev_event_free(struct udev_event_kernel *ev)
 449 {
 450         /* XXX: use objcache eventually */
 451         kfree(ev, M_UDEV);
 452 }
 453
 454 static char *
 455 udev_event_externalize(struct udev_event_kernel *ev)
 456 {
 457         prop_dictionary_t       dict;
 458         char *xml;
 459         int error;
 460
 461
 462         dict = prop_dictionary_create();
 463         if (dict == NULL) {
 464                 log(LOG_DEBUG, "udev_event_externalize: prop_dictionary_create() failed\n");
 465                 return NULL;
 466         }
 467
 468         if ((error = _udev_dict_set_int(dict, "evtype", ev->ev.ev_type))) {
 469                 prop_object_release(dict);
 470                 return NULL;
 471         }
 472
 473         if (prop_dictionary_set(dict, "evdict", ev->ev.ev_dict) == false) {
 474                 prop_object_release(dict);
 475                 return NULL;
 476         }
 477
 478         prop_object_release(ev->ev.ev_dict);
 479
 480         xml = prop_dictionary_externalize(dict);
 481
 482         prop_object_release(dict);
 483
 484         return xml;
 485 }
 486
 487 int
 488 udev_event_attach(cdev_t dev, char *name, int alias)
 489 {
 490         prop_dictionary_t       dict;
 491         int error;
 492
 493         KKASSERT(dev != NULL);
 494
 495         error = ENOMEM;
 496
 497         if (alias) {
 498                 dict = prop_dictionary_copy(dev->si_dict);
 499                 if (dict == NULL)
 500                         goto error_out;
 501
 502                 if ((error = _udev_dict_set_cstr(dict, "name", name))) {
 503                         prop_object_release(dict);
 504                         goto error_out;
 505                 }
 506
 507                 _udev_dict_set_int(dict, "alias", 1);
 508
 509                 udev_event_insert(UDEV_EVENT_ATTACH, dict);
 510                 prop_object_release(dict);
 511         } else {
 512                 error = udev_init_dict(dev);
 513                 if (error)
 514                         goto error_out;
 515
 516                 _udev_dict_set_int(dev->si_dict, "alias", 0);
 517                 udev_event_insert(UDEV_EVENT_ATTACH, dev->si_dict);
 518         }
 519
 520 error_out:
 521         return error;
 522 }
 523
 524 int
 525 udev_event_detach(cdev_t dev, char *name, int alias)
 526 {
 527         prop_dictionary_t       dict;
 528
 529         KKASSERT(dev != NULL);
 530
 531         if (alias) {
 532                 dict = prop_dictionary_copy(dev->si_dict);
 533                 if (dict == NULL)
 534                         goto error_out;
 535
 536                 if (_udev_dict_set_cstr(dict, "name", name)) {
 537                         prop_object_release(dict);
 538                         goto error_out;
 539                 }
 540
 541                 _udev_dict_set_int(dict, "alias", 1);
 542
 543                 udev_event_insert(UDEV_EVENT_DETACH, dict);
 544                 prop_object_release(dict);
 545         } else {
 546                 udev_event_insert(UDEV_EVENT_DETACH, dev->si_dict);
 547         }
 548
 549 error_out:
 550         udev_destroy_dict(dev);
 551
 552         return 0;
 553 }
 554
 555 /*
 556  * dev stuff
 557  */
 558 static int
 559 udev_dev_open(struct dev_open_args *ap)
 560 {
 561         if (udevctx.opened)
 562                 return EBUSY;
 563
 564         udevctx.opened = 1;
 565
 566         return 0;
 567 }
 568
 569 static int
 570 udev_dev_close(struct dev_close_args *ap)
 571 {
 572         udevctx.opened = 0;
 573         udevctx.initiated = 0;
 574         wakeup(&udevctx);
 575
 576         return 0;
 577 }
 578
 579 static struct filterops udev_dev_read_filtops =
 580         { FILTEROP_ISFD, NULL, udev_dev_filter_detach, udev_dev_filter_read };
 581
 582 static int
 583 udev_dev_kqfilter(struct dev_kqfilter_args *ap)
 584 {
 585         struct knote *kn = ap->a_kn;
 586         struct klist *klist;
 587
 588         ap->a_result = 0;
 589         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
 590
 591         switch (kn->kn_filter) {
 592         case EVFILT_READ:
 593                 kn->kn_fop = &udev_dev_read_filtops;
 594                 break;
 595         default:
 596                 ap->a_result = EOPNOTSUPP;
 597                 lockmgr(&udevctx.lock, LK_RELEASE);
 598                 return (0);
 599         }
 600
 601         klist = &udevctx.kq.ki_note;
 602         knote_insert(klist, kn);
 603
 604         lockmgr(&udevctx.lock, LK_RELEASE);
 605
 606         return (0);
 607 }
 608
 609 static void
 610 udev_dev_filter_detach(struct knote *kn)
 611 {
 612         struct klist *klist;
 613
 614         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
 615         klist = &udevctx.kq.ki_note;
 616         knote_remove(klist, kn);
 617         lockmgr(&udevctx.lock, LK_RELEASE);
 618 }
 619
 620 static int
 621 udev_dev_filter_read(struct knote *kn, long hint)
 622 {
 623         int ready = 0;
 624
 625         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
 626         if (!TAILQ_EMPTY(&udevctx.ev_queue))
 627                 ready = 1;
 628         lockmgr(&udevctx.lock, LK_RELEASE);
 629
 630         return (ready);
 631 }
 632
 633 static int
 634 udev_dev_read(struct dev_read_args *ap)
 635 {
 636         struct udev_event_kernel *ev;
 637         struct uio *uio = ap->a_uio;
 638         char    *xml;
 639         size_t  len;
 640         int     error;
 641
 642
 643         lockmgr(&udevctx.lock, LK_EXCLUSIVE);
 644
 645         for (;;) {
 646                 if ((ev = udev_event_remove()) != NULL) {
 647                         if ((xml = udev_event_externalize(ev)) == NULL) {
 648                                 lockmgr(&udevctx.lock, LK_RELEASE);
 649                                 return ENOMEM;
 650                         }
 651
 652                         len = strlen(xml) + 1; /* account for NULL-termination */
 653                         if (uio->uio_resid < len) {
 654                                 error = ENOMEM;
 655                         } else {
 656                                 error = uiomove((caddr_t)xml, len, uio);
 657                         }
 658
 659                         kfree(xml, M_TEMP);
 660                         udev_event_free(ev);
 661                         lockmgr(&udevctx.lock, LK_RELEASE);
 662                         return error;
 663                 }
 664
 665                 if ((error = lksleep(&udevctx, &udevctx.lock, 0, "udevq", 0))) {
 666                         lockmgr(&udevctx.lock, LK_RELEASE);
 667                         return error;
 668                 }
 669         }
 670
 671         lockmgr(&udevctx.lock, LK_RELEASE);
 672
 673 }
 674
 675 static int
 676 udev_dev_ioctl(struct dev_ioctl_args *ap)
 677 {
 678         prop_dictionary_t dict;
 679         prop_object_t   po;
 680         prop_string_t   ps;
 681         struct plistref *pref;
 682         int i, error;
 683
 684         error = 0;
 685
 686         switch(ap->a_cmd) {
 687         case UDEVPROP:
 688                 /* Use proplib(3) for userspace/kernel communication */
 689                 pref = (struct plistref *)ap->a_data;
 690                 error = prop_dictionary_copyin_ioctl(pref, ap->a_cmd, &dict);
 691                 if (error)
 692                         return error;
 693
 694                 po = prop_dictionary_get(dict, "command");
 695                 if (po == NULL || prop_object_type(po) != PROP_TYPE_STRING) {
 696                         log(LOG_DEBUG, "udev: prop_dictionary_get() failed\n");
 697                         prop_object_release(dict);
 698                         return EINVAL;
 699                 }
 700
 701                 ps = po;
 702                 /* Handle cmd */
 703                 for(i = 0; cmd_fn[i].cmd != NULL; i++) {
 704                         if (prop_string_equals_cstring(ps, cmd_fn[i].cmd))
 705                                 break;
 706                 }
 707
 708                 if (cmd_fn[i].cmd != NULL) {
 709                         error = cmd_fn[i].fn(pref, ap->a_cmd, dict);
 710                 } else {
 711                         error = EINVAL;
 712                 }
 713
 714                 //prop_object_release(po);
 715                 prop_object_release(dict);
 716                 break;
 717         default:
 718                 error = ENOTTY; /* Inappropriate ioctl for device */
 719                 break;
 720         }
 721
 722         return(error);
 723 }
 724
 725 static void
 726 udev_getdevs_scan_callback(cdev_t cdev, void *arg)
 727 {
 728         struct udev_prop_ctx *ctx = arg;
 729
 730         KKASSERT(arg != NULL);
 731
 732         if (cdev->si_dict == NULL)
 733                 return;
 734
 735         if (prop_array_add(ctx->cdevs, cdev->si_dict) == false) {
 736                 ctx->error = EINVAL;
 737                 return;
 738         }
 739 }
 740
 741 static int
 742 udev_getdevs_ioctl(struct plistref *pref, u_long cmd, prop_dictionary_t dict)
 743 {
 744         prop_dictionary_t odict;
 745         struct udev_prop_ctx ctx;
 746         int error;
 747
 748         ctx.error = 0;
 749         ctx.cdevs = prop_array_create();
 750         if (ctx.cdevs == NULL) {
 751                 log(LOG_DEBUG, "udev_getdevs_ioctl: prop_array_create() failed\n");
 752                 return EINVAL;
 753         }
 754
 755         /* XXX: need devfs_scan_alias_callback() */
 756         devfs_scan_callback(udev_getdevs_scan_callback, &ctx);
 757
 758         if (ctx.error != 0) {
 759                 prop_object_release(ctx.cdevs);
 760                 return (ctx.error);
 761         }
 762         udevctx.initiated = 1;
 763
 764         odict = prop_dictionary_create();
 765         if (odict == NULL) {
 766                 return ENOMEM;
 767         }
 768
 769         if ((prop_dictionary_set(odict, "array", ctx.cdevs)) == 0) {
 770                 log(LOG_DEBUG, "udev_getdevs_ioctl: prop_dictionary_set failed\n");
 771                 prop_object_release(odict);
 772                 return ENOMEM;
 773         }
 774
 775         error = prop_dictionary_copyout_ioctl(pref, cmd, odict);
 776
 777         prop_object_release(odict);
 778         return error;
 779 }
 780
 781
 782 /*
 783  * SYSINIT stuff
 784  */
 785 static void
 786 udev_init(void)
 787 {
 788         lockinit(&udevctx.lock, "udevevq", 0, LK_CANRECURSE);
 789         TAILQ_INIT(&udevctx.ev_queue);
 790 }
 791
 792 static void
 793 udev_uninit(void)
 794 {
 795 }
 796
 797 static void
 798 udev_dev_init(void)
 799 {
 800         udev_dev = make_dev(&udev_dev_ops,
 801             0,
 802             UID_ROOT,
 803             GID_WHEEL,
 804             0600,
 805             "udev");
 806 }
 807
 808 static void
 809 udev_dev_uninit(void)
 810 {
 811         destroy_dev(udev_dev);
 812 }
 813
 814 SYSINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY, udev_init, NULL);
 815 SYSUNINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY, udev_uninit, NULL);
 816 SYSINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY, udev_dev_init, NULL);
 817 SYSUNINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY, udev_dev_uninit, NULL);