Return to setup.c CVS log

Up to [Research Unix] / researchv8dc / cmd / adb

Annotation of researchv8dc/cmd/adb/setup.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * adb - routines to read a.out+core at startup
        !             3:  * stuff in here is pretty vax dependent
        !             4:  */
        !             5: #include "defs.h"
        !             6: #include "machine.h"
        !             7: #include <a.out.h>
        !             8: #include <sys/types.h>
        !             9: #include <sys/dir.h>
        !            10: #include <sys/user.h>
        !            11: #include <sys/proc.h>
        !            12: #include <sys/pioctl.h>
        !            13: #include "base.h"
        !            14: 
        !            15: char   *symfil = "a.out";
        !            16: char   *corfil = "core";
        !            17: 
        !            18: MAP    symmap[NMAP];
        !            19: MAP    cormap[NMAP];
        !            20: 
        !            21: int fsym, fcor;
        !            22: 
        !            23: static ADDR datbase;
        !            24: ADDR txtsize, datsize, stksize;
        !            25: static ADDR entry;
        !            26: static int magic;
        !            27: 
        !            28: setsym()
        !            29: {
        !            30:        ADDR loc;
        !            31:        struct exec hdr;
        !            32:        register struct nlist *sp;
        !            33:        int ssiz;
        !            34:        register char *strtab;
        !            35:        register MAP *mp;
        !            36:        char *malloc();
        !            37: 
        !            38:        fsym = getfile(symfil, 1);
        !            39:        mp = symmap;
        !            40:        if (read(fsym, (char *)&hdr, sizeof hdr) != sizeof hdr ||
        !            41:            badmagic(hdr.a_magic)) {
        !            42:                mp->f = mp->b = 0;
        !            43:                mp->e = MAXFILE;
        !            44:                mp->sp = DATASP;
        !            45:                mp->flag = MPINUSE;
        !            46:                mp++;
        !            47:                mp->flag = 0;
        !            48:                return;
        !            49:        }
        !            50:        magic = hdr.a_magic;
        !            51:        entry = hdr.a_entry;
        !            52:        loc = hdr.a_text+hdr.a_data;
        !            53:        switch (magic) {
        !            54: 
        !            55:        case OMAGIC:
        !            56:                txtsize = 0;
        !            57:                datbase = 0;
        !            58:                datsize = loc;
        !            59:                mp->b = 0;
        !            60:                mp->e = loc;
        !            61:                mp->f = N_TXTOFF(hdr);
        !            62:                mp->sp = DATASP;
        !            63:                mp->flag = MPINUSE;
        !            64:                break;
        !            65: 
        !            66:        case ZMAGIC:
        !            67:        case NMAGIC:
        !            68:                mp->b = 0;
        !            69:                mp->e = txtsize = hdr.a_text;
        !            70:                mp->f = N_TXTOFF(hdr);
        !            71:                mp->sp = INSTSP;
        !            72:                mp->flag = MPINUSE;
        !            73:                mp++;
        !            74:                mp->b = datbase = round((WORD)hdr.a_text, (WORD)PAGSIZ);
        !            75:                mp->e = datsize = datbase + hdr.a_data;
        !            76:                mp->f = N_TXTOFF(hdr) + hdr.a_text;
        !            77:                mp->sp = DATASP;
        !            78:                mp->flag = MPINUSE;
        !            79:                break;
        !            80:        }
        !            81:        loc = N_SYMOFF(hdr);
        !            82:        symtab = (struct nlist *) malloc(hdr.a_syms);
        !            83:        esymtab = &symtab[hdr.a_syms / sizeof (struct nlist)];
        !            84:        if (symtab == NULL) {
        !            85:                printf("no space for symbol table\n");
        !            86:                goto nosymt;
        !            87:        }
        !            88:        lseek(fsym, (off_t)loc, 0);
        !            89:        if (hdr.a_syms == 0)
        !            90:                goto nosymt;
        !            91:        if (read(fsym, symtab, hdr.a_syms) != hdr.a_syms
        !            92:        || read(fsym, (char *)&ssiz, sizeof(ssiz)) != sizeof(ssiz)) {
        !            93:                printf("error reading string table\n");
        !            94:                goto nosymt;
        !            95:        }
        !            96:        strtab = (char *) malloc(ssiz);
        !            97:        if (strtab == 0) {
        !            98:                printf("no space for string table\n");
        !            99:                goto nosymt;
        !           100:        }
        !           101:        *(int *)strtab = ssiz;
        !           102:        ssiz -= sizeof (ssiz);
        !           103:        if (read(fsym, strtab + sizeof (ssiz), ssiz) != ssiz) {
        !           104:                printf("error reading symbol table\n");
        !           105:                goto nosymt;
        !           106:        }
        !           107:        for (sp = symtab; sp < esymtab; sp++)
        !           108:                if (sp->n_un.n_strx)
        !           109:                        /* SHOULD PERFORM RANGE CHECK HERE */
        !           110:                        sp->n_un.n_name = strtab + sp->n_un.n_strx;
        !           111: nosymt:
        !           112:        if (INKERNEL(entry)) {
        !           113:                symmap[0].b += KERNOFF;
        !           114:                symmap[1].b += KERNOFF;
        !           115:                symmap[0].e += KERNOFF;
        !           116:                symmap[1].e += KERNOFF;
        !           117:        }
        !           118:        mp++;
        !           119:        mp->flag = 0;
        !           120: }
        !           121: 
        !           122: setcor()
        !           123: {
        !           124:        register MAP *mp;
        !           125: 
        !           126:        fcor = getfile(corfil,2);
        !           127:        if (fcor < 0
        !           128:        ||  (mapimage() == 0 && mapcore() == 0)) {
        !           129:                /* not a core image */
        !           130:                mp = cormap;
        !           131:                mp->b = 0;
        !           132:                mp->e = MAXFILE;
        !           133:                mp->f = 0;
        !           134:                mp->sp = DATASP;
        !           135:                mp->flag = MPINUSE;
        !           136:                mp++;
        !           137:                mp->flag = 0;
        !           138:                return;
        !           139:        }
        !           140: }
        !           141: 
        !           142: /*
        !           143:  * set up maps for a direct process image (/proc)
        !           144:  */
        !           145: 
        !           146: int
        !           147: mapimage()
        !           148: {
        !           149:        struct user u;
        !           150:        struct proc p;
        !           151:        register MAP *mp;
        !           152: 
        !           153:        if (ioctl(fcor, PIOCGETPR, &p) < 0)
        !           154:                return (0);             /* not /proc */
        !           155:        lseek(fcor, (off_t)UBASE, 0);
        !           156:        if (read(fcor, (char *)&u, sizeof(u)) != sizeof(u)
        !           157:        ||  badmagic(u.u_exdata.ux_mag)) {
        !           158:                printf("%s: can't read user block\n", corfil);
        !           159:                return (0);
        !           160:        }
        !           161:        if (p.p_stat != SSTOP)
        !           162:                signo = 0;              /* running */
        !           163:        else
        !           164:                signo = p.p_cursig;
        !           165:        sigcode = u.u_code;
        !           166:        txtsize = ctob(u.u_tsize);
        !           167:        datsize = ctob(u.u_dsize);
        !           168:        stksize = ctob(u.u_ssize);
        !           169: #if NOTDEF             /* no ID separation on VAX */
        !           170:        if (magic == IMAGIC)
        !           171:                datbase = 0;
        !           172:        else
        !           173: #endif
        !           174:                datbase = txtsize;
        !           175:        mp = cormap;
        !           176:        if (txtsize) {
        !           177:                mp->b = 0;
        !           178:                mp->e = txtsize;
        !           179:                mp->f = TXTBASE;
        !           180:                mp->flag = MPINUSE;
        !           181: #if NOTDEF             /* no ID separation on VAX */
        !           182:                if (magic == IMAGIC)
        !           183:                        mp->sp = INSTSP;
        !           184:                else
        !           185: #endif
        !           186:                        mp->sp = DATASP;
        !           187:                mp++;
        !           188:        }
        !           189:        mp->b = txtsize;
        !           190:        mp->e = mp->b + datsize;
        !           191:        mp->f = DATBASE + mp->b;
        !           192:        mp->sp = DATASP;
        !           193:        mp->flag = MPINUSE;
        !           194:        mp++;
        !           195:        mp->b = MAXSTOR - stksize;
        !           196:        mp->e = MAXSTOR + ctob(UPAGES);
        !           197:        mp->f = DATBASE + mp->b;
        !           198:        mp->sp = DATASP;
        !           199:        mp->flag = MPINUSE;
        !           200:        mp++;
        !           201:        mp->b = 0;
        !           202:        mp->e = ctob(UPAGES);
        !           203:        mp->f = UBASE;
        !           204:        mp->sp = UBLKSP;
        !           205:        mp->flag = MPINUSE;
        !           206:        mp++;
        !           207:        mp->flag = 0;
        !           208:        rsnarf();
        !           209:        return (1);
        !           210: }
        !           211: 
        !           212: mapcore()
        !           213: {
        !           214:        struct user u;
        !           215:        register MAP *mp;
        !           216: 
        !           217:        lseek(fcor, (off_t)0, 0);
        !           218:        if (read(fcor, (char *)&u, sizeof(u)) != sizeof(u)
        !           219:        ||  badmagic(u.u_exdata.ux_mag))
        !           220:                return (0);
        !           221:        if (magic && magic != u.u_exdata.ux_mag)
        !           222:                printf("%s: not from %s\n", corfil, symfil);
        !           223:        magic = u.u_exdata.ux_mag;
        !           224:        signo = u.u_arg[0];
        !           225:        sigcode = u.u_code;
        !           226:        txtsize = ctob(u.u_tsize);
        !           227:        datsize = ctob(u.u_dsize);
        !           228:        stksize = ctob(u.u_ssize);
        !           229:        mp = cormap;
        !           230:        switch (magic) {
        !           231: 
        !           232:        case OMAGIC:
        !           233:                mp->b = 0;
        !           234:                mp->e = txtsize + datsize;
        !           235:                mp->f = ctob(UPAGES);
        !           236:                mp->sp = DATASP;
        !           237:                mp->flag = MPINUSE;
        !           238:                mp++;
        !           239:                mp->b = MAXSTOR - stksize;
        !           240:                mp->e = MAXSTOR;
        !           241:                mp->f = txtsize + datsize + ctob(UPAGES);
        !           242:                mp->sp = DATASP;
        !           243:                mp->flag = MPINUSE;
        !           244:                break;
        !           245: 
        !           246:        case NMAGIC:
        !           247:        case ZMAGIC:
        !           248:                mp->b = txtsize;
        !           249:                mp->e = mp->b + datsize;
        !           250:                mp->f = ctob(UPAGES);
        !           251:                mp->sp = DATASP;
        !           252:                mp->flag = MPINUSE;
        !           253:                mp++;
        !           254:                mp->b = MAXSTOR - stksize;
        !           255:                mp->e = MAXSTOR;
        !           256:                mp->f = datsize + ctob(UPAGES);
        !           257:                mp->sp = DATASP;
        !           258:                mp->flag = MPINUSE;
        !           259:                break;
        !           260:        }
        !           261:        mp++;
        !           262:        mp->b = 0;
        !           263:        mp->e = ctob(UPAGES);
        !           264:        mp->f = 0;
        !           265:        mp->sp = UBLKSP;
        !           266:        mp->flag = MPINUSE;
        !           267:        mp++;
        !           268:        mp->flag = 0;
        !           269:        rsnarf();
        !           270:        return (1);
        !           271: }
        !           272: 
        !           273: badmagic(num)
        !           274: int num;
        !           275: {
        !           276: 
        !           277:        switch (num) {
        !           278:        case OMAGIC:
        !           279:        case NMAGIC:
        !           280:        case ZMAGIC:
        !           281:                return (0);
        !           282: 
        !           283:        default:
        !           284:                return (1);
        !           285:        }
        !           286: }
        !           287: 
        !           288: cmdmap(itype, star)
        !           289: register int star, itype;
        !           290: {
        !           291:        register MAP *mp;
        !           292:        extern char lastc;
        !           293: 
        !           294:        if (itype & SYMF)
        !           295:                mp = symmap;
        !           296:        else
        !           297:                mp = cormap;
        !           298:        if (star)       /* UGH */
        !           299:                mp++;
        !           300:        if (expr(0))
        !           301:                mp->b = expv; 
        !           302:        if (expr(0))
        !           303:                mp->e = expv; 
        !           304:        if (expr(0))
        !           305:                mp->f = expv; 
        !           306:        mp->flag |= MPINUSE;
        !           307:        if (rdc()=='?' && (itype&SYMF) == 0) {
        !           308:                if (fcor)
        !           309:                        close(fcor);
        !           310:                fcor=fsym;
        !           311:        } else if (lastc == '/' && itype&SYMF) {
        !           312:                if (fsym)
        !           313:                        close(fsym);
        !           314:                fsym=fcor;
        !           315:        } else
        !           316:                reread();
        !           317: }
        !           318: 
        !           319: create(f)
        !           320:        char *f;
        !           321: {
        !           322:        register int fd;
        !           323: 
        !           324:        fd = creat(f, 0666);
        !           325:        if (fd < 0)
        !           326:                return (-1);
        !           327:        close(fd);
        !           328:        return (open(f, wtflag));
        !           329: }
        !           330: 
        !           331: getfile(filnam, cnt)
        !           332:        char *filnam;
        !           333: {
        !           334:        register int fsym;
        !           335: 
        !           336:        if (strcmp(filnam, "-") == 0)
        !           337:                return (-1);
        !           338:        fsym = open(filnam, wtflag);
        !           339:        if (fsym < 0 && xargc > cnt) {
        !           340:                if (wtflag)
        !           341:                        fsym = create(filnam);
        !           342:                if (fsym < 0)
        !           343:                        printf("cannot open `%s'\n", filnam);
        !           344:        }
        !           345:        return (fsym);
        !           346: }
        !           347: 
        !           348: setvar()
        !           349: {
        !           350: 
        !           351:        var[varchk('b')] = datbase;
        !           352:        var[varchk('d')] = datsize;
        !           353:        var[varchk('e')] = entry;
        !           354:        var[varchk('m')] = magic;
        !           355:        var[varchk('s')] = stksize;
        !           356:        var[varchk('t')] = txtsize;
        !           357: }

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