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