1 /* $NetBSD: lua.c,v 1.19 2017/01/20 12:25:07 maya Exp $ */ 2 3 /* 4 * Copyright (c) 2014 by Lourival Vieira Neto <lneto@NetBSD.org>. 5 * Copyright (c) 2011 - 2014 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 if (!pmf_device_register(self, NULL, NULL)) 145 aprint_error_dev(self, "couldn't establish power handler\n"); 146 147 /* Sysctl to provide some control over behaviour */ 148 sysctl_createv(&sc->sc_log, 0, NULL, &node, 149 CTLFLAG_OWNDESC, 150 CTLTYPE_NODE, "lua", 151 SYSCTL_DESCR("Lua options"), 152 NULL, 0, NULL, 0, 153 CTL_KERN, CTL_CREATE, CTL_EOL); 154 155 if (node == NULL) { 156 aprint_error(": can't create sysctl node\n"); 157 return; 158 } 159 160 /* 161 * XXX Some of the sysctl values must not be changed after the 162 * securelevel has been raised. 163 */ 164 sysctl_createv(&sc->sc_log, 0, &node, NULL, 165 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 166 CTLTYPE_BOOL, "require", 167 SYSCTL_DESCR("Enable the require command"), 168 NULL, 0, &lua_require_on, 0, 169 CTL_CREATE, CTL_EOL); 170 171 sysctl_createv(&sc->sc_log, 0, &node, NULL, 172 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 173 CTLTYPE_BOOL, "autoload", 174 SYSCTL_DESCR("Enable automatic load of modules"), 175 NULL, 0, &lua_autoload_on, 0, 176 CTL_CREATE, CTL_EOL); 177 178 sysctl_createv(&sc->sc_log, 0, &node, NULL, 179 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 180 CTLTYPE_BOOL, "bytecode", 181 SYSCTL_DESCR("Enable loading of bytecode"), 182 NULL, 0, &lua_bytecode_on, 0, 183 CTL_CREATE, CTL_EOL); 184 185 sysctl_createv(&sc->sc_log, 0, &node, NULL, 186 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 187 CTLTYPE_INT, "verbose", 188 SYSCTL_DESCR("Enable verbose output"), 189 NULL, 0, &lua_verbose, 0, 190 CTL_CREATE, CTL_EOL); 191 192 sysctl_createv(&sc->sc_log, 0, &node, NULL, 193 CTLFLAG_READWRITE | CTLFLAG_OWNDESC, 194 CTLTYPE_INT, "maxcount", 195 SYSCTL_DESCR("Limit maximum instruction count"), 196 NULL, 0, &lua_max_instr, 0, 197 CTL_CREATE, CTL_EOL); 198 199 aprint_normal_dev(self, "%s\n", LUA_COPYRIGHT); 200 } 201 202 static int 203 lua_detach(device_t self, int flags) 204 { 205 struct lua_softc *sc; 206 struct lua_state *s; 207 208 sc = device_private(self); 209 pmf_device_deregister(self); 210 211 if (sc->sc_log != NULL) { 212 sysctl_teardown(&sc->sc_log); 213 sc->sc_log = NULL; 214 } 215 216 /* Traverse the list of states and close them */ 217 while ((s = LIST_FIRST(&lua_states)) != NULL) { 218 LIST_REMOVE(s, lua_next); 219 klua_close(s->K); 220 if (lua_verbose) 221 device_printf(self, "state %s destroyed\n", 222 s->lua_name); 223 kmem_free(s, sizeof(struct lua_state)); 224 } 225 mutex_destroy(&sc->sc_lock); 226 cv_destroy(&sc->sc_inuse_cv); 227 mutex_destroy(&sc->sc_state_lock); 228 cv_destroy(&sc->sc_state_cv); 229 sc_self = NULL; 230 return 0; 231 } 232 233 int 234 luaopen(dev_t dev, int flag, int mode, struct lwp *l) 235 { 236 struct lua_softc *sc; 237 int error = 0; 238 239 if (minor(dev) > 0) 240 return ENXIO; 241 242 sc = device_lookup_private(&lua_cd, minor(dev)); 243 if (sc == NULL) 244 return ENXIO; 245 246 mutex_enter(&sc->sc_lock); 247 while (sc->sc_inuse == true) { 248 error = cv_wait_sig(&sc->sc_inuse_cv, &sc->sc_lock); 249 if (error) 250 break; 251 } 252 if (!error) 253 sc->sc_inuse = true; 254 mutex_exit(&sc->sc_lock); 255 256 if (error) 257 return error; 258 return 0; 259 } 260 261 int 262 luaclose(dev_t dev, int flag, int mode, struct lwp *l) 263 { 264 struct lua_softc *sc; 265 266 if (minor(dev) > 0) 267 return ENXIO; 268 sc = device_lookup_private(&lua_cd, minor(dev)); 269 mutex_enter(&sc->sc_lock); 270 sc->sc_inuse = false; 271 cv_signal(&sc->sc_inuse_cv); 272 mutex_exit(&sc->sc_lock); 273 return 0; 274 } 275 276 int 277 luaioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 278 { 279 struct lua_softc *sc; 280 struct lua_info *info; 281 struct lua_create *create; 282 struct lua_require *require; 283 struct lua_load *load; 284 struct lua_state *s; 285 struct lua_module *m; 286 kauth_cred_t cred; 287 struct nameidata nd; 288 struct pathbuf *pb; 289 struct vattr va; 290 struct lua_loadstate ls; 291 int error, n; 292 klua_State *K; 293 294 sc = device_lookup_private(&lua_cd, minor(dev)); 295 if (!device_is_active(sc->sc_dev)) 296 return EBUSY; 297 298 switch (cmd) { 299 case LUAINFO: 300 info = data; 301 if (info->states == NULL) { 302 info->num_states = 0; 303 LIST_FOREACH(s, &lua_states, lua_next) 304 info->num_states++; 305 } else { 306 n = 0; 307 LIST_FOREACH(s, &lua_states, lua_next) { 308 if (n > info->num_states) 309 break; 310 copyoutstr(s->lua_name, info->states[n].name, 311 MAX_LUA_NAME, NULL); 312 copyoutstr(s->lua_desc, info->states[n].desc, 313 MAX_LUA_DESC, NULL); 314 info->states[n].user = s->K->ks_user; 315 n++; 316 } 317 info->num_states = n; 318 } 319 break; 320 case LUACREATE: 321 create = data; 322 323 if (*create->name == '_') { 324 if (lua_verbose) 325 device_printf(sc->sc_dev, "names of user " 326 "created states must not begin with '_'"); 327 return ENXIO; 328 } 329 LIST_FOREACH(s, &lua_states, lua_next) 330 if (!strcmp(s->lua_name, create->name)) { 331 if (lua_verbose) 332 device_printf(sc->sc_dev, 333 "state %s exists\n", create->name); 334 return EBUSY; 335 } 336 337 K = kluaL_newstate(create->name, create->desc, IPL_NONE); 338 K->ks_user = true; 339 340 if (K == NULL) 341 return ENOMEM; 342 if (lua_verbose) 343 device_printf(sc->sc_dev, "state %s created\n", 344 create->name); 345 break; 346 case LUADESTROY: 347 create = data; 348 349 K = klua_find(create->name); 350 351 if (K != NULL && (K->ks_user == true)) { 352 klua_close(K); 353 return 0; 354 } 355 return EBUSY; 356 case LUAREQUIRE: /* 'require' a module in a State */ 357 require = data; 358 LIST_FOREACH(s, &lua_states, lua_next) 359 if (!strcmp(s->lua_name, require->state)) { 360 LIST_FOREACH(m, &s->lua_modules, mod_next) 361 if (!strcmp(m->mod_name, require->module)) 362 return ENXIO; 363 LIST_FOREACH(m, &lua_modules, mod_next) 364 if (!strcmp(m->mod_name, 365 require->module)) { 366 if (lua_verbose) 367 device_printf( 368 sc->sc_dev, 369 "requiring module " 370 "%s to state %s\n", 371 m->mod_name, 372 s->lua_name); 373 klua_lock(s->K); 374 luaL_requiref( 375 s->K->L, 376 m->mod_name, 377 m->open, 378 1); 379 klua_unlock(s->K); 380 m->refcount++; 381 LIST_INSERT_HEAD( 382 &s->lua_modules, m, 383 mod_next); 384 return 0; 385 } 386 } 387 return ENXIO; 388 case LUALOAD: 389 load = data; 390 if (strrchr(load->path, '/') == NULL) 391 return ENXIO; 392 393 LIST_FOREACH(s, &lua_states, lua_next) 394 if (!strcmp(s->lua_name, load->state)) { 395 if (lua_verbose) 396 device_printf(sc->sc_dev, 397 "loading %s into state %s\n", 398 load->path, s->lua_name); 399 cred = kauth_cred_get(); 400 pb = pathbuf_create(load->path); 401 if (pb == NULL) 402 return ENOMEM; 403 NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, pb); 404 pathbuf_destroy(pb); 405 error = vn_open(&nd, FREAD, 0); 406 if (error) { 407 if (lua_verbose) 408 device_printf(sc->sc_dev, 409 "error vn_open %d\n", 410 error); 411 return error; 412 } 413 error = VOP_GETATTR(nd.ni_vp, &va, 414 kauth_cred_get()); 415 if (error) { 416 VOP_UNLOCK(nd.ni_vp); 417 vn_close(nd.ni_vp, FREAD, 418 kauth_cred_get()); 419 if (lua_verbose) 420 device_printf(sc->sc_dev, 421 "erro VOP_GETATTR %d\n", 422 error); 423 return error; 424 } 425 if (va.va_type != VREG) { 426 VOP_UNLOCK(nd.ni_vp); 427 vn_close(nd.ni_vp, FREAD, 428 kauth_cred_get()); 429 return EINVAL; 430 } 431 ls.vp = nd.ni_vp; 432 ls.off = 0L; 433 ls.size = va.va_size; 434 VOP_UNLOCK(nd.ni_vp); 435 klua_lock(s->K); 436 error = lua_load(s->K->L, lua_reader, &ls, 437 strrchr(load->path, '/') + 1, "bt"); 438 vn_close(nd.ni_vp, FREAD, cred); 439 switch (error) { 440 case 0: /* no error */ 441 break; 442 case LUA_ERRSYNTAX: 443 if (lua_verbose) 444 device_printf(sc->sc_dev, 445 "syntax error\n"); 446 klua_unlock(s->K); 447 return EINVAL; 448 case LUA_ERRMEM: 449 if (lua_verbose) 450 device_printf(sc->sc_dev, 451 "memory error\n"); 452 klua_unlock(s->K); 453 return ENOMEM; 454 default: 455 if (lua_verbose) 456 device_printf(sc->sc_dev, 457 "load error %d: %s\n", 458 error, 459 lua_tostring(s->K->L, -1)); 460 klua_unlock(s->K); 461 return EINVAL; 462 } 463 if (lua_max_instr > 0) 464 lua_sethook(s->K->L, lua_maxcount, 465 LUA_MASKCOUNT, lua_max_instr); 466 error = lua_pcall(s->K->L, 0, LUA_MULTRET, 0); 467 if (error) { 468 if (lua_verbose) { 469 device_printf(sc->sc_dev, 470 "execution error: %s\n", 471 lua_tostring(s->K->L, -1)); 472 } 473 klua_unlock(s->K); 474 return EINVAL; 475 } 476 klua_unlock(s->K); 477 return 0; 478 } 479 return ENXIO; 480 } 481 return 0; 482 } 483 484 static int 485 lua_require(lua_State *L) 486 { 487 struct lua_state *s; 488 struct lua_module *m, *md; 489 const char *module; 490 char name[MAXPATHLEN]; 491 492 module = lua_tostring(L, -1); 493 md = NULL; 494 LIST_FOREACH(m, &lua_modules, mod_next) 495 if (!strcmp(m->mod_name, module)) { 496 md = m; 497 break; 498 } 499 500 if (md == NULL && lua_autoload_on && strchr(module, '/') == NULL) { 501 snprintf(name, sizeof name, "lua%s", module); 502 if (lua_verbose) 503 device_printf(sc_self, "autoload %s\n", name); 504 module_autoload(name, MODULE_CLASS_MISC); 505 LIST_FOREACH(m, &lua_modules, mod_next) 506 if (!strcmp(m->mod_name, module)) { 507 md = m; 508 break; 509 } 510 } 511 512 if (md != NULL) 513 LIST_FOREACH(s, &lua_states, lua_next) 514 if (s->K->L == L) { 515 if (lua_verbose) 516 device_printf(sc_self, 517 "require module %s\n", 518 md->mod_name); 519 luaL_requiref(L, md->mod_name, md->open, 0); 520 521 md->refcount++; 522 LIST_INSERT_HEAD(&s->lua_modules, md, mod_next); 523 return 1; 524 } 525 526 lua_pushstring(L, "module not found"); 527 return lua_error(L); 528 } 529 530 typedef struct { 531 size_t size; 532 } __packed alloc_header_t; 533 534 static void * 535 lua_alloc(void *ud, void *ptr, size_t osize, size_t nsize) 536 { 537 void *nptr = NULL; 538 539 const size_t hdr_size = sizeof(alloc_header_t); 540 alloc_header_t *hdr = (alloc_header_t *) ((char *) ptr - hdr_size); 541 542 if (nsize == 0) { /* freeing */ 543 if (ptr != NULL) 544 kmem_intr_free(hdr, hdr->size); 545 } else if (ptr != NULL && nsize <= hdr->size - hdr_size) /* shrinking */ 546 return ptr; /* don't need to reallocate */ 547 else { /* creating or expanding */ 548 km_flag_t sleep = cpu_intr_p() || cpu_softintr_p() ? 549 KM_NOSLEEP : KM_SLEEP; 550 551 size_t alloc_size = nsize + hdr_size; 552 alloc_header_t *nhdr = kmem_intr_alloc(alloc_size, sleep); 553 if (nhdr == NULL) /* failed to allocate */ 554 return NULL; 555 556 nhdr->size = alloc_size; 557 nptr = (void *) ((char *) nhdr + hdr_size); 558 559 if (ptr != NULL) { /* expanding */ 560 memcpy(nptr, ptr, osize); 561 kmem_intr_free(hdr, hdr->size); 562 } 563 } 564 return nptr; 565 } 566 567 static const char * 568 lua_reader(lua_State *L, void *data, size_t *size) 569 { 570 struct lua_loadstate *ls; 571 static char buf[1024]; 572 size_t rsiz; 573 574 ls = data; 575 if (ls->size < sizeof(buf)) 576 rsiz = ls->size; 577 else 578 rsiz = sizeof(buf); 579 vn_rdwr(UIO_READ, ls->vp, buf, rsiz, ls->off, UIO_SYSSPACE, 580 0, curlwp->l_cred, NULL, curlwp); 581 if (ls->off == 0L && lua_bytecode_on == false && buf[0] == 0x1b) { 582 *size = 0L; 583 lua_pushstring(L, "loading of bytecode is not allowed"); 584 lua_error(L); 585 return NULL; 586 } else { 587 *size = rsiz; 588 ls->off += *size; 589 ls->size -= *size; 590 } 591 return buf; 592 } 593 594 static void 595 lua_maxcount(lua_State *L, lua_Debug *d) 596 { 597 lua_pushstring(L, "maximum instruction count exceeded"); 598 lua_error(L); 599 } 600 601 int 602 klua_mod_register(const char *name, lua_CFunction open) 603 { 604 struct lua_module *m; 605 606 LIST_FOREACH(m, &lua_modules, mod_next) 607 if (!strcmp(m->mod_name, name)) 608 return EBUSY; 609 m = kmem_zalloc(sizeof(struct lua_module), KM_SLEEP); 610 strlcpy(m->mod_name, name, LUA_MAX_MODNAME); 611 m->open = open; 612 m->refcount = 0; 613 LIST_INSERT_HEAD(&lua_modules, m, mod_next); 614 if (lua_verbose) 615 device_printf(sc_self, "registered lua module %s\n", name); 616 return 0; 617 } 618 619 int 620 klua_mod_unregister(const char *name) 621 { 622 struct lua_module *m; 623 624 LIST_FOREACH(m, &lua_modules, mod_next) 625 if (!strcmp(m->mod_name, name)) { 626 if (m->refcount == 0) { 627 LIST_REMOVE(m, mod_next); 628 kmem_free(m, sizeof(struct lua_module)); 629 if (lua_verbose) 630 device_printf(sc_self, 631 "unregistered lua module %s\n", 632 name); 633 return 0; 634 } else 635 return EBUSY; 636 } 637 return 0; 638 } 639 640 klua_State * 641 klua_newstate(lua_Alloc f, void *ud, const char *name, const char *desc, 642 int ipl) 643 { 644 klua_State *K; 645 struct lua_state *s; 646 struct lua_softc *sc; 647 int error = 0; 648 649 s = kmem_zalloc(sizeof(struct lua_state), KM_SLEEP); 650 sc = device_private(sc_self); 651 mutex_enter(&sc->sc_state_lock); 652 while (sc->sc_state == true) { 653 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 654 if (error) 655 break; 656 } 657 if (!error) 658 sc->sc_state = true; 659 mutex_exit(&sc->sc_state_lock); 660 661 if (error) { 662 kmem_free(s, sizeof(struct lua_state)); 663 return NULL; 664 } 665 666 K = kmem_zalloc(sizeof(klua_State), KM_SLEEP); 667 K->L = lua_newstate(f, ud); 668 K->ks_user = false; 669 if (K->L == NULL) { 670 kmem_free(K, sizeof(klua_State)); 671 K = NULL; 672 goto finish; 673 } 674 675 strlcpy(s->lua_name, name, MAX_LUA_NAME); 676 strlcpy(s->lua_desc, desc, MAX_LUA_DESC); 677 s->K = K; 678 679 if (lua_require_on || lua_autoload_on) { 680 lua_pushcfunction(K->L, lua_require); 681 lua_setglobal(K->L, "require"); 682 } 683 LIST_INSERT_HEAD(&lua_states, s, lua_next); 684 685 mutex_init(&K->ks_lock, MUTEX_DEFAULT, ipl); 686 687 finish: 688 mutex_enter(&sc->sc_state_lock); 689 sc->sc_state = false; 690 cv_signal(&sc->sc_state_cv); 691 mutex_exit(&sc->sc_state_lock); 692 return K; 693 } 694 695 inline klua_State * 696 kluaL_newstate(const char *name, const char *desc, int ipl) 697 { 698 return klua_newstate(lua_alloc, NULL, name, desc, ipl); 699 } 700 701 void 702 klua_close(klua_State *K) 703 { 704 struct lua_state *s; 705 struct lua_softc *sc; 706 struct lua_module *m; 707 int error = 0; 708 709 /* XXX consider registering a handler instead of a fixed name. */ 710 lua_getglobal(K->L, "onClose"); 711 if (lua_isfunction(K->L, -1)) 712 lua_pcall(K->L, -1, 0, 0); 713 714 sc = device_private(sc_self); 715 mutex_enter(&sc->sc_state_lock); 716 while (sc->sc_state == true) { 717 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 718 if (error) 719 break; 720 } 721 if (!error) 722 sc->sc_state = true; 723 mutex_exit(&sc->sc_state_lock); 724 725 if (error) 726 return; /* Nothing we can do... */ 727 728 LIST_FOREACH(s, &lua_states, lua_next) 729 if (s->K == K) { 730 LIST_REMOVE(s, lua_next); 731 LIST_FOREACH(m, &s->lua_modules, mod_next) 732 m->refcount--; 733 kmem_free(s, sizeof(struct lua_state)); 734 } 735 736 lua_close(K->L); 737 mutex_destroy(&K->ks_lock); 738 kmem_free(K, sizeof(klua_State)); 739 740 mutex_enter(&sc->sc_state_lock); 741 sc->sc_state = false; 742 cv_signal(&sc->sc_state_cv); 743 mutex_exit(&sc->sc_state_lock); 744 } 745 746 static klua_State * 747 klua_find(const char *name) 748 { 749 struct lua_state *s; 750 struct lua_softc *sc; 751 klua_State *K; 752 int error = 0; 753 754 K = NULL; 755 sc = device_private(sc_self); 756 mutex_enter(&sc->sc_state_lock); 757 while (sc->sc_state == true) { 758 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 759 if (error) 760 break; 761 } 762 if (!error) 763 sc->sc_state = true; 764 mutex_exit(&sc->sc_state_lock); 765 766 if (error) 767 return NULL; 768 769 LIST_FOREACH(s, &lua_states, lua_next) 770 if (!strcmp(s->lua_name, name)) { 771 K = s->K; 772 break; 773 } 774 775 mutex_enter(&sc->sc_state_lock); 776 sc->sc_state = false; 777 cv_signal(&sc->sc_state_cv); 778 mutex_exit(&sc->sc_state_lock); 779 return K; 780 } 781 782 inline void 783 klua_lock(klua_State *K) 784 { 785 mutex_enter(&K->ks_lock); 786 } 787 788 inline void 789 klua_unlock(klua_State *K) 790 { 791 mutex_exit(&K->ks_lock); 792 } 793 794 MODULE(MODULE_CLASS_MISC, lua, NULL); 795 796 #ifdef _MODULE 797 static const struct cfiattrdata luabus_iattrdata = { 798 "luabus", 0, { { NULL, NULL, 0 },} 799 }; 800 801 static const struct cfiattrdata *const lua_attrs[] = { 802 &luabus_iattrdata, NULL 803 }; 804 805 CFDRIVER_DECL(lua, DV_DULL, lua_attrs); 806 extern struct cfattach lua_ca; 807 static int lualoc[] = { 808 -1, 809 -1, 810 -1 811 }; 812 813 static struct cfdata lua_cfdata[] = { 814 { 815 .cf_name = "lua", 816 .cf_atname = "lua", 817 .cf_unit = 0, 818 .cf_fstate = FSTATE_STAR, 819 .cf_loc = lualoc, 820 .cf_flags = 0, 821 .cf_pspec = NULL, 822 }, 823 { NULL, NULL, 0, FSTATE_NOTFOUND, NULL, 0, NULL } 824 }; 825 #endif 826 827 static int 828 lua_modcmd(modcmd_t cmd, void *opaque) 829 { 830 #ifdef _MODULE 831 devmajor_t cmajor, bmajor; 832 int error = 0; 833 834 cmajor = bmajor = NODEVMAJOR; 835 #endif 836 switch (cmd) { 837 case MODULE_CMD_INIT: 838 #ifdef _MODULE 839 error = config_cfdriver_attach(&lua_cd); 840 if (error) 841 return error; 842 843 error = config_cfattach_attach(lua_cd.cd_name, 844 &lua_ca); 845 if (error) { 846 config_cfdriver_detach(&lua_cd); 847 aprint_error("%s: unable to register cfattach\n", 848 lua_cd.cd_name); 849 return error; 850 } 851 error = config_cfdata_attach(lua_cfdata, 1); 852 if (error) { 853 config_cfattach_detach(lua_cd.cd_name, 854 &lua_ca); 855 config_cfdriver_detach(&lua_cd); 856 aprint_error("%s: unable to register cfdata\n", 857 lua_cd.cd_name); 858 return error; 859 } 860 error = devsw_attach(lua_cd.cd_name, NULL, &bmajor, 861 &lua_cdevsw, &cmajor); 862 if (error) { 863 aprint_error("%s: unable to register devsw\n", 864 lua_cd.cd_name); 865 config_cfattach_detach(lua_cd.cd_name, &lua_ca); 866 config_cfdriver_detach(&lua_cd); 867 return error; 868 } 869 config_attach_pseudo(lua_cfdata); 870 #endif 871 return 0; 872 case MODULE_CMD_FINI: 873 #ifdef _MODULE 874 error = config_cfdata_detach(lua_cfdata); 875 if (error) 876 return error; 877 878 config_cfattach_detach(lua_cd.cd_name, &lua_ca); 879 config_cfdriver_detach(&lua_cd); 880 devsw_detach(NULL, &lua_cdevsw); 881 #endif 882 return 0; 883 case MODULE_CMD_AUTOUNLOAD: 884 /* no auto-unload */ 885 return EBUSY; 886 default: 887 return ENOTTY; 888 } 889 } 890