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