kernel/debug.c

   1 /* This file implements kernel debugging functionality that is not included
   2  * in the standard kernel. Available functionality includes timing of lock
   3  * functions and sanity checking of the scheduling queues.
   4  */
   5
   6 #include "kernel.h"
   7
   8 #include <minix/callnr.h>
   9 #include <minix/sysutil.h>
  10 #include <minix/u64.h>
  11 #include <limits.h>
  12 #include <string.h>
  13 #include <assert.h>
  14
  15 #define MAX_LOOP (NR_PROCS + NR_TASKS)
  16
  17 int runqueues_ok_cpu(unsigned cpu)
  18 {
  19   int q, l = 0;
  20   register struct proc *xp;
  21   struct proc **rdy_head, **rdy_tail;
  22
  23   rdy_head = get_cpu_var(cpu, run_q_head);
  24   rdy_tail = get_cpu_var(cpu, run_q_tail);
  25
  26   for (xp = BEG_PROC_ADDR; xp < END_PROC_ADDR; ++xp) {
  27         xp->p_found = 0;
  28         if (l++ > MAX_LOOP) panic("check error");
  29   }
  30
  31   for (q=l=0; q < NR_SCHED_QUEUES; q++) {
  32     if (rdy_head[q] && !rdy_tail[q]) {
  33         printf("head but no tail in %d\n", q);
  34         return 0;
  35     }
  36     if (!rdy_head[q] && rdy_tail[q]) {
  37         printf("tail but no head in %d\n", q);
  38         return 0;
  39     }
  40     if (rdy_tail[q] && rdy_tail[q]->p_nextready) {
  41         printf("tail and tail->next not null in %d\n", q);
  42         return 0;
  43     }
  44     for(xp = rdy_head[q]; xp; xp = xp->p_nextready) {
  45         const vir_bytes vxp = (vir_bytes) xp;
  46         vir_bytes dxp;
  47         if(vxp < (vir_bytes) BEG_PROC_ADDR || vxp >= (vir_bytes) END_PROC_ADDR) {
  48                 printf("xp out of range\n");
  49                 return 0;
  50         }
  51         dxp = vxp - (vir_bytes) BEG_PROC_ADDR;
  52         if(dxp % sizeof(struct proc)) {
  53                 printf("xp not a real pointer");
  54                 return 0;
  55         }
  56         if(!proc_ptr_ok(xp)) {
  57                 printf("xp bogus pointer");
  58                 return 0;
  59         }
  60         if (RTS_ISSET(xp, RTS_SLOT_FREE)) {
  61                 printf("scheduling error: dead proc q %d %d\n",
  62                         q, xp->p_endpoint);
  63                 return 0;
  64         }
  65         if (!proc_is_runnable(xp)) {
  66                 printf("scheduling error: unready on runq %d proc %d\n",
  67                         q, xp->p_nr);
  68                 return 0;
  69         }
  70         if (xp->p_priority != q) {
  71                 printf("scheduling error: wrong priority q %d proc %d ep %d name %s\n",
  72                         q, xp->p_nr, xp->p_endpoint, xp->p_name);
  73                 return 0;
  74         }
  75         if (xp->p_found) {
  76                 printf("scheduling error: double sched q %d proc %d\n",
  77                         q, xp->p_nr);
  78                 return 0;
  79         }
  80         xp->p_found = 1;
  81         if (!xp->p_nextready && rdy_tail[q] != xp) {
  82                 printf("sched err: last element not tail q %d proc %d\n",
  83                         q, xp->p_nr);
  84                 return 0;
  85         }
  86         if (l++ > MAX_LOOP) {
  87                 printf("loop in schedule queue?");
  88                 return 0;
  89         }
  90     }
  91   }
  92
  93   for (xp = BEG_PROC_ADDR; xp < END_PROC_ADDR; ++xp) {
  94         if(!proc_ptr_ok(xp)) {
  95                 printf("xp bogus pointer in proc table\n");
  96                 return 0;
  97         }
  98         if (isemptyp(xp))
  99                 continue;
 100         if(proc_is_runnable(xp) && !xp->p_found) {
 101                 printf("sched error: ready proc %d not on queue\n", xp->p_nr);
 102                 return 0;
 103         }
 104   }
 105
 106   /* All is ok. */
 107   return 1;
 108 }
 109
 110 #ifdef CONFIG_SMP
 111 static int runqueues_ok_all(void)
 112 {
 113         unsigned c;
 114
 115         for (c = 0 ; c < ncpus; c++) {
 116                 if (!runqueues_ok_cpu(c))
 117                         return 0;
 118         }
 119         return 1;
 120 }
 121
 122 int runqueues_ok(void)
 123 {
 124         return runqueues_ok_all();
 125 }
 126
 127 #else
 128
 129 int runqueues_ok(void)
 130 {
 131         return runqueues_ok_cpu(0);
 132 }
 133
 134
 135 #endif
 136
 137 char *
 138 rtsflagstr(const u32_t flags)
 139 {
 140         static char str[100];
 141         str[0] = '\0';
 142
 143 #define FLAG(n) if(flags & n) { strlcat(str, #n " ", sizeof(str)); }
 144
 145         FLAG(RTS_SLOT_FREE);
 146         FLAG(RTS_PROC_STOP);
 147         FLAG(RTS_SENDING);
 148         FLAG(RTS_RECEIVING);
 149         FLAG(RTS_SIGNALED);
 150         FLAG(RTS_SIG_PENDING);
 151         FLAG(RTS_P_STOP);
 152         FLAG(RTS_NO_PRIV);
 153         FLAG(RTS_NO_ENDPOINT);
 154         FLAG(RTS_VMINHIBIT);
 155         FLAG(RTS_PAGEFAULT);
 156         FLAG(RTS_VMREQUEST);
 157         FLAG(RTS_VMREQTARGET);
 158         FLAG(RTS_PREEMPTED);
 159         FLAG(RTS_NO_QUANTUM);
 160
 161         return str;
 162 }
 163
 164 char *
 165 miscflagstr(const u32_t flags)
 166 {
 167         static char str[100];
 168         str[0] = '\0';
 169
 170         FLAG(MF_REPLY_PEND);
 171         FLAG(MF_DELIVERMSG);
 172         FLAG(MF_KCALL_RESUME);
 173
 174         return str;
 175 }
 176
 177 char *
 178 schedulerstr(struct proc *scheduler)
 179 {
 180         if (scheduler != NULL)
 181         {
 182                 return scheduler->p_name;
 183         }
 184
 185         return "KERNEL";
 186 }
 187
 188 static void
 189 print_proc_name(struct proc *pp)
 190 {
 191         char *name = pp->p_name;
 192         endpoint_t ep = pp->p_endpoint;
 193
 194         if(name) {
 195                 printf("%s(%d)", name, ep);
 196         }
 197         else {
 198                 printf("%d", ep);
 199         }
 200 }
 201
 202 static void
 203 print_endpoint(endpoint_t ep)
 204 {
 205         int proc_nr;
 206         struct proc *pp = NULL;
 207
 208         switch(ep) {
 209         case ANY:
 210                 printf("ANY");
 211         break;
 212         case SELF:
 213                 printf("SELF");
 214         break;
 215         case NONE:
 216                 printf("NONE");
 217         break;
 218         default:
 219                 if(!isokendpt(ep, &proc_nr)) {
 220                         printf("??? %d\n", ep);
 221                 }
 222                 else {
 223                         pp = proc_addr(proc_nr);
 224                         if(isemptyp(pp)) {
 225                                 printf("??? empty slot %d\n", proc_nr);
 226                         }
 227                         else {
 228                                 print_proc_name(pp);
 229                         }
 230                 }
 231         break;
 232         }
 233 }
 234
 235 static void
 236 print_sigmgr(struct proc *pp)
 237 {
 238         endpoint_t sig_mgr, bak_sig_mgr;
 239         sig_mgr = priv(pp)->s_sig_mgr;
 240         bak_sig_mgr = priv(pp)->s_bak_sig_mgr;
 241         printf("sigmgr ");
 242         print_endpoint(sig_mgr);
 243         if(bak_sig_mgr != NONE) {
 244                 printf(" / ");
 245                 print_endpoint(bak_sig_mgr);
 246         }
 247 }
 248
 249 void print_proc(struct proc *pp)
 250 {
 251         endpoint_t dep;
 252
 253         printf("%d: %s %d prio %d time %d/%d cycles 0x%x%08x cpu %2d "
 254                         "cr3 0x%lx rts %s misc %s sched %s ",
 255                 proc_nr(pp), pp->p_name, pp->p_endpoint,
 256                 pp->p_priority, pp->p_user_time,
 257                 pp->p_sys_time, ex64hi(pp->p_cycles),
 258                 ex64lo(pp->p_cycles), pp->p_cpu,
 259                 pp->p_seg.p_cr3,
 260                 rtsflagstr(pp->p_rts_flags), miscflagstr(pp->p_misc_flags),
 261                 schedulerstr(pp->p_scheduler));
 262
 263         print_sigmgr(pp);
 264
 265         dep = P_BLOCKEDON(pp);
 266         if(dep != NONE) {
 267                 printf(" blocked on: ");
 268                 print_endpoint(dep);
 269         }
 270         printf("\n");
 271 }
 272
 273 static void print_proc_depends(struct proc *pp, const int level)
 274 {
 275         struct proc *depproc = NULL;
 276         endpoint_t dep;
 277 #define COL { int i; for(i = 0; i < level; i++) printf("> "); }
 278
 279         if(level >= NR_PROCS) {
 280                 printf("loop??\n");
 281                 return;
 282         }
 283
 284         COL
 285
 286         print_proc(pp);
 287
 288         COL
 289         proc_stacktrace(pp);
 290
 291
 292         dep = P_BLOCKEDON(pp);
 293         if(dep != NONE && dep != ANY) {
 294                 int procno;
 295                 if(isokendpt(dep, &procno)) {
 296                         depproc = proc_addr(procno);
 297                         if(isemptyp(depproc))
 298                                 depproc = NULL;
 299                 }
 300                 if (depproc)
 301                         print_proc_depends(depproc, level+1);
 302         }
 303 }
 304
 305 void print_proc_recursive(struct proc *pp)
 306 {
 307         print_proc_depends(pp, 0);
 308 }
 309
 310 #if DEBUG_DUMPIPC
 311 static const char *mtypename(int mtype, int iscall)
 312 {
 313         /* use generated file to recognize message types */
 314         if (iscall) {
 315                 switch(mtype) {
 316 #define IDENT(x) case x: return #x;
 317 #include "extracted-mtype.h"
 318 #undef IDENT
 319                 }
 320         } else {
 321                 switch(mtype) {
 322 #define IDENT(x) case x: return #x;
 323 #include "extracted-errno.h"
 324 #undef IDENT
 325                 }
 326         }
 327
 328         /* no match */
 329         return NULL;
 330 }
 331
 332 static void printproc(struct proc *rp)
 333 {
 334         if (rp)
 335                 printf(" %s(%d)", rp->p_name, rp - proc);
 336         else
 337                 printf(" kernel");
 338 }
 339
 340 static void printparam(const char *name, const void *data, size_t size)
 341 {
 342         printf(" %s=", name);
 343         switch (size) {
 344                 case sizeof(char):      printf("%d", *(char *) data);   break;
 345                 case sizeof(short):     printf("%d", *(short *) data);  break;
 346                 case sizeof(int):       printf("%d", *(int *) data);    break;
 347                 default:                printf("(%u bytes)", size);     break;
 348         }
 349 }
 350
 351 static void printmsg(message *msg, struct proc *src, struct proc *dst,
 352         char operation, int iscall, int printparams)
 353 {
 354         const char *name;
 355         int mtype = msg->m_type;
 356
 357         /* source, destination and message type */
 358         printf("%c", operation);
 359         printproc(src);
 360         printproc(dst);
 361         name = mtypename(mtype, iscall);
 362         if (name) {
 363                 printf(" %s(%d)", name, mtype);
 364         } else {
 365                 printf(" %d", mtype);
 366         }
 367
 368         if (iscall && printparams) {
 369 #define IDENT(x, y) if (mtype == x) printparam(#y, &msg->y, sizeof(msg->y));
 370 #include "extracted-mfield.h"
 371 #undef IDENT
 372         }
 373         printf("\n");
 374 }
 375 #endif
 376
 377 #if DEBUG_IPCSTATS
 378 #define IPCPROCS (NR_PROCS+1)   /* number of slots we need */
 379 #define KERNELIPC NR_PROCS      /* slot number to use for kernel calls */
 380 static int messages[IPCPROCS][IPCPROCS];
 381
 382 #define PRINTSLOTS 20
 383 static struct {
 384         int src, dst, messages;
 385 } winners[PRINTSLOTS];
 386 static int total, goodslots;
 387
 388 static void printstats(int ticks)
 389 {
 390         int i;
 391         for(i = 0; i < goodslots; i++) {
 392 #define name(s) (s == KERNELIPC ? "kernel" : proc_addr(s)->p_name)
 393 #define persec(n) (system_hz*(n)/ticks)
 394                 char    *n1 = name(winners[i].src),
 395                         *n2 = name(winners[i].dst);
 396                 printf("%2d.  %8s -> %8s  %9d/s\n",
 397                         i, n1, n2, persec(winners[i].messages));
 398         }
 399         printf("total %d/s\n", persec(total));
 400 }
 401
 402 static void sortstats(void)
 403 {
 404         /* Print top message senders/receivers. */
 405         int src_slot, dst_slot;
 406         total = goodslots = 0;
 407         for(src_slot = 0; src_slot < IPCPROCS; src_slot++) {
 408                 for(dst_slot = 0; dst_slot < IPCPROCS; dst_slot++) {
 409                         int w = PRINTSLOTS, rem,
 410                                 n = messages[src_slot][dst_slot];
 411                         total += n;
 412                         while(w > 0 && n > winners[w-1].messages)
 413                                 w--;
 414                         if(w >= PRINTSLOTS) continue;
 415
 416                         /* This combination has beaten the current winners
 417                          * and should be inserted at position 'w.'
 418                          */
 419                         rem = PRINTSLOTS-w-1;
 420                         assert(rem >= 0);
 421                         assert(rem < PRINTSLOTS);
 422                         if(rem > 0) {
 423                                 assert(w+1 <= PRINTSLOTS-1);
 424                                 assert(w >= 0);
 425                                 memmove(&winners[w+1], &winners[w],
 426                                         rem*sizeof(winners[0]));
 427                         }
 428                         winners[w].src = src_slot;
 429                         winners[w].dst = dst_slot;
 430                         winners[w].messages = n;
 431                         if(goodslots < PRINTSLOTS) goodslots++;
 432                 }
 433         }
 434 }
 435
 436 #define proc2slot(p, s) { \
 437         if(p) { s = p->p_nr; } \
 438         else { s = KERNELIPC; } \
 439         assert(s >= 0 && s < IPCPROCS); \
 440 }
 441
 442 static void statmsg(message *msg, struct proc *srcp, struct proc *dstp)
 443 {
 444         int src, dst, now, secs, dt;
 445         static int lastprint;
 446
 447         /* Stat message. */
 448         assert(src);
 449         proc2slot(srcp, src);
 450         proc2slot(dstp, dst);
 451         messages[src][dst]++;
 452
 453         /* Print something? */
 454         now = get_uptime();
 455         dt = now - lastprint;
 456         secs = dt/system_hz;
 457         if(secs >= 30) {
 458                 memset(winners, 0, sizeof(winners));
 459                 sortstats();
 460                 printstats(dt);
 461                 memset(messages, 0, sizeof(messages));
 462                 lastprint = now;
 463         }
 464 }
 465 #endif
 466
 467 #if DEBUG_IPC_HOOK
 468 void hook_ipc_msgkcall(message *msg, struct proc *proc)
 469 {
 470 #if DEBUG_DUMPIPC
 471         printmsg(msg, proc, NULL, 'k', 1, 1);
 472 #endif
 473 }
 474
 475 void hook_ipc_msgkresult(message *msg, struct proc *proc)
 476 {
 477 #if DEBUG_DUMPIPC
 478         printmsg(msg, NULL, proc, 'k', 0, 0);
 479 #endif
 480 #if DEBUG_IPCSTATS
 481         statmsg(msg, proc, NULL);
 482 #endif
 483 }
 484
 485 void hook_ipc_msgrecv(message *msg, struct proc *src, struct proc *dst)
 486 {
 487 #if DEBUG_DUMPIPC
 488         printmsg(msg, src, dst, 'r', src->p_misc_flags & MF_REPLY_PEND, 0);
 489 #endif
 490 #if DEBUG_IPCSTATS
 491         statmsg(msg, src, dst);
 492 #endif
 493 }
 494
 495 void hook_ipc_msgsend(message *msg, struct proc *src, struct proc *dst)
 496 {
 497 #if DEBUG_DUMPIPC
 498         printmsg(msg, src, dst, 's', src->p_misc_flags & MF_REPLY_PEND, 1);
 499 #endif
 500 }
 501
 502 void hook_ipc_clear(struct proc *p)
 503 {
 504 #if DEBUG_IPCSTATS
 505         int slot, i;
 506         assert(p);
 507         proc2slot(p, slot);
 508         for(i = 0; i < IPCPROCS; i++)
 509                 messages[slot][i] = messages[i][slot] = 0;
 510 #endif
 511 }
 512 #endif