Return to proc.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / ps / ps3.0

Annotation of coherent/b/bin/ps/ps3.0/proc.c, revision 1.1.1.1

1.1       root        1: #include <sys/seg.h>
                      2: #include <sys/proc.h>
                      3: #include "ps.h"
                      4: 
                      5: /*
                      6:  * Determine the size of a process in K.
                      7:  */
                      8: unsigned long
                      9: proc_size( segp, real_flag )
                     10:        SEG *segp[];
                     11:        unsigned real_flag;     /* Determine real process size?  */
                     12: {
                     13:        long len;
                     14:        register SEG *sp;
                     15:        register int n;
                     16: 
                     17:        len = 0;
                     18:        for (n=0; n<NUSEG+1; n++) {
                     19:                if ( !real_flag ) {
                     20:                        if (n==SIUSERP || n==SIAUXIL) {
                     21:                                continue;
                     22:                        }
                     23:                }
                     24:                if ( (sp = segp[n]) == NULL ) {
                     25:                        continue;
                     26:                }
                     27:                /*
                     28:                 * If one segment can't be mapped, give up.
                     29:                 */
                     30:                if ( NULL == ( sp = kumap(sp, sizeof(SEG) ) ) ) {
                     31:                        return 0;
                     32:                }
                     33: 
                     34:                /*
                     35:                 * Add to the running total of segment sizes.
                     36:                 */
                     37:                len += sp->s_size;
                     38: 
                     39:                /*
                     40:                 * We're done with this segment.
                     41:                 */
                     42:                free(sp);
                     43:        }
                     44:        return( len );
                     45: } /* proc_size() */
                     46: 
                     47: /*
                     48:  * What state is the process in; asleep, running, stopped, or zombie?
                     49:  * Returns a single character indicating which.
                     50:  */
                     51: char
                     52: state( pp )
                     53:        PROC *pp;
                     54: {
                     55:        register unsigned s;
                     56: 
                     57:        s = pp->p_state;
                     58:        if (s == PSSLEEP) {
                     59:                if ((pp->p_flags&PFSTOP) != 0)
                     60:                        return ('T');
                     61:                return ('S');
                     62:        }
                     63:        if (s == PSRUN)
                     64:                return ('R');
                     65:        if (s == PSDEAD)
                     66:                return ('Z');
                     67:        return ('?');
                     68: } /* state() */
                     69: 
                     70: /*
                     71:  * Read in the process table.  Allocate memory for the whole process
                     72:  * table, which will be returned.  Returns NULL if something goes
                     73:  * wrong.  Also fills in a value for the number processes (num_procs).
                     74:  */
                     75: PROC *
                     76: create_proc_table( num_procs, pargs )
                     77:        int *num_procs;
                     78:        PROC_ARGS pargs;
                     79: {
                     80: } /* create_proc_table() */
                     81: 
                     82: /*
                     83:  * Fill in data about each process.  Allocate memory for
                     84:  * a table of PROC_DATA structs and fill it in to return.  Returns
                     85:  * NULL if anything goes wrong.
                     86:  */
                     87: PROC_DATA *
                     88: create_proc_data( proc_table, num_procs, pargs )
                     89:        PROC proc_table[];
                     90:        int num_procs;
                     91:        PROC_ARGS pargs;
                     92: {
                     93: } /* create_proc_data() */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.