~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~
dmp.c

  1 static char rcsid[] = "$Id: dmp.c,v 1.4 1996/06/04 09:01:02 paul Exp $";
  2 /* This file contains some dumping routines for debugging. */
  3 
  4 #include "kernel.h"
  5 #include <minix/com.h>
  6 #include "proc.h"
  7 
  8 char *vargv;
  9 
 10 FORWARD _PROTOTYPE(char *proc_name, (int proc_nr));
 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 = 0;
 23   phys_clicks text, data, size;
 24   int proc_nr;
 25 
 26   printf("\n--pid --pc- ---sp- flag -user --sys-- -text- -data- -size- -recv- command\n");
 27 
 28   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
 29         proc_nr = proc_number(rp);
 30         if (rp->p_flags & P_SLOT_FREE) continue;
 31         if (++n > 20) break;
 32         text = rp->p_map[T].mem_phys;
 33         data = rp->p_map[D].mem_phys;
 34         size = rp->p_map[T].mem_len
 35                 + ((rp->p_map[S].mem_phys + rp->p_map[S].mem_len) - data);
 36         printf("%5d %5lx %6lx %2x %7U %7U %5uK %5uK %5uK ",
 37                proc_nr < 0 ? proc_nr : rp->p_pid,
 38                (unsigned long) rp->p_reg.pc,
 39                (unsigned long) rp->p_reg.sp,
 40                rp->p_flags,
 41                rp->user_time, rp->sys_time,
 42                click_to_round_k(text), click_to_round_k(data),
 43                click_to_round_k(size));
 44         if (rp->p_flags & RECEIVING) {
 45                 printf("%-7.7s", proc_name(rp->p_getfrom));
 46         } else
 47         if (rp->p_flags & SENDING) {
 48                 printf("S:%-5.5s", proc_name(rp->p_sendto));
 49         } else
 50         if (rp->p_flags == 0) {
 51                 printf("       ");
 52         }
 53         printf("%s\n", rp->p_name);
 54   }
 55   if (rp == END_PROC_ADDR) rp = BEG_PROC_ADDR; else printf("--more--\r");
 56   oldrp = rp;
 57 }
 58 #endif                          /* (CHIP == INTEL) */
 59 
 60 /*===========================================================================*
 61  *                              p_dmp                                        *
 62  *===========================================================================*/
 63 #if (MACHINE == SUN)
 64 PUBLIC void p_dmp()
 65 {
 66 /* Proc table dump */
 67 
 68   register struct proc *rp;
 69   int index;
 70 
 71   printf(
 72  "\ncommand pid    pc        sp      flag user    sys  recv   send\n");
 73 
 74   for (rp = BEG_PROC_ADDR; rp < END_PROC_ADDR; rp++)  {
 75         if (rp->p_flags & P_SLOT_FREE) continue;
 76         printf("%-7.7s", rp->p_name);
 77         printf("%4d %8X  %8X %6X %4D %6D  ",
 78                 rp->p_pid, (long)rp->p_reg.pc,
 79                 (long)rp->p_reg.sp,
 80                 rp->p_flags, rp->user_time, rp->sys_time);
 81         printf("%-7.7s", rp->p_flags & RECEIVING ? proc_name(rp->p_getfrom) :
 82                "");
 83         if (rp->p_flags & SENDING) {
 84                 printf("S: ");
 85                 printf("%-7.7s", proc_name(rp->p_sendto));
 86         }
 87         printf("\n");
 88   }
 89   printf("\nproc       callq   sendlk   mesbuf from   to   nready pend blkd held alarm\n");
 90   for (rp = &proc[0]; rp < &proc[NR_PROCS+NR_TASKS]; rp++)  {
 91         if (rp->p_flags & P_SLOT_FREE) continue;
 92         printf("%-7.7s", rp->p_name);
 93         printf(" %8X %8X %8X %4d %4d %8X %4d %4d %4d %X\n",
 94                 rp->p_callerq,
 95                 rp->p_sendlink,
 96                 rp->p_messbuf,
 97                 rp->p_getfrom,
 98                 rp->p_sendto,
 99                 rp->p_nextready,
100                 rp->p_pending,
101                 rp->p_int_blocked,
102                 rp->p_int_held,
103                 rp->p_alarm
104         );
105   }
106   for (index = 0; index < NQ; index++) {
107         printf("q=%d: ", index);
108         for (rp = rdy_head[index]; rp != NIL_PROC; rp = rp->p_nextready)
109                 printf(" %d", (int)(rp-proc));
110         printf("\n");
111   }
112   printf("held_head = 0x%X\n", held_head);
113   printf("\n");
114 }
115 #endif /* MACHINE == SUN */
116 
117 /*===========================================================================*
118  *                              map_dmp                                      *
119  *===========================================================================*/
120 #if (SHADOWING == 0)
121 PUBLIC void map_dmp()
122 {
123   register struct proc *rp;
124   static struct proc *oldrp = cproc_addr(HARDWARE);
125   int n = 0;
126   phys_clicks size;
127 
128   printf("\nPROC NAME-  -----TEXT-----  -----DATA-----  ----STACK-----  -SIZE-\n");
129   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
130         if (rp->p_flags & P_SLOT_FREE) continue;
131         if (++n > 20) break;
132         size = rp->p_map[T].mem_len +
133 #if (MACHINE == SUN)
134             rp->p_map[D].mem_len + rp->p_map[S].mem_len;
135 #else
136                 ((rp->p_map[S].mem_phys + rp->p_map[S].mem_len)
137                                                 - rp->p_map[D].mem_phys);
138 #endif
139         printf("%3d %-6.6s  %4x %4x %4x  %4x %4x %4x  %4x %4x %4x  %5uK\n",
140                proc_number(rp),
141                rp->p_name,
142                rp->p_map[T].mem_vir, rp->p_map[T].mem_phys, rp->p_map[T].mem_len,
143                rp->p_map[D].mem_vir, rp->p_map[D].mem_phys, rp->p_map[D].mem_len,
144                rp->p_map[S].mem_vir, rp->p_map[S].mem_phys, rp->p_map[S].mem_len,
145                click_to_round_k(size));
146   }
147   if (rp == END_PROC_ADDR) rp = cproc_addr(HARDWARE); else printf("--more--\r");
148   oldrp = rp;
149 }
150 
151 #else
152 
153 PUBLIC void map_dmp()
154 {
155   register struct proc *rp;
156   static struct proc *oldrp = cproc_addr(HARDWARE);
157   int n = 0;
158   vir_clicks base, limit;
159 
160   printf("\nPROC NAME-  --TEXT---  --DATA---  --STACK-- SHADOW FLIP P BASE  SIZE\n");
161   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
162         if (rp->p_flags & P_SLOT_FREE) continue;
163         if (++n > 20) break;
164         base = rp->p_map[T].mem_phys;
165         limit = rp->p_map[S].mem_phys + rp->p_map[S].mem_len;
166         printf("%3d %-6.6s  %4x %4x  %4x %4x  %4x %4x   %4x %4d %d %4uK\n",
167                proc_number(rp),
168                rp->p_name,
169                rp->p_map[T].mem_phys, rp->p_map[T].mem_len,
170                rp->p_map[D].mem_phys, rp->p_map[D].mem_len,
171                rp->p_map[S].mem_phys, rp->p_map[S].mem_len,
172                rp->p_shadow, rp->p_nflips, rp->p_physio,
173                click_to_round_k(base), click_to_round_k(limit));
174   }
175   if (rp == END_PROC_ADDR) rp = cproc_addr(HARDWARE); else printf("--more--\r");
176   oldrp = rp;
177 }
178 
179 #endif
180 
181 #if (CHIP == M68000)
182 FORWARD _PROTOTYPE(void mem_dmp, (char *adr, int len));
183 
184 /*===========================================================================*
185  *                              p_dmp                                        *
186  *===========================================================================*/
187 PUBLIC void p_dmp()
188 {
189 /* Proc table dump */
190 
191   register struct proc *rp;
192   static struct proc *oldrp = BEG_PROC_ADDR;
193   int n = 0;
194   vir_clicks base, limit;
195 
196   printf(
197          "\nproc pid     pc     sp  splow flag  user    sys   recv   command\n");
198 
199   for (rp = oldrp; rp < END_PROC_ADDR; rp++) {
200         if (rp->p_flags & P_SLOT_FREE) continue;
201         if (++n > 20) break;
202         base = rp->p_map[T].mem_phys;
203         limit = rp->p_map[S].mem_phys + rp->p_map[S].mem_len;
204         printf("%4u %4u %6lx %6lx %6lx %4x %5U %6U   ",
205                proc_number(rp),
206                rp->p_pid,
207                (unsigned long) rp->p_reg.pc,
208                (unsigned long) rp->p_reg.sp,
209                (unsigned long) rp->p_splow,
210                rp->p_flags,
211                rp->user_time, rp->sys_time);
212         if (rp->p_flags & RECEIVING) {
213                 printf("%-7.7s", proc_name(rp->p_getfrom));
214         } else
215         if (rp->p_flags & SENDING) {
216                 printf("S:%-5.5s", proc_name(rp->p_sendto));
217         } else
218         if (rp->p_flags == 0) {
219                 printf("       ");
220         }
221         printf("%s\n", rp->p_name);
222   }
223   if (rp == END_PROC_ADDR) rp = BEG_PROC_ADDR; else printf("--more--\r");
224   oldrp = rp;
225 }
226 
227 
228 /*===========================================================================*
229  *                              reg_dmp                                      *
230  *===========================================================================*/
231 PUBLIC void reg_dmp(rp)
232 struct proc *rp;
233 {
234   register int i;
235   static char *regs[NR_REGS] = {
236                     "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
237                     "a0", "a1", "a2", "a3", "a4", "a5", "a6"
238   };
239   reg_t *regptr = (reg_t *) & rp->p_reg;
240 
241   printf("reg = %08lx, ", rp);
242   printf("ksp = %08lx\n", (long) &rp + sizeof(rp));
243   printf(" pc = %08lx, ", rp->p_reg.pc);
244   printf(" sr =     %04x, ", rp->p_reg.psw);
245   printf("trp =       %2x\n", rp->p_trap);
246   for (i = 0; i < NR_REGS; i++) 
247         printf("%3s = %08lx%s",regs[i], *regptr++, (i&3) == 3 ? "\n" : ", ");
248   printf(" a7 = %08lx\n", rp->p_reg.sp);
249 #if (SHADOWING == 1)
250     mem_dmp((char *) (((long) rp->p_reg.pc & ~31L) - 96), 128);
251     mem_dmp((char *) (((long) rp->p_reg.sp & ~31L) - 32), 256);
252 #else
253     mem_dmp((char *) (((long) rp->p_reg.pc & ~31L) - 96 +
254                         ((long)rp->p_map[T].mem_phys<<CLICK_SHIFT)), 128);
255     mem_dmp((char *) (((long) rp->p_reg.sp & ~31L) - 32 +
256                         ((long)rp->p_map[S].mem_phys<<CLICK_SHIFT)), 256);
257 #endif
258 }
259 
260 
261 /*===========================================================================*
262  *                              mem_dmp                                      *
263  *===========================================================================*/
264 PRIVATE void mem_dmp(adr, len)
265 char *adr;
266 int len;
267 {
268   register i;
269   register long *p;
270 
271   for (i = 0, p = (long *) adr; i < len; i += 4) {
272 #if (CHIP == M68000)
273         if ((i & 31) == 0) printf("\n%lX:", p);
274         printf(" %8lX", *p++);
275 #else
276         if ((i & 31) == 0) printf("\n%X:", p);
277         printf(" %8X", *p++);
278 #endif /* (CHIP == M68000) */
279   }
280   printf("\n");
281 }
282 
283 #endif                          /* (CHIP == M68000) */
284 
285 
286 /*===========================================================================*
287  *                              proc_name                                    *
288  *===========================================================================*/
289 PRIVATE char *proc_name(proc_nr)
290 int proc_nr;
291 {
292   if (proc_nr == ANY) return "ANY";
293   return proc_addr(proc_nr)->p_name;
294 }
295
~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~
This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.
Minix Cross Reference Minix/kernel/dmp.c

Minix Cross Reference
Minix/kernel/dmp.c
