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) ? priv(pp)->s_sig_mgr : NONE;
 240         bak_sig_mgr = priv(pp) ? priv(pp)->s_bak_sig_mgr : NONE;
 241         if(sig_mgr == NONE) { printf("no sigmgr"); return; }
 242         printf("sigmgr ");
 243         print_endpoint(sig_mgr);
 244         if(bak_sig_mgr != NONE) {
 245                 printf(" / ");
 246                 print_endpoint(bak_sig_mgr);
 247         }
 248 }
 249
 250 void print_proc(struct proc *pp)
 251 {
 252         endpoint_t dep;
 253
 254         printf("%d: %s %d prio %d time %d/%d cycles 0x%x%08x cpu %2d "
 255                         "pdbr 0x%lx rts %s misc %s sched %s ",
 256                 proc_nr(pp), pp->p_name, pp->p_endpoint,
 257                 pp->p_priority, pp->p_user_time,
 258                 pp->p_sys_time, ex64hi(pp->p_cycles),
 259                 ex64lo(pp->p_cycles), pp->p_cpu,
 260 #if defined(__i386__)
 261                 pp->p_seg.p_cr3,
 262 #elif defined(__arm__)
 263                 pp->p_seg.p_ttbr,
 264 #endif
 265                 rtsflagstr(pp->p_rts_flags), miscflagstr(pp->p_misc_flags),
 266                 schedulerstr(pp->p_scheduler));
 267
 268         print_sigmgr(pp);
 269
 270         dep = P_BLOCKEDON(pp);
 271         if(dep != NONE) {
 272                 printf(" blocked on: ");
 273                 print_endpoint(dep);
 274         }
 275         printf("\n");
 276 }
 277
 278 static void print_proc_depends(struct proc *pp, const int level)
 279 {
 280         struct proc *depproc = NULL;
 281         endpoint_t dep;
 282 #define COL { int i; for(i = 0; i < level; i++) printf("> "); }
 283
 284         if(level >= NR_PROCS) {
 285                 printf("loop??\n");
 286                 return;
 287         }
 288
 289         COL
 290
 291         print_proc(pp);
 292
 293         COL
 294         proc_stacktrace(pp);
 295
 296
 297         dep = P_BLOCKEDON(pp);
 298         if(dep != NONE && dep != ANY) {
 299                 int procno;
 300                 if(isokendpt(dep, &procno)) {
 301                         depproc = proc_addr(procno);
 302                         if(isemptyp(depproc))
 303                                 depproc = NULL;
 304                 }
 305                 if (depproc)
 306                         print_proc_depends(depproc, level+1);
 307         }
 308 }
 309
 310 void print_proc_recursive(struct proc *pp)
 311 {
 312         print_proc_depends(pp, 0);
 313 }
 314
 315 #if DEBUG_DUMPIPC
 316 static const char *mtypename(int mtype, int iscall)
 317 {
 318         /* use generated file to recognize message types */
 319         if (iscall) {
 320                 switch(mtype) {
 321 #define IDENT(x) case x: return #x;
 322 #include "extracted-mtype.h"
 323 #undef IDENT
 324                 }
 325         } else {
 326                 switch(mtype) {
 327 #define IDENT(x) case x: return #x;
 328 #include "extracted-errno.h"
 329 #undef IDENT
 330                 }
 331         }
 332
 333         /* no match */
 334         return NULL;
 335 }
 336
 337 static void printproc(struct proc *rp)
 338 {
 339         if (rp)
 340                 printf(" %s(%d)", rp->p_name, rp - proc);
 341         else
 342                 printf(" kernel");
 343 }
 344
 345 static void printparam(const char *name, const void *data, size_t size)
 346 {
 347         printf(" %s=", name);
 348         switch (size) {
 349                 case sizeof(char):      printf("%d", *(char *) data);   break;
 350                 case sizeof(short):     printf("%d", *(short *) data);  break;
 351                 case sizeof(int):       printf("%d", *(int *) data);    break;
 352                 default:                printf("(%u bytes)", size);     break;
 353         }
 354 }
 355
 356 static void printmsg(message *msg, struct proc *src, struct proc *dst,
 357         char operation, int iscall, int printparams)
 358 {
 359         const char *name;
 360         int mtype = msg->m_type;
 361
 362         /* source, destination and message type */
 363         printf("%c", operation);
 364         printproc(src);
 365         printproc(dst);
 366         name = mtypename(mtype, iscall);
 367         if (name) {
 368                 printf(" %s(%d)", name, mtype);
 369         } else {
 370                 printf(" %d", mtype);
 371         }
 372
 373         if (iscall && printparams) {
 374 #define IDENT(x, y) if (mtype == x) printparam(#y, &msg->y, sizeof(msg->y));
 375 #include "extracted-mfield.h"
 376 #undef IDENT
 377         }
 378         printf("\n");
 379 }
 380 #endif
 381
 382 #if DEBUG_IPCSTATS
 383 #define IPCPROCS (NR_PROCS+1)   /* number of slots we need */
 384 #define KERNELIPC NR_PROCS      /* slot number to use for kernel calls */
 385 static int messages[IPCPROCS][IPCPROCS];
 386
 387 #define PRINTSLOTS 20
 388 static struct {
 389         int src, dst, messages;
 390 } winners[PRINTSLOTS];
 391 static int total, goodslots;
 392
 393 static void printstats(int ticks)
 394 {
 395         int i;
 396         for(i = 0; i < goodslots; i++) {
 397 #define name(s) (s == KERNELIPC ? "kernel" : proc_addr(s)->p_name)
 398 #define persec(n) (system_hz*(n)/ticks)
 399                 char    *n1 = name(winners[i].src),
 400                         *n2 = name(winners[i].dst);
 401                 printf("%2d.  %8s -> %8s  %9d/s\n",
 402                         i, n1, n2, persec(winners[i].messages));
 403         }
 404         printf("total %d/s\n", persec(total));
 405 }
 406
 407 static void sortstats(void)
 408 {
 409         /* Print top message senders/receivers. */
 410         int src_slot, dst_slot;
 411         total = goodslots = 0;
 412         for(src_slot = 0; src_slot < IPCPROCS; src_slot++) {
 413                 for(dst_slot = 0; dst_slot < IPCPROCS; dst_slot++) {
 414                         int w = PRINTSLOTS, rem,
 415                                 n = messages[src_slot][dst_slot];
 416                         total += n;
 417                         while(w > 0 && n > winners[w-1].messages)
 418                                 w--;
 419                         if(w >= PRINTSLOTS) continue;
 420
 421                         /* This combination has beaten the current winners
 422                          * and should be inserted at position 'w.'
 423                          */
 424                         rem = PRINTSLOTS-w-1;
 425                         assert(rem >= 0);
 426                         assert(rem < PRINTSLOTS);
 427                         if(rem > 0) {
 428                                 assert(w+1 <= PRINTSLOTS-1);
 429                                 assert(w >= 0);
 430                                 memmove(&winners[w+1], &winners[w],
 431                                         rem*sizeof(winners[0]));
 432                         }
 433                         winners[w].src = src_slot;
 434                         winners[w].dst = dst_slot;
 435                         winners[w].messages = n;
 436                         if(goodslots < PRINTSLOTS) goodslots++;
 437                 }
 438         }
 439 }
 440
 441 #define proc2slot(p, s) { \
 442         if(p) { s = p->p_nr; } \
 443         else { s = KERNELIPC; } \
 444         assert(s >= 0 && s < IPCPROCS); \
 445 }
 446
 447 static void statmsg(message *msg, struct proc *srcp, struct proc *dstp)
 448 {
 449         int src, dst, now, secs, dt;
 450         static int lastprint;
 451
 452         /* Stat message. */
 453         assert(src);
 454         proc2slot(srcp, src);
 455         proc2slot(dstp, dst);
 456         messages[src][dst]++;
 457
 458         /* Print something? */
 459         now = get_uptime();
 460         dt = now - lastprint;
 461         secs = dt/system_hz;
 462         if(secs >= 30) {
 463                 memset(winners, 0, sizeof(winners));
 464                 sortstats();
 465                 printstats(dt);
 466                 memset(messages, 0, sizeof(messages));
 467                 lastprint = now;
 468         }
 469 }
 470 #endif
 471
 472 #if DEBUG_IPC_HOOK
 473 void hook_ipc_msgkcall(message *msg, struct proc *proc)
 474 {
 475 #if DEBUG_DUMPIPC
 476         printmsg(msg, proc, NULL, 'k', 1, 1);
 477 #endif
 478 }
 479
 480 void hook_ipc_msgkresult(message *msg, struct proc *proc)
 481 {
 482 #if DEBUG_DUMPIPC
 483         printmsg(msg, NULL, proc, 'k', 0, 0);
 484 #endif
 485 #if DEBUG_IPCSTATS
 486         statmsg(msg, proc, NULL);
 487 #endif
 488 }
 489
 490 void hook_ipc_msgrecv(message *msg, struct proc *src, struct proc *dst)
 491 {
 492 #if DEBUG_DUMPIPC
 493         printmsg(msg, src, dst, 'r', src->p_misc_flags & MF_REPLY_PEND, 0);
 494 #endif
 495 #if DEBUG_IPCSTATS
 496         statmsg(msg, src, dst);
 497 #endif
 498 }
 499
 500 void hook_ipc_msgsend(message *msg, struct proc *src, struct proc *dst)
 501 {
 502 #if DEBUG_DUMPIPC
 503         printmsg(msg, src, dst, 's', src->p_misc_flags & MF_REPLY_PEND, 1);
 504 #endif
 505 }
 506
 507 void hook_ipc_clear(struct proc *p)
 508 {
 509 #if DEBUG_IPCSTATS
 510         int slot, i;
 511         assert(p);
 512         proc2slot(p, slot);
 513         for(i = 0; i < IPCPROCS; i++)
 514                 messages[slot][i] = messages[i][slot] = 0;
 515 #endif
 516 }
 517 #endif