![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / ps / ps_b4_krnl68|
Return to ps.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / ps / ps_b4_krnl68 |
1.1 ! root 1: static char _version[]="ps version 2.10"; ! 2: /* ! 3: * Modifications copyright INETCO Systems Ltd. ! 4: * ! 5: * Print out process statuses. ! 6: * ! 7: * $Log: ps.c,v $ ! 8: * Revision 1.7 92/09/18 09:42:29 bin ! 9: * version 210 fom piggy ! 10: * ! 11: * Revision 1.3 91/07/17 14:22:55 bin ! 12: * stevesf supplied as INETCO source because previous sources are of ! 13: * questionable origin... this one works ! 14: * ! 15: * Revision 1.2 89/06/12 15:15:22 src ! 16: * Bug: A directory at the end of the '/dev' directory would cause 'ps' ! 17: * to crash with the message "Cannot open <dir> in /dev". ! 18: * Fix: A stat was being done without the return code being checked. (ART) ! 19: * ! 20: * Revision 1.1 89/06/12 14:42:24 src ! 21: * Initial revision ! 22: * ! 23: * 88/02/15 Allan Cornish /usr/src/cmd/cmd/ps.c ! 24: * Kernel processes are now displayed regardless of -ax flags. ! 25: * ! 26: * 87/11/25 Allan Cornish /usr/src/cmd/cmd/ps.c ! 27: * Debug flag now -D. Drivers now displayed by -d flag. ! 28: * ! 29: * 87/11/12 Allan Cornish /usr/src/cmd/cmd/ps.c ! 30: * Modified to support Coherent 9.0 [protected mode] segmentation. ! 31: * ! 32: * 87/10/20 Allan Cornish /usr/src/cmd/cmd/ps.c ! 33: * Now extracts cmd name from u_comm field in uproc struct for kernel procs. ! 34: * Kernel processes only displayed if -d [debug] flag given. ! 35: * ! 36: * 87/09/28 Phil Selby /usr/src/cmd/cmd/ps.c ! 37: * Altered so that the terminal name rather than major and minor ! 38: * device number is printed out ! 39: * ! 40: * 84/08/21 Rec ! 41: * Added gflag for group identification. ! 42: * ! 43: * 84/07/16 Lauren Weinstein ! 44: * Initial version. ! 45: */ ! 46: ! 47: #include <sys/coherent.h> ! 48: #include <sys/param.h> ! 49: #include <sys/proc.h> ! 50: #include <sys/sched.h> ! 51: #include <dirent.h> ! 52: #include <sys/seg.h> ! 53: #include <sys/stat.h> ! 54: #include <sys/uproc.h> ! 55: #include <sys/mmu.h> ! 56: #include <signal.h> ! 57: #include <access.h> ! 58: #include <fcntl.h> ! 59: #include <stdio.h> ! 60: #include <ctype.h> ! 61: #include <coff.h> ! 62: #include <pwd.h> ! 63: ! 64: /* ! 65: * This is a kludge for the i8086 only and will be ! 66: * made to disappear when the segmentation (jproto) ! 67: * is thrown away. ! 68: #undef SISTACK ! 69: #define SISTACK SIPDATA ! 70: */ ! 71: ! 72: /* ! 73: * Terminal information stored in memory for use by ps in TTY field ! 74: */ ! 75: ! 76: struct handle { ! 77: dev_t dnum; /* device number */ ! 78: char dname[DIRSIZ]; /* device name */ ! 79: struct handle *nptr; /* pointer to next */ ! 80: } *fptr, *lptr; ! 81: ! 82: /* ! 83: * Maximum sizes. ! 84: */ ! 85: #define ARGSIZE 512 ! 86: ! 87: /* ! 88: * Functions to see if a pointer is in alloc space and to map a ! 89: * pointer from alloca space to this process. ! 90: */ ! 91: #define map(p) (&(allp[(char *)(p) - (char *) callocp.sr_base])) ! 92: ! 93: /* ! 94: * For easy referencing. ! 95: */ ! 96: #define NUM_SYMS 7 /* Number of symbols to look up. */ ! 97: #define aprocq nl[0].n_value ! 98: #define autime nl[1].n_value ! 99: #define astime nl[2].n_value ! 100: #define aallocp nl[3].n_value ! 101: #define aend nl[4].n_value ! 102: #define asysmem nl[5].n_value ! 103: #define au nl[6].n_value ! 104: ! 105: #define TRUE (1==1) ! 106: #define FALSE (1==2) ! 107: #define LESSER(a, b) ((a < b)?a:b) ! 108: ! 109: /* ! 110: * Defines for referencing page tables. ! 111: */ ! 112: #define BPCSHIFT 12 /* Shift this many to convert bytes to clicks. */ ! 113: #define ONE_CLICK 4096 /* Bytes in a click. */ ! 114: #define CLICK_OFFSET 0x00000fffL /* Bits in virtual address indexing into page. */ ! 115: #define PT_CLICK_ADDR 0xfffff000L /* Bits in pte pointing at the page. */ ! 116: #define PT_PRESENT(entry) (0x01 == (entry & 0x01)) /* Is the page for ! 117: * this pte present? ! 118: */ ! 119: /* ! 120: * This is the address of the start of the U area segment. This ! 121: * should probably be extracted somehow from an include file. ! 122: * It can be derived with much pain from the s_vmem field in the seg ! 123: * struct from the U area segment. ! 124: */ ! 125: #define USEG_BASE 0xfffff000 ! 126: ! 127: /* ! 128: * Variables. ! 129: */ ! 130: int aflag; /* All processes */ ! 131: int dflag; /* Driver flag */ ! 132: int dbflag; /* Debug flag */ ! 133: int fflag; /* Print out all fields */ ! 134: int gflag; /* Print out process groups */ ! 135: int lflag; /* Long format */ ! 136: int mflag; /* Print scheduling values */ ! 137: int nflag; /* No header */ ! 138: int rflag; /* Print out real sizes */ ! 139: int tflag; /* Print times */ ! 140: int wflag; /* Wide format */ ! 141: int xflag; /* Get special processes */ ! 142: int Pflag; /* UNDOCUMENTED: ignore present bit. */ ! 143: dev_t ttdev; /* Terminal device */ ! 144: ! 145: /* ! 146: * Table for namelist. ! 147: */ ! 148: SYMENT nl[NUM_SYMS]; ! 149: ! 150: /* ! 151: * Symbols. ! 152: */ ! 153: char *allp; /* Pointer to alloc space */ ! 154: char *kfile; /* Kernel data memory file */ ! 155: char *nfile; /* Namelist file */ ! 156: char *mfile; /* Memory file */ ! 157: char *dfile; /* Swap file */ ! 158: char argp[ARGSIZE]; /* Arguments */ ! 159: int kfd; /* Kernel memory file descriptor */ ! 160: int mfd; /* Memory file descriptor */ ! 161: int dfd; /* Swap file descriptor */ ! 162: struct uproc u; /* User process area */ ! 163: unsigned cutime; /* Unsigned time */ ! 164: PROC cprocq; /* Process queue header */ ! 165: SR callocp; /* Size of alloc area */ ! 166: SYSMEM sysmem; /* Useful system-memory info. ! 167: * This variable MUST be called ! 168: * "sysmem" for the MAPIO() macro. ! 169: */ ! 170: char *malloc(); ! 171: char *uname(); ! 172: unsigned cval(); ! 173: cseg_t pt_index(); ! 174: char *pick_nfile(); ! 175: ! 176: main(argc, argv) ! 177: int argc; ! 178: char *argv[]; ! 179: { ! 180: register int i; ! 181: register char *cp; ! 182: ! 183: #if 0 ! 184: fprintf(stderr, "initialise()\n"); /* DEBUG */ ! 185: #endif /* 0 */ ! 186: initialise(); ! 187: #if 0 ! 188: fprintf(stderr, "parse args()\n"); /* DEBUG */ ! 189: #endif /* 0 */ ! 190: for (i=1; i<argc; i++) { ! 191: for (cp=&argv[i][0]; *cp; cp++) { ! 192: switch (*cp) { ! 193: case '-': ! 194: continue; ! 195: case 'a': ! 196: aflag++; ! 197: continue; ! 198: case 'c': ! 199: if (++i >= argc) ! 200: usage(); ! 201: nfile = argv[i]; ! 202: continue; ! 203: case 'd': ! 204: dflag++; ! 205: continue; ! 206: case 'D': ! 207: dbflag++; ! 208: continue; ! 209: case 'f': ! 210: fflag++; ! 211: continue; ! 212: case 'g': ! 213: gflag++; ! 214: continue; ! 215: case 'k': ! 216: if (++i >= argc) ! 217: usage(); ! 218: mfile = argv[i]; ! 219: continue; ! 220: case 'l': ! 221: lflag++; ! 222: continue; ! 223: case 'm': ! 224: mflag++; ! 225: continue; ! 226: case 'n': ! 227: nflag++; ! 228: continue; ! 229: case 'P': ! 230: Pflag++; ! 231: continue; ! 232: case 'r': ! 233: rflag++; ! 234: continue; ! 235: case 't': ! 236: tflag++; ! 237: continue; ! 238: case 'w': ! 239: wflag++; ! 240: continue; ! 241: case 'x': ! 242: xflag++; ! 243: continue; ! 244: default: ! 245: usage(); ! 246: } ! 247: } ! 248: } ! 249: ! 250: #if 0 ! 251: fprintf(stderr, "execute()\n"); /* DEBUG */ ! 252: #endif /* 0 */ ! 253: execute(); ! 254: ! 255: #if 0 ! 256: fprintf(stderr, "exit(0)\n"); /* DEBUG */ ! 257: #endif /* 0 */ ! 258: exit(0); ! 259: } ! 260: ! 261: /* ! 262: * Initialise. ! 263: */ ! 264: initialise() ! 265: { ! 266: register char *cp; ! 267: ! 268: aflag = 0; ! 269: gflag = 0; ! 270: lflag = 0; ! 271: mflag = 0; ! 272: nflag = 0; ! 273: Pflag = 0; ! 274: xflag = 0; ! 275: nfile = pick_nfile(); ! 276: kfile = "/dev/kmem"; ! 277: mfile = "/dev/mem"; ! 278: dfile = "/dev/swap"; ! 279: if ((cp=malloc(BUFSIZ)) != NULL) ! 280: setbuf(stdout, cp); ! 281: ! 282: /* Initialise the request for coffnlist(). */ ! 283: strcpy(nl[0]._n._n_name, "procq"); ! 284: nl[0].n_type = -1; ! 285: strcpy(nl[1]._n._n_name, "utimer"); ! 286: nl[1].n_type = -1; ! 287: strcpy(nl[2]._n._n_name, "stimer"); ! 288: nl[2].n_type = -1; ! 289: strcpy(nl[3]._n._n_name, "allocp"); ! 290: nl[3].n_type = -1; ! 291: strcpy(nl[4]._n._n_name, "end"); ! 292: nl[4].n_type = -1; ! 293: strcpy(nl[5]._n._n_name, "sysmem"); ! 294: nl[5].n_type = -1; ! 295: strcpy(nl[6]._n._n_name, "u"); ! 296: nl[6].n_type = -1; ! 297: ! 298: } ! 299: ! 300: /* ! 301: * Print out usage. ! 302: */ ! 303: usage() ! 304: { ! 305: panic("Usage: ps [-][acdfgklmnrtwx]"); ! 306: } ! 307: ! 308: ! 309: /* ! 310: * Print out information about processes. ! 311: */ ! 312: execute() ! 313: { ! 314: int fd; ! 315: int c, l; ! 316: int loop_count; /* Keep track of the number of entries read. */ ! 317: register PROC *pp1, *pp2; ! 318: ! 319: #if 0 ! 320: printf("execute()\n"); ! 321: fflush(stdout); ! 322: #endif /* 0 */ ! 323: ! 324: /* ! 325: * Check to see if the desired kernel exists and is accessable. ! 326: * NB: the access() system call uses the REAL uid to check ! 327: * permissions--it will not work here. ! 328: */ ! 329: if (-1 == (fd = open(nfile, O_RDONLY))) { ! 330: panic("%s is not readable or does not exist.", nfile); ! 331: } ! 332: close(fd); ! 333: ! 334: #if 0 ! 335: fprintf(stderr, "Extract symbol information from the kernel %s.\n", nfile); /* DEBUG */ ! 336: #endif /* 0 */ ! 337: /* ! 338: * Extract symbol information from the kernel. ! 339: */ ! 340: if (0 == coffnlist(nfile, nl, "", NUM_SYMS) ) { ! 341: panic("Can not use kernel image %s.", nfile); ! 342: } ! 343: ! 344: if (nl[0].n_type == -1) { ! 345: panic("Bad namelist file %s", nfile); ! 346: } ! 347: ! 348: #if 0 ! 349: fprintf(stderr, "Open the physical memory device.\n"); /* DEBUG */ ! 350: fflush(stderr); ! 351: #endif /* 0 */ ! 352: /* ! 353: * Open the physical memory device. ! 354: */ ! 355: if ((mfd=open(mfile, 0)) < 0) { ! 356: panic("Cannot open %s", mfile); ! 357: } ! 358: ! 359: #if 0 ! 360: fprintf(stderr, "Open the virtual memory device.\n"); /* DEBUG */ ! 361: fflush(stderr); ! 362: #endif /* 0 */ ! 363: /* ! 364: * Open the virtual memory device. ! 365: */ ! 366: if ((kfd = open(kfile, 0)) < 0) { ! 367: panic("Cannot open %s", kfile); ! 368: } ! 369: ! 370: /* ! 371: * Open swap device if it exists ! 372: */ ! 373: dfd = open(dfile, 0); ! 374: ! 375: #if 0 ! 376: fprintf(stderr, "Fetch the head of the process queue.\n"); /* DEBUG */ ! 377: fflush(stderr); ! 378: #endif /* 0 */ ! 379: /* ! 380: * Fetch the head of the process queue. ! 381: */ ! 382: kread((long)aprocq, &cprocq, sizeof (cprocq)); ! 383: ! 384: /* ! 385: * Fetch information about system memory. ! 386: */ ! 387: kread((long)asysmem, &sysmem, sizeof (sysmem)); ! 388: ! 389: ! 390: ! 391: #if 0 ! 392: fprintf(stderr, "Take a snapshot of kernel memory.\n"); /* DEBUG */ ! 393: fflush(stderr); ! 394: #endif /* 0 */ ! 395: /* ! 396: * Take a snapshot of kernel memory. ! 397: */ ! 398: kread((unsigned long)aallocp, &callocp, sizeof (callocp)); ! 399: ! 400: #if 0 ! 401: fprintf(stderr, "callocp.sr_size: %x\n", callocp.sr_size); ! 402: fflush(stderr); ! 403: #endif /* 0 */ ! 404: ! 405: if ((allp=malloc(callocp.sr_size)) == NULL) { ! 406: panic( "Out of core or invalid kernel specified" ); ! 407: } ! 408: ! 409: #if 0 ! 410: fprintf(stderr, "kread(%x, %x, %x)\n", /* DEBUG */ ! 411: (unsigned long)callocp.sr_base, allp, callocp.sr_size); ! 412: fflush(stderr); ! 413: #endif /* 0 */ ! 414: ! 415: kread((unsigned long)callocp.sr_base, allp, callocp.sr_size); ! 416: ! 417: ! 418: #if 0 ! 419: fprintf(stderr, "Fetch the current tick time.\n"); /* DEBUG */ ! 420: fflush(stderr); ! 421: #endif /* 0 */ ! 422: /* ! 423: * Fetch the current tick time. ! 424: */ ! 425: kread((long)autime, &cutime, sizeof (cutime)); ! 426: ! 427: #if 0 ! 428: fprintf(stderr, "Find out what our controlling terminal is.\n"); /* DEBUG */ ! 429: fflush(stderr); ! 430: #endif /* 0 */ ! 431: /* ! 432: * Find out what our controlling terminal is. ! 433: */ ! 434: settdev(); ! 435: ! 436: fttys( "/dev"); /* load all the devices in dev */ ! 437: ! 438: #if 0 ! 439: fprintf(stderr, "Calculate the length of the output line.\n"); /* DEBUG */ ! 440: fflush(stderr); ! 441: #endif /* 0 */ ! 442: /* ! 443: * Calculate the length of the output line. ! 444: */ ! 445: l = strlen("TTY PID"); ! 446: if (dbflag) ! 447: l += strlen("0xffffffff "); ! 448: if (gflag) ! 449: l += strlen(" GROUP"); ! 450: if (lflag) ! 451: l += strlen(" PPID UID K F S EVENT"); ! 452: if (mflag) ! 453: l += strlen(" CVAL SVAL IVAL RVAL"); ! 454: if (tflag) ! 455: l += strlen(" UTIME STIME"); ! 456: if (nflag == 0) { ! 457: if (dbflag) ! 458: printf(" "); ! 459: printf("TTY PID"); ! 460: if (gflag) ! 461: printf(" GROUP"); ! 462: if (lflag) ! 463: printf(" PPID UID K F S EVENT"); ! 464: if (mflag) ! 465: printf(" CVAL SVAL IVAL RVAL"); ! 466: if (tflag) ! 467: printf(" UTIME STIME"); ! 468: putchar('\n'); ! 469: fflush(stdout); ! 470: } ! 471: ! 472: #if 0 ! 473: fprintf(stderr, "Walk through the process queue printing out each entry.\n"); /* DEBUG */ ! 474: fflush(stderr); ! 475: #endif /* 0 */ ! 476: /* ! 477: * Walk through the process queue printing out each entry. ! 478: */ ! 479: loop_count = 0; /* How many PROC entries have we seen? */ ! 480: pp1 = &cprocq; ! 481: while ((pp2=pp1->p_nback) != (PROC *) aprocq) { ! 482: loop_count++; ! 483: ! 484: #if 0 ! 485: fprintf(stderr, "count: %d\n", loop_count); /* DEBUG */ ! 486: fflush(stderr); ! 487: #endif /* 0 */ ! 488: ! 489: if (range((char *)pp2) == 0) ! 490: panic("Fragmented list"); ! 491: pp1 = map(pp2); ! 492: ! 493: /* ! 494: * Kernel process - display only if '-d' argument given. ! 495: */ ! 496: if ( pp1->p_flags & PFKERN ) { ! 497: #if 0 ! 498: fprintf(stderr, "PFKERN\n"); /* DEBUG */ ! 499: fflush(stderr); ! 500: #endif /* 0 */ ! 501: if ( dflag == 0 ) { ! 502: continue; ! 503: } ! 504: } ! 505: ! 506: /* ! 507: * Unattached process - display only if '-x' argument given. ! 508: */ ! 509: else if ( pp1->p_ttdev == NODEV ) { ! 510: #if 0 ! 511: fprintf(stderr, "NODEV\n"); /* DEBUG */ ! 512: fflush(stderr); ! 513: #endif /* 0 */ ! 514: if ( xflag == 0 ) { ! 515: continue; ! 516: } ! 517: } ! 518: ! 519: /* ! 520: * Attached to other terminal - display only if '-a' arg given. ! 521: */ ! 522: else if ( pp1->p_ttdev != ttdev ) { ! 523: #if 0 ! 524: fprintf(stderr, "Other tty\n"); /* DEBUG */ ! 525: fflush(stderr); ! 526: #endif /* 0 */ ! 527: if ( aflag == 0 ) ! 528: continue; ! 529: } ! 530: ! 531: #if 0 ! 532: fprintf(stderr, "ASSERTION: pp1 is a proc entry we want to print.\n"); /* DEBUG */ ! 533: fflush(stderr); ! 534: #endif /* 0 */ ! 535: /* ! 536: * ASSERTION: pp1 is a proc entry we want to print. ! 537: */ ! 538: ! 539: if (dbflag) ! 540: printf("0x%8x ", pp2); ! 541: ptty(pp1); ! 542: printf(" %5d", pp1->p_pid); ! 543: if (gflag) ! 544: printf(" %5d", pp1->p_group); ! 545: if (lflag) { ! 546: printf(" %5d", pp1->p_ppid); ! 547: fflush(stdout); ! 548: printf(" %8.8s", uname(pp1)); ! 549: fflush(stdout); ! 550: psize(pp1); ! 551: fflush(stdout); ! 552: printf(" %4o", pp1->p_flags); ! 553: fflush(stdout); ! 554: printf(" %c", c=state(pp1, pp2)); ! 555: fflush(stdout); ! 556: if (c == 'S') { ! 557: print_event(pp1); ! 558: } else { ! 559: if (fflag) ! 560: printf(" -"); ! 561: else ! 562: printf(" "); ! 563: } ! 564: fflush(stdout); ! 565: } ! 566: if (mflag) { ! 567: printf(" %9u", cval(pp1, pp2)); ! 568: printf(" %9u", pp1->p_sval); ! 569: printf(" %10d", pp1->p_ival); ! 570: printf(" %10d", pp1->p_rval); ! 571: } ! 572: if (tflag) { ! 573: ptime(pp1->p_utime); ! 574: ptime(pp1->p_stime); ! 575: } ! 576: printf(" "); ! 577: printl(pp1, (wflag?132:80)-l-1); ! 578: ! 579: putchar('\n'); ! 580: fflush(stdout); ! 581: } ! 582: rttys(); /* release all alloced space */ ! 583: } ! 584: ! 585: /* ! 586: * Set our terminal device. ! 587: */ ! 588: settdev() ! 589: { ! 590: register PROC *pp1, *pp2; ! 591: register int p; ! 592: int loop_count; ! 593: ! 594: p = getpid(); ! 595: pp1 = &cprocq; ! 596: ! 597: loop_count = 0; /* How many PROC entries have we seen? */ ! 598: while ((pp2=pp1->p_nforw) != (PROC *) aprocq) { ! 599: loop_count++; ! 600: #if 0 ! 601: fprintf(stderr, "settdev() count: %d\n", loop_count); /* DEBUG */ ! 602: fflush(stderr); ! 603: #endif /* 0 */ ! 604: ! 605: #if 0 ! 606: fprintf(stderr, "range():sr_base: %x < %x < sr_base + sr_size: %x\n", ! 607: callocp.sr_base, pp2, callocp.sr_base + callocp.sr_size); /* DEBUG */ ! 608: fflush(stderr); ! 609: #endif /* 0 */ ! 610: if (range((char *)pp2) == 0) ! 611: break; ! 612: ! 613: #if 0 ! 614: fprintf(stderr, "About to map %x\n", pp2); /* DEBUG */ ! 615: fflush(stderr); ! 616: ! 617: fprintf(stderr, "offset = (%x - sr_base) = %x \n", ! 618: pp2, ((char *)pp2) - callocp.sr_base ); /* DEBUG */ ! 619: fflush(stderr); ! 620: fprintf(stderr, "(allp:%x + offset): \n", ! 621: allp, allp + ( ((char *) pp2) - ( (char *) callocp.sr_base) ) ); /* DEBUG */ ! 622: fflush(stderr); ! 623: #endif /* 0 */ ! 624: ! 625: pp1 = map(pp2); ! 626: ! 627: #if 0 ! 628: fprintf(stderr, "mapped %x to %x\n", pp2, pp1); /* DEBUG */ ! 629: fflush(stderr); ! 630: #endif /* 0 */ ! 631: if (pp1->p_pid == p) { ! 632: ttdev = pp1->p_ttdev; ! 633: return; ! 634: } ! 635: } ! 636: ttdev = NODEV; ! 637: } ! 638: ! 639: /* ! 640: * Finds all special files in the specified directory (e.g. /dev) ! 641: */ ! 642: ! 643: fttys( dirname) ! 644: ! 645: char *dirname; ! 646: ! 647: { ! 648: int filein; /* directory file descriptor */ ! 649: struct stat sbuf; /* stat structure */ ! 650: struct direct dbuf; /* directory buffer structure */ ! 651: ! 652: /* move to the appropriate directory and open file for reading */ ! 653: ! 654: chdir( dirname ); ! 655: ! 656: if( ( filein = open( ".", 0) ) < 0 ) { ! 657: fprintf( stderr, "Cannot open '%s' in /dev\n", dirname ); ! 658: exit( 1 ); ! 659: } ! 660: ! 661: read( filein, &dbuf, sizeof(dbuf) ); /* read . */ ! 662: read( filein, &dbuf, sizeof(dbuf) ); /* read .. */ ! 663: ! 664: while( read( filein, &dbuf, sizeof(dbuf) ) ) { ! 665: if( stat( dbuf.d_name, &sbuf ) < 0 ) ! 666: continue; ! 667: ! 668: if( sbuf.st_mode & S_IFCHR ) ! 669: addname( dbuf.d_name, sbuf.st_rdev ); ! 670: ! 671: else if( sbuf.st_mode & S_IFDIR ) ! 672: fttys( dbuf.d_name ); ! 673: } ! 674: ! 675: close( filein ); ! 676: chdir( ".." ); ! 677: } ! 678: ! 679: /* ! 680: * Adds a name and device to the master list of ttys. ! 681: */ ! 682: ! 683: addname( devname, devnum ) ! 684: char *devname; ! 685: dev_t devnum; ! 686: { ! 687: extern struct handle *fptr; ! 688: extern struct handle *lptr; ! 689: ! 690: if( fptr == (struct handle *) NULL ) { ! 691: if( (fptr=(struct handle *) malloc( sizeof(struct handle))) == ! 692: (struct handle *) NULL ) { ! 693: fprintf( stderr, "Out of memory\n"); ! 694: exit( 1 ); ! 695: } ! 696: ! 697: fptr->nptr = (struct handle *) NULL; ! 698: strcpy( fptr->dname, devname); ! 699: fptr->dnum = devnum; ! 700: } ! 701: ! 702: else { ! 703: lptr = fptr; ! 704: ! 705: while( ( lptr->nptr != (struct handle *) NULL ) && ! 706: ( lptr->dnum != devnum ) ) lptr = lptr->nptr; ! 707: ! 708: if( lptr->dnum == devnum ) ! 709: return; ! 710: ! 711: if( (lptr->nptr=(struct handle *)malloc(sizeof(struct handle))) ! 712: == (struct handle *) NULL ) { ! 713: fprintf( stderr, "Out of memory\n"); ! 714: exit( 1 ); ! 715: } ! 716: ! 717: lptr = lptr->nptr; ! 718: lptr->nptr = (struct handle *) NULL; ! 719: strcpy( lptr->dname, devname); ! 720: lptr->dnum = devnum; ! 721: } ! 722: } ! 723: ! 724: /* ! 725: * Release allocated space on exit (default action anyway) ! 726: */ ! 727: ! 728: rttys() ! 729: { ! 730: /* release allocated space */ ! 731: ! 732: lptr = fptr; ! 733: while( lptr->nptr != (struct handle *) NULL ) { ! 734: fptr = lptr; ! 735: lptr = fptr->nptr; ! 736: free( fptr); ! 737: } ! 738: free( lptr); ! 739: } ! 740: ! 741: /* ! 742: * Print the controlling terminal name. If not found it prints the ! 743: * major and minor device numbers. If no controlling terminal on the ! 744: * process then '--------' is printed. ! 745: */ ! 746: ! 747: ptty( pp ) ! 748: register PROC *pp; ! 749: { ! 750: register dev_t d; ! 751: ! 752: /* when supplied with a device number, look for the name ! 753: of the special file from the dev directory */ ! 754: ! 755: if( ((dev_t)( d = pp->p_ttdev )) == NODEV ) { ! 756: printf( "-------"); ! 757: return; ! 758: } ! 759: ! 760: lptr = fptr; ! 761: while( lptr->nptr != (struct handle *) NULL ) { ! 762: if( lptr->dnum == d ) { ! 763: printf( "%-7.7s", lptr->dname); ! 764: return; ! 765: } ! 766: lptr = lptr->nptr; ! 767: } ! 768: if( lptr->dnum == d ) { ! 769: printf( "%-7.7s", lptr->dname); ! 770: return; ! 771: } ! 772: printf( "%3d %3d", major( d ), minor( d ) ); ! 773: return; ! 774: } ! 775: ! 776: /* ! 777: * Given a process, return it's user name. ! 778: */ ! 779: char * ! 780: uname(pp) ! 781: register PROC *pp; ! 782: { ! 783: static char name[8]; ! 784: register struct passwd *pwp; ! 785: ! 786: if ((pwp=getpwuid(pp->p_ruid)) != NULL) ! 787: return (pwp->pw_name); ! 788: sprintf(name, "%d", pp->p_ruid); ! 789: return (name); ! 790: } ! 791: ! 792: /* ! 793: * Return the core value for a process. ! 794: */ ! 795: unsigned ! 796: cval(pp1, pp2) ! 797: register PROC *pp1; ! 798: PROC *pp2; ! 799: { ! 800: unsigned u; ! 801: register PROC *pp3, *pp4; ! 802: ! 803: if (pp1->p_state == PSSLEEP) { ! 804: u = (cutime-pp1->p_lctim) * 1; ! 805: if (pp1->p_cval+u > pp1->p_cval) ! 806: return (pp1->p_cval+u); ! 807: return (-1); ! 808: } ! 809: u = 0; ! 810: pp3 = &cprocq; ! 811: while ((pp4=pp3->p_lforw) != (PROC *) aprocq) { ! 812: if (range((char *)pp4) == 0) ! 813: break; ! 814: pp3 = map(pp4); ! 815: u -= pp3->p_cval; ! 816: if (pp2 == pp4) ! 817: return (u); ! 818: } ! 819: if (pp1->p_pid == getpid()) ! 820: return (pp1->p_cval); ! 821: return (0); ! 822: } /* cval() */ ! 823: ! 824: /* ! 825: * Return the size in K of the given process. ! 826: */ ! 827: psize(pp) ! 828: register PROC *pp; ! 829: { ! 830: long len; ! 831: register SEG *sp; ! 832: register int n; ! 833: ! 834: len = 0; ! 835: for (n=0; n<NUSEG+1; n++) { ! 836: if (rflag == 0) ! 837: if (n==SIUSERP || n==SIAUXIL) ! 838: continue; ! 839: if ((sp=pp->p_segp[n]) == NULL) ! 840: continue; ! 841: if (range((char *)sp) == 0) { ! 842: printf(" ?K"); ! 843: return; ! 844: } ! 845: sp = map(sp); ! 846: len += sp->s_size; ! 847: } ! 848: if (len != 0) ! 849: printf("%4ldK", len/1024); ! 850: else { ! 851: if (fflag) ! 852: printf(" -"); ! 853: else ! 854: printf(" "); ! 855: } ! 856: } ! 857: ! 858: /* ! 859: * Get the state of the process. ! 860: */ ! 861: state(pp1, pp2) ! 862: register PROC *pp1; ! 863: char *pp2; ! 864: { ! 865: register unsigned s; ! 866: ! 867: s = pp1->p_state; ! 868: if (s == PSSLEEP) { ! 869: if (pp1->p_event == pp2) ! 870: return ('W'); ! 871: if ((pp1->p_flags&PFSTOP) != 0) ! 872: return ('T'); ! 873: return ('S'); ! 874: } ! 875: if (s == PSRUN) ! 876: return ('R'); ! 877: if (s == PSDEAD) ! 878: return ('Z'); ! 879: return ('?'); ! 880: } ! 881: ! 882: /* ! 883: * Given a time in HZ, print it out. ! 884: */ ! 885: ptime(l) ! 886: long l; ! 887: { ! 888: register unsigned m; ! 889: ! 890: if ((l=(l+HZ/2)/HZ) == 0) { ! 891: if (fflag) ! 892: printf(" -"); ! 893: else ! 894: printf(" "); ! 895: return; ! 896: } ! 897: if ((m=l/60) >= 100) { ! 898: printf("%6d", m); ! 899: return; ! 900: } ! 901: printf(" %2d:%02d", m, (unsigned)l%60); ! 902: } ! 903: ! 904: /* ! 905: * Print out the reason for a sleep. ! 906: */ ! 907: print_event(pp) ! 908: register PROC *pp; ! 909: { ! 910: /* Only print the u.u_sleep field if it is non-empty. */ ! 911: ! 912: if ( (u_init(pp->p_segp[SIUSERP], &u) != 0) && ! 913: ('\0' != u.u_sleep[0]) ) { ! 914: printf(" %10.10s", u.u_sleep ); ! 915: } else { ! 916: /* Otherwise, print the address we are sleeping on. */ ! 917: printf(" 0x%08X", pp->p_event); ! 918: } ! 919: ! 920: fflush(stdout); ! 921: } /* print_event() */ ! 922: ! 923: /* ! 924: * Print out the command line of a process. ! 925: */ ! 926: printl(pp, m) ! 927: register PROC *pp; ! 928: { ! 929: register char *cp; ! 930: register int c; ! 931: register int argc; ! 932: register int n; ! 933: static SR *srp; ! 934: ! 935: if (pp->p_state == PSDEAD) { ! 936: printf("<zombie>"); ! 937: return; ! 938: } ! 939: if (pp->p_pid == 0) { ! 940: printf("<idle>"); ! 941: return; ! 942: } ! 943: ! 944: if (u_init(pp->p_segp[SIUSERP], &u) == 0) { ! 945: printf("<ghost>"); ! 946: return; ! 947: } ! 948: ! 949: printf(" %.10s", u.u_comm); ! 950: return; ! 951: ! 952: /* ! 953: * Handle kernel processes. ! 954: */ ! 955: if ( pp->p_flags & PFKERN ) { ! 956: printf("<%.*s>",sizeof(u.u_comm), u.u_comm[0] ? u.u_comm : ""); ! 957: return; ! 958: } ! 959: ! 960: if ((argc=u.u_argc) <= 0) ! 961: return; ! 962: ! 963: srp = &u.u_segl[SISTACK]; ! 964: printf("segread 2 in printl\n"); ! 965: printf("u.u_argp: %x, srp->sr_base: %x\n", ! 966: u.u_argp, srp->sr_base); ! 967: printf("u.u_argc: %x srp->sr_size: %x\n", u.u_argc, srp->sr_size); ! 968: ! 969: n = segread(&u.u_segl[SISTACK], u.u_argp, argp, 64); ! 970: ! 971: if (n == 0) { ! 972: fprintf(stderr, "Bad segread()\n"); /* DEBUG */ ! 973: return; ! 974: } ! 975: ! 976: m -= 2; ! 977: cp = argp; ! 978: ! 979: while (argc--) { ! 980: while ((c=*cp++) != '\0') { ! 981: if (!isascii(c) || !isprint(c)) { ! 982: #if 0 /* Blocked out for test purposes. */ ! 983: return; ! 984: #else ! 985: putchar('.'); ! 986: continue; ! 987: #endif /* 0 */ ! 988: } ! 989: if (m-- == 0) ! 990: return; ! 991: putchar(c); ! 992: } ! 993: fflush(stdout); ! 994: #if 0 /* Blocked out for test purposes. */ ! 995: if (m-- == 0) ! 996: return; ! 997: #endif /* 0 */ ! 998: if (argc != 0) ! 999: putchar(' '); ! 1000: } ! 1001: } ! 1002: ! 1003: ! 1004: /* ! 1005: * Given a segment pointer `sp', read a u area into buffer `bp'. ! 1006: */ ! 1007: u_init(sp, bp) ! 1008: SEG *sp; ! 1009: char *bp; ! 1010: { ! 1011: #ifdef UPROC_VERSION ! 1012: /* Have we verrified the uproc version number? */ ! 1013: static version_ok = FALSE; ! 1014: #endif /* UPROC_VERSION */ ! 1015: ! 1016: register SEG *sp1; ! 1017: long offset; ! 1018: ! 1019: #if 0 ! 1020: printf("u_init(sp:%x, bp:%x)\n", sp, bp); ! 1021: fflush(stdout); ! 1022: #endif /* 0 */ ! 1023: ! 1024: if (range((char *)sp) == 0) { ! 1025: return (0); ! 1026: } ! 1027: ! 1028: sp1 = map(sp); ! 1029: ! 1030: /* ! 1031: * Figure out how far into the U segment the U area is. ! 1032: * We do this by subtracting the starting address of the ! 1033: * U area segment from the address of u. ! 1034: */ ! 1035: offset = au - USEG_BASE; ! 1036: ! 1037: /* ! 1038: * If the process is not swapped out, read directly from ! 1039: * main memory. Otherwise, read from the swap device. ! 1040: */ ! 1041: if ((sp1->s_flags&SFCORE) != 0) { ! 1042: if (0 == pt_mread( sp1->s_vmem, offset, bp, sizeof(UPROC) )) { ! 1043: return (0); ! 1044: } ! 1045: } else if ( ! 1046: dread((long)(sp1->s_daddr*BSIZE)+offset, bp, sizeof(UPROC)) < 0 ! 1047: ){ ! 1048: return (0); ! 1049: } ! 1050: ! 1051: #ifdef UPROC_VERSION ! 1052: /* ! 1053: * Check the version number on this U area. ! 1054: * I.e. does this ps match this kernel? ! 1055: */ ! 1056: if ( ((UPROC *) bp)->u_version != UPROC_VERSION ) { ! 1057: /* ! 1058: * Only print the warning if we have not yet seen ! 1059: * a valid version number, and then only once. ! 1060: * ! 1061: * If we have seen at least one valid version number, ! 1062: * it probably means that this process was dying. ! 1063: */ ! 1064: if (!version_ok) { ! 1065: static int printed_once = FALSE; ! 1066: if (!printed_once) { ! 1067: fprintf( stderr, ! 1068: "\nps WARNING: u area version is %x, not %x.\n", ! 1069: ((UPROC *) bp)->u_version, UPROC_VERSION ); ! 1070: printed_once = TRUE; ! 1071: } ! 1072: } ! 1073: return (0); ! 1074: } ! 1075: version_ok = TRUE; /* We've now seen one valid version number. */ ! 1076: #endif /* UPROC_VERSION */ ! 1077: ! 1078: return (1); ! 1079: } ! 1080: ! 1081: ! 1082: /* ! 1083: * Given an open segment pointer `sr' and an offset into the segment, ! 1084: * `s', read `n' bytes from the segment into the buffer `bp'. ! 1085: */ ! 1086: segread(sr, s, bp, n) ! 1087: SR *sr; ! 1088: vaddr_t s; ! 1089: char *bp; ! 1090: int n; ! 1091: { ! 1092: register SEG *sp1; ! 1093: vaddr_t offset; ! 1094: ! 1095: #if 0 ! 1096: printf("segread(sr:%x, s:%x, bp:%x, n:%x)\n", sr, s, bp, n); ! 1097: fflush(stdout); ! 1098: #endif /* 0 */ ! 1099: ! 1100: if (range((char *)sr->sr_segp) == 0) { ! 1101: return (0); ! 1102: } ! 1103: ! 1104: sp1 = map(sr->sr_segp); ! 1105: ! 1106: /* If segment grows up... */ ! 1107: if (0 == (SFDOWN & (sp1->s_flags)) ) { ! 1108: /* then sr_base is the bottom of the segment, */ ! 1109: offset = s - sr->sr_base; ! 1110: } else { ! 1111: /* otherwise sr_base is the top of the segment. */ ! 1112: offset = s - (sr->sr_base - sr->sr_size); ! 1113: } ! 1114: ! 1115: /* ! 1116: * If the process is not swapped out, read directly from ! 1117: * main memory. Otherwise, read from the swap device. ! 1118: */ ! 1119: if ((sp1->s_flags&SFCORE) != 0) { ! 1120: if (0 == pt_mread( sp1->s_vmem, offset, bp, n )) { ! 1121: return (0); ! 1122: } ! 1123: } else if (dread( (long)sp1->s_daddr*BSIZE + s, bp, n ) < 0 ) { ! 1124: return( 0 ); ! 1125: } ! 1126: return (1); ! 1127: } /* segread() */ ! 1128: ! 1129: /* ! 1130: * Read `n' bytes into the buffer `bp' from kernel memory ! 1131: * starting at seek position `s'. ! 1132: */ ! 1133: kread(s, bp, n) ! 1134: long s; ! 1135: char *bp; ! 1136: int n; ! 1137: { ! 1138: lseek(kfd, (long)s, 0); ! 1139: if (read(kfd, bp, n) != n) ! 1140: panic("Kernel memory read error"); ! 1141: } ! 1142: ! 1143: /* ! 1144: * Read `n' bytes into the buffer `bp' from absolute memory ! 1145: * starting at seek position `s'. ! 1146: */ ! 1147: mread(s, bp, n) ! 1148: long s; ! 1149: char *bp; ! 1150: int n; ! 1151: { ! 1152: lseek(mfd, (long)s, 0); ! 1153: if (read(mfd, bp, n) != n) ! 1154: panic("Memory read error"); ! 1155: } ! 1156: ! 1157: /* ! 1158: * Read `n' bytes into the buffer `bp' from the swap file ! 1159: * starting at seek position `s'. ! 1160: */ ! 1161: dread(s, bp, n) ! 1162: long s; ! 1163: char *bp; ! 1164: int n; ! 1165: { ! 1166: /* ! 1167: * If swap device exists go look at it ! 1168: */ ! 1169: if( dfd > 0 ) { ! 1170: lseek(dfd, (long)s, 0); ! 1171: ! 1172: if (read(dfd, bp, n) != n) ! 1173: panic("Swap read error"); ! 1174: ! 1175: return( 1 ); ! 1176: } ! 1177: ! 1178: return( 0 ); ! 1179: } ! 1180: ! 1181: /* ! 1182: * Print out an error message and exit. ! 1183: */ ! 1184: panic(a1) ! 1185: char *a1; ! 1186: { ! 1187: fflush(stdout); ! 1188: sleep(2); ! 1189: ! 1190: fprintf(stderr, "%r", &a1); ! 1191: fprintf(stderr, "\n"); ! 1192: ! 1193: fflush(stderr); ! 1194: exit(1); ! 1195: } ! 1196: ! 1197: /* ! 1198: * Functions to see if a pointer is in alloc space and to map a ! 1199: * pointer from alloc space to this process. ! 1200: */ ! 1201: int ! 1202: range(p) ! 1203: char *p; ! 1204: { ! 1205: return (p>=(char *)(callocp.sr_base) && ! 1206: p<(char*)(callocp.sr_base + callocp.sr_size)); ! 1207: } /* range() */ ! 1208: ! 1209: /* ! 1210: * Read `n' bytes into the buffer `bp' from physical memory ! 1211: * starting at seek position `s', relative to the page table 'table'. ! 1212: * ! 1213: * 'table' is a fraction of a 386 page table. The upper 20 bits of the ! 1214: * adjusted virtual address 's' form an index into the table. The address ! 1215: * 's' must be adjusted so that it is relative to the start of the fractional ! 1216: * table 'table'. 'table' is fractional because COH386 does not store whole ! 1217: * page tables for non-running processes. ! 1218: * ! 1219: * The entries in the table are 32 bits long (called 'pte'). The lowest bit ! 1220: * is the present bit. If this is 0 for ANY of the pages we are asked to ! 1221: * read, we return 0, indicating that we have read nothing. The upper ! 1222: * 20 bits of this entry point in physical memory to a click. The lower ! 1223: * 12 bits of the virtual address 's' are used as an index into this click ! 1224: * to find the desired data. ! 1225: * ! 1226: * All other bits in the page table entry are ignored by this routine. ! 1227: * ! 1228: * Returns 0 on failure, 1 on success. ! 1229: */ ! 1230: ! 1231: int ! 1232: pt_mread(table, s, bp, n) ! 1233: cseg_t *table; /* Page table. */ ! 1234: vaddr_t s; /* Where to start reading. */ ! 1235: char *bp; /* Buffer to copy into. */ ! 1236: int n; /* Number of bytes to read. */ ! 1237: { ! 1238: int to_read; /* Number of bytes to read next. */ ! 1239: vaddr_t page_offset; /* How far into page to start reading. */ ! 1240: cseg_t pt_entry; /* Current entry from Page Table. */ ! 1241: ! 1242: ! 1243: #if 0 ! 1244: printf("pt_mread(table: %x, s: %x, bp: %x, n: %x)\n", table, s, bp, n); ! 1245: fflush(stdout); ! 1246: sleep(1); ! 1247: #endif /* 0 */ ! 1248: ! 1249: pt_entry = pt_index(table, s>>BPCSHIFT); ! 1250: ! 1251: if (!Pflag && !PT_PRESENT(pt_entry)) { ! 1252: #if 0 /* If the page is not present, the proess probably died already. */ ! 1253: static printed_once = FALSE; ! 1254: if (!printed_once) { ! 1255: printf("\npage not present: %x\n", pt_entry); ! 1256: printed_once = TRUE; ! 1257: } ! 1258: #endif /* 0 */ ! 1259: return(0); ! 1260: } ! 1261: pt_entry &= PT_CLICK_ADDR; /* Extract Address of click. */ ! 1262: page_offset = s & CLICK_OFFSET; /* Extract offset into click. */ ! 1263: to_read = LESSER(n, ONE_CLICK - page_offset); /* How far to end of click? */ ! 1264: ! 1265: while (n > 0) { ! 1266: ! 1267: #if 0 ! 1268: printf("pt_mread(): mread(from: %x, to: %x, for: %x))\n", ! 1269: pt_entry+page_offset, bp, to_read); ! 1270: fflush(stdout); ! 1271: sleep(1); ! 1272: #endif /* 0 */ ! 1273: ! 1274: mread(pt_entry+page_offset, bp, to_read); ! 1275: ! 1276: n -= to_read; /* How many left? */ ! 1277: s += to_read; /* From where? */ ! 1278: bp += to_read; /* To where? */ ! 1279: ! 1280: pt_entry = pt_index(table, s>>BPCSHIFT); ! 1281: if (!Pflag && !PT_PRESENT(pt_entry)) { ! 1282: printf("partition not present: %x.\n", pt_entry); ! 1283: return(0); ! 1284: } ! 1285: pt_entry &= PT_CLICK_ADDR; /* Extract Address of click. */ ! 1286: page_offset = s & CLICK_OFFSET; /* Extract offset into click. */ ! 1287: to_read = LESSER(n, ONE_CLICK); ! 1288: } /* while (n > 0) */ ! 1289: ! 1290: return(1); ! 1291: } /* pt_mread() */ ! 1292: ! 1293: cseg_t ! 1294: pt_index(table, index) ! 1295: cseg_t *table; ! 1296: vaddr_t index; ! 1297: { ! 1298: cseg_t pte; /* The page table entry we are looking for. */ ! 1299: ! 1300: #if 0 ! 1301: printf("pt_index(0x%x, 0x%x)\n", table, index); ! 1302: fflush(stdout); ! 1303: sleep(1); ! 1304: #endif /* 0 */ ! 1305: ! 1306: kread(table+index, &pte, sizeof(cseg_t)); ! 1307: ! 1308: return(pte); ! 1309: } /* pt_index() */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.