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