m_svr42mp.c

unix系统下top命令的源代码

	 * Save current CPU time for next time around
	 * For the moment recreate the hash table each time, as the code
	 * is easier that way.
	 */

	/*
	 * Empty the hash table.
	 */
	for (pos = 0; pos < numoldprocs; pos++)
	{
		oldbase[pos].oldpid	= -1;
	}

	/*
	 * Recreate the hash table from the curruwproc information.
	 */
	for (i = 0; i < numprocs; i++)
	{

		/*
		 * Find an empty spot in the hash table.
		 */
		pos	= HASH(baseptr[i].p.p_epid);


		while (1)
		{
			if (oldbase[pos].oldpid == -1)
				break;
			pos++;

			if (pos == numoldprocs)
				pos	= 0;
		}

		oldbase[pos].oldpid	= baseptr[i].p.p_epid;

		oldbase[pos].oldtime	= baseptr[i].PR_time.tv_sec *
					   1.0e9 +
					  baseptr[i].PR_time.tv_nsec;

		oldbase[pos].oldpct	= baseptr[i].wcpu;
	}

	lasttime = thistime;
}


/* ************************************************************************** */

/*
 * Return the owner of the specified process, for use in commands.c
 * as we're running setuid root.
 */
uid_t
proc_owner (pid_t pid)
{
	register struct uwproc		*uwp;
	struct	proc			 p;
	int				 i;

	for (i = 0, uwp = pbase; i < numprocs; i++, uwp++)
	{
		if (uwp->p.p_epid == pid)
			return (uwp->ps.pr_uid);
	}

	return -1;
}

/* ************************************************************************** */

int
setpriority (int dummy, int who, int niceval)
{
	int		scale;
	int		prio;
	pcinfo_t	pcinfo;
	pcparms_t	pcparms;
	tsparms_t	*tsparms;

	strcpy (pcinfo.pc_clname, "TS");

	if (priocntl (0, 0, PC_GETCID, (caddr_t) & pcinfo) == -1)
		return -1;

	prio = niceval;
	if (prio > PRIO_MAX)
		prio = PRIO_MAX;
	else if (prio < PRIO_MIN)
		prio = PRIO_MIN;

	tsparms			= (tsparms_t *) pcparms.pc_clparms;
	scale			= ((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri;
	tsparms->ts_uprilim	= tsparms->ts_upri = -(scale * prio) / 20;
	pcparms.pc_cid		= pcinfo.pc_cid;

	if (priocntl (P_PID, who, PC_SETPARMS, (caddr_t) & pcparms) == -1)
		return (-1);

	return (0);
}

/* ************************************************************************** */

/*
 * get_swapinfo
 * Get total and free swap.
 * Snarfed from m_sunos5.c
 */
void
get_swapinfo(long *total, long *fr)
{
	register int		cnt, i;
	register int		t, f;

	struct swaptable	*swt;
	struct swapent		*ste;

	static char		path[256];

	/*
	 * Get total number of swap entries.
	 */
	cnt	= swapctl(SC_GETNSWP, 0);

	/*
	 * Allocate enough space to hold count + n swapents.
	 */
	swt = (struct swaptable *)malloc(sizeof(int) +
	cnt * sizeof(struct swapent));
	if (swt == NULL)
	{
		*total = 0;
		*fr = 0;

		return;
	}
	swt->swt_n = cnt;

	/*
	 * Fill in ste_path pointers: we don't care about the paths,
	 * so we point them all to the same buffer.
	 */
	ste = &(swt->swt_ent[0]);
	i = cnt;
	while (--i >= 0)
	{
		ste++->ste_path = path;
	}

	/*
	 * Grab all swap info.
	 */
	swapctl(SC_LIST, swt);

	/*
	 * Walk thru the structs and sum up the fields.
	 */
	t = f = 0;
	ste = &(swt->swt_ent[0]);
	i = cnt;
	while (--i >= 0)
	{
		/*
		 * Dont count slots being deleted.
		 */
		if (!(ste->ste_flags & ST_INDEL))
		{
			t += ste->ste_pages;
			f += ste->ste_free;
		}
		ste++;
	}

	/*
	 * Fill in the results.
	 */
	*total = t;
	*fr = f;

	free(swt);
}


/* ************************************************************************** */

/* comparison routine for qsort */

/*
 *  proc_compare - comparison function for "qsort"
 *	Compares the resource consumption of two processes using five
 *  	distinct keys.  The keys (in descending order of importance) are:
 *  	percent cpu, cpu ticks, state, resident set size, total virtual
 *  	memory usage.  The process states are ordered as follows (from least
 *  	to most important):  idle, stop, sleep, run, on processor.  The
 *  	array declaration below maps a process state index into a number
 *  	that reflects this ordering.
 */

unsigned char sorted_state[] =
{
  5,				/* run on a processor   */
  4,				/* run			*/
  3,				/* sleep		*/
  2,				/* stop			*/
  1,				/* idle			*/
};


#if 0       /* original compare rtn for single sort order */
int
proc_compare(void *v1, void *v2)
{
    struct uwproc		**pp1 = (struct uwproc **)v1;
    struct uwproc		**pp2 = (struct uwproc **)v2;

    register struct uwproc 	 *p1	= *pp1;
    register struct uwproc 	 *p2  = *pp2;

    register long result;

    double	d;

    /* use %cpu to break the tie. */
    d = p2->pctcpu - p1->pctcpu;

    if (d == 0.0)
    {
	/* use cpticks to break the tie */
	if ((result = p2->PR_time.tv_sec - p1->PR_time.tv_sec) == 0)
	  {
	    /* use process state to break the tie. */
	    if ((result = (long) (sorted_state[p2->PR_state] -
				  sorted_state[p1->.PR_state])) == 0)
	      {
		/* use priority to break the tie */
		if ((result = p2->PR_pri - p1->PR_pri) == 0)
		  {
		    /* use resident set size (rssize) to break the tie */
		    if ((result = p2->ps.pr_rssize - p1->ps.pr_rssize) == 0)
		      {
			/* use total memory to break the tie */
			result = (p2->ps.pr_size - p1->ps.pr_size);
		      }
		  }
	      }
	  }
    } 
    else
    {
	if (d < 0.0)
	{
		result	= -1;
	}
	else
	{
		result	= 1;
	}
    }

    return (result);
}
#endif

/* ----------------- comparison routines for qsort ---------------- */

/* First, the possible comparison keys.  These are defined in such a way
   that they can be merely listed in the source code to define the actual
   desired ordering.
 */

#define ORDERKEY_PCTCPU  if (dresult = p2->pctcpu - p1->pctcpu,\
			     (result = dresult > 0.0 ? 1 : \
			     dresult < 0.0 ? -1 : 0) == 0)

#define ORDERKEY_CPTICKS if ((result = p2->PR_time.tv_sec - p1->PR_time.tv_sec) == 0)
#define ORDERKEY_STATE   if ((result = (long) (sorted_state[p2->PR_state] - \
			       sorted_state[p1->PR_state])) == 0)

#define ORDERKEY_PRIO    if ((result = p2->PR_pri - p1->PR_pri) == 0)
#define ORDERKEY_RSSIZE  if ((result = p2->ps.pr_rssize-p1->ps.pr_rssize) == 0)
#define ORDERKEY_MEM     if ((result = (p2->ps.pr_size - p1->ps.pr_size)) == 0)

#define ORDERKEY_PID     if ((result = (p2->ps.pr_pid  - p1->ps.pr_pid))  == 0)
#define ORDERKEY_UID     if ((result = (p2->ps.pr_uid  - p1->ps.pr_uid))  == 0)
#define ORDERKEY_RPID    if ((result = (p1->ps.pr_pid  - p2->ps.pr_pid))  == 0)
#define ORDERKEY_RUID    if ((result = (p1->ps.pr_uid  - p2->ps.pr_uid))  == 0)


/* compare_cpu - the comparison function for sorting by cpu % (deflt) */
int
compare_cpu(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_PCTCPU

    ORDERKEY_CPTICKS
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_RSSIZE
    ORDERKEY_MEM

    ;

    return (result);
}

/* compare_state - comparison function for sorting by state,pri,time,size */
int
compare_state (void *v1, void *v2)
{
    struct uwproc		**pp1 = (struct uwproc **)v1;
    struct uwproc		**pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_CPTICKS
    ORDERKEY_RSSIZE
    ORDERKEY_MEM
    ORDERKEY_PCTCPU
    ;

    return (result);
}

/* compare_size - the comparison function for sorting by total memory usage */
int
compare_size(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long           result;
    double                  dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_MEM
    ORDERKEY_RSSIZE
    ORDERKEY_PCTCPU
    ORDERKEY_CPTICKS
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ;

    return (result);
  }

/* compare_res - the comparison function for sorting by resident set size */
int
compare_res(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_RSSIZE
    ORDERKEY_MEM
    ORDERKEY_PCTCPU
    ORDERKEY_CPTICKS
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ;

    return (result);
  }

/* compare_time - the comparison function for sorting by total cpu time */
int
compare_time(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_CPTICKS
    ORDERKEY_PCTCPU
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_MEM
    ORDERKEY_RSSIZE
    ;

    return (result);
  }

/* compare_pid - the comparison function for sorting by pid */
int
compare_pid(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_PID
    ORDERKEY_CPTICKS
    ORDERKEY_PCTCPU
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_MEM
    ORDERKEY_RSSIZE
    ;

    return (result);
  }

/* compare_uid - the comparison function for sorting by user ID */
int
compare_uid(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_UID
    ORDERKEY_CPTICKS
    ORDERKEY_PCTCPU
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_MEM
    ORDERKEY_RSSIZE
    ;

    return (result);
  }

/* compare_rpid - the comparison function for sorting by pid ascending */
int
compare_rpid(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_RPID
    ORDERKEY_CPTICKS
    ORDERKEY_PCTCPU
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_MEM
    ORDERKEY_RSSIZE
    ;

    return (result);
  }

/* compare_uid - the comparison function for sorting by user ID ascending */
int
compare_ruid(void *v1, void *v2)
{
    struct uwproc	    **pp1 = (struct uwproc **)v1;
    struct uwproc	    **pp2 = (struct uwproc **)v2;
    register struct uwproc  *p1;
    register struct uwproc  *p2;
    register long result;
    double dresult;

    /* remove one level of indirection */
    p1 = *pp1;
    p2 = *pp2;

    ORDERKEY_RUID 
    ORDERKEY_CPTICKS
    ORDERKEY_PCTCPU
    ORDERKEY_STATE
    ORDERKEY_PRIO
    ORDERKEY_MEM
    ORDERKEY_RSSIZE
    ;

    return (result);
  }