minix/usr.bin/mtop/mtop.c

   1
   2 /* Author: Ben Gras <beng@few.vu.nl>  17 march 2006 */
   3
   4 #define _MINIX_SYSTEM 1
   5
   6 #include <stdio.h>
   7 #include <unistd.h>
   8 #include <pwd.h>
   9 #include <curses.h>
  10 #include <minix/timers.h>
  11 #include <stdlib.h>
  12 #include <limits.h>
  13 #include <termcap.h>
  14 #include <termios.h>
  15 #include <time.h>
  16 #include <string.h>
  17 #include <signal.h>
  18 #include <fcntl.h>
  19 #include <errno.h>
  20 #include <dirent.h>
  21 #include <assert.h>
  22
  23 #include <sys/ttycom.h>
  24 #include <sys/ioctl.h>
  25 #include <sys/times.h>
  26 #include <sys/types.h>
  27 #include <sys/time.h>
  28 #include <sys/select.h>
  29
  30 #include <minix/com.h>
  31 #include <minix/config.h>
  32 #include <minix/type.h>
  33 #include <minix/endpoint.h>
  34 #include <minix/const.h>
  35 #include <minix/u64.h>
  36 #include <minix/paths.h>
  37 #include <minix/procfs.h>
  38
  39 #define TIMECYCLEKEY 't'
  40 #define ORDERKEY 'o'
  41
  42 #define ORDER_CPU       0
  43 #define ORDER_MEMORY    1
  44 #define ORDER_HIGHEST   ORDER_MEMORY
  45 int order = ORDER_CPU;
  46
  47 u32_t system_hz;
  48
  49 /* name of cpu cycle types, in the order they appear in /psinfo. */
  50 const char *cputimenames[] = { "user", "ipc", "kernelcall" };
  51
  52 #define CPUTIMENAMES ((int) (sizeof(cputimenames)/sizeof(cputimenames[0])))
  53
  54 #define CPUTIME(m, i) (m & (1L << (i)))
  55
  56 unsigned int nr_procs, nr_tasks;
  57 int nr_total;
  58
  59 #define  SLOT_NR(e) (_ENDPOINT_P(e) + nr_tasks)
  60
  61 #define  TC_BUFFER  1024        /* Size of termcap(3) buffer    */
  62 #define  TC_STRINGS  200        /* Enough room for cm,cl,so,se  */
  63
  64 const char *Tclr_all;
  65
  66 int blockedverbose = 0;
  67
  68 #define  USED           0x1
  69 #define  IS_TASK        0x2
  70 #define  IS_SYSTEM      0x4
  71 #define  BLOCKED        0x8
  72
  73 struct proc {
  74         int p_flags;
  75         endpoint_t p_endpoint;
  76         pid_t p_pid;
  77         u64_t p_cpucycles[CPUTIMENAMES];
  78         int p_priority;
  79         endpoint_t p_blocked;
  80         clock_t p_user_time;
  81         vir_bytes p_memory;
  82         uid_t p_effuid;
  83         int p_nice;
  84         char p_name[PROC_NAME_LEN+1];
  85 };
  86
  87 struct proc *proc = NULL, *prev_proc = NULL;
  88
  89 static void
  90 parse_file(pid_t pid)
  91 {
  92         char path[PATH_MAX], name[256], type, state;
  93         int version, endpt;
  94         FILE *fp;
  95         struct proc *p;
  96         int slot;
  97
  98         sprintf(path, "%d/psinfo", pid);
  99
 100         if ((fp = fopen(path, "r")) == NULL)
 101                 return;
 102
 103         if (fscanf(fp, "%d", &version) != 1) {
 104                 fclose(fp);
 105                 return;
 106         }
 107
 108         if (version != PSINFO_VERSION) {
 109                 fputs("procfs version mismatch!\n", stderr);
 110                 exit(1);
 111         }
 112
 113         if (fscanf(fp, " %c %d", &type, &endpt) != 2) {
 114                 fclose(fp);
 115                 return;
 116         }
 117
 118         slot = SLOT_NR(endpt);
 119
 120         if (slot < 0 || slot >= nr_total) {
 121                 fprintf(stderr, "top: unreasonable endpoint number %d\n",
 122                     endpt);
 123                 fclose(fp);
 124                 return;
 125         }
 126
 127         p = &proc[slot];
 128
 129         if (type == TYPE_TASK)
 130                 p->p_flags |= IS_TASK;
 131         else if (type == TYPE_SYSTEM)
 132                 p->p_flags |= IS_SYSTEM;
 133
 134         p->p_endpoint = endpt;
 135         p->p_pid = pid;
 136
 137         if (fscanf(fp, " %255s %c %d %d %u %*u %"PRIu64" %"PRIu64" %"PRIu64
 138             " %lu %d %u",
 139             name, &state, &p->p_blocked, &p->p_priority, &p->p_user_time,
 140             &p->p_cpucycles[0], &p->p_cpucycles[1], &p->p_cpucycles[2],
 141             &p->p_memory, &p->p_nice, &p->p_effuid) != 11) {
 142                 fclose(fp);
 143                 return;
 144         }
 145
 146         strlcpy(p->p_name, name, sizeof(p->p_name));
 147
 148         if (state != STATE_RUN)
 149                 p->p_flags |= BLOCKED;
 150
 151         p->p_flags |= USED;
 152
 153         fclose(fp);
 154 }
 155
 156 static void parse_dir(void)
 157 {
 158         DIR *p_dir;
 159         struct dirent *p_ent;
 160         pid_t pid;
 161         char *end;
 162
 163         if ((p_dir = opendir(".")) == NULL) {
 164                 perror("opendir on " _PATH_PROC);
 165                 exit(1);
 166         }
 167
 168         for (p_ent = readdir(p_dir); p_ent != NULL; p_ent = readdir(p_dir)) {
 169                 pid = strtol(p_ent->d_name, &end, 10);
 170
 171                 if (!end[0] && pid != 0)
 172                         parse_file(pid);
 173         }
 174
 175         closedir(p_dir);
 176 }
 177
 178 static void get_procs(void)
 179 {
 180         struct proc *p;
 181         int i;
 182
 183         p = prev_proc;
 184         prev_proc = proc;
 185         proc = p;
 186
 187         if (proc == NULL) {
 188                 proc = malloc(nr_total * sizeof(proc[0]));
 189
 190                 if (proc == NULL) {
 191                         fprintf(stderr, "Out of memory!\n");
 192                         exit(1);
 193                 }
 194         }
 195
 196         for (i = 0; i < nr_total; i++)
 197                 proc[i].p_flags = 0;
 198
 199         parse_dir();
 200 }
 201
 202 static int print_memory(void)
 203 {
 204         FILE *fp;
 205         unsigned int pagesize;
 206         unsigned long total, freemem, largest, cached;
 207
 208         if ((fp = fopen("meminfo", "r")) == NULL)
 209                 return 0;
 210
 211         if (fscanf(fp, "%u %lu %lu %lu %lu", &pagesize, &total, &freemem,
 212                         &largest, &cached) != 5) {
 213                 fclose(fp);
 214                 return 0;
 215         }
 216
 217         fclose(fp);
 218
 219         printf("main memory: %ldK total, %ldK free, %ldK contig free, "
 220                 "%ldK cached\n",
 221                 (pagesize * total)/1024, (pagesize * freemem)/1024,
 222                 (pagesize * largest)/1024, (pagesize * cached)/1024);
 223
 224         return 1;
 225 }
 226
 227 static int print_load(double *loads, int nloads)
 228 {
 229         int i;
 230         printf("load averages: ");
 231         for(i = 0; i < nloads; i++)
 232                 printf("%s %.2f", (i > 0) ? "," : "", loads[i]);
 233         printf("\n");
 234         return 1;
 235 }
 236
 237 static int print_proc_summary(struct proc *pproc)
 238 {
 239         int p, alive, running, sleeping;
 240
 241         alive = running = sleeping = 0;
 242
 243         for(p = 0; p < nr_total; p++) {
 244                 if (pproc[p].p_endpoint == IDLE)
 245                         continue;
 246                 if(!(pproc[p].p_flags & USED))
 247                         continue;
 248                 alive++;
 249                 if(pproc[p].p_flags & BLOCKED)
 250                         sleeping++;
 251                 else
 252                         running++;
 253         }
 254         printf("%d processes: %d running, %d sleeping\n",
 255                 alive, running, sleeping);
 256         return 1;
 257 }
 258
 259 struct tp {
 260         struct proc *p;
 261         u64_t ticks;
 262 };
 263
 264 static int cmp_procs(const void *v1, const void *v2)
 265 {
 266         const struct tp *p1 = (const struct tp *) v1,
 267                 *p2 = (const struct tp *) v2;
 268         int p1blocked, p2blocked;
 269
 270         if(order == ORDER_MEMORY) {
 271                 if(p1->p->p_memory < p2->p->p_memory) return 1;
 272                 if(p1->p->p_memory > p2->p->p_memory) return -1;
 273                 return 0;
 274         }
 275
 276         p1blocked = !!(p1->p->p_flags & BLOCKED);
 277         p2blocked = !!(p2->p->p_flags & BLOCKED);
 278
 279         /* Primarily order by used number of cpu cycles.
 280          *
 281          * Exception: if in blockedverbose mode, a blocked
 282          * process is always printed after an unblocked
 283          * process, and used cpu cycles don't matter.
 284          *
 285          * In both cases, process slot number is a tie breaker.
 286          */
 287
 288         if(blockedverbose && (p1blocked || p2blocked)) {
 289                 if(!p1blocked && p2blocked)
 290                         return -1;
 291                 if(!p2blocked && p1blocked)
 292                         return 1;
 293         } else if(p1->ticks != p2->ticks) {
 294                 if(p1->ticks > p2->ticks) return -1;
 295                 assert(p1->ticks < p2->ticks);
 296                 return 1;
 297         }
 298
 299         /* Process slot number is a tie breaker. */
 300         return (int) (p1->p - p2->p);
 301 }
 302
 303 static struct tp *lookup(endpoint_t who, struct tp *tptab, int np)
 304 {
 305         int t;
 306
 307         for(t = 0; t < np; t++)
 308                 if(who == tptab[t].p->p_endpoint)
 309                         return &tptab[t];
 310
 311         fprintf(stderr, "lookup: tp %d (0x%x) not found.\n", who, who);
 312         abort();
 313
 314         return NULL;
 315 }
 316
 317 double ktotal = 0;
 318
 319 static void print_proc(struct tp *tp, u64_t total_ticks)
 320 {
 321         int euid = 0;
 322         static struct passwd *who = NULL;
 323         static int last_who = -1;
 324         const char *name = "";
 325         int ticks;
 326         struct proc *pr = tp->p;
 327
 328         printf("%5d ", pr->p_pid);
 329         euid = pr->p_effuid;
 330         name = pr->p_name;
 331
 332         if(last_who != euid || !who) {
 333                 who = getpwuid(euid);
 334                 last_who = euid;
 335         }
 336
 337         if(who && who->pw_name) printf("%-8s ", who->pw_name);
 338         else if(!(pr->p_flags & IS_TASK)) printf("%8d ", pr->p_effuid);
 339         else printf("         ");
 340
 341         printf(" %2d ", pr->p_priority);
 342         if(!(pr->p_flags & IS_TASK)) {
 343                 printf(" %3d ", pr->p_nice);
 344         } else printf("     ");
 345         printf("%6ldK", (pr->p_memory + 512) / 1024);
 346         printf("%6s", (pr->p_flags & BLOCKED) ? "" : "RUN");
 347         ticks = pr->p_user_time;
 348         printf(" %3u:%02u ", (ticks/system_hz/60), (ticks/system_hz)%60);
 349
 350         printf("%6.2f%% %s", 100.0 * tp->ticks / total_ticks, name);
 351 }
 352
 353 static char *cputimemodename(int cputimemode)
 354 {
 355         static char name[100];
 356         int i;
 357
 358         name[0] = '\0';
 359
 360         for(i = 0; i < CPUTIMENAMES; i++) {
 361                 if(CPUTIME(cputimemode, i)) {
 362                         assert(strlen(name) +
 363                                 strlen(cputimenames[i]) < sizeof(name));
 364                         strcat(name, cputimenames[i]);
 365                         strcat(name, " ");
 366                 }
 367         }
 368
 369         return name;
 370 }
 371
 372 static u64_t cputicks(struct proc *p1, struct proc *p2, int timemode)
 373 {
 374         int i;
 375         u64_t t = 0;
 376         for(i = 0; i < CPUTIMENAMES; i++) {
 377                 if(!CPUTIME(timemode, i))
 378                         continue;
 379                 if(p1->p_endpoint == p2->p_endpoint) {
 380                         t = t + p2->p_cpucycles[i] - p1->p_cpucycles[i];
 381                 } else {
 382                         t = t + p2->p_cpucycles[i];
 383                 }
 384         }
 385
 386         return t;
 387 }
 388
 389 static const char *ordername(int orderno)
 390 {
 391         switch(orderno) {
 392                 case ORDER_CPU: return "cpu";
 393                 case ORDER_MEMORY: return "memory";
 394         }
 395         return "invalid order";
 396 }
 397
 398 static void print_procs(int maxlines,
 399         struct proc *proc1, struct proc *proc2, int cputimemode)
 400 {
 401         int p, nprocs;
 402         u64_t idleticks = 0;
 403         u64_t kernelticks = 0;
 404         u64_t systemticks = 0;
 405         u64_t userticks = 0;
 406         u64_t total_ticks = 0;
 407         int blockedseen = 0;
 408         static struct tp *tick_procs = NULL;
 409
 410         if (tick_procs == NULL) {
 411                 tick_procs = malloc(nr_total * sizeof(tick_procs[0]));
 412
 413                 if (tick_procs == NULL) {
 414                         fprintf(stderr, "Out of memory!\n");
 415                         exit(1);
 416                 }
 417         }
 418
 419         for(p = nprocs = 0; p < nr_total; p++) {
 420                 u64_t uticks;
 421                 if(!(proc2[p].p_flags & USED))
 422                         continue;
 423                 tick_procs[nprocs].p = proc2 + p;
 424                 tick_procs[nprocs].ticks = cputicks(&proc1[p], &proc2[p], cputimemode);
 425                 uticks = cputicks(&proc1[p], &proc2[p], 1);
 426                 total_ticks = total_ticks + uticks;
 427                 if(p-NR_TASKS == IDLE) {
 428                         idleticks = uticks;
 429                         continue;
 430                 }
 431                 if(p-NR_TASKS == KERNEL) {
 432                         kernelticks = uticks;
 433                 }
 434                 if(!(proc2[p].p_flags & IS_TASK)) {
 435                         if(proc2[p].p_flags & IS_SYSTEM)
 436                                 systemticks = systemticks + tick_procs[nprocs].ticks;
 437                         else
 438                                 userticks = userticks + tick_procs[nprocs].ticks;
 439                 }
 440
 441                 nprocs++;
 442         }
 443
 444         if (total_ticks == 0)
 445                 return;
 446
 447         qsort(tick_procs, nprocs, sizeof(tick_procs[0]), cmp_procs);
 448
 449         printf("CPU states: %6.2f%% user, ", 100.0 * userticks / total_ticks);
 450         printf("%6.2f%% system, ", 100.0 * systemticks / total_ticks);
 451         printf("%6.2f%% kernel, ", 100.0 * kernelticks/ total_ticks);
 452         printf("%6.2f%% idle", 100.0 * idleticks / total_ticks);
 453
 454 #define NEWLINE do { printf("\n"); if(--maxlines <= 0) { return; } } while(0)
 455         NEWLINE;
 456
 457         printf("CPU time displayed ('%c' to cycle): %s; ",
 458                 TIMECYCLEKEY, cputimemodename(cputimemode));
 459         printf(" sort order ('%c' to cycle): %s", ORDERKEY, ordername(order));
 460         NEWLINE;
 461
 462         NEWLINE;
 463
 464         printf("  PID USERNAME PRI NICE    SIZE STATE   TIME     CPU COMMAND");
 465         NEWLINE;
 466         for(p = 0; p < nprocs; p++) {
 467                 struct proc *pr;
 468                 int level = 0;
 469
 470                 pr = tick_procs[p].p;
 471
 472                 if((pr->p_flags & IS_TASK) && pr->p_pid != KERNEL) {
 473                         /* skip old kernel tasks as they don't run anymore */
 474                         continue;
 475                 }
 476
 477                 /* If we're in blocked verbose mode, indicate start of
 478                  * blocked processes.
 479                  */
 480                 if(blockedverbose && (pr->p_flags & BLOCKED) && !blockedseen) {
 481                         NEWLINE;
 482                         printf("Blocked processes:");
 483                         NEWLINE;
 484                         blockedseen = 1;
 485                 }
 486
 487                 print_proc(&tick_procs[p], total_ticks);
 488                 NEWLINE;
 489
 490                 if(!blockedverbose)
 491                         continue;
 492
 493                 /* Traverse dependency chain if blocked. */
 494                 while(pr->p_flags & BLOCKED) {
 495                         endpoint_t dep = NONE;
 496                         struct tp *tpdep;
 497                         level += 5;
 498
 499                         if((dep = pr->p_blocked) == NONE) {
 500                                 printf("not blocked on a process");
 501                                 NEWLINE;
 502                                 break;
 503                         }
 504
 505                         if(dep == ANY)
 506                                 break;
 507
 508                         tpdep = lookup(dep, tick_procs, nprocs);
 509                         pr = tpdep->p;
 510                         printf("%*s> ", level, "");
 511                         print_proc(tpdep, total_ticks);
 512                         NEWLINE;
 513                 }
 514         }
 515 }
 516
 517 static void showtop(int cputimemode, int r)
 518 {
 519 #define NLOADS 3
 520         double loads[NLOADS];
 521         int nloads, lines = 0;
 522         struct winsize winsize;
 523
 524         if(ioctl(STDIN_FILENO, TIOCGWINSZ, &winsize) != 0) {
 525                 perror("TIOCGWINSZ");
 526                 fprintf(stderr, "TIOCGWINSZ failed\n");
 527                 exit(1);
 528         }
 529
 530         get_procs();
 531         if (prev_proc == NULL) {
 532                 /*
 533                  * A delay short enough to be unnoticable but long enough to
 534                  * allow for accumulation of sufficient data for the initial
 535                  * display not to show wildly inaccurate numbers.
 536                  */
 537                 usleep(100000);
 538                 get_procs();
 539         }
 540
 541         if((nloads = getloadavg(loads, NLOADS)) != NLOADS) {
 542                 fprintf(stderr, "getloadavg() failed - %d loads\n", nloads);
 543                 exit(1);
 544         }
 545
 546
 547         printf("%s", Tclr_all);
 548
 549         lines += print_load(loads, NLOADS);
 550         lines += print_proc_summary(proc);
 551         lines += print_memory();
 552
 553         if(winsize.ws_row > 0) r = winsize.ws_row;
 554
 555         print_procs(r - lines - 2, prev_proc, proc, cputimemode);
 556         fflush(NULL);
 557 }
 558
 559 static void init(int *rows)
 560 {
 561         char  *term;
 562         static char   buffer[TC_BUFFER], strings[TC_STRINGS];
 563         char *s = strings, *v;
 564
 565         *rows = 0;
 566
 567         if(!(term = getenv("TERM"))) {
 568                 fprintf(stderr, "No TERM set\n");
 569                 exit(1);
 570         }
 571
 572         if ( tgetent( buffer, term ) != 1 ) {
 573                 fprintf(stderr, "tgetent failed for term %s\n", term);
 574                 exit(1);
 575         }
 576
 577         initscr();
 578         cbreak();
 579
 580         if ( (Tclr_all = tgetstr( "cl", &s )) == NULL )
 581                 Tclr_all = "\f";
 582
 583         if((v = tgetstr ("li", &s)) != NULL)
 584                 sscanf(v, "%d", rows);
 585         if(*rows < 1) *rows = 24;
 586 }
 587
 588 static void sigwinch(int sig) { }
 589
 590 static void getkinfo(void)
 591 {
 592         FILE *fp;
 593
 594         if ((fp = fopen("kinfo", "r")) == NULL) {
 595                 fprintf(stderr, "opening " _PATH_PROC "kinfo failed\n");
 596                 exit(1);
 597         }
 598
 599         if (fscanf(fp, "%u %u", &nr_procs, &nr_tasks) != 2) {
 600                 fprintf(stderr, "reading from " _PATH_PROC "kinfo failed\n");
 601                 exit(1);
 602         }
 603
 604         fclose(fp);
 605
 606         nr_total = (int) (nr_procs + nr_tasks);
 607 }
 608
 609 int main(int argc, char *argv[])
 610 {
 611         int r, optc, s = 0;
 612         int cputimemode = 1;    /* bitmap. */
 613
 614         if (chdir(_PATH_PROC) != 0) {
 615                 perror("chdir to " _PATH_PROC);
 616                 return 1;
 617         }
 618
 619         system_hz = (u32_t) sysconf(_SC_CLK_TCK);
 620
 621         getkinfo();
 622
 623         init(&r);
 624
 625         while((optc=getopt(argc, argv, "s:B")) != EOF) {
 626                 switch(optc) {
 627                         case 's':
 628                                 s = atoi(optarg);
 629                                 break;
 630                         case 'B':
 631                                 blockedverbose = 1;
 632                                 break;
 633                         default:
 634                                 fprintf(stderr,
 635                                         "Usage: %s [-s<secdelay>] [-B]\n",
 636                                                 argv[0]);
 637                                 return 1;
 638                 }
 639         }
 640
 641         if(s < 1)
 642                 s = 2;
 643
 644         /* Catch window size changes so display is updated properly
 645          * right away.
 646          */
 647         signal(SIGWINCH, sigwinch);
 648
 649         while(1) {
 650                 fd_set fds;
 651                 int ns;
 652                 struct timeval tv;
 653                 showtop(cputimemode, r);
 654                 tv.tv_sec = s;
 655                 tv.tv_usec = 0;
 656
 657                 FD_ZERO(&fds);
 658                 FD_SET(STDIN_FILENO, &fds);
 659
 660                 if((ns=select(STDIN_FILENO+1, &fds, NULL, NULL, &tv)) < 0
 661                         && errno != EINTR) {
 662                         perror("select");
 663                         sleep(1);
 664                 }
 665
 666                 if(ns > 0 && FD_ISSET(STDIN_FILENO, &fds)) {
 667                         char inc;
 668                         if(read(STDIN_FILENO, &inc, 1) == 1) {
 669                                 switch(inc) {
 670                                         case 'q':
 671                                                 putchar('\r');
 672                                                 return 0;
 673                                                 break;
 674                                         case ORDERKEY:
 675                                                 order++;
 676                                                 if(order > ORDER_HIGHEST)
 677                                                         order = 0;
 678                                                 break;
 679                                         case TIMECYCLEKEY:
 680                                                 cputimemode++;
 681                                                 if(cputimemode >= (1L << CPUTIMENAMES))
 682                                                 cputimemode = 1;
 683                                                 break;
 684                                 }
 685                         }
 686                 }
 687         }
 688
 689         return 0;
 690 }
 691