Annotation of src/sys/modules/lua/lua.c, revision 1.1

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

CVSweb <webmaster@jp.NetBSD.org>