Return to boot.c CVS log

Up to [Research Unix] / researchv9 / sys / boot / stand

Annotation of researchv9/sys/boot/stand/boot.c, revision 1.1

1.1     ! root        1: #include <sys/reboot.h>
        !             2: #include <machine/sunromvec.h>
        !             3: 
        !             4: /*
        !             5:  * Boot program... argument from monitor determines
        !             6:  * whether boot stops to ask for system name and which device
        !             7:  * boot comes from.
        !             8:  */
        !             9: 
        !            10: int (*readfile())();
        !            11: 
        !            12: char aline[100];
        !            13: 
        !            14: char bunix[] = "unix"; /* and room to patch to whatever */
        !            15: 
        !            16: main()
        !            17: {
        !            18:        register struct bootparam *bp;
        !            19:        register char *arg;
        !            20:        register int howto;
        !            21:        register int io;
        !            22:        int (*go2)();
        !            23: 
        !            24:        bp = *(romp->v_bootparam);              /* S-2: via romvec */
        !            25: 
        !            26:        arg = bp->bp_argv[0];
        !            27:        howto = bootflags(bp->bp_argv[1]);
        !            28:        if ((howto&RB_ASKNAME)==0) {
        !            29:                register char *s, *p;
        !            30: 
        !            31:                for (s = arg, p = aline; *s; s++, p++)
        !            32:                        *p = *s;
        !            33:                
        !            34:                /*
        !            35:                 * If no file name given, default to "unix"
        !            36:                 * We only do this if we aren't asking for input
        !            37:                 */
        !            38:                for (s = aline; *s;)
        !            39:                        if (*s++ == ')')
        !            40:                                break;
        !            41:                if (*s == '\0') {
        !            42:                        for (p = bunix; *p;)
        !            43:                                *s++ = *p++;
        !            44:                        *s = '\0';
        !            45:                }
        !            46:        }
        !            47:        for (;;) {
        !            48:                if (howto & RB_ASKNAME) {
        !            49:                        printf("Boot: ");
        !            50:                        gets(aline);
        !            51:                        if (*aline == 0)
        !            52:                                continue;       /* Null input - try again */
        !            53:                        parseparam(aline, howto, bp);
        !            54:                } else
        !            55:                        printf("Boot: %s\n", aline);
        !            56:                io = open(aline, 0);
        !            57:                if (io >= 0) {
        !            58:                        go2 = readfile(io, 1);
        !            59:                        if (!(howto & RB_ASKNAME))  {
        !            60:                                _exitto(go2);
        !            61:                                /*NOTREACHED*/ ;
        !            62:                        }
        !            63:                        if ((int)go2 != -1)
        !            64:                                (*go2)(arg);
        !            65:                } else {
        !            66:                        printf("boot failed\n");
        !            67:                        if (!(howto & RB_ASKNAME))
        !            68:                                _stop((char *) 0);
        !            69:                }
        !            70:        }
        !            71: }
        !            72: 
        !            73: 
        !            74: struct bootf {
        !            75:        char    let;
        !            76:        short   bit;
        !            77: } bootf[] = {
        !            78:        'a',    RB_ASKNAME,
        !            79:        's',    RB_SINGLE,
        !            80:        'i',    0,
        !            81:        'h',    RB_HALT,
        !            82:        0,      0,
        !            83: };
        !            84: 
        !            85: /*
        !            86:  * Parse the boot line to determine boot flags 
        !            87:  */
        !            88: bootflags(cp)
        !            89:        register char *cp;
        !            90: {
        !            91:        register int i, boothowto = 0;
        !            92: 
        !            93:        if (*cp++ == '-')
        !            94:        do {
        !            95:                for (i = 0; bootf[i].let; i++) {
        !            96:                        if (*cp == bootf[i].let) {
        !            97:                                boothowto |= bootf[i].bit;
        !            98:                                break;
        !            99:                        }
        !           100:                }
        !           101:                cp++;
        !           102:        } while (bootf[i].let && *cp);
        !           103:        return (boothowto);
        !           104: }
        !           105:  
        !           106: /*
        !           107:  * Parse the boot line and put it in bootparam.  Stuff in -a -s or -as if
        !           108:  * s/he only typed one argument and if they were in effect before.
        !           109:  */
        !           110: parseparam(line, defaults, bp)
        !           111:        register char *line;
        !           112:        int defaults;
        !           113:        register struct bootparam *bp;
        !           114: {
        !           115:        register int narg = 0, i;
        !           116:        register char *cp = bp->bp_strings;
        !           117: 
        !           118:        while(*line) {
        !           119:                if (narg == 1)          /* terminate line for open */
        !           120:                        *line++ = 0;
        !           121:                while (*line == ' ')
        !           122:                        line++;
        !           123:                if (*line)
        !           124:                        bp->bp_argv[narg++] = cp;
        !           125:                while (*line != ' ' && *line != 0)
        !           126:                        *cp++ = *line++;
        !           127:                *cp++ = 0;
        !           128:        };
        !           129:        bp->bp_argv[narg] = 0;
        !           130:        /*
        !           131:         * Stuff in default switches
        !           132:         */
        !           133:        if (narg == 1 && defaults) {
        !           134:                bp->bp_argv[narg++] = cp;
        !           135:                *cp++ = '-';
        !           136:                for (i = 0; bootf[i].let; i++) {
        !           137:                        if (defaults & bootf[i].bit)
        !           138:                                *cp++ = bootf[i].let;
        !           139:                }
        !           140:                *cp = 0;
        !           141:                bp->bp_argv[narg] = 0;
        !           142:        }
        !           143: }

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