Return to kdb_print.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / kdb / Old

Annotation of 43BSDReno/sys/kdb/Old/kdb_print.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)kdb_print.c 7.16 (Berkeley) 5/3/90
        !             7:  */
        !             8: 
        !             9: #include "machine/mtpr.h"
        !            10: #undef ISP
        !            11: #include "../kdb/defs.h"
        !            12: #undef CTRL
        !            13: #include "ioctl.h"
        !            14: #include "tty.h"
        !            15: #include "vnode.h"
        !            16: #include "mount.h"
        !            17: 
        !            18: char   *BADRAD;
        !            19: 
        !            20: ADDR   lastframe;
        !            21: ADDR   callpc;
        !            22: 
        !            23: char   *BADMOD;
        !            24: char   *lp;
        !            25: long   maxpos;
        !            26: int    radix;
        !            27: char   lastc;
        !            28: 
        !            29: /* breakpoints */
        !            30: BKPTR  bkpthead;
        !            31: 
        !            32: extern REGLIST reglist[];
        !            33: 
        !            34: /* general printing routines ($) */
        !            35: 
        !            36: printtrace(modif)
        !            37: {
        !            38:        register narg, i;
        !            39:        register BKPTR bkptr;
        !            40:        register ADDR word;
        !            41:        register char *comptr;
        !            42:        register ADDR argp, frame;
        !            43:        register struct nlist *sp;
        !            44:        int ntramp;
        !            45:        register struct proc *p;
        !            46:        extern struct proc *allproc;
        !            47: 
        !            48:        if (cntflg==0)
        !            49:                cntval = -1;
        !            50:        switch (modif) {
        !            51: 
        !            52:        case 'd':
        !            53:                if (adrflg) {
        !            54:                        if (adrval < 2 || adrval > 16)
        !            55:                                error(BADRAD);
        !            56:                        radix = adrval;
        !            57:                }
        !            58:                printf("radix=%d base ten", radix);
        !            59:                break;
        !            60: 
        !            61:        case 'w': case 'W':
        !            62:                printf("maxpos=%d", maxpos=(adrflg?adrval:MAXPOS));
        !            63:                break;
        !            64: 
        !            65:        case 's': case 'S':
        !            66:                printf("maxoff=%d", maxoff=(adrflg?adrval:MAXOFF));
        !            67:                break;
        !            68: 
        !            69:        case 'V':
        !            70:                printf("variables\n");
        !            71:                for (i=0;i<=35;i++)
        !            72:                        if (var[i]) {
        !            73:                                printc((i<=9 ? '0' : 'a'-10) + i);
        !            74:                                printf(" = %R\n",var[i]);
        !            75:                        }
        !            76:                break;
        !            77: 
        !            78:        case 0: case '?':
        !            79:                if (p = (struct proc *)var[varchk('p')])
        !            80:                        printf("pid = %d\n", p->p_pid);
        !            81:                else
        !            82:                        printf("in idle loop\n");
        !            83:                printtrap(var[varchk('t')], var[varchk('c')]);
        !            84:                /* fall thru... */
        !            85:        case 'r': case 'R':
        !            86:                printregs(modif);
        !            87:                return;
        !            88: 
        !            89:        case 'c': case 'C':
        !            90:                if (adrflg) {
        !            91:                        frame = adrval;
        !            92:                        callpc = getprevpc(frame);
        !            93:                } else {
        !            94:                        frame = pcb.pcb_fp;
        !            95:                        callpc = pcb.pcb_pc;
        !            96:                }
        !            97:                lastframe = NOFRAME;
        !            98:                ntramp = 0;
        !            99:                while (cntval-- && frame != NOFRAME) {
        !           100:                        char *name;
        !           101: 
        !           102:                        chkerr();
        !           103:                        /* check for pc in pcb (signal trampoline code) */
        !           104:                        if (issignalpc(callpc)) {
        !           105:                                name = "sigtramp";
        !           106:                                ntramp++;
        !           107:                        } else {
        !           108:                                ntramp = 0;
        !           109:                                (void) findsym((long)callpc, ISYM);
        !           110:                                if (cursym)
        !           111:                                        name = cursym->n_un.n_name;
        !           112:                                else
        !           113:                                        name = "?";
        !           114:                        }
        !           115:                        printf("%s(", name);
        !           116:                        narg = getnargs(frame);
        !           117:                        if (narg > 10)
        !           118:                                narg = 10;
        !           119:                        argp = frame;
        !           120:                        if (ntramp != 1)
        !           121:                                while (narg) {
        !           122:                                        printf("%R",
        !           123:                                            get((off_t)(argp = nextarg(argp)),
        !           124:                                                DSP));
        !           125:                                        if (--narg != 0)
        !           126:                                                printc(',');
        !           127:                                }
        !           128:                        printf(") at ");
        !           129:                        psymoff((long)callpc, ISYM, "\n");
        !           130: 
        !           131:                        if (modif=='C') {
        !           132:                                while (localsym((long)frame)) {
        !           133:                                        word = get((off_t)localval, DSP);
        !           134:                                        printf("%8t%s:%10t",
        !           135:                                            cursym->n_un.n_name);
        !           136:                                        if (errflg) {
        !           137:                                                printf("?\n");
        !           138:                                                errflg = 0;
        !           139:                                        } else
        !           140:                                                printf("%R\n", word);
        !           141:                                }
        !           142:                        }
        !           143:                        if (ntramp != 1) {
        !           144:                                callpc = getprevpc(frame);
        !           145:                                lastframe = frame;
        !           146:                                frame = getprevframe(frame);
        !           147:                        } else
        !           148:                                callpc = getsignalpc(lastframe);
        !           149:                        if (!adrflg && !INSTACK(frame))
        !           150:                                break;
        !           151:                }
        !           152:                break;
        !           153: 
        !           154:                /*print externals*/
        !           155:        case 'e': case 'E':
        !           156:                for (sp = symtab; sp < esymtab; sp++)
        !           157:                        if (sp->n_type==(N_DATA|N_EXT) ||
        !           158:                            sp->n_type==(N_BSS|N_EXT))
        !           159:                                printf("%s:%12t%R\n", sp->n_un.n_name,
        !           160:                                        get((off_t)sp->n_value, DSP));
        !           161:                break;
        !           162: 
        !           163:                /*print breakpoints*/
        !           164:        case 'b': case 'B':
        !           165:                printf("breakpoints\ncount%8tbkpt%24tcommand\n");
        !           166:                for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt)
        !           167:                        if (bkptr->flag) {
        !           168:                                printf("%-8.8d",bkptr->count);
        !           169:                                psymoff((long)bkptr->loc,ISYM,"%24t");
        !           170:                                comptr=bkptr->comm;
        !           171:                                while (*comptr)
        !           172:                                        printc(*comptr++);
        !           173:                        }
        !           174:                break;
        !           175: 
        !           176:        case 'k':
        !           177:                panic("kdb requested panic");
        !           178:                /* NOTREACHED */
        !           179: 
        !           180:        case 'l': {
        !           181:                struct pte savemmap;
        !           182:                extern char vmmap[];
        !           183: 
        !           184:                savemmap = mmap[0];
        !           185:                for (p = allproc; p; p = p->p_nxt) {
        !           186:                        printf("%X pid %5d%c%5d %c ", p, p->p_pid,
        !           187:                                p == (struct proc *)var[varchk('p')]? '*' : ' ',
        !           188:                                p->p_ppid,
        !           189:                                p->p_stat == SSLEEP ? 'S' :
        !           190:                                p->p_stat == SRUN ? 'R':
        !           191:                                p->p_stat == SIDL ? 'I':
        !           192:                                p->p_stat == SSTOP ? 'T' : '?');
        !           193:                        if (p->p_wchan)
        !           194:                                psymoff((long)p->p_wchan, ISYM, "");
        !           195:                        if ((p->p_flag & SLOAD) && p->p_addr) {
        !           196:                                int i;
        !           197:                                *(int *)mmap = *(int *)p->p_addr;
        !           198:                                mtpr(TBIS, vmmap);
        !           199: #define U      ((struct user *)vmmap)
        !           200: #ifdef not_until_uarea_completely_mapped
        !           201:                                if (U->u_ttyp)
        !           202:                                        printf(" ctty %x ", U->u_ttyp);
        !           203: #endif
        !           204:                                printf(" %.8s ", p->p_comm);
        !           205: #undef U
        !           206:                        }
        !           207: 
        !           208:                        printc(EOR);
        !           209:                }
        !           210:                mmap[0] = savemmap;
        !           211:                mtpr(TBIS, vmmap);
        !           212:                break;
        !           213:        }
        !           214: 
        !           215:        case 't':       /* XXX - debug */
        !           216:                if (adrflg) {
        !           217:                      printf("dev       state  rawq   canq  outq  lwat hwat\n");
        !           218: 
        !           219: #define T      ((struct tty *)adrval)  
        !           220:                        printf("%x  %x %d %d %d %d %d\n", T->t_dev, 
        !           221:                                T->t_state, T->t_rawq.c_cc, 
        !           222:                                T->t_canq.c_cc, T->t_outq.c_cc,
        !           223:                                T->t_lowat, T->t_hiwat);
        !           224:               printf(" &rawq    &canq      &outq    &outq.c_cf  &rawq.c_cf\n");
        !           225:                        printf(" %x %x  %x %x %x \n", &T->t_rawq, 
        !           226:                                &T->t_canq, &T->t_outq, &T->t_outq.c_cf, 
        !           227:                                &T->t_rawq.c_cf);
        !           228: #undef T
        !           229:                }
        !           230: 
        !           231:        case 'v': {
        !           232:                register struct mount *mp;
        !           233:                register struct vnode *vp;
        !           234: 
        !           235:                printf("Locked vnodes\n");
        !           236:                mp = rootfs;
        !           237:                do {
        !           238:                        for (vp = mp->m_mounth; vp; vp = vp->v_mountf)
        !           239:                                if (VOP_ISLOCKED(vp))
        !           240:                                        vprint((char *)0, vp);
        !           241:                        mp = mp->m_next;
        !           242:                } while (mp != rootfs);
        !           243:                break;
        !           244:        }
        !           245: 
        !           246:        default:
        !           247:                error(BADMOD);
        !           248:        }
        !           249: }
        !           250: 
        !           251: static
        !           252: printregs(c)
        !           253: {
        !           254:        register REGPTR p;
        !           255:        ADDR v;
        !           256: 
        !           257:        for (p = reglist; p->rname; p++) {
        !           258:                if (c != 'R' && ishiddenreg(p))
        !           259:                        continue;
        !           260:                v = *p->rkern;
        !           261:                printf("%s%6t%R %16t", p->rname, v);
        !           262:                valpr((long)v, p->rkern == &pcb.pcb_pc ? ISYM : DSYM);
        !           263:                printc(EOR);
        !           264:        }
        !           265:        printpc();
        !           266: }
        !           267: 
        !           268: getreg(regnam)
        !           269: {
        !           270:        register REGPTR p;
        !           271:        register char *regptr;
        !           272:        char *olp;
        !           273: 
        !           274:        olp = lp;
        !           275:        for (p = reglist; p->rname; p++) {
        !           276:                regptr = p->rname;
        !           277:                if (regnam == *regptr++) {
        !           278:                        while (*regptr)
        !           279:                                if (readchar() != *regptr++) {
        !           280:                                        --regptr;
        !           281:                                        break;
        !           282:                                }
        !           283:                        if (*regptr)
        !           284:                                lp = olp;
        !           285:                        else
        !           286:                                return ((int)p->rkern);
        !           287:                }
        !           288:        }
        !           289:        lp = olp;
        !           290:        return (-1);
        !           291: }
        !           292: 
        !           293: printpc()
        !           294: {
        !           295: 
        !           296:        psymoff((long)pcb.pcb_pc, ISYM, ":%16t");
        !           297:        printins(ISP, (long)chkget((off_t)pcb.pcb_pc, ISP));
        !           298:        printc(EOR);
        !           299: }

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