Annotation of src/sys/modules/lua/lua.c, revision 1.17
1.17 ! salazar 1: /* $NetBSD: lua.c,v 1.16 2015/02/07 04:09:13 christos Exp $ */
1.1 mbalmer 2:
3: /*
1.9 lneto 4: * Copyright (c) 2014 by Lourival Vieira Neto <lneto@NetBSD.org>.
1.14 mbalmer 5: * Copyright (c) 2011 - 2014 by Marc Balmer <mbalmer@NetBSD.org>.
1.1 mbalmer 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>
1.5 mbalmer 40: #include <sys/kmem.h>
1.1 mbalmer 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>
1.9 lneto 49: #include <sys/cpu.h>
1.1 mbalmer 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 = {
1.8 dholland 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,
1.13 dholland 107: .d_discard = nodiscard,
1.8 dholland 108: .d_flag = D_OTHER | D_MPSAFE
1.1 mbalmer 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:
1.12 lneto 198: aprint_normal_dev(self, "%s\n", LUA_COPYRIGHT);
1.1 mbalmer 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);
1.5 mbalmer 222: kmem_free(s, sizeof(struct lua_state));
1.1 mbalmer 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;
1.4 mbalmer 236: int error = 0;
1.1 mbalmer 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:
1.9 lneto 336: K = kluaL_newstate(create->name, create->desc, IPL_NONE);
1.1 mbalmer 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)
1.17 ! salazar 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;
1.1 mbalmer 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);
1.9 lneto 372: klua_lock(s->K);
1.15 lneto 373: luaL_requiref(
374: s->K->L,
375: m->mod_name,
376: m->open,
377: 1);
1.9 lneto 378: klua_unlock(s->K);
1.1 mbalmer 379: m->refcount++;
380: LIST_INSERT_HEAD(
381: &s->lua_modules, m,
382: mod_next);
383: return 0;
384: }
1.17 ! salazar 385: }
1.1 mbalmer 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);
1.9 lneto 434: klua_lock(s->K);
1.1 mbalmer 435: error = lua_load(s->K->L, lua_reader, &ls,
1.12 lneto 436: strrchr(load->path, '/') + 1, "bt");
1.1 mbalmer 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");
1.9 lneto 445: klua_unlock(s->K);
1.1 mbalmer 446: return EINVAL;
447: case LUA_ERRMEM:
448: if (lua_verbose)
449: device_printf(sc->sc_dev,
450: "memory error\n");
1.9 lneto 451: klua_unlock(s->K);
1.1 mbalmer 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));
1.9 lneto 459: klua_unlock(s->K);
1.1 mbalmer 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: }
1.9 lneto 472: klua_unlock(s->K);
1.1 mbalmer 473: return EINVAL;
474: }
1.9 lneto 475: klua_unlock(s->K);
1.1 mbalmer 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);
1.3 mbalmer 503: module_autoload(name, MODULE_CLASS_MISC);
1.1 mbalmer 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);
1.15 lneto 518: luaL_requiref(L, md->mod_name, md->open, 0);
519:
1.1 mbalmer 520: md->refcount++;
521: LIST_INSERT_HEAD(&s->lua_modules, md, mod_next);
1.12 lneto 522: return 1;
1.1 mbalmer 523: }
524:
525: lua_pushstring(L, "module not found");
526: return lua_error(L);
527: }
528:
1.9 lneto 529: typedef struct {
530: size_t size;
531: } __packed alloc_header_t;
532:
533: static void *
1.1 mbalmer 534: lua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
535: {
1.9 lneto 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);
1.5 mbalmer 540:
1.9 lneto 541: if (nsize == 0) { /* freeing */
1.1 mbalmer 542: if (ptr != NULL)
1.9 lneto 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);
1.5 mbalmer 561: }
562: }
563: return nptr;
1.1 mbalmer 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
1.11 lneto 601: klua_mod_register(const char *name, lua_CFunction open)
1.1 mbalmer 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;
1.5 mbalmer 608: m = kmem_zalloc(sizeof(struct lua_module), KM_SLEEP);
1.1 mbalmer 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
1.11 lneto 619: klua_mod_unregister(const char *name)
1.1 mbalmer 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);
1.5 mbalmer 627: kmem_free(m, sizeof(struct lua_module));
1.1 mbalmer 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 *
1.9 lneto 640: klua_newstate(lua_Alloc f, void *ud, const char *name, const char *desc,
1.14 mbalmer 641: int ipl)
1.1 mbalmer 642: {
643: klua_State *K;
644: struct lua_state *s;
645: struct lua_softc *sc;
1.4 mbalmer 646: int error = 0;
1.1 mbalmer 647:
1.5 mbalmer 648: s = kmem_zalloc(sizeof(struct lua_state), KM_SLEEP);
1.1 mbalmer 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:
1.16 christos 660: if (error) {
661: kmem_free(s, sizeof(struct lua_state));
1.1 mbalmer 662: return NULL;
1.16 christos 663: }
1.1 mbalmer 664:
1.5 mbalmer 665: K = kmem_zalloc(sizeof(klua_State), KM_SLEEP);
1.1 mbalmer 666: K->L = lua_newstate(f, ud);
667: K->ks_user = false;
668: if (K->L == NULL) {
1.5 mbalmer 669: kmem_free(K, sizeof(klua_State));
1.1 mbalmer 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:
1.9 lneto 684: mutex_init(&K->ks_lock, MUTEX_DEFAULT, ipl);
1.1 mbalmer 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:
1.9 lneto 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:
1.1 mbalmer 700: void
701: klua_close(klua_State *K)
702: {
703: struct lua_state *s;
704: struct lua_softc *sc;
705: struct lua_module *m;
1.4 mbalmer 706: int error = 0;
1.1 mbalmer 707:
1.14 mbalmer 708: /* XXX consider registering a handler instead of a fixed name. */
1.1 mbalmer 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--;
1.5 mbalmer 732: kmem_free(s, sizeof(struct lua_state));
1.1 mbalmer 733: }
734:
735: lua_close(K->L);
736: mutex_destroy(&K->ks_lock);
1.5 mbalmer 737: kmem_free(K, sizeof(klua_State));
1.1 mbalmer 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;
1.4 mbalmer 751: int error = 0;
1.1 mbalmer 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:
1.9 lneto 781: inline void
1.1 mbalmer 782: klua_lock(klua_State *K)
783: {
784: mutex_enter(&K->ks_lock);
785: }
786:
1.9 lneto 787: inline void
1.1 mbalmer 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: };
1.14 mbalmer 799:
1.1 mbalmer 800: static const struct cfiattrdata *const lua_attrs[] = {
801: &luabus_iattrdata, NULL
802: };
1.14 mbalmer 803:
1.1 mbalmer 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: };
1.14 mbalmer 811:
1.1 mbalmer 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: }
CVSweb <webmaster@jp.NetBSD.org>