Return to setup.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / common_source

Annotation of 43BSDReno/bin/adb/common_source/setup.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)setup.c    5.3 (Berkeley) 6/25/90";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * adb - routines to read a.out and core files at startup
        !             7:  */
        !             8: 
        !             9: #include "defs.h"
        !            10: #include <sys/file.h>
        !            11: #include <machine/machparam.h>
        !            12: 
        !            13: static struct exec filhdr;
        !            14: 
        !            15: off_t  lseek();
        !            16: char   *malloc();
        !            17: 
        !            18: /* NB. the following works only with letter (alpha) variables */
        !            19: #define        setavar(name, value) (var[(name) - 'a' + 10] = (value))
        !            20: 
        !            21: setsym()
        !            22: {
        !            23:        register struct nlist *sp;
        !            24:        int strsize;
        !            25:        char *strtab;
        !            26:        off_t loc, dbase;
        !            27: 
        !            28:        txtmap.ufd = symfile.fd = getfile(1);
        !            29:        if (read(symfile.fd, (char *)&filhdr, sizeof(filhdr)) != sizeof(filhdr) ||
        !            30:            N_BADMAG(filhdr)) {
        !            31:                bzero((char *)&filhdr, sizeof(filhdr));
        !            32:                txtmap.m1.e = -(addr_t)1;
        !            33:                return;
        !            34:        }
        !            35:        loc = filhdr.a_text + filhdr.a_data;
        !            36:        txtmap.m1.f = txtmap.m2.f = N_TXTOFF(filhdr);
        !            37:        switch ((int)filhdr.a_magic) {
        !            38: 
        !            39:        case OMAGIC:
        !            40:                /* text map 1 is empty; map 2 goes from 0 to loc */
        !            41:                txtmap.m2.b = dbase = 0;
        !            42:                txtmap.m2.e = loc;
        !            43:                break;
        !            44: 
        !            45:        case ZMAGIC:
        !            46:        case NMAGIC:
        !            47:                /* text map 1 maps text segment, map 2 maps data */
        !            48:                txtmap.m1.e = filhdr.a_text;
        !            49:                txtmap.m2.b = dbase = roundup(filhdr.a_text, CLBYTES);
        !            50:                txtmap.m2.e = dbase + filhdr.a_data;
        !            51:                txtmap.m2.f += txtmap.m1.e;
        !            52:                break;
        !            53:        }
        !            54: 
        !            55:        /* save data segment base in variable b */
        !            56:        setavar('b', dbase);
        !            57: 
        !            58:        if (filhdr.a_syms != 0) {
        !            59:                loc = N_SYMOFF(filhdr);
        !            60:                symtab = (struct nlist *)malloc((u_int)filhdr.a_syms);
        !            61:                if (symtab == NULL)
        !            62:                        goto nospace;
        !            63:                esymtab = &symtab[filhdr.a_syms / sizeof(struct nlist)];
        !            64:                (void) lseek(symfile.fd, loc, L_SET);
        !            65: 
        !            66: #define        rd(a, n) \
        !            67:        if (read(symfile.fd, (char *)(a), (int)(n)) != (n)) \
        !            68:                goto readerr
        !            69: 
        !            70:                rd(symtab, filhdr.a_syms);
        !            71:                rd(&strsize, sizeof(strsize));
        !            72:                /*
        !            73:                 * offsets in the string table are relative to the offset
        !            74:                 * of the number we just read; we adjust for it here.
        !            75:                 */
        !            76:                strsize -= sizeof(strsize);
        !            77:                if ((strtab = malloc((u_int)strsize)) == NULL)
        !            78:                        goto nospace;
        !            79:                rd(strtab, strsize);
        !            80:                for (sp = symtab; sp < esymtab; sp++) {
        !            81:                        if (sp->n_un.n_strx == 0)
        !            82:                                continue;
        !            83:                        sp->n_un.n_strx -= sizeof(strsize);
        !            84:                        if ((u_long)sp->n_un.n_strx >= strsize) {
        !            85:                                adbprintf("bad string index %D in symtab\n",
        !            86:                                    (expr_t)sp->n_un.n_strx);
        !            87:                                sp->n_un.n_name = "";
        !            88:                        } else
        !            89:                                sp->n_un.n_name = strtab + sp->n_un.n_strx;
        !            90:                }
        !            91: #undef rd
        !            92:        }
        !            93:        if (INKERNEL(filhdr.a_entry)) {
        !            94:                txtmap.m1.b += KERNTEXTOFF;
        !            95:                txtmap.m1.e += KERNTEXTOFF;
        !            96:                txtmap.m2.b += KERNTEXTOFF;
        !            97:                txtmap.m2.e += KERNTEXTOFF;
        !            98:        }
        !            99:        return;
        !           100: 
        !           101: readerr:
        !           102:        prints("Error reading symbol|string table (old format a.out?)\n");
        !           103:        exit(1);
        !           104:        /* NOTREACHED */
        !           105: 
        !           106: nospace:
        !           107:        prints("Not enough space for symbol|string table\n");
        !           108:        exit(1);
        !           109:        /* NOTREACHED */
        !           110: }
        !           111: 
        !           112: setcore()
        !           113: {
        !           114:        off_t stacksize;
        !           115: 
        !           116:        datmap.m1.e = -(addr_t)1;
        !           117:        if ((datmap.ufd = corefile.fd = getfile(2)) < 0)
        !           118:                goto ret;
        !           119:        if (kernel && INKERNEL(filhdr.a_entry) && getkcore()) {
        !           120:                kcore = 1;
        !           121:                goto ret;
        !           122:        }
        !           123:        if (read(corefile.fd, (char *)&u, ctob(UPAGES)) != ctob(UPAGES) ||
        !           124:            !udot()) {
        !           125:                adbprintf("not core file = %s\n", corefile.name);
        !           126:                goto ret;
        !           127:        }
        !           128:        signo = u.u_sig;
        !           129:        sigcode = u.u_code;
        !           130:        filhdr.a_text = ctob(u.u_tsize);
        !           131:        filhdr.a_data = ctob(u.u_dsize);
        !           132:        stacksize = ctob(u.u_ssize);
        !           133:        switch ((int)filhdr.a_magic) {
        !           134: 
        !           135:        case OMAGIC:
        !           136:                datmap.m1.b = 0;
        !           137:                datmap.m1.e = filhdr.a_text + filhdr.a_data;
        !           138:                datmap.m2.f = ctob(UPAGES) + datmap.m1.e;
        !           139:                break;
        !           140: 
        !           141:        case NMAGIC:
        !           142:        case ZMAGIC:
        !           143:                datmap.m1.b = roundup(filhdr.a_text, CLBYTES);
        !           144:                datmap.m1.e = datmap.m1.b + filhdr.a_data;
        !           145:                datmap.m2.f = ctob(UPAGES) + filhdr.a_data;
        !           146:                break;
        !           147:        }
        !           148:        /* save (possibly new) data segment base, and save stack size */
        !           149:        setavar('b', datmap.m1.b);
        !           150:        setavar('s', stacksize);
        !           151:        datmap.m1.f = ctob(UPAGES);
        !           152:        datmap.m2.b = KERNBASE - ctob(UPAGES) - stacksize;
        !           153:        datmap.m2.e = KERNBASE - ctob(UPAGES);
        !           154: ret:
        !           155:        u.u_ar0 = (int *)((caddr_t)&u + ctob(UPAGES));  /* XXX */
        !           156:        setavar('d', filhdr.a_data);
        !           157:        setavar('e', filhdr.a_entry);
        !           158:        setavar('m', filhdr.a_magic);
        !           159:        setavar('t', filhdr.a_text);
        !           160: }

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