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