Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <thread.h>
#include <bio.h>
#include <fcall.h>
#include "object.h"
#include "parse.h"
#include "print.h"
#include "catset.h"
#include "../debug.h"

// #include <pool.h>

char            *user, *mapname, *svrname;
int             p[2];
int             mfd[2];
int             debug = 0; //DBGSERVER|DBGSTATE|DBGPICKLE|DBGPLAY;
Biobuf          *f;
char            *file;

Object *root;

Object **       otab;           // object table
int             notab;  // no of entries used
int             sotab;  // no of entries mallocated (invariant sotab >= notab)
int             hotab;  // no of holes in otab;

char usage[] = "Usage: %s [-f] [-l] [mapfile]\n";

char *startdir;

Object **catobjects;    /* for quickly finding category objects */
int ncat = 0;

void
post(char *name, char *envname, int srvfd)
{
        int fd;
        char buf[32];

        fd = create(name, OWRITE, 0666);
        if(fd < 0)
                return;
        sprint(buf, "%d",srvfd);
        if(write(fd, buf, strlen(buf)) != strlen(buf))
                sysfatal("srv write: %r");
        close(fd);
        putenv(envname, name);
}

int
robusthandler(void*, char *s)
{
        if (debug) fprint(2, "inthandler: %s\n", s);
        return (s && (strstr(s, "interrupted") || strstr(s, "hangup")));
}

long
robustread(int fd, void *buf, long sz)
{
        long r;
        char err[32];

        do {
                r = read(fd , buf, sz);
                if (r < 0)
                        rerrstr(err, sizeof(err));
        } while (r < 0 && robusthandler(nil, err));
        return r;
}

void
delobject(Object *o)
{
        /* Free an object and all its descendants */
        Object *oo;
        int i;

        for (i = 0; i < o->nchildren; i++){
                oo = o->children[i];
                if (oo->parent == o)
                        delobject(oo);
        }
        freeobject(o, "r");
}

void
threadmain(int argc, char *argv[]) {
        char *q;
        char *srvname;
        char *mntpt;
        int list;

        mntpt = "/mnt";
        user = strdup(getuser());
        srvname = nil;
        list = 0;

        // mainmem->flags |= POOL_NOREUSE;

        ARGBEGIN{
        case 'l':
                list = 1;
                break;
        case 'm':
                mntpt = ARGF();
                break;
        case 'd':
                debug = strtoul(ARGF(), nil, 0);
                break;
        case 's':
                srvname = ARGF();
                break;
        case 'f':
                fflag = 1;
                break;
        default:
                fprint(2, usage, argv0);
                exits("usage");
        }ARGEND

        switch (argc) {
        default:
                fprint(2, usage, argv0);
                exits("usage");
        case 0:
                mapname = DEFAULTMAP;
                break;
        case 1:
                mapname = argv[0];
                break;
        }

        quotefmtinstall();

        if((f = Bopen(mapname, OREAD)) == nil)
                sysfatal("%s: %r", mapname);
        free(file);
        file = strdup(mapname);
        free(startdir);
        startdir = strdup(mapname);
        if ((q = strrchr(startdir, '/')))
                *q = '\0';
        else
                startdir[0] = '\0';
        inittokenlist();
        getobject(Root, nil);
        Bterm(f);
        f = nil;
        root->parent = root;

        if(list){
                listfiles(root);
                threadexits(nil);
        }

        if(pipe(p) < 0)
                sysfatal("pipe failed: %r");
        mfd[0] = p[0];
        mfd[1] = p[0];

        threadnotify(robusthandler, 1);
        user = strdup(getuser());

        if(debug)
                fmtinstall('F', fcallfmt);

        procrfork(io, nil, STACKSIZE, RFFDG);   //RFNOTEG?

        close(p[0]);    /* don't deadlock if child fails */

        if(srvname){
                srvname = smprint("/srv/jukefs.%s", srvname);
                remove(srvname);
                post(srvname, "jukefs", p[1]);
        }
        if(mount(p[1], -1, mntpt, MBEFORE, "") < 0)
                sysfatal("mount failed: %r");
        threadexits(nil);
}

void
reread(void)
{
        int i;
        extern int catnr;
        char *q;

        assert(f == nil);
        if((f = Bopen(mapname, OREAD)) == nil)
                fprint(2, "reread: %s: %r\n", mapname);
        freetree(root);
        root = nil;
        for(i = 0; i< ntoken; i++){
                free(tokenlist[i].name);
                catsetfree(&tokenlist[i].categories);
        }
        catnr = 0;
        free(tokenlist);
        free(catobjects);
        catobjects = nil;
        ncat = 0;
        tokenlist = nil;
        ntoken = Ntoken;
        inittokenlist();
        free(file);
        file = strdup(mapname);
        free(startdir);
        startdir = strdup(mapname);
        if ((q = strrchr(startdir, '/')))
                *q = '\0';
        else
                startdir[0] = '\0';
        getobject(Root, nil);
        root->parent = root;
        Bterm(f);
        f = nil;
}