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

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

CVSweb <webmaster@jp.NetBSD.org>