1: /* This file contains some dumping routines for debugging. */
   2: 
   3: #include "kernel.h"
   4: #include <minix/com.h>
   5: #include "proc.h"
   6: 
   7: FORWARD _PROTOTYPE(char *proc_name, (int proc_nr));
   8: 
   9: #define click_to_round_k(n) \
  10:         ((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
  11: 
  12: /*===========================================================================*
  13:  *                              p_dmp                                        *
  14:  *===========================================================================*/
  15: #if (CHIP == INTEL)
  16: PUBLIC void p_dmp()
  17: {
  18: /* Proc table dump */
  19: 
  20:   register struct proc *rp;
  21:   static struct proc *oldrp = BEG_PROC_ADDR;
  22:   int n = ;
  23:   phys_clicks text, data, size;
  24: 
  25:   printf("\n--pid --pc- ---sp- flag -user --sys-- -text- -data- -size- -recv- command\n");
  26: 
  27:   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
  28:         if (isemptyp(rp)) continue;
  29:         if (++n > ) break;
  30:         text = rp->p_map[T].mem_phys;
  31:         data = rp->p_map[D].mem_phys;
  32:         size = rp->p_map[T].mem_len
  33:                 + ((rp->p_map[S].mem_phys + rp->p_map[S].mem_len) - data);
  34:         if (rp->p_pid == ) {
  35:                 printf("(%3d)", proc_number(rp));
  36:         } else {
  37:                 printf("%5d", rp->p_pid);
  38:         }
  39:         printf(" %5lx %6lx %2x %7lu %7lu %5uK %5uK %5uK ",
  40:                (unsigned long) rp->p_reg.pc,
  41:                (unsigned long) rp->p_reg.sp,
  42:                rp->p_flags,
  43:                rp->user_time, rp->sys_time,
  44:                click_to_round_k(text), click_to_round_k(data),
  45:                click_to_round_k(size));
  46:         if (rp->p_flags & RECEIVING) {
  47:                 printf("%-7.7s", proc_name(rp->p_getfrom));
  48:         } else
  49:         if (rp->p_flags & SENDING) {
  50:                 printf("S:%-5.5s", proc_name(rp->p_sendto));
  51:         } else
  52:         if (rp->p_flags == ) {
  53:                 printf("       ");
  54:         }
  55:         printf("%s\n", rp->p_name);
  56:   }
  57:   if (rp == END_PROC_ADDR) rp = BEG_PROC_ADDR; else printf("--more--\r");
  58:   oldrp = rp;
  59: }
  60: #endif                          /* (CHIP == INTEL) */
  61: 
  62: /*===========================================================================*
  63:  *                              map_dmp                                      *
  64:  *===========================================================================*/
  65: PUBLIC void map_dmp()
  66: {
  67:   register struct proc *rp;
  68:   static struct proc *oldrp = cproc_addr(HARDWARE);
  69:   int n = ;
  70:   phys_clicks size;
  71: 
  72:   printf("\nPROC NAME-  -----TEXT-----  -----DATA-----  ----STACK-----  -SIZE-\n");
  73:   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
  74:         if (isemptyp(rp)) continue;
  75:         if (++n > ) break;
  76:         size = rp->p_map[T].mem_len
  77:                 + ((rp->p_map[S].mem_phys + rp->p_map[S].mem_len)
  78:                                                 - rp->p_map[D].mem_phys);
  79:         printf("%3d %-6.6s  %4x %4x %4x  %4x %4x %4x  %4x %4x %4x  %5uK\n",
  80:                proc_number(rp),
  81:                rp->p_name,
  82:                rp->p_map[T].mem_vir, rp->p_map[T].mem_phys, rp->p_map[T].mem_len,
  83:                rp->p_map[D].mem_vir, rp->p_map[D].mem_phys, rp->p_map[D].mem_len,
  84:                rp->p_map[S].mem_vir, rp->p_map[S].mem_phys, rp->p_map[S].mem_len,
  85:                click_to_round_k(size));
  86:   }
  87:   if (rp == END_PROC_ADDR) rp = cproc_addr(HARDWARE); else printf("--more--\r");
  88:   oldrp = rp;
  89: }
  90: 
  91: #if (CHIP == M68000)
  92: FORWARD _PROTOTYPE(void mem_dmp, (char *adr, int len));
  93: 
  94: /*===========================================================================*
  95:  *                              p_dmp                                        *
  96:  *===========================================================================*/
  97: PUBLIC void p_dmp()
  98: {
  99: /* Proc table dump */
 100: 
 101:   register struct proc *rp;
 102:   static struct proc *oldrp = BEG_PROC_ADDR;
 103:   int n = 0;
 104:   vir_clicks base, limit;
 105: 
 106:   printf(
 107:          "\nproc pid     pc     sp  splow flag  user    sys   recv   command\n");
 108: 
 109:   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
 110:         if (isemptyp(rp)) continue;
 111:         if (++n > 20) break;
 112:         base = rp->p_map[T].mem_phys;
 113:         limit = rp->p_map[S].mem_phys + rp->p_map[S].mem_len;
 114:         printf("%4u %4u %6lx %6lx %6lx %4x %5lu %6lu   ",
 115:                proc_number(rp),
 116:                rp->p_pid,
 117:                (unsigned long) rp->p_reg.pc,
 118:                (unsigned long) rp->p_reg.sp,
 119:                (unsigned long) rp->p_splow,
 120:                rp->p_flags,
 121:                rp->user_time, rp->sys_time);
 122:         if (rp->p_flags & RECEIVING) {
 123:                 printf("%-7.7s", proc_name(rp->p_getfrom));
 124:         } else
 125:         if (rp->p_flags & SENDING) {
 126:                 printf("S:%-5.5s", proc_name(rp->p_sendto));
 127:         } else
 128:         if (rp->p_flags == 0) {
 129:                 printf("       ");
 130:         }
 131:         printf("%s\n", rp->p_name);
 132:   }
 133:   if (rp == END_PROC_ADDR) rp = BEG_PROC_ADDR; else printf("--more--\r");
 134:   oldrp = rp;
 135: }
 136: 
 137: 
 138: /*===========================================================================*
 139:  *                              reg_dmp                                      *
 140:  *===========================================================================*/
 141: PUBLIC void reg_dmp(rp)
 142: struct proc *rp;
 143: {
 144:   register int i;
 145:   static char *regs[NR_REGS] = {
 146:                     "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
 147:                     "a0", "a1", "a2", "a3", "a4", "a5", "a6"
 148:   };
 149:   reg_t *regptr = (reg_t *) & rp->p_reg;
 150: 
 151:   printf("reg = %08lx, ", rp);
 152:   printf("ksp = %08lx\n", (long) &rp + sizeof(rp));
 153:   printf(" pc = %08lx, ", rp->p_reg.pc);
 154:   printf(" sr =     %04x, ", rp->p_reg.psw);
 155:   printf("trp =       %2x\n", rp->p_trap);
 156:   for (i = 0; i < NR_REGS; i++) 
 157:         printf("%3s = %08lx%s",regs[i], *regptr++, (i&3) == 3 ? "\n" : ", ");
 158:   printf(" a7 = %08lx\n", rp->p_reg.sp);
 159:     mem_dmp((char *) (((long) rp->p_reg.pc & ~31L) - 96), 128);
 160:     mem_dmp((char *) (((long) rp->p_reg.sp & ~31L) - 32), 256);
 161: }
 162: 
 163: 
 164: /*===========================================================================*
 165:  *                              mem_dmp                                      *
 166:  *===========================================================================*/
 167: PRIVATE void mem_dmp(adr, len)
 168: char *adr;
 169: int len;
 170: {
 171:   register i;
 172:   register long *p;
 173: 
 174:   for (i = 0, p = (long *) adr; i < len; i += 4) {
 175: #if (CHIP == M68000)
 176:         if ((i & 31) == 0) printf("\n%lX:", p);
 177:         printf(" %8lX", *p++);
 178: #else
 179:         if ((i & 31) == 0) printf("\n%X:", p);
 180:         printf(" %8X", *p++);
 181: #endif /* (CHIP == M68000) */
 182:   }
 183:   printf("\n");
 184: }
 185: 
 186: #endif                          /* (CHIP == M68000) */
 187: 
 188: 
 189: /*===========================================================================*
 190:  *                              proc_name                                    *
 191:  *===========================================================================*/
 192: PRIVATE char *proc_name(proc_nr)
 193: int proc_nr;
 194: {
 195:   if (proc_nr == ANY) return "ANY";
 196:   return proc_addr(proc_nr)->p_name;
 197: }