1 /* $NetBSD: lua.c,v 1.8 2014/03/16 05:20:30 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 2011, 2013 by Marc Balmer <mbalmer@NetBSD.org>. 5 * All rights reserved. 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 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the Author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 /* Lua device driver */ 32 33 #include <sys/param.h> 34 #include <sys/fcntl.h> 35 #include <sys/conf.h> 36 #include <sys/condvar.h> 37 #include <sys/device.h> 38 #include <sys/ioctl.h> 39 #include <sys/kmem.h> 40 #include <sys/lock.h> 41 #include <sys/lua.h> 42 #include <sys/module.h> 43 #include <sys/mutex.h> 44 #include <sys/namei.h> 45 #include <sys/queue.h> 46 #include <sys/sysctl.h> 47 #include <sys/vnode.h> 48 49 #include <lauxlib.h> 50 51 #include "luavar.h" 52 53 struct lua_softc { 54 device_t sc_dev; 55 56 kmutex_t sc_lock; 57 kcondvar_t sc_inuse_cv; 58 bool sc_inuse; 59 60 /* Locking access to state queues */ 61 kmutex_t sc_state_lock; 62 kcondvar_t sc_state_cv; 63 bool sc_state; 64 65 struct sysctllog *sc_log; 66 }; 67 68 static device_t sc_self; 69 static bool lua_autoload_on = true; 70 static bool lua_require_on = true; 71 static bool lua_bytecode_on = false; 72 static int lua_verbose; 73 static int lua_max_instr; 74 75 static LIST_HEAD(, lua_state) lua_states; 76 static LIST_HEAD(, lua_module) lua_modules; 77 78 static int lua_match(device_t, cfdata_t, void *); 79 static void lua_attach(device_t, device_t, void *); 80 static int lua_detach(device_t, int); 81 static klua_State *klua_find(const char *); 82 static const char *lua_reader(lua_State *, void *, size_t *); 83 static void lua_maxcount(lua_State *, lua_Debug *); 84 85 static int lua_require(lua_State *); 86 87 CFATTACH_DECL_NEW(lua, sizeof(struct lua_softc), 88 lua_match, lua_attach, lua_detach, NULL); 89 90 dev_type_open(luaopen); 91 dev_type_close(luaclose); 92 dev_type_ioctl(luaioctl); 93 94 const struct cdevsw lua_cdevsw = { 95 .d_open = luaopen, 96 .d_close = luaclose, 97 .d_read = noread, 98 .d_write = nowrite, 99 .d_ioctl = luaioctl, 100 .d_stop = nostop, 101 .d_tty = notty, 102 .d_poll = nopoll, 103 .d_mmap = nommap, 104 .d_kqfilter = nokqfilter, 105 .d_flag = D_OTHER | D_MPSAFE 106 }; 107 108 struct lua_loadstate { 109 struct vnode *vp; 110 size_t size; 111 off_t off; 112 }; 113 114 extern struct cfdriver lua_cd; 115 116 static int 117 lua_match(device_t parent, cfdata_t match, void *aux) 118 { 119 return 1; 120 } 121 122 static void 123 lua_attach(device_t parent, device_t self, void *aux) 124 { 125 struct lua_softc *sc; 126 const struct sysctlnode *node; 127 128 if (sc_self) 129 return; 130 131 sc = device_private(self); 132 sc->sc_dev = self; 133 sc_self = self; 134 135 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_VM); 136 cv_init(&sc->sc_inuse_cv, "luactl"); 137 138 mutex_init(&sc->sc_state_lock, MUTEX_DEFAULT, IPL_VM); 139 cv_init(&sc->sc_state_cv, "luastate"); 140 141 pmf_device_register(self, NULL, NULL); 142 143 /* Sysctl to provide some control over behaviour */ 144 sysctl_createv(&sc->sc_log, 0, NULL, &node, 145 CTLFLAG_OWNDESC, 146 CTLTYPE_NODE, "lua", 147 SYSCTL_DESCR("Lua options"), 148 NULL, 0, NULL, 0, 149 CTL_KERN, CTL_CREATE, CTL_EOL); 150 151 if (node == NULL) { 152 printf(": can't create sysctl node\n"); 153 return; 154 } 155 156 /* 157 * XXX Some of the sysctl values must not be changed after the 158 * securelevel has been raised. 159 */ 160 sysctl_createv(&sc->sc_log, 0, &node, NULL, 161 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 162 CTLTYPE_BOOL, "require", 163 SYSCTL_DESCR("Enable the require command"), 164 NULL, 0, &lua_require_on, 0, 165 CTL_CREATE, CTL_EOL); 166 167 sysctl_createv(&sc->sc_log, 0, &node, NULL, 168 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 169 CTLTYPE_BOOL, "autoload", 170 SYSCTL_DESCR("Enable automatic load of modules"), 171 NULL, 0, &lua_autoload_on, 0, 172 CTL_CREATE, CTL_EOL); 173 174 sysctl_createv(&sc->sc_log, 0, &node, NULL, 175 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 176 CTLTYPE_BOOL, "bytecode", 177 SYSCTL_DESCR("Enable loading of bytecode"), 178 NULL, 0, &lua_bytecode_on, 0, 179 CTL_CREATE, CTL_EOL); 180 181 sysctl_createv(&sc->sc_log, 0, &node, NULL, 182 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 183 CTLTYPE_INT, "verbose", 184 SYSCTL_DESCR("Enable verbose output"), 185 NULL, 0, &lua_verbose, 0, 186 CTL_CREATE, CTL_EOL); 187 188 sysctl_createv(&sc->sc_log, 0, &node, NULL, 189 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 190 CTLTYPE_INT, "maxcount", 191 SYSCTL_DESCR("Limit maximum instruction count"), 192 NULL, 0, &lua_max_instr, 0, 193 CTL_CREATE, CTL_EOL); 194 195 aprint_normal_dev(self, "%s %s\n", LUA_RELEASE, LUA_COPYRIGHT); 196 } 197 198 static int 199 lua_detach(device_t self, int flags) 200 { 201 struct lua_softc *sc; 202 struct lua_state *s; 203 204 sc = device_private(self); 205 pmf_device_deregister(self); 206 207 if (sc->sc_log != NULL) { 208 sysctl_teardown(&sc->sc_log); 209 sc->sc_log = NULL; 210 } 211 212 /* Traverse the list of states and close them */ 213 while ((s = LIST_FIRST(&lua_states)) != NULL) { 214 LIST_REMOVE(s, lua_next); 215 klua_close(s->K); 216 if (lua_verbose) 217 device_printf(self, "state %s destroyed\n", 218 s->lua_name); 219 kmem_free(s, sizeof(struct lua_state)); 220 } 221 mutex_destroy(&sc->sc_lock); 222 cv_destroy(&sc->sc_inuse_cv); 223 mutex_destroy(&sc->sc_state_lock); 224 cv_destroy(&sc->sc_state_cv); 225 sc_self = NULL; 226 return 0; 227 } 228 229 int 230 luaopen(dev_t dev, int flag, int mode, struct lwp *l) 231 { 232 struct lua_softc *sc; 233 int error = 0; 234 235 if (minor(dev) > 0) 236 return ENXIO; 237 238 sc = device_lookup_private(&lua_cd, minor(dev)); 239 if (sc == NULL) 240 return ENXIO; 241 242 mutex_enter(&sc->sc_lock); 243 while (sc->sc_inuse == true) { 244 error = cv_wait_sig(&sc->sc_inuse_cv, &sc->sc_lock); 245 if (error) 246 break; 247 } 248 if (!error) 249 sc->sc_inuse = true; 250 mutex_exit(&sc->sc_lock); 251 252 if (error) 253 return error; 254 return 0; 255 } 256 257 int 258 luaclose(dev_t dev, int flag, int mode, struct lwp *l) 259 { 260 struct lua_softc *sc; 261 262 if (minor(dev) > 0) 263 return ENXIO; 264 sc = device_lookup_private(&lua_cd, minor(dev)); 265 mutex_enter(&sc->sc_lock); 266 sc->sc_inuse = false; 267 cv_signal(&sc->sc_inuse_cv); 268 mutex_exit(&sc->sc_lock); 269 return 0; 270 } 271 272 int 273 luaioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 274 { 275 struct lua_softc *sc; 276 struct lua_info *info; 277 struct lua_create *create; 278 struct lua_require *require; 279 struct lua_load *load; 280 struct lua_state *s; 281 struct lua_module *m; 282 kauth_cred_t cred; 283 struct nameidata nd; 284 struct pathbuf *pb; 285 struct vattr va; 286 struct lua_loadstate ls; 287 int error, n; 288 klua_State *K; 289 290 sc = device_lookup_private(&lua_cd, minor(dev)); 291 if (!device_is_active(sc->sc_dev)) 292 return EBUSY; 293 294 switch (cmd) { 295 case LUAINFO: 296 info = data; 297 if (info->states == NULL) { 298 info->num_states = 0; 299 LIST_FOREACH(s, &lua_states, lua_next) 300 info->num_states++; 301 } else { 302 n = 0; 303 LIST_FOREACH(s, &lua_states, lua_next) { 304 if (n > info->num_states) 305 break; 306 copyoutstr(s->lua_name, info->states[n].name, 307 MAX_LUA_NAME, NULL); 308 copyoutstr(s->lua_desc, info->states[n].desc, 309 MAX_LUA_DESC, NULL); 310 info->states[n].user = s->K->ks_user; 311 n++; 312 } 313 info->num_states = n; 314 } 315 break; 316 case LUACREATE: 317 create = data; 318 319 if (*create->name == '_') { 320 if (lua_verbose) 321 device_printf(sc->sc_dev, "names of user " 322 "created states must not begin with '_'"); 323 return ENXIO; 324 } 325 LIST_FOREACH(s, &lua_states, lua_next) 326 if (!strcmp(s->lua_name, create->name)) { 327 if (lua_verbose) 328 device_printf(sc->sc_dev, 329 "state %s exists\n", create->name); 330 return EBUSY; 331 } 332 333 K = klua_newstate(lua_alloc, NULL, create->name, 334 create->desc); 335 K->ks_user = true; 336 337 if (K == NULL) 338 return ENOMEM; 339 if (lua_verbose) 340 device_printf(sc->sc_dev, "state %s created\n", 341 create->name); 342 break; 343 case LUADESTROY: 344 create = data; 345 346 K = klua_find(create->name); 347 348 if (K != NULL && (K->ks_user == true)) { 349 klua_close(K); 350 return 0; 351 } 352 return EBUSY; 353 case LUAREQUIRE: /* 'require' a module in a State */ 354 require = data; 355 LIST_FOREACH(s, &lua_states, lua_next) 356 if (!strcmp(s->lua_name, require->state)) 357 LIST_FOREACH(m, &lua_modules, mod_next) 358 if (!strcmp(m->mod_name, 359 require->module)) { 360 if (lua_verbose) 361 device_printf( 362 sc->sc_dev, 363 "requiring module " 364 "%s to state %s\n", 365 m->mod_name, 366 s->lua_name); 367 m->open(s->K->L); 368 m->refcount++; 369 LIST_INSERT_HEAD( 370 &s->lua_modules, m, 371 mod_next); 372 return 0; 373 } 374 return ENXIO; 375 case LUALOAD: 376 load = data; 377 if (strrchr(load->path, '/') == NULL) 378 return ENXIO; 379 380 LIST_FOREACH(s, &lua_states, lua_next) 381 if (!strcmp(s->lua_name, load->state)) { 382 if (lua_verbose) 383 device_printf(sc->sc_dev, 384 "loading %s into state %s\n", 385 load->path, s->lua_name); 386 cred = kauth_cred_get(); 387 pb = pathbuf_create(load->path); 388 if (pb == NULL) 389 return ENOMEM; 390 NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, pb); 391 pathbuf_destroy(pb); 392 error = vn_open(&nd, FREAD, 0); 393 if (error) { 394 if (lua_verbose) 395 device_printf(sc->sc_dev, 396 "error vn_open %d\n", 397 error); 398 return error; 399 } 400 error = VOP_GETATTR(nd.ni_vp, &va, 401 kauth_cred_get()); 402 if (error) { 403 VOP_UNLOCK(nd.ni_vp); 404 vn_close(nd.ni_vp, FREAD, 405 kauth_cred_get()); 406 if (lua_verbose) 407 device_printf(sc->sc_dev, 408 "erro VOP_GETATTR %d\n", 409 error); 410 return error; 411 } 412 if (va.va_type != VREG) { 413 VOP_UNLOCK(nd.ni_vp); 414 vn_close(nd.ni_vp, FREAD, 415 kauth_cred_get()); 416 return EINVAL; 417 } 418 ls.vp = nd.ni_vp; 419 ls.off = 0L; 420 ls.size = va.va_size; 421 VOP_UNLOCK(nd.ni_vp); 422 error = lua_load(s->K->L, lua_reader, &ls, 423 strrchr(load->path, '/') + 1); 424 vn_close(nd.ni_vp, FREAD, cred); 425 switch (error) { 426 case 0: /* no error */ 427 break; 428 case LUA_ERRSYNTAX: 429 if (lua_verbose) 430 device_printf(sc->sc_dev, 431 "syntax error\n"); 432 return EINVAL; 433 case LUA_ERRMEM: 434 if (lua_verbose) 435 device_printf(sc->sc_dev, 436 "memory error\n"); 437 return ENOMEM; 438 default: 439 if (lua_verbose) 440 device_printf(sc->sc_dev, 441 "load error %d: %s\n", 442 error, 443 lua_tostring(s->K->L, -1)); 444 return EINVAL; 445 } 446 if (lua_max_instr > 0) 447 lua_sethook(s->K->L, lua_maxcount, 448 LUA_MASKCOUNT, lua_max_instr); 449 error = lua_pcall(s->K->L, 0, LUA_MULTRET, 0); 450 if (error) { 451 if (lua_verbose) { 452 device_printf(sc->sc_dev, 453 "execution error: %s\n", 454 lua_tostring(s->K->L, -1)); 455 } 456 return EINVAL; 457 } 458 return 0; 459 } 460 return ENXIO; 461 } 462 return 0; 463 } 464 465 static int 466 lua_require(lua_State *L) 467 { 468 struct lua_state *s; 469 struct lua_module *m, *md; 470 const char *module; 471 char name[MAXPATHLEN]; 472 473 module = lua_tostring(L, -1); 474 md = NULL; 475 LIST_FOREACH(m, &lua_modules, mod_next) 476 if (!strcmp(m->mod_name, module)) { 477 md = m; 478 break; 479 } 480 481 if (md == NULL && lua_autoload_on && strchr(module, '/') == NULL) { 482 snprintf(name, sizeof name, "lua%s", module); 483 if (lua_verbose) 484 device_printf(sc_self, "autoload %s\n", name); 485 module_autoload(name, MODULE_CLASS_MISC); 486 LIST_FOREACH(m, &lua_modules, mod_next) 487 if (!strcmp(m->mod_name, module)) { 488 md = m; 489 break; 490 } 491 } 492 493 if (md != NULL) 494 LIST_FOREACH(s, &lua_states, lua_next) 495 if (s->K->L == L) { 496 if (lua_verbose) 497 device_printf(sc_self, 498 "require module %s\n", 499 md->mod_name); 500 md->open(L); 501 md->refcount++; 502 LIST_INSERT_HEAD(&s->lua_modules, md, mod_next); 503 return 0; 504 } 505 506 lua_pushstring(L, "module not found"); 507 return lua_error(L); 508 } 509 510 void * 511 lua_alloc(void *ud, void *ptr, size_t osize, size_t nsize) 512 { 513 void *nptr; 514 515 if (nsize == 0) { 516 nptr = NULL; 517 if (ptr != NULL) 518 kmem_free(ptr, osize); 519 } else { 520 nptr = kmem_alloc(nsize, KM_SLEEP); 521 if (ptr != NULL) { 522 memcpy(nptr, ptr, osize < nsize ? osize : nsize); 523 kmem_free(ptr, osize); 524 } 525 } 526 return nptr; 527 } 528 529 static const char * 530 lua_reader(lua_State *L, void *data, size_t *size) 531 { 532 struct lua_loadstate *ls; 533 static char buf[1024]; 534 size_t rsiz; 535 536 ls = data; 537 if (ls->size < sizeof(buf)) 538 rsiz = ls->size; 539 else 540 rsiz = sizeof(buf); 541 vn_rdwr(UIO_READ, ls->vp, buf, rsiz, ls->off, UIO_SYSSPACE, 542 0, curlwp->l_cred, NULL, curlwp); 543 if (ls->off == 0L && lua_bytecode_on == false && buf[0] == 0x1b) { 544 *size = 0L; 545 lua_pushstring(L, "loading of bytecode is not allowed"); 546 lua_error(L); 547 return NULL; 548 } else { 549 *size = rsiz; 550 ls->off += *size; 551 ls->size -= *size; 552 } 553 return buf; 554 } 555 556 static void 557 lua_maxcount(lua_State *L, lua_Debug *d) 558 { 559 lua_pushstring(L, "maximum instruction count exceeded"); 560 lua_error(L); 561 } 562 563 int 564 lua_mod_register(const char *name, int (*open)(void *)) 565 { 566 struct lua_module *m; 567 568 LIST_FOREACH(m, &lua_modules, mod_next) 569 if (!strcmp(m->mod_name, name)) 570 return EBUSY; 571 m = kmem_zalloc(sizeof(struct lua_module), KM_SLEEP); 572 strlcpy(m->mod_name, name, LUA_MAX_MODNAME); 573 m->open = open; 574 m->refcount = 0; 575 LIST_INSERT_HEAD(&lua_modules, m, mod_next); 576 if (lua_verbose) 577 device_printf(sc_self, "registered lua module %s\n", name); 578 return 0; 579 } 580 581 int 582 lua_mod_unregister(const char *name) 583 { 584 struct lua_module *m; 585 586 LIST_FOREACH(m, &lua_modules, mod_next) 587 if (!strcmp(m->mod_name, name)) { 588 if (m->refcount == 0) { 589 LIST_REMOVE(m, mod_next); 590 kmem_free(m, sizeof(struct lua_module)); 591 if (lua_verbose) 592 device_printf(sc_self, 593 "unregistered lua module %s\n", 594 name); 595 return 0; 596 } else 597 return EBUSY; 598 } 599 return 0; 600 } 601 602 klua_State * 603 klua_newstate(lua_Alloc f, void *ud, const char *name, const char *desc) 604 { 605 klua_State *K; 606 struct lua_state *s; 607 struct lua_softc *sc; 608 int error = 0; 609 610 s = kmem_zalloc(sizeof(struct lua_state), KM_SLEEP); 611 sc = device_private(sc_self); 612 mutex_enter(&sc->sc_state_lock); 613 while (sc->sc_state == true) { 614 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 615 if (error) 616 break; 617 } 618 if (!error) 619 sc->sc_state = true; 620 mutex_exit(&sc->sc_state_lock); 621 622 if (error) 623 return NULL; 624 625 K = kmem_zalloc(sizeof(klua_State), KM_SLEEP); 626 K->L = lua_newstate(f, ud); 627 K->ks_user = false; 628 if (K->L == NULL) { 629 kmem_free(K, sizeof(klua_State)); 630 K = NULL; 631 goto finish; 632 } 633 634 strlcpy(s->lua_name, name, MAX_LUA_NAME); 635 strlcpy(s->lua_desc, desc, MAX_LUA_DESC); 636 s->K = K; 637 638 if (lua_require_on || lua_autoload_on) { 639 lua_pushcfunction(K->L, lua_require); 640 lua_setglobal(K->L, "require"); 641 } 642 LIST_INSERT_HEAD(&lua_states, s, lua_next); 643 644 mutex_init(&K->ks_lock, MUTEX_DEFAULT, IPL_VM); 645 cv_init(&K->ks_inuse_cv, "luainuse"); 646 647 finish: 648 mutex_enter(&sc->sc_state_lock); 649 sc->sc_state = false; 650 cv_signal(&sc->sc_state_cv); 651 mutex_exit(&sc->sc_state_lock); 652 return K; 653 } 654 655 void 656 klua_close(klua_State *K) 657 { 658 struct lua_state *s; 659 struct lua_softc *sc; 660 struct lua_module *m; 661 int error = 0; 662 663 /* Notify the Lua state that it is about to be closed */ 664 if (klua_lock(K)) 665 return; /* Nothing we can do about */ 666 667 lua_getglobal(K->L, "onClose"); 668 if (lua_isfunction(K->L, -1)) 669 lua_pcall(K->L, -1, 0, 0); 670 671 /* 672 * Don't unlock, make sure no one uses the state until it is destroyed 673 * klua_unlock(K); 674 */ 675 676 sc = device_private(sc_self); 677 mutex_enter(&sc->sc_state_lock); 678 while (sc->sc_state == true) { 679 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 680 if (error) 681 break; 682 } 683 if (!error) 684 sc->sc_state = true; 685 mutex_exit(&sc->sc_state_lock); 686 687 if (error) 688 return; /* Nothing we can do... */ 689 690 LIST_FOREACH(s, &lua_states, lua_next) 691 if (s->K == K) { 692 LIST_REMOVE(s, lua_next); 693 LIST_FOREACH(m, &s->lua_modules, mod_next) 694 m->refcount--; 695 kmem_free(s, sizeof(struct lua_state)); 696 } 697 698 lua_close(K->L); 699 cv_destroy(&K->ks_inuse_cv); 700 mutex_destroy(&K->ks_lock); 701 kmem_free(K, sizeof(klua_State)); 702 703 mutex_enter(&sc->sc_state_lock); 704 sc->sc_state = false; 705 cv_signal(&sc->sc_state_cv); 706 mutex_exit(&sc->sc_state_lock); 707 } 708 709 static klua_State * 710 klua_find(const char *name) 711 { 712 struct lua_state *s; 713 struct lua_softc *sc; 714 klua_State *K; 715 int error = 0; 716 717 K = NULL; 718 sc = device_private(sc_self); 719 mutex_enter(&sc->sc_state_lock); 720 while (sc->sc_state == true) { 721 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 722 if (error) 723 break; 724 } 725 if (!error) 726 sc->sc_state = true; 727 mutex_exit(&sc->sc_state_lock); 728 729 if (error) 730 return NULL; 731 732 LIST_FOREACH(s, &lua_states, lua_next) 733 if (!strcmp(s->lua_name, name)) { 734 K = s->K; 735 break; 736 } 737 738 mutex_enter(&sc->sc_state_lock); 739 sc->sc_state = false; 740 cv_signal(&sc->sc_state_cv); 741 mutex_exit(&sc->sc_state_lock); 742 return K; 743 } 744 745 int 746 klua_lock(klua_State *K) 747 { 748 int error; 749 750 error = 0; 751 mutex_enter(&K->ks_lock); 752 while (K->ks_inuse == true) { 753 error = cv_wait_sig(&K->ks_inuse_cv, &K->ks_lock); 754 if (error) 755 break; 756 } 757 if (!error) 758 K->ks_inuse = true; 759 mutex_exit(&K->ks_lock); 760 761 if (error) 762 return error; 763 return 0; 764 } 765 766 void 767 klua_unlock(klua_State *K) 768 { 769 mutex_enter(&K->ks_lock); 770 K->ks_inuse = false; 771 cv_signal(&K->ks_inuse_cv); 772 mutex_exit(&K->ks_lock); 773 } 774 775 MODULE(MODULE_CLASS_MISC, lua, NULL); 776 777 #ifdef _MODULE 778 static const struct cfiattrdata luabus_iattrdata = { 779 "luabus", 0, { { NULL, NULL, 0 },} 780 }; 781 static const struct cfiattrdata *const lua_attrs[] = { 782 &luabus_iattrdata, NULL 783 }; 784 CFDRIVER_DECL(lua, DV_DULL, lua_attrs); 785 extern struct cfattach lua_ca; 786 static int lualoc[] = { 787 -1, 788 -1, 789 -1 790 }; 791 static struct cfdata lua_cfdata[] = { 792 { 793 .cf_name = "lua", 794 .cf_atname = "lua", 795 .cf_unit = 0, 796 .cf_fstate = FSTATE_STAR, 797 .cf_loc = lualoc, 798 .cf_flags = 0, 799 .cf_pspec = NULL, 800 }, 801 { NULL, NULL, 0, FSTATE_NOTFOUND, NULL, 0, NULL } 802 }; 803 #endif 804 805 static int 806 lua_modcmd(modcmd_t cmd, void *opaque) 807 { 808 #ifdef _MODULE 809 devmajor_t cmajor, bmajor; 810 int error = 0; 811 812 cmajor = bmajor = NODEVMAJOR; 813 #endif 814 switch (cmd) { 815 case MODULE_CMD_INIT: 816 #ifdef _MODULE 817 error = config_cfdriver_attach(&lua_cd); 818 if (error) 819 return error; 820 821 error = config_cfattach_attach(lua_cd.cd_name, 822 &lua_ca); 823 if (error) { 824 config_cfdriver_detach(&lua_cd); 825 aprint_error("%s: unable to register cfattach\n", 826 lua_cd.cd_name); 827 return error; 828 } 829 error = config_cfdata_attach(lua_cfdata, 1); 830 if (error) { 831 config_cfattach_detach(lua_cd.cd_name, 832 &lua_ca); 833 config_cfdriver_detach(&lua_cd); 834 aprint_error("%s: unable to register cfdata\n", 835 lua_cd.cd_name); 836 return error; 837 } 838 error = devsw_attach(lua_cd.cd_name, NULL, &bmajor, 839 &lua_cdevsw, &cmajor); 840 if (error) { 841 aprint_error("%s: unable to register devsw\n", 842 lua_cd.cd_name); 843 config_cfattach_detach(lua_cd.cd_name, &lua_ca); 844 config_cfdriver_detach(&lua_cd); 845 return error; 846 } 847 config_attach_pseudo(lua_cfdata); 848 #endif 849 return 0; 850 case MODULE_CMD_FINI: 851 #ifdef _MODULE 852 error = config_cfdata_detach(lua_cfdata); 853 if (error) 854 return error; 855 856 config_cfattach_detach(lua_cd.cd_name, &lua_ca); 857 config_cfdriver_detach(&lua_cd); 858 devsw_detach(NULL, &lua_cdevsw); 859 #endif 860 return 0; 861 case MODULE_CMD_AUTOUNLOAD: 862 /* no auto-unload */ 863 return EBUSY; 864 default: 865 return ENOTTY; 866 } 867 } 868