![[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 / d / bin|
Return to ps.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * Modifications copyright INETCO Systems Ltd.
3: *
4: * Print out process statuses.
5: *
6: * $Log: ps.c,v $
7: * Revision 1.3 91/07/17 14:22:55 bin
8: * stevesf supplied as INETCO source because previous sources are of
9: * questionable origin... this one works
10: *
11: * Revision 1.2 89/06/12 15:15:22 src
12: * Bug: A directory at the end of the '/dev' directory would cause 'ps'
13: * to crash with the message "Cannot open <dir> in /dev".
14: * Fix: A stat was being done without the return code being checked. (ART)
15: *
16: * Revision 1.1 89/06/12 14:42:24 src
17: * Initial revision
18: *
19: * 88/02/15 Allan Cornish /usr/src/cmd/cmd/ps.c
20: * Kernel processes are now displayed regardless of -ax flags.
21: *
22: * 87/11/25 Allan Cornish /usr/src/cmd/cmd/ps.c
23: * Debug flag now -D. Drivers now displayed by -d flag.
24: *
25: * 87/11/12 Allan Cornish /usr/src/cmd/cmd/ps.c
26: * Modified to support Coherent 9.0 [protected mode] segmentation.
27: *
28: * 87/10/20 Allan Cornish /usr/src/cmd/cmd/ps.c
29: * Now extracts cmd name from u_comm field in uproc struct for kernel procs.
30: * Kernel processes only displayed if -d [debug] flag given.
31: *
32: * 87/09/28 Phil Selby /usr/src/cmd/cmd/ps.c
33: * Altered so that the terminal name rather than major and minor
34: * device number is printed out
35: *
36: * 84/08/21 Rec
37: * Added gflag for group identification.
38: *
39: * 84/07/16 Lauren Weinstein
40: * Initial version.
41: */
42:
43: #include <stdio.h>
44: #include <ctype.h>
45: #include <sys/const.h>
46: #include <l.out.h>
47: #include <pwd.h>
48: #include <sys/proc.h>
49: #include <sys/sched.h>
50: #include <sys/dir.h>
51: #include <sys/seg.h>
52: #include <sys/stat.h>
53: #include <sys/uproc.h>
54:
55: /*
56: * This is a kludge for the i8086 only and will be
57: * made to disappear when the segmentation (jproto)
58: * is thrown away.
59: */
60: #undef SISTACK
61: #define SISTACK SIPDATA
62:
63: /*
64: * Terminal information stored in memory for use by ps in TTY field
65: */
66:
67: struct handle {
68: dev_t dnum; /* device number */
69: char dname[DIRSIZ]; /* device name */
70: struct handle *nptr; /* pointer to next */
71: } *fptr, *lptr;
72:
73: /*
74: * Maximum sizes.
75: */
76: #define ARGSIZE 512
77:
78: /*
79: * Functions to see if a pointer is in alloc space and to map a
80: * pointer from alloc space to this process.
81: */
82: #define range(p) (p>=(char *)(aend) && p<(char *)(aend)+casize)
83: #define map(p) (&allp[(char *)p - (char *)aend])
84:
85: /*
86: * For easy referencing.
87: */
88: #define aprocq nl[0].n_value
89: #define autime nl[1].n_value
90: #define astime nl[2].n_value
91: #define aasize nl[3].n_value
92: #define aend nl[4].n_value
93:
94: /*
95: * Variables.
96: */
97: int aflag; /* All processes */
98: int dflag; /* Driver flag */
99: int dbflag; /* Debug flag */
100: int fflag; /* Print out all fields */
101: int gflag; /* Print out process groups */
102: int lflag; /* Long format */
103: int mflag; /* Print scheduling values */
104: int nflag; /* No header */
105: int rflag; /* Print out real sizes */
106: int tflag; /* Print times */
107: int wflag; /* Wide format */
108: int xflag; /* Get special processes */
109: dev_t ttdev; /* Terminal device */
110:
111: /*
112: * Table for namelist.
113: */
114: struct nlist nl[] ={
115: "procq_", 0, 0,
116: "utimer_", 0, 0,
117: "stimer_", 0, 0,
118: "asize_", 0, 0,
119: "end_", 0, 0,
120: ""
121: };
122:
123: /*
124: * Symbols.
125: */
126: char *allp; /* Pointer to alloc space */
127: char *kfile; /* Kernel data memory file */
128: char *nfile; /* Namelist file */
129: char *mfile; /* Memory file */
130: char *dfile; /* Swap file */
131: char argp[ARGSIZE]; /* Arguments */
132: int kfd; /* Kernel memory file descriptor */
133: int mfd; /* Memory file descriptor */
134: int dfd; /* Swap file descriptor */
135: struct uproc u; /* User process area */
136: int cutime; /* Unsigned time */
137: PROC cprocq; /* Process queue header */
138: unsigned casize; /* Size of alloc area */
139:
140: main(argc, argv)
141: char *argv[];
142: {
143: register int i;
144: register char *cp;
145:
146: initialise();
147: for (i=1; i<argc; i++) {
148: for (cp=&argv[i][0]; *cp; cp++) {
149: switch (*cp) {
150: case '-':
151: continue;
152: case 'a':
153: aflag++;
154: continue;
155: case 'c':
156: if (++i >= argc)
157: usage();
158: nfile = argv[i];
159: continue;
160: case 'd':
161: dflag++;
162: continue;
163: case 'D':
164: dbflag++;
165: continue;
166: case 'f':
167: fflag++;
168: continue;
169: case 'g':
170: gflag++;
171: continue;
172: case 'k':
173: if (++i >= argc)
174: usage();
175: mfile = argv[i];
176: continue;
177: case 'l':
178: lflag++;
179: continue;
180: case 'm':
181: mflag++;
182: continue;
183: case 'n':
184: nflag++;
185: continue;
186: case 'r':
187: rflag++;
188: continue;
189: case 't':
190: tflag++;
191: continue;
192: case 'w':
193: wflag++;
194: continue;
195: case 'x':
196: xflag++;
197: continue;
198: default:
199: usage();
200: }
201: }
202: }
203: execute();
204: exit(0);
205: }
206:
207: /*
208: * Initialise.
209: */
210: initialise()
211: {
212: register char *cp;
213:
214: aflag = 0;
215: gflag = 0;
216: lflag = 0;
217: mflag = 0;
218: nflag = 0;
219: xflag = 0;
220: nfile = "/coherent";
221: kfile = "/dev/kmem";
222: mfile = "/dev/mem";
223: dfile = "/dev/swap";
224: if ((cp=malloc(BUFSIZ)) != NULL)
225: setbuf(stdout, cp);
226: }
227:
228: /*
229: * Print out usage.
230: */
231: usage()
232: {
233: panic("Usage: ps [-][acdfgklmnrtwx]");
234: }
235:
236: /*
237: * Print out information about processes.
238: */
239: execute()
240: {
241: int c, l;
242: register PROC *pp1, *pp2;
243:
244: nlist(nfile, nl);
245: if (nl[0].n_type == 0)
246: panic("Bad namelist file %s", nfile);
247: if ((mfd=open(mfile, 0)) < 0)
248: panic("Cannot open %s", mfile);
249: if ((kfd = open(kfile, 0)) < 0)
250: panic("Cannot open %s", kfile);
251:
252: /*
253: * Open swap device if it exists
254: */
255: dfd = open(dfile, 0);
256:
257: kread((long)aasize, &casize, sizeof (casize));
258: kread((long)aprocq, &cprocq, sizeof (cprocq));
259:
260: if ((allp=malloc(casize)) == NULL)
261: panic( "Out of core or invalid kernel specified" );
262:
263: kread((long)aend, allp, casize);
264: kread((long)autime, &cutime, sizeof (cutime));
265: settdev();
266: fttys( "/dev"); /* load all the devices in dev */
267: l = 9;
268: if (dbflag)
269: l += 7;
270: if (gflag)
271: l += 6;
272: if (lflag)
273: l += 34;
274: if (mflag)
275: l += 26;
276: if (tflag)
277: l += 12;
278: if (nflag == 0) {
279: if (dbflag)
280: printf(" ");
281: printf("TTY PID");
282: if (gflag)
283: printf(" GROUP");
284: if (lflag)
285: printf(" PPID UID K F S EVENT");
286: if (mflag)
287: printf(" CVAL SVAL IVAL RVAL");
288: if (tflag)
289: printf(" UTIME STIME");
290: putchar('\n');
291: fflush(stdout);
292: }
293: pp1 = &cprocq;
294: while ((pp2=pp1->p_nback) != aprocq) {
295:
296: if (range((char *)pp2) == 0)
297: panic("Fragmented list");
298: pp1 = (PROC *) map(pp2);
299:
300: /*
301: * Kernel process - display only if '-d' argument given.
302: */
303: if ( pp1->p_flags & PFKERN ) {
304: if ( dflag == 0 )
305: continue;
306: }
307:
308: /*
309: * Unattached process - display only if '-x' argument given.
310: */
311: else if ( pp1->p_ttdev == NODEV ) {
312: if ( xflag == 0 )
313: continue;
314: }
315:
316: /*
317: * Attached to other terminal - display only if '-a' arg given.
318: */
319: else if ( pp1->p_ttdev != ttdev ) {
320: if ( aflag == 0 )
321: continue;
322: }
323:
324: if (dbflag)
325: printf("%06o ", pp2);
326: ptty(pp1);
327: printf(" %5d", pp1->p_pid);
328: if (gflag)
329: printf(" %5d", pp1->p_group);
330: if (lflag) {
331: printf(" %5d", pp1->p_ppid);
332: printf(" %8.8s", uname(pp1));
333: psize(pp1);
334: printf(" %4o", pp1->p_flags);
335: printf(" %c", c=state(pp1, pp2));
336: if (c == 'S')
337: printf(" %06o", pp1->p_event);
338: else {
339: if (fflag)
340: printf(" -");
341: else
342: printf(" ");
343: }
344: }
345: if (mflag) {
346: printf(" %5u", cval(pp1, pp2));
347: printf(" %5u", pp1->p_sval);
348: printf(" %6d", pp1->p_ival);
349: printf(" %6d", pp1->p_rval);
350: }
351: if (tflag) {
352: ptime(pp1->p_utime);
353: ptime(pp1->p_stime);
354: }
355: printf(" ");
356: printl(pp1, (wflag?132:80)-l-1);
357: putchar('\n');
358: fflush(stdout);
359: }
360: rttys(); /* release all alloced space */
361: }
362:
363: /*
364: * Set our terminal device.
365: */
366: settdev()
367: {
368: register PROC *pp1, *pp2;
369: register int p;
370:
371: p = getpid();
372: pp1 = &cprocq;
373: while ((pp2=pp1->p_nforw) != aprocq) {
374: if (range((char *)pp2) == 0)
375: break;
376: pp1 = (PROC *) map(pp2);
377: if (pp1->p_pid == p) {
378: ttdev = pp1->p_ttdev;
379: return;
380: }
381: }
382: ttdev = NODEV;
383: }
384:
385: /*
386: * Finds all special file in the specified directory (e.g. /dev)
387: */
388:
389: fttys( dirname)
390:
391: char *dirname;
392:
393: {
394: int filein; /* directory file descriptor */
395: struct stat sbuf; /* stat structure */
396: struct direct dbuf; /* directory buffer structure */
397:
398: /* move to the appropriate directory and open file for reading */
399:
400: chdir( dirname );
401:
402: if( ( filein = open( ".", 0) ) < 0 ) {
403: fprintf( stderr, "Cannot open '%s' in /dev\n", dirname );
404: exit( 1 );
405: }
406:
407: read( filein, &dbuf, sizeof(dbuf) ); /* read . */
408: read( filein, &dbuf, sizeof(dbuf) ); /* read .. */
409:
410: while( read( filein, &dbuf, sizeof(dbuf) ) ) {
411: if( stat( dbuf.d_name, &sbuf ) < 0 )
412: continue;
413:
414: if( sbuf.st_mode & S_IFCHR )
415: addname( dbuf.d_name, sbuf.st_rdev );
416:
417: else if( sbuf.st_mode & S_IFDIR )
418: fttys( dbuf.d_name );
419: }
420:
421: close( filein );
422: chdir( ".." );
423: }
424:
425: /*
426: * Adds a name and and device number of type handle
427: */
428:
429: addname( devname, devnum )
430:
431: char *devname;
432: dev_t devnum;
433:
434: {
435: extern struct handle *fptr;
436: extern struct handle *lptr;
437:
438: if( fptr == (struct handle *) NULL ) {
439: if( (fptr=(struct handle *) malloc( sizeof(struct handle))) ==
440: (struct handle *) NULL ) {
441: fprintf( stderr, "Out of memory\n");
442: exit( 1 );
443: }
444:
445: fptr->nptr = (struct handle *) NULL;
446: strcpy( fptr->dname, devname);
447: fptr->dnum = devnum;
448: }
449:
450: else {
451: lptr = fptr;
452:
453: while( ( lptr->nptr != (struct handle *) NULL ) &&
454: ( lptr->dnum != devnum ) ) lptr = lptr->nptr;
455:
456: if( lptr->dnum == devnum )
457: return;
458:
459: if( (lptr->nptr=(struct handle *)malloc(sizeof(struct handle)))
460: == (struct handle *) NULL ) {
461: fprintf( stderr, "Out of memory\n");
462: exit( 1 );
463: }
464:
465: lptr = lptr->nptr;
466: lptr->nptr = (struct handle *) NULL;
467: strcpy( lptr->dname, devname);
468: lptr->dnum = devnum;
469: }
470: }
471:
472: /*
473: * Release allocated space on exit (default action anyway)
474: */
475:
476: rttys()
477: {
478: /* release allocated space */
479:
480: lptr = fptr;
481: while( lptr->nptr != (struct handle *) NULL ) {
482: fptr = lptr;
483: lptr = fptr->nptr;
484: free( fptr);
485: }
486: free( lptr);
487: }
488:
489: /*
490: * Print the controlling terminal name. If not found it prints the
491: * major and minor device numbers. If no controlling terminal on the
492: * process than '--------' is printed.
493: */
494:
495: ptty( pp )
496: register PROC *pp;
497: {
498: register int d;
499:
500: /* when supplied with a device number, look for the name
501: of the special file from the dev directory */
502:
503: if( ( d = pp->p_ttdev ) == NODEV ) {
504: printf( "-------");
505: return;
506: }
507:
508: lptr = fptr;
509: while( lptr->nptr != (struct handle *) NULL ) {
510: if( lptr->dnum == d ) {
511: printf( "%-7.7s", lptr->dname);
512: return;
513: }
514: lptr = lptr->nptr;
515: }
516: if( lptr->dnum == d ) {
517: printf( "%-7.7s", lptr->dname);
518: return;
519: }
520: printf( "%3d %3d", major( d ), minor( d ) );
521: return;
522: }
523:
524: /*
525: * Given a process, return it's user name.
526: */
527: uname(pp)
528: register PROC *pp;
529: {
530: static char name[8];
531: register struct passwd *pwp;
532:
533: if ((pwp=getpwuid(pp->p_ruid)) != NULL)
534: return (pwp->pw_name);
535: sprintf(name, "%d", pp->p_ruid);
536: return (name);
537: }
538:
539: /*
540: * Return the core value for a process.
541: */
542: cval(pp1, pp2)
543: register PROC *pp1;
544: {
545: unsigned u;
546: register PROC *pp3, *pp4;
547:
548: if (pp1->p_state == PSSLEEP) {
549: u = (cutime-pp1->p_lctim) * 1;
550: if (pp1->p_cval+u > pp1->p_cval)
551: return (pp1->p_cval+u);
552: return (-1);
553: }
554: u = 0;
555: pp3 = &cprocq;
556: while ((pp4=pp3->p_lforw) != aprocq) {
557: if (range((char *)pp4) == 0)
558: break;
559: pp3 = (PROC *) map(pp4);
560: u -= pp3->p_cval;
561: if (pp2 == pp4)
562: return (u);
563: }
564: if (pp1->p_pid == getpid())
565: return (pp1->p_cval);
566: return (0);
567: }
568:
569: /*
570: * Return the size in K of the given process.
571: */
572: psize(pp)
573: register PROC *pp;
574: {
575: long l;
576: register SEG *sp;
577: register int n;
578:
579: l = 0;
580: for (n=0; n<NUSEG+1; n++) {
581: if (rflag == 0)
582: if (n==SIUSERP || n==SIAUXIL)
583: continue;
584: if ((sp=pp->p_segp[n]) == NULL)
585: continue;
586: if (range((char *)sp) == 0) {
587: printf(" ?K");
588: return;
589: }
590: sp = (SEG *) map(sp);
591: l += sp->s_size;
592: }
593: if (l != 0)
594: printf("%4ldK", l/1024);
595: else {
596: if (fflag)
597: printf(" -");
598: else
599: printf(" ");
600: }
601: }
602:
603: /*
604: * Get the state of the process.
605: */
606: state(pp1, pp2)
607: register PROC *pp1;
608: {
609: register int s;
610:
611: s = pp1->p_state;
612: if (s == PSSLEEP) {
613: if (pp1->p_event == pp2)
614: return ('W');
615: if ((pp1->p_flags&PFSTOP) != 0)
616: return ('T');
617: return ('S');
618: }
619: if (s == PSRUN)
620: return ('R');
621: if (s == PSDEAD)
622: return ('Z');
623: return ('?');
624: }
625:
626: /*
627: * Given a time in HZ, print it out.
628: */
629: ptime(l)
630: long l;
631: {
632: register unsigned m;
633:
634: if ((l=(l+HZ/2)/HZ) == 0) {
635: if (fflag)
636: printf(" -");
637: else
638: printf(" ");
639: return;
640: }
641: if ((m=l/60) >= 100) {
642: printf("%6d", m);
643: return;
644: }
645: printf(" %2d:%02d", m, (unsigned)l%60);
646: }
647:
648: /*
649: * Print out the command line of a process.
650: */
651: printl(pp, m)
652: register PROC *pp;
653: {
654: register char *cp;
655: register int c;
656: register int argc;
657: register int n;
658:
659: if (pp->p_state == PSDEAD)
660: return;
661: if (pp->p_pid == 0) {
662: printf("<idle>");
663: return;
664: }
665: if (segread(pp->p_segp[SIUSERP], 0, &u, sizeof (u)) == 0)
666: return;
667:
668: /*
669: * Handle kernel processes.
670: */
671: if ( pp->p_flags & PFKERN ) {
672: printf("<%.*s>",sizeof(u.u_comm), u.u_comm[0] ? u.u_comm : "");
673: return;
674: }
675:
676: n = segread(pp->p_segp[SISTACK], (u.u_argp-u.u_segl[SISTACK].sr_base),
677: argp, sizeof (argp));
678:
679: if (n == 0)
680: return;
681:
682: if ((argc=u.u_argc) <= 0)
683: return;
684:
685: m -= 2;
686: cp = argp;
687:
688: while (argc--) {
689: while ((c=*cp++) != '\0') {
690: if (!isascii(c) || !isprint(c))
691: return;
692: if (m-- == 0)
693: return;
694: putchar(c);
695: }
696: if (m-- == 0)
697: return;
698: if (argc != 0)
699: putchar(' ');
700: }
701: }
702:
703: /*
704: * Given a segment pointer `sp' and an offset into the segment,
705: * `s', read `n' bytes from the segment into the buffer `bp'.
706: */
707: segread(sp, s, bp, n)
708:
709: SEG *sp;
710: vaddr_t s;
711: char *bp;
712:
713: {
714: register SEG *sp1;
715:
716: if (range((char *)sp) == 0)
717: return (0);
718:
719: sp1 = (SEG *) map(sp);
720:
721: if ((sp1->s_flags&SFCORE) != 0)
722: mread( sp1->s_paddr + s, bp, n );
723:
724: else
725: if( dread( (long)sp1->s_daddr*BSIZE + s, bp, n ) < 0 )
726: return( 0 );
727:
728: return (1);
729: }
730:
731: /*
732: * Read `n' bytes into the buffer `bp' from kernel memory
733: * starting at seek position `s'.
734: */
735: kread(s, bp, n)
736: long s;
737: {
738: lseek(kfd, (long)s, 0);
739: if (read(kfd, bp, n) != n)
740: panic("Kernel memory read error");
741: }
742:
743: /*
744: * Read `n' bytes into the buffer `bp' from absolute memory
745: * starting at seek position `s'.
746: */
747: mread(s, bp, n)
748: long s;
749: {
750: lseek(mfd, (long)s, 0);
751: if (read(mfd, bp, n) != n)
752: panic("Memory read error");
753: }
754:
755: /*
756: * Read `n' bytes into the buffer `bp' from the swap file
757: * starting at seek position `s'.
758: */
759: dread(s, bp, n)
760: long s;
761: {
762: /*
763: * If swap device exists go look at it
764: */
765: if( dfd > 0 ) {
766: lseek(dfd, (long)s, 0);
767:
768: if (read(dfd, bp, n) != n)
769: panic("Swap read error");
770:
771: return( 1 );
772: }
773:
774: return( 0 );
775: }
776:
777: /*
778: * Print out an error message and exit.
779: */
780: panic(a1)
781: char *a1;
782: {
783: fflush(stdout);
784: fprintf(stderr, "%r", &a1);
785: fprintf(stderr, "\n");
786: exit(1);
787: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.