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