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