Return to main.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / gnot

Annotation of lucent/sys/src/9/gnot/main.c, revision 1.1

1.1     ! root        1: #include       "u.h"
        !             2: #include       "../port/lib.h"
        !             3: #include       "mem.h"
        !             4: #include       "dat.h"
        !             5: #include       "fns.h"
        !             6: #include       "io.h"
        !             7: #include       "ureg.h"
        !             8: #include       "init.h"
        !             9: 
        !            10: #include       <libg.h>
        !            11: #include       <gnot.h>
        !            12: 
        !            13: typedef struct Boot Boot;
        !            14: struct Boot
        !            15: {
        !            16:        long station;
        !            17:        long traffic;
        !            18:        char user[NAMELEN];
        !            19:        char server[64];
        !            20:        char line[64];
        !            21:        char device;
        !            22: };
        !            23: #define BOOT ((Boot*)0)
        !            24: 
        !            25: char   bootuser[NAMELEN];
        !            26: char   bootline[64];
        !            27: char   bootserver[72];
        !            28: int    bank[2];
        !            29: uchar  *sp;
        !            30: 
        !            31: extern GBitmap gscreen;
        !            32: 
        !            33: void unloadboot(void);
        !            34: 
        !            35: void
        !            36: main(void)
        !            37: {
        !            38:        u = 0;
        !            39:        unloadboot();
        !            40:        machinit();
        !            41:        active.exiting = 0;
        !            42:        active.machs = 1;
        !            43:        mmuinit();
        !            44:        confinit();
        !            45:        xinit();
        !            46:        kmapinit();
        !            47:        duartinit();
        !            48:        screeninit();
        !            49:        printinit();
        !            50:        print("bank 0: %dM  bank 1: %dM\n", bank[0], bank[1]);
        !            51:        flushmmu();
        !            52:        pageinit();
        !            53:        procinit0();
        !            54:        initseg();
        !            55:        chandevreset();
        !            56:        streaminit();
        !            57:        swapinit();
        !            58:        kmapinit();
        !            59:        userinit();
        !            60:        schedinit();
        !            61: }
        !            62: 
        !            63: void
        !            64: unloadboot(void)
        !            65: {
        !            66:        char s[64];
        !            67: 
        !            68:        memmove(bootuser, BOOT->user, sizeof(bootuser)-1);
        !            69:        bootuser[sizeof(bootuser)-1] = 0;
        !            70:        memmove(bootline, BOOT->line, sizeof(bootline)-1);
        !            71:        bootline[sizeof(bootline)-1] = 0;
        !            72:        memmove(s, BOOT->server, sizeof(s) - 1);
        !            73:        s[sizeof(s)-1] = 0;
        !            74:        switch(BOOT->device){
        !            75:        case 'a':
        !            76:                sprint(bootserver, "19200!%s", s);
        !            77:                break;
        !            78:        case 'A':
        !            79:                sprint(bootserver, "9600!%s", s);
        !            80:                break;
        !            81:        case 'i':
        !            82:                sprint(bootserver, "incon!%s", s);
        !            83:                break;
        !            84:        default:
        !            85:                /* older boot ROM's don't zero out BOOT->user if it isn't set. */
        !            86:                memset(bootuser, 0, sizeof(bootuser));
        !            87:                sprint(bootserver, "scsi!%s", s);
        !            88:                break;
        !            89:        }
        !            90: }
        !            91: 
        !            92: void
        !            93: machinit(void)
        !            94: {
        !            95:        int n;
        !            96: 
        !            97:        n = m->machno;
        !            98:        memset(m, 0, sizeof(Mach));
        !            99:        m->machno = n;
        !           100:        m->fpstate = FPinit;
        !           101:        fprestore(&initfp);
        !           102: }
        !           103: 
        !           104: void
        !           105: mmuinit(void)
        !           106: {
        !           107:        ulong l, d, i;
        !           108: 
        !           109:        /*
        !           110:         * Invalidate user addresses
        !           111:         */
        !           112:        for(l=0; l<4*1024*1024; l+=BY2PG)
        !           113:                putmmu(l, INVALIDPTE, 0);
        !           114:        /*
        !           115:         * Four meg of usable memory, with top 256K for screen
        !           116:         */
        !           117:        for(i=1,l=KTZERO; i<MB4/BY2PG; l+=BY2PG,i++)
        !           118:                putkmmu(l, PPN(l)|PTEVALID|PTEKERNEL);
        !           119:        /*
        !           120:         * Screen after end
        !           121:         */
        !           122:        l = PGROUND((ulong)end);
        !           123:        gscreen.base = (ulong*)l;
        !           124:        for(i=0,d=DISPLAYRAM; i<256*1024/BY2PG; d+=BY2PG,l+=BY2PG,i++)
        !           125:                putkmmu(l, PPN(d)|PTEVALID|PTEKERNEL);
        !           126: }
        !           127: 
        !           128: void
        !           129: init0(void)
        !           130: {
        !           131:        u->nerrlab = 0;
        !           132:        m->proc = u->p;
        !           133:        u->p->state = Running;
        !           134:        u->p->mach = m;
        !           135:        spllo();
        !           136:        
        !           137:        u->slash = (*devtab[0].attach)(0);
        !           138:        u->dot = clone(u->slash, 0);
        !           139: 
        !           140:        kproc("alarm", alarmkproc, 0);
        !           141:        chandevinit();
        !           142: 
        !           143:        if(!waserror()){
        !           144:                ksetterm("at&t %s");
        !           145:                ksetenv("cputype", "68020");
        !           146:                poperror();
        !           147:        }
        !           148: 
        !           149:        touser(sp);
        !           150: }
        !           151: 
        !           152: FPsave initfp;
        !           153: 
        !           154: void
        !           155: userinit(void)
        !           156: {
        !           157:        Proc *p;
        !           158:        Segment *s;
        !           159:        User *up;
        !           160:        KMap *k;
        !           161:        Page *pg;
        !           162: 
        !           163:        p = newproc();
        !           164:        p->pgrp = newpgrp();
        !           165:        p->egrp = smalloc(sizeof(Egrp));
        !           166:        p->egrp->ref = 1;
        !           167:        p->fgrp = smalloc(sizeof(Fgrp));
        !           168:        p->fgrp->ref = 1;
        !           169:        p->procmode = 0640;
        !           170: 
        !           171:        strcpy(p->text, "*init*");
        !           172:        strcpy(p->user, eve);
        !           173:        p->fpstate = FPinit;
        !           174: 
        !           175:        /*
        !           176:         * Kernel Stack
        !           177:         */
        !           178:        p->sched.pc = (ulong)init0;
        !           179:        p->sched.sp = USERADDR+BY2PG-5*BY2WD;
        !           180:        p->sched.sr = SUPER|SPL(0);
        !           181:        p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
        !           182: 
        !           183:        /*
        !           184:         * User
        !           185:         */
        !           186:        k = kmap(p->upage);
        !           187:        up = (User*)VA(k);
        !           188:        up->p = p;
        !           189:        kunmap(k);
        !           190: 
        !           191:        /*
        !           192:         * User Stack, copy in boot arguments
        !           193:         */
        !           194:        s = newseg(SG_STACK, USTKTOP-BY2PG, 1);
        !           195:        p->seg[SSEG] = s;
        !           196:        pg = newpage(1, 0, USTKTOP-BY2PG);
        !           197:        segpage(s, pg);
        !           198:        k = kmap(pg);
        !           199:        bootargs(VA(k));
        !           200:        kunmap(k);
        !           201: 
        !           202:        /*
        !           203:         * Text
        !           204:         */
        !           205:        s = newseg(SG_TEXT, UTZERO, 1);
        !           206:        p->seg[TSEG] = s;
        !           207:        segpage(s, newpage(1, 0, UTZERO));
        !           208:        k = kmap(s->map[0]->pages[0]);
        !           209:        memmove((ulong*)VA(k), initcode, sizeof initcode);
        !           210:        kunmap(k);
        !           211: 
        !           212:        ready(p);
        !           213: }
        !           214: 
        !           215: uchar *
        !           216: pusharg(char *p)
        !           217: {
        !           218:        int n;
        !           219: 
        !           220:        n = strlen(p)+1;
        !           221:        sp -= n;
        !           222:        memmove(sp, p, n);
        !           223:        return sp;
        !           224: }
        !           225: 
        !           226: void
        !           227: bootargs(ulong base)
        !           228: {
        !           229:        int i, ac;
        !           230:        uchar *av[32];
        !           231:        char *p, *pp;
        !           232:        uchar **lsp;
        !           233: 
        !           234:        sp = (uchar*)base + BY2PG - MAXSYSARG*BY2WD;
        !           235: 
        !           236:        ac = 0;
        !           237:        for(p = bootline; p && *p; p = pp){
        !           238:                pp = strchr(p, ' ');
        !           239:                if(pp)
        !           240:                        *pp++ = 0;
        !           241:                av[ac++] = pusharg(p);
        !           242:        }
        !           243:        if(bootuser[0]){
        !           244:                av[ac++] = pusharg("-u");
        !           245:                av[ac++] = pusharg(bootuser);
        !           246:        }
        !           247:        av[ac++] = pusharg(bootserver);
        !           248: 
        !           249:        /* 4 byte word align stack */
        !           250:        sp = (uchar*)((ulong)sp & ~3);
        !           251: 
        !           252:        /* build argc, argv on stack */
        !           253:        sp -= (ac+1)*sizeof(sp);
        !           254:        lsp = (uchar**)sp;
        !           255:        for(i = 0; i < ac; i++)
        !           256:                *lsp++ = av[i] + ((USTKTOP - BY2PG) - base);
        !           257:        *lsp = 0;
        !           258:        sp += (USTKTOP - BY2PG) - base - sizeof(sp);
        !           259: }
        !           260: 
        !           261: void
        !           262: exit(int ispanic)
        !           263: {
        !           264:        int i;
        !           265: 
        !           266:        u = 0;
        !           267:        wipekeys();
        !           268:        spllo();
        !           269:        while(consactive())
        !           270:                for(i=0; i<1000; i++)
        !           271:                        ;
        !           272:        splhi();
        !           273:        if(ispanic)
        !           274:                for(;;);
        !           275:        firmware();
        !           276: }
        !           277: 
        !           278: banksize(int base)
        !           279: {
        !           280:        ulong va;
        !           281: 
        !           282:        if(end > (char *)((KZERO|1024L*1024L)-BY2PG))
        !           283:                return 0;
        !           284:        va = UZERO;     /* user page 1 is free to play with */
        !           285:        putmmu(va, PTEVALID|(base+0)*MB/BY2PG, 0);
        !           286:        *(ulong*)va = 0;        /* 0 at 0M */
        !           287:        putmmu(va, PTEVALID|(base+1)*MB/BY2PG, 0);
        !           288:        *(ulong*)va = 1;        /* 1 at 1M */
        !           289:        putmmu(va, PTEVALID|(base+4)*MB/BY2PG, 0);
        !           290:        *(ulong*)va = 4;        /* 4 at 4M */
        !           291:        putmmu(va, PTEVALID|(base+0)*MB/BY2PG, 0);
        !           292:        if(*(ulong*)va == 0)
        !           293:                return 16;
        !           294:        putmmu(va, PTEVALID|(base+1)*MB/BY2PG, 0);
        !           295:        if(*(ulong*)va == 1)
        !           296:                return 4;
        !           297:        putmmu(va, PTEVALID|(base+0)*MB/BY2PG, 0);
        !           298:        if(*(ulong*)va == 4)
        !           299:                return 1;
        !           300:        return 0;
        !           301: }
        !           302: 
        !           303: Conf   conf;
        !           304: 
        !           305: void
        !           306: confinit(void)
        !           307: {
        !           308:        int mul, pcnt;
        !           309:        ulong ktop;
        !           310: 
        !           311:        conf.nmach = 1;
        !           312:        if(conf.nmach > MAXMACH)
        !           313:                panic("confinit");
        !           314:        conf.monitor = 1;
        !           315:        bank[0] = banksize(0);
        !           316:        bank[1] = banksize(16);
        !           317:        conf.npage0 = (bank[0]*MB)/BY2PG;
        !           318:        conf.base0 = 0;
        !           319:        conf.npage1 = (bank[1]*MB)/BY2PG;
        !           320:        conf.base1 = 16*MB;
        !           321:        conf.npage = conf.npage0+conf.npage1;
        !           322: 
        !           323:        pcnt = screenbits()-1;          /* Calculate % of memory for page pool */
        !           324:        pcnt = 70 - (pcnt*10);
        !           325:        conf.upages = (conf.npage*pcnt)/100;
        !           326: 
        !           327:        ktop = PGROUND((ulong)end) + 256*1024;  /* cf. mmuinit */
        !           328:        ktop = PADDR(ktop);
        !           329:        conf.npage0 -= ktop/BY2PG;
        !           330:        conf.base0 += ktop;
        !           331: 
        !           332:        mul = 1 + (conf.npage1>0);
        !           333:        conf.nproc = 50*mul;
        !           334:        conf.nswap = 4096;
        !           335:        conf.nimage = 50;
        !           336:        conf.copymode = 0;              /* copy on write */
        !           337:        conf.portispaged = 0;
        !           338:        confinit1(mul);
        !           339: }
        !           340: 
        !           341: /*
        !           342:  *  set up floating point for a new process
        !           343:  */
        !           344: void
        !           345: procsetup(Proc *p)
        !           346: {
        !           347:        long fpnull;
        !           348: 
        !           349:        fpnull = 0;
        !           350:        splhi();
        !           351:        m->fpstate = FPinit;
        !           352:        p->fpstate = FPinit;
        !           353:        fprestore((FPsave*)&fpnull);
        !           354:        spllo();
        !           355: }
        !           356: 
        !           357: /*
        !           358:  * Save the part of the process state.
        !           359:  */
        !           360: void
        !           361: procsave(Proc *p)
        !           362: {
        !           363:        Balu *balu = (Balu *)u->balusave;
        !           364: 
        !           365:        USED(p);
        !           366:        fpsave(&u->fpsave);
        !           367:        if(u->fpsave.type){
        !           368:                if(u->fpsave.size > sizeof u->fpsave.junk)
        !           369:                        panic("fpsize %d max %d\n", u->fpsave.size, sizeof u->fpsave.junk);
        !           370:                fpregsave(u->fpsave.reg);
        !           371:                u->p->fpstate = FPactive;
        !           372:                m->fpstate = FPdirty;
        !           373:        }
        !           374:        if(BALU->cr0 != 0xFFFFFFFF)     /* balu busy */
        !           375:                memmove(balu, BALU, sizeof(Balu));
        !           376:        else{
        !           377:                balu->cr0 = 0xFFFFFFFF;
        !           378:                BALU->cr0 = 0xFFFFFFFF;
        !           379:        }
        !           380: }
        !           381: 
        !           382: /*
        !           383:  *  Restore what procsave() saves
        !           384:  *
        !           385:  *  Procsave() makes sure that what state points to is long enough
        !           386:  */
        !           387: void
        !           388: procrestore(Proc *p)
        !           389: {
        !           390:        Balu *balu = (Balu *)u->balusave;
        !           391: 
        !           392:        if(p->fpstate != m->fpstate){
        !           393:                if(p->fpstate == FPinit){
        !           394:                        u->p->fpstate = FPinit;
        !           395:                        fprestore(&initfp);
        !           396:                        m->fpstate = FPinit;
        !           397:                }else{
        !           398:                        fpregrestore(u->fpsave.reg);
        !           399:                        fprestore(&u->fpsave);
        !           400:                        m->fpstate = FPdirty;
        !           401:                }
        !           402:        }
        !           403:        if(balu->cr0 != 0xFFFFFFFF)     /* balu busy */
        !           404:                memmove(BALU, balu, sizeof BALU);
        !           405: }
        !           406: 
        !           407: void
        !           408: buzz(int f, int d)
        !           409: {
        !           410:        USED(f, d);
        !           411: }
        !           412: 
        !           413: void
        !           414: lights(int val)
        !           415: {
        !           416:        USED(val);
        !           417: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.