Annotation of src/sys/modules/lua/lua.c, revision 1.8
1.8 ! dholland 1: /* $NetBSD: lua.c,v 1.7 2014/02/25 18:30:12 pooka 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 = {
1.8 ! dholland 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
1.1 mbalmer 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);
1.5 mbalmer 219: kmem_free(s, sizeof(struct lua_state));
1.1 mbalmer 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;
1.4 mbalmer 233: int error = 0;
1.1 mbalmer 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);
1.3 mbalmer 485: module_autoload(name, MODULE_CLASS_MISC);
1.1 mbalmer 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: {
1.5 mbalmer 513: void *nptr;
514:
1.1 mbalmer 515: if (nsize == 0) {
1.5 mbalmer 516: nptr = NULL;
1.1 mbalmer 517: if (ptr != NULL)
1.5 mbalmer 518: kmem_free(ptr, osize);
519: } else {
520: nptr = kmem_alloc(nsize, KM_SLEEP);
521: if (ptr != NULL) {
1.6 lneto 522: memcpy(nptr, ptr, osize < nsize ? osize : nsize);
1.5 mbalmer 523: kmem_free(ptr, osize);
524: }
525: }
526: return nptr;
1.1 mbalmer 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;
1.5 mbalmer 571: m = kmem_zalloc(sizeof(struct lua_module), KM_SLEEP);
1.1 mbalmer 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);
1.5 mbalmer 590: kmem_free(m, sizeof(struct lua_module));
1.1 mbalmer 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;
1.4 mbalmer 608: int error = 0;
1.1 mbalmer 609:
1.5 mbalmer 610: s = kmem_zalloc(sizeof(struct lua_state), KM_SLEEP);
1.1 mbalmer 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:
1.5 mbalmer 625: K = kmem_zalloc(sizeof(klua_State), KM_SLEEP);
1.1 mbalmer 626: K->L = lua_newstate(f, ud);
627: K->ks_user = false;
628: if (K->L == NULL) {
1.5 mbalmer 629: kmem_free(K, sizeof(klua_State));
1.1 mbalmer 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;
1.4 mbalmer 661: int error = 0;
1.1 mbalmer 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--;
1.5 mbalmer 695: kmem_free(s, sizeof(struct lua_state));
1.1 mbalmer 696: }
697:
698: lua_close(K->L);
699: cv_destroy(&K->ks_inuse_cv);
700: mutex_destroy(&K->ks_lock);
1.5 mbalmer 701: kmem_free(K, sizeof(klua_State));
1.1 mbalmer 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;
1.4 mbalmer 715: int error = 0;
1.1 mbalmer 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>