1 /* $NetBSD: lua.c,v 1.18 2016/07/14 04:00:46 msaitoh 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 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 aprint_error(": 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, &s->lua_modules, mod_next) 360 if (!strcmp(m->mod_name, require->module)) 361 return ENXIO; 362 LIST_FOREACH(m, &lua_modules, mod_next) 363 if (!strcmp(m->mod_name, 364 require->module)) { 365 if (lua_verbose) 366 device_printf( 367 sc->sc_dev, 368 "requiring module " 369 "%s to state %s\n", 370 m->mod_name, 371 s->lua_name); 372 klua_lock(s->K); 373 luaL_requiref( 374 s->K->L, 375 m->mod_name, 376 m->open, 377 1); 378 klua_unlock(s->K); 379 m->refcount++; 380 LIST_INSERT_HEAD( 381 &s->lua_modules, m, 382 mod_next); 383 return 0; 384 } 385 } 386 return ENXIO; 387 case LUALOAD: 388 load = data; 389 if (strrchr(load->path, '/') == NULL) 390 return ENXIO; 391 392 LIST_FOREACH(s, &lua_states, lua_next) 393 if (!strcmp(s->lua_name, load->state)) { 394 if (lua_verbose) 395 device_printf(sc->sc_dev, 396 "loading %s into state %s\n", 397 load->path, s->lua_name); 398 cred = kauth_cred_get(); 399 pb = pathbuf_create(load->path); 400 if (pb == NULL) 401 return ENOMEM; 402 NDINIT(&nd, LOOKUP, FOLLOW | NOCHROOT, pb); 403 pathbuf_destroy(pb); 404 error = vn_open(&nd, FREAD, 0); 405 if (error) { 406 if (lua_verbose) 407 device_printf(sc->sc_dev, 408 "error vn_open %d\n", 409 error); 410 return error; 411 } 412 error = VOP_GETATTR(nd.ni_vp, &va, 413 kauth_cred_get()); 414 if (error) { 415 VOP_UNLOCK(nd.ni_vp); 416 vn_close(nd.ni_vp, FREAD, 417 kauth_cred_get()); 418 if (lua_verbose) 419 device_printf(sc->sc_dev, 420 "erro VOP_GETATTR %d\n", 421 error); 422 return error; 423 } 424 if (va.va_type != VREG) { 425 VOP_UNLOCK(nd.ni_vp); 426 vn_close(nd.ni_vp, FREAD, 427 kauth_cred_get()); 428 return EINVAL; 429 } 430 ls.vp = nd.ni_vp; 431 ls.off = 0L; 432 ls.size = va.va_size; 433 VOP_UNLOCK(nd.ni_vp); 434 klua_lock(s->K); 435 error = lua_load(s->K->L, lua_reader, &ls, 436 strrchr(load->path, '/') + 1, "bt"); 437 vn_close(nd.ni_vp, FREAD, cred); 438 switch (error) { 439 case 0: /* no error */ 440 break; 441 case LUA_ERRSYNTAX: 442 if (lua_verbose) 443 device_printf(sc->sc_dev, 444 "syntax error\n"); 445 klua_unlock(s->K); 446 return EINVAL; 447 case LUA_ERRMEM: 448 if (lua_verbose) 449 device_printf(sc->sc_dev, 450 "memory error\n"); 451 klua_unlock(s->K); 452 return ENOMEM; 453 default: 454 if (lua_verbose) 455 device_printf(sc->sc_dev, 456 "load error %d: %s\n", 457 error, 458 lua_tostring(s->K->L, -1)); 459 klua_unlock(s->K); 460 return EINVAL; 461 } 462 if (lua_max_instr > 0) 463 lua_sethook(s->K->L, lua_maxcount, 464 LUA_MASKCOUNT, lua_max_instr); 465 error = lua_pcall(s->K->L, 0, LUA_MULTRET, 0); 466 if (error) { 467 if (lua_verbose) { 468 device_printf(sc->sc_dev, 469 "execution error: %s\n", 470 lua_tostring(s->K->L, -1)); 471 } 472 klua_unlock(s->K); 473 return EINVAL; 474 } 475 klua_unlock(s->K); 476 return 0; 477 } 478 return ENXIO; 479 } 480 return 0; 481 } 482 483 static int 484 lua_require(lua_State *L) 485 { 486 struct lua_state *s; 487 struct lua_module *m, *md; 488 const char *module; 489 char name[MAXPATHLEN]; 490 491 module = lua_tostring(L, -1); 492 md = NULL; 493 LIST_FOREACH(m, &lua_modules, mod_next) 494 if (!strcmp(m->mod_name, module)) { 495 md = m; 496 break; 497 } 498 499 if (md == NULL && lua_autoload_on && strchr(module, '/') == NULL) { 500 snprintf(name, sizeof name, "lua%s", module); 501 if (lua_verbose) 502 device_printf(sc_self, "autoload %s\n", name); 503 module_autoload(name, MODULE_CLASS_MISC); 504 LIST_FOREACH(m, &lua_modules, mod_next) 505 if (!strcmp(m->mod_name, module)) { 506 md = m; 507 break; 508 } 509 } 510 511 if (md != NULL) 512 LIST_FOREACH(s, &lua_states, lua_next) 513 if (s->K->L == L) { 514 if (lua_verbose) 515 device_printf(sc_self, 516 "require module %s\n", 517 md->mod_name); 518 luaL_requiref(L, md->mod_name, md->open, 0); 519 520 md->refcount++; 521 LIST_INSERT_HEAD(&s->lua_modules, md, mod_next); 522 return 1; 523 } 524 525 lua_pushstring(L, "module not found"); 526 return lua_error(L); 527 } 528 529 typedef struct { 530 size_t size; 531 } __packed alloc_header_t; 532 533 static void * 534 lua_alloc(void *ud, void *ptr, size_t osize, size_t nsize) 535 { 536 void *nptr = NULL; 537 538 const size_t hdr_size = sizeof(alloc_header_t); 539 alloc_header_t *hdr = (alloc_header_t *) ((char *) ptr - hdr_size); 540 541 if (nsize == 0) { /* freeing */ 542 if (ptr != NULL) 543 kmem_intr_free(hdr, hdr->size); 544 } else if (ptr != NULL && nsize <= hdr->size - hdr_size) /* shrinking */ 545 return ptr; /* don't need to reallocate */ 546 else { /* creating or expanding */ 547 km_flag_t sleep = cpu_intr_p() || cpu_softintr_p() ? 548 KM_NOSLEEP : KM_SLEEP; 549 550 size_t alloc_size = nsize + hdr_size; 551 alloc_header_t *nhdr = kmem_intr_alloc(alloc_size, sleep); 552 if (nhdr == NULL) /* failed to allocate */ 553 return NULL; 554 555 nhdr->size = alloc_size; 556 nptr = (void *) ((char *) nhdr + hdr_size); 557 558 if (ptr != NULL) { /* expanding */ 559 memcpy(nptr, ptr, osize); 560 kmem_intr_free(hdr, hdr->size); 561 } 562 } 563 return nptr; 564 } 565 566 static const char * 567 lua_reader(lua_State *L, void *data, size_t *size) 568 { 569 struct lua_loadstate *ls; 570 static char buf[1024]; 571 size_t rsiz; 572 573 ls = data; 574 if (ls->size < sizeof(buf)) 575 rsiz = ls->size; 576 else 577 rsiz = sizeof(buf); 578 vn_rdwr(UIO_READ, ls->vp, buf, rsiz, ls->off, UIO_SYSSPACE, 579 0, curlwp->l_cred, NULL, curlwp); 580 if (ls->off == 0L && lua_bytecode_on == false && buf[0] == 0x1b) { 581 *size = 0L; 582 lua_pushstring(L, "loading of bytecode is not allowed"); 583 lua_error(L); 584 return NULL; 585 } else { 586 *size = rsiz; 587 ls->off += *size; 588 ls->size -= *size; 589 } 590 return buf; 591 } 592 593 static void 594 lua_maxcount(lua_State *L, lua_Debug *d) 595 { 596 lua_pushstring(L, "maximum instruction count exceeded"); 597 lua_error(L); 598 } 599 600 int 601 klua_mod_register(const char *name, lua_CFunction open) 602 { 603 struct lua_module *m; 604 605 LIST_FOREACH(m, &lua_modules, mod_next) 606 if (!strcmp(m->mod_name, name)) 607 return EBUSY; 608 m = kmem_zalloc(sizeof(struct lua_module), KM_SLEEP); 609 strlcpy(m->mod_name, name, LUA_MAX_MODNAME); 610 m->open = open; 611 m->refcount = 0; 612 LIST_INSERT_HEAD(&lua_modules, m, mod_next); 613 if (lua_verbose) 614 device_printf(sc_self, "registered lua module %s\n", name); 615 return 0; 616 } 617 618 int 619 klua_mod_unregister(const char *name) 620 { 621 struct lua_module *m; 622 623 LIST_FOREACH(m, &lua_modules, mod_next) 624 if (!strcmp(m->mod_name, name)) { 625 if (m->refcount == 0) { 626 LIST_REMOVE(m, mod_next); 627 kmem_free(m, sizeof(struct lua_module)); 628 if (lua_verbose) 629 device_printf(sc_self, 630 "unregistered lua module %s\n", 631 name); 632 return 0; 633 } else 634 return EBUSY; 635 } 636 return 0; 637 } 638 639 klua_State * 640 klua_newstate(lua_Alloc f, void *ud, const char *name, const char *desc, 641 int ipl) 642 { 643 klua_State *K; 644 struct lua_state *s; 645 struct lua_softc *sc; 646 int error = 0; 647 648 s = kmem_zalloc(sizeof(struct lua_state), KM_SLEEP); 649 sc = device_private(sc_self); 650 mutex_enter(&sc->sc_state_lock); 651 while (sc->sc_state == true) { 652 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 653 if (error) 654 break; 655 } 656 if (!error) 657 sc->sc_state = true; 658 mutex_exit(&sc->sc_state_lock); 659 660 if (error) { 661 kmem_free(s, sizeof(struct lua_state)); 662 return NULL; 663 } 664 665 K = kmem_zalloc(sizeof(klua_State), KM_SLEEP); 666 K->L = lua_newstate(f, ud); 667 K->ks_user = false; 668 if (K->L == NULL) { 669 kmem_free(K, sizeof(klua_State)); 670 K = NULL; 671 goto finish; 672 } 673 674 strlcpy(s->lua_name, name, MAX_LUA_NAME); 675 strlcpy(s->lua_desc, desc, MAX_LUA_DESC); 676 s->K = K; 677 678 if (lua_require_on || lua_autoload_on) { 679 lua_pushcfunction(K->L, lua_require); 680 lua_setglobal(K->L, "require"); 681 } 682 LIST_INSERT_HEAD(&lua_states, s, lua_next); 683 684 mutex_init(&K->ks_lock, MUTEX_DEFAULT, ipl); 685 686 finish: 687 mutex_enter(&sc->sc_state_lock); 688 sc->sc_state = false; 689 cv_signal(&sc->sc_state_cv); 690 mutex_exit(&sc->sc_state_lock); 691 return K; 692 } 693 694 inline klua_State * 695 kluaL_newstate(const char *name, const char *desc, int ipl) 696 { 697 return klua_newstate(lua_alloc, NULL, name, desc, ipl); 698 } 699 700 void 701 klua_close(klua_State *K) 702 { 703 struct lua_state *s; 704 struct lua_softc *sc; 705 struct lua_module *m; 706 int error = 0; 707 708 /* XXX consider registering a handler instead of a fixed name. */ 709 lua_getglobal(K->L, "onClose"); 710 if (lua_isfunction(K->L, -1)) 711 lua_pcall(K->L, -1, 0, 0); 712 713 sc = device_private(sc_self); 714 mutex_enter(&sc->sc_state_lock); 715 while (sc->sc_state == true) { 716 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 717 if (error) 718 break; 719 } 720 if (!error) 721 sc->sc_state = true; 722 mutex_exit(&sc->sc_state_lock); 723 724 if (error) 725 return; /* Nothing we can do... */ 726 727 LIST_FOREACH(s, &lua_states, lua_next) 728 if (s->K == K) { 729 LIST_REMOVE(s, lua_next); 730 LIST_FOREACH(m, &s->lua_modules, mod_next) 731 m->refcount--; 732 kmem_free(s, sizeof(struct lua_state)); 733 } 734 735 lua_close(K->L); 736 mutex_destroy(&K->ks_lock); 737 kmem_free(K, sizeof(klua_State)); 738 739 mutex_enter(&sc->sc_state_lock); 740 sc->sc_state = false; 741 cv_signal(&sc->sc_state_cv); 742 mutex_exit(&sc->sc_state_lock); 743 } 744 745 static klua_State * 746 klua_find(const char *name) 747 { 748 struct lua_state *s; 749 struct lua_softc *sc; 750 klua_State *K; 751 int error = 0; 752 753 K = NULL; 754 sc = device_private(sc_self); 755 mutex_enter(&sc->sc_state_lock); 756 while (sc->sc_state == true) { 757 error = cv_wait_sig(&sc->sc_state_cv, &sc->sc_state_lock); 758 if (error) 759 break; 760 } 761 if (!error) 762 sc->sc_state = true; 763 mutex_exit(&sc->sc_state_lock); 764 765 if (error) 766 return NULL; 767 768 LIST_FOREACH(s, &lua_states, lua_next) 769 if (!strcmp(s->lua_name, name)) { 770 K = s->K; 771 break; 772 } 773 774 mutex_enter(&sc->sc_state_lock); 775 sc->sc_state = false; 776 cv_signal(&sc->sc_state_cv); 777 mutex_exit(&sc->sc_state_lock); 778 return K; 779 } 780 781 inline void 782 klua_lock(klua_State *K) 783 { 784 mutex_enter(&K->ks_lock); 785 } 786 787 inline void 788 klua_unlock(klua_State *K) 789 { 790 mutex_exit(&K->ks_lock); 791 } 792 793 MODULE(MODULE_CLASS_MISC, lua, NULL); 794 795 #ifdef _MODULE 796 static const struct cfiattrdata luabus_iattrdata = { 797 "luabus", 0, { { NULL, NULL, 0 },} 798 }; 799 800 static const struct cfiattrdata *const lua_attrs[] = { 801 &luabus_iattrdata, NULL 802 }; 803 804 CFDRIVER_DECL(lua, DV_DULL, lua_attrs); 805 extern struct cfattach lua_ca; 806 static int lualoc[] = { 807 -1, 808 -1, 809 -1 810 }; 811 812 static struct cfdata lua_cfdata[] = { 813 { 814 .cf_name = "lua", 815 .cf_atname = "lua", 816 .cf_unit = 0, 817 .cf_fstate = FSTATE_STAR, 818 .cf_loc = lualoc, 819 .cf_flags = 0, 820 .cf_pspec = NULL, 821 }, 822 { NULL, NULL, 0, FSTATE_NOTFOUND, NULL, 0, NULL } 823 }; 824 #endif 825 826 static int 827 lua_modcmd(modcmd_t cmd, void *opaque) 828 { 829 #ifdef _MODULE 830 devmajor_t cmajor, bmajor; 831 int error = 0; 832 833 cmajor = bmajor = NODEVMAJOR; 834 #endif 835 switch (cmd) { 836 case MODULE_CMD_INIT: 837 #ifdef _MODULE 838 error = config_cfdriver_attach(&lua_cd); 839 if (error) 840 return error; 841 842 error = config_cfattach_attach(lua_cd.cd_name, 843 &lua_ca); 844 if (error) { 845 config_cfdriver_detach(&lua_cd); 846 aprint_error("%s: unable to register cfattach\n", 847 lua_cd.cd_name); 848 return error; 849 } 850 error = config_cfdata_attach(lua_cfdata, 1); 851 if (error) { 852 config_cfattach_detach(lua_cd.cd_name, 853 &lua_ca); 854 config_cfdriver_detach(&lua_cd); 855 aprint_error("%s: unable to register cfdata\n", 856 lua_cd.cd_name); 857 return error; 858 } 859 error = devsw_attach(lua_cd.cd_name, NULL, &bmajor, 860 &lua_cdevsw, &cmajor); 861 if (error) { 862 aprint_error("%s: unable to register devsw\n", 863 lua_cd.cd_name); 864 config_cfattach_detach(lua_cd.cd_name, &lua_ca); 865 config_cfdriver_detach(&lua_cd); 866 return error; 867 } 868 config_attach_pseudo(lua_cfdata); 869 #endif 870 return 0; 871 case MODULE_CMD_FINI: 872 #ifdef _MODULE 873 error = config_cfdata_detach(lua_cfdata); 874 if (error) 875 return error; 876 877 config_cfattach_detach(lua_cd.cd_name, &lua_ca); 878 config_cfdriver_detach(&lua_cd); 879 devsw_detach(NULL, &lua_cdevsw); 880 #endif 881 return 0; 882 case MODULE_CMD_AUTOUNLOAD: 883 /* no auto-unload */ 884 return EBUSY; 885 default: 886 return ENOTTY; 887 } 888 } 889