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_DEFINE_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, "udevs/%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         destroy_dev(ap->a_head.a_dev);
 627         lockmgr(&udev_lk, LK_EXCLUSIVE);
 628         TAILQ_REMOVE(&udevq, softc, entry);
 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         /*
 643          * WARNING! devfs_clone_bitmap_put() interacts with the devfs
 644          *          thread, avoid deadlocks by ensuring we are unlocked
 645          *          before calling.
 646          */
 647         devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(udev), softc->unit);
 648         wakeup(&udev_evq);
 649
 650         kfree(softc, M_UDEV);
 651
 652         return 0;
 653 }
 654
 655 static struct filterops udev_dev_read_filtops =
 656         { FILTEROP_ISFD | FILTEROP_MPSAFE, NULL,
 657           udev_dev_filter_detach, udev_dev_filter_read };
 658
 659 static int
 660 udev_dev_kqfilter(struct dev_kqfilter_args *ap)
 661 {
 662         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
 663         struct knote *kn = ap->a_kn;
 664         struct klist *klist;
 665
 666         ap->a_result = 0;
 667         lockmgr(&udev_lk, LK_EXCLUSIVE);
 668
 669         switch (kn->kn_filter) {
 670         case EVFILT_READ:
 671                 kn->kn_fop = &udev_dev_read_filtops;
 672                 kn->kn_hook = (caddr_t)softc;
 673                 break;
 674         default:
 675                 ap->a_result = EOPNOTSUPP;
 676                 lockmgr(&udev_lk, LK_RELEASE);
 677                 return (0);
 678         }
 679
 680         klist = &udev_kq.ki_note;
 681         knote_insert(klist, kn);
 682
 683         lockmgr(&udev_lk, LK_RELEASE);
 684
 685         return (0);
 686 }
 687
 688 static void
 689 udev_dev_filter_detach(struct knote *kn)
 690 {
 691         struct klist *klist;
 692
 693         lockmgr(&udev_lk, LK_EXCLUSIVE);
 694         klist = &udev_kq.ki_note;
 695         knote_remove(klist, kn);
 696         lockmgr(&udev_lk, LK_RELEASE);
 697 }
 698
 699 static int
 700 udev_dev_filter_read(struct knote *kn, long hint)
 701 {
 702         struct udev_softc *softc = (void *)kn->kn_hook;
 703         struct udev_event_kernel *ev;
 704         int ready = 0;
 705
 706         lockmgr(&udev_lk, LK_EXCLUSIVE);
 707         if (softc->initiated) {
 708                 ev = TAILQ_NEXT(&softc->marker, link);
 709                 while (ev && ev->ev.ev_dict == NULL)
 710                         ev = TAILQ_NEXT(ev, link);
 711                 if (ev)
 712                         ready = 1;
 713         }
 714         lockmgr(&udev_lk, LK_RELEASE);
 715
 716         return (ready);
 717 }
 718
 719 static int
 720 udev_dev_read(struct dev_read_args *ap)
 721 {
 722         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
 723         struct udev_event_kernel *ev;
 724         struct uio *uio = ap->a_uio;
 725         char    *xml;
 726         size_t  len;
 727         int     error;
 728
 729         lockmgr(&udev_lk, LK_EXCLUSIVE);
 730
 731         /*
 732          * Automatically enable message collection if it has not already
 733          * been enabled.
 734          */
 735         if (softc->initiated == 0) {
 736                 softc->initiated = 1;
 737                 ++udev_initiated_count;
 738                 TAILQ_INSERT_HEAD(&udev_evq, &softc->marker, link);
 739         }
 740
 741         /*
 742          * Loop, sleep interruptably until we get an event or signal.
 743          */
 744         error = 0;
 745         for (;;) {
 746                 if (softc->initiated) {
 747                         ev = TAILQ_NEXT(&softc->marker, link);
 748                         while (ev && ev->ev.ev_dict == NULL)
 749                                 ev = TAILQ_NEXT(ev, link);
 750                         if (ev) {
 751                                 if ((xml = udev_event_externalize(ev)) == NULL) {
 752                                         error = ENOMEM;
 753                                         break;
 754                                 }
 755                                 len = strlen(xml) + 1; /* include terminator */
 756                                 if (uio->uio_resid < len)
 757                                         error = ENOMEM;
 758                                 else
 759                                         error = uiomove((caddr_t)xml, len, uio);
 760                                 kfree(xml, M_TEMP);
 761
 762                                 /*
 763                                  * Move the marker
 764                                  */
 765                                 TAILQ_REMOVE(&udev_evq, &softc->marker, link);
 766                                 TAILQ_INSERT_AFTER(&udev_evq,
 767                                                    ev, &softc->marker, link);
 768                                 udev_clean_events_locked();
 769                                 break;
 770                         }
 771                 }
 772                 if (ap->a_ioflag & IO_NDELAY) {
 773                         error = EWOULDBLOCK;
 774                         break;
 775                 }
 776                 if ((error = lksleep(&udev_evq, &udev_lk, PCATCH, "udevq", 0)))
 777                         break;
 778         }
 779
 780         lockmgr(&udev_lk, LK_RELEASE);
 781         return error;
 782 }
 783
 784 static int
 785 udev_dev_ioctl(struct dev_ioctl_args *ap)
 786 {
 787         struct udev_softc *softc = ap->a_head.a_dev->si_drv1;
 788         prop_dictionary_t dict;
 789         prop_object_t   po;
 790         prop_string_t   ps;
 791         struct plistref *pref;
 792         int i, error;
 793         int seq;
 794
 795         error = 0;
 796
 797         switch(ap->a_cmd) {
 798         case UDEVPROP:
 799                 /* Use proplib(3) for userspace/kernel communication */
 800                 pref = (struct plistref *)ap->a_data;
 801                 error = prop_dictionary_copyin_ioctl(pref, ap->a_cmd, &dict);
 802                 if (error)
 803                         return error;
 804
 805                 po = prop_dictionary_get(dict, "command");
 806                 if (po == NULL || prop_object_type(po) != PROP_TYPE_STRING) {
 807                         log(LOG_DEBUG, "udev: prop_dictionary_get() failed\n");
 808                         prop_object_release(dict);
 809                         return EINVAL;
 810                 }
 811
 812                 ps = po;
 813                 /* Handle cmd */
 814                 for(i = 0; cmd_fn[i].cmd != NULL; i++) {
 815                         if (prop_string_equals_cstring(ps, cmd_fn[i].cmd))
 816                                 break;
 817                 }
 818
 819                 if (cmd_fn[i].cmd != NULL) {
 820                         error = cmd_fn[i].fn(softc, pref, ap->a_cmd, dict);
 821                 } else {
 822                         error = EINVAL;
 823                 }
 824
 825                 //prop_object_release(po);
 826                 prop_object_release(dict);
 827                 break;
 828         case UDEVWAIT:
 829                 /*
 830                  * Wait for events based on sequence number.  Updates
 831                  * sequence number for loop.
 832                  */
 833                 lockmgr(&udev_lk, LK_EXCLUSIVE);
 834                 seq = *(int *)ap->a_data;
 835                 ++udev_seqwait;
 836                 while (seq == udev_seq) {
 837                         error = lksleep(&udev_seqwait, &udev_lk,
 838                                         PCATCH, "udevw", 0);
 839                         if (error)
 840                                 break;
 841                 }
 842                 --udev_seqwait;
 843                 *(int *)ap->a_data = udev_seq;
 844                 lockmgr(&udev_lk, LK_RELEASE);
 845                 break;
 846         default:
 847                 error = ENOTTY; /* Inappropriate ioctl for device */
 848                 break;
 849         }
 850
 851         return(error);
 852 }
 853
 854 static void
 855 udev_getdevs_scan_callback(char *name, cdev_t cdev, bool is_alias, void *arg)
 856 {
 857         struct udev_prop_ctx *ctx = arg;
 858
 859         KKASSERT(arg != NULL);
 860
 861         if (cdev->si_dict == NULL)
 862                 return;
 863
 864         if (prop_array_add(ctx->cdevs, cdev->si_dict) == false) {
 865                 ctx->error = EINVAL;
 866                 return;
 867         }
 868 }
 869
 870 static int
 871 udev_getdevs_ioctl(struct udev_softc *softc, struct plistref *pref,
 872                    u_long cmd, prop_dictionary_t dict)
 873 {
 874         prop_dictionary_t odict;
 875         struct udev_prop_ctx ctx;
 876         int error;
 877
 878         /*
 879          * Ensure event notification is enabled before doing the devfs
 880          * scan so nothing gets missed.
 881          */
 882         lockmgr(&udev_lk, LK_EXCLUSIVE);
 883         if (softc->initiated == 0) {
 884                 softc->initiated = 1;
 885                 ++udev_initiated_count;
 886                 TAILQ_INSERT_HEAD(&udev_evq, &softc->marker, link);
 887         }
 888         lockmgr(&udev_lk, LK_RELEASE);
 889
 890         /*
 891          * Devfs scan to build full dictionary.
 892          */
 893         ctx.error = 0;
 894         ctx.cdevs = prop_array_create();
 895         if (ctx.cdevs == NULL) {
 896                 log(LOG_DEBUG,
 897                     "udev_getdevs_ioctl: prop_array_create() failed\n");
 898                 return EINVAL;
 899         }
 900
 901         devfs_scan_callback(udev_getdevs_scan_callback, &ctx);
 902
 903         if (ctx.error != 0) {
 904                 prop_object_release(ctx.cdevs);
 905                 return (ctx.error);
 906         }
 907
 908         odict = prop_dictionary_create();
 909         if (odict == NULL) {
 910                 return ENOMEM;
 911         }
 912
 913         if ((prop_dictionary_set(odict, "array", ctx.cdevs)) == 0) {
 914                 log(LOG_DEBUG,
 915                     "udev_getdevs_ioctl: prop_dictionary_set failed\n");
 916                 prop_object_release(odict);
 917                 return ENOMEM;
 918         }
 919
 920         error = prop_dictionary_copyout_ioctl(pref, cmd, odict);
 921
 922         prop_object_release(odict);
 923         return error;
 924 }
 925
 926
 927 /*
 928  * SYSINIT stuff
 929  */
 930 static void
 931 udev_init(void)
 932 {
 933         lockinit(&udev_lk, "udevlk", 0, LK_CANRECURSE);
 934         TAILQ_INIT(&udevq);
 935         TAILQ_INIT(&udev_evq);
 936         udev_event_kernel_cache = objcache_create_simple(M_UDEV, sizeof(struct udev_event_kernel));
 937 }
 938
 939 static void
 940 udev_uninit(void)
 941 {
 942         objcache_destroy(udev_event_kernel_cache);
 943 }
 944
 945 static void
 946 udev_dev_init(void)
 947 {
 948         udev_dev = make_autoclone_dev(&udev_dev_ops, &DEVFS_CLONE_BITMAP(udev),
 949                                       udev_dev_clone,
 950                                       UID_ROOT, GID_WHEEL, 0600, "udev");
 951 }
 952
 953 static void
 954 udev_dev_uninit(void)
 955 {
 956         destroy_dev(udev_dev);
 957 }
 958
 959 SYSINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY,
 960         udev_init, NULL);
 961 SYSUNINIT(subr_udev_register, SI_SUB_CREATE_INIT, SI_ORDER_ANY,
 962         udev_uninit, NULL);
 963 SYSINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY,
 964         udev_dev_init, NULL);
 965 SYSUNINIT(subr_udev_dev_register, SI_SUB_DRIVERS, SI_ORDER_ANY,
 966         udev_dev_uninit, NULL);