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