perfmon.c

操作系统SunOS 4.1.3版本的源码

	  p_stats[possible_stats[PAGING]].value[num_of_val] =
	     ans[PAGING];
	if WANT_STAT(CONTEXT_SW)
	  p_stats[possible_stats[CONTEXT_SW]].value[num_of_val] =
	     ans[CONTEXT_SW];

	(void)gettimeofday(&current_time, &dummy_zone);
	if (current_time.tv_sec < saved_time.tv_sec) {
	  /* Super-user must have set the clock back */
	  saved_time = current_time;
	  saved_time.tv_sec -= SECS_PER_TIME_TICK;
	}
	if (saved_time.tv_sec+SECS_PER_TIME_TICK <= current_time.tv_sec) {
	  saved_time = current_time;
	  do_time[num_of_val] = 1;
	} else
	  do_time[num_of_val] = 0;

	next_display(gfx->gfx_pixwin);
}


extern char	*remotehost;
static CLIENT	*client, *oldclient;

/*
 * setup sets up a client to use the remote routine RSTATPROG for collecting
 * remote machine statistics.
 */
setup()
{
        enum clnt_stat clnt_stat;
        struct hostent          *hp;
        struct timeval          timeout;
        struct sockaddr_in      serveradr;
        int                     snum = RPC_ANYSOCK;

        bzero((char *)&serveradr, sizeof (serveradr));
        if (remotehost) {
                if ((hp = gethostbyname(remotehost)) == NULL) {
                        (void)fprintf(stderr,
                            "Sorry, host %s not in hosts database\n",
                             remotehost);
                        exit(1);
                }
                bcopy(hp->h_addr, (char *)&serveradr.sin_addr, hp->h_length);
        }        
        else {
                if (hp = gethostbyname("localhost"))
                        bcopy(hp->h_addr, (char *)&serveradr.sin_addr,
                            hp->h_length);
                else
                        serveradr.sin_addr.s_addr = inet_addr("127.0.0.1");
        }
        serveradr.sin_family = AF_INET;
        serveradr.sin_port = 0;
        timeout.tv_sec = 5;
        timeout.tv_usec = 0;
	if ((vers == VER_NONE) || (vers == RSTATVERS_VAR)) {
		if ((client = clntudp_bufcreate(&serveradr, RSTATPROG,
				RSTATVERS_VAR, timeout, &snum,
				sizeof(struct rpc_msg), UDPMSGSIZE)) == NULL)
			return (-1);

                clnt_stat = clnt_call(client, NULLPROC, xdr_void, 0,xdr_void,
                                        0, TIMEOUT);
                if (clnt_stat == RPC_SUCCESS) {
                        vers = RSTATVERS_VAR;
                } else if (clnt_stat != RPC_PROGVERSMISMATCH) {
                        clnt_destroy(client);
                        return(-1);
                } else {                /* version mismatch */
                        clnt_destroy(client);
                        vers = RSTATVERS_SWTCH;
                }
        }
	if ((vers == VER_NONE) || (vers == RSTATVERS_SWTCH)) {
		snum = RPC_ANYSOCK;
        	if ((client = clntudp_bufcreate(&serveradr, RSTATPROG,
            		RSTATVERS_SWTCH, timeout, &snum, 
			sizeof(struct rpc_msg), sizeof(struct rpc_msg) + 
			sizeof(struct statsswtch))) == NULL) 
                	return(-1);
                clnt_stat = clnt_call(client, NULLPROC, xdr_void, 0,
                                      xdr_void, 0, TIMEOUT);
                if (clnt_stat == RPC_SUCCESS) {
                        vers = RSTATVERS_SWTCH;
                } else {
                        clnt_destroy(client);
                        return (-1);
                }
        }
        if (oldsocket >= 0)
                (void)close(oldsocket);
        oldsocket = snum;
        if (oldclient)
                clnt_destroy(oldclient);
        oldclient = client;
        return(0);
}


#define TRIES	8
/* static data used only by getdata_swtch(), getdata_var() */
static  struct statsswtch p_statsswtch;
static  struct statsvar stats_var;
static  int *oldtime;
static  int total;                      /* Default to zero */
static  int toterr;                     /* Default to zero */
static  int totcoll;                    /* Default to zero */
static  struct timeval tm, oldtm;
static  int *xfer1;
static  int badcnt;                     /* Default to zero */
static  int oldi, olds, oldp, oldsp;
static  int getdata_init_done;          /* Default to zero */

int
getdata_swtch()
{
        register int i, t;
        register int msecs;
        int maxtfer;
        enum clnt_stat clnt_stat;
        int intrs, swtchs, pag, spag;
        int sum, ppersec;

        clnt_stat = clnt_call(client, RSTATPROC_STATS, xdr_void, 0,
                xdr_statsswtch,  &p_statsswtch, TIMEOUT);
        if (clnt_stat == RPC_TIMEDOUT)
                return(NULL);
        if (clnt_stat != RPC_SUCCESS) {
		if (!sick) {
			sick = 1 ;
/*        clnt_perror(client, "cpugetdata"); -JCH- ignored until reason known */
		}
		redisplay();
                return(NULL);
        }

	if (oldtime == (int *)NULL) { /* allocate memory for structures */
		cpustates = 4;          /* compatibility with version 3*/
		dk_ndrive = 4;
/*
		oldtime = (int *) malloc(cpustates * sizeof(int));
		xfer1 = (int *) malloc(dk_ndrive * sizeof(int));
		if ( (oldtime == NULL) || (xfer1 == NULL)) {
			fprintf(stderr,"failed in malloc()\n");
			exit(1);
		}
*/
	}
        for (i = 0; i < cpustates; i++) {
                t = p_statsswtch.cp_time[i];
                p_statsswtch.cp_time[i] -= oldtime[i];
                oldtime[i] = t;
        }
        t = 0;
        for (i = 0; i < cpustates; i++)   /* assume IDLE is last */
                t += p_statsswtch.cp_time[i];
        if (p_statsswtch.cp_time[cpustates -1] + t <= 0) {
                t++;
                badcnt++;
                if (badcnt >= TRIES) {
			sick = 1 ;
			redisplay() ;
/*
                   (void)fprintf(stderr,
                     "perfmon: rstatd on %s returned bad data\n", remotehost);
                        exit(1);
*/
                }
        } else if (sick) {   
                badcnt = sick = 0;
		redisplay() ;
        } else {
		badcnt = 0 ;
        } 
	ans[USER_CPU_PERCENTAGE] = cpu_usage(CP_USER, &p_statsswtch) +
				   cpu_usage(CP_NICE, &p_statsswtch);
	ans[SYSTEM_CPU_PERCENTAGE] = cpu_usage(CP_SYS, &p_statsswtch);
 
        if ( gettimeofday(&tm, (struct timezone *)0) == -1 )
		perror("perfmon: gettimeofday failed");
        msecs = (1000*(tm.tv_sec - oldtm.tv_sec) +
            (tm.tv_usec - oldtm.tv_usec)/1000);
	++msecs;		/* to avoid msecs == 0 */

        sum = p_statsswtch.if_ipackets + p_statsswtch.if_opackets;
        ppersec = 1000*(sum - total) / msecs;
        total = sum;
        ans[PACKETS] = ppersec;
        ans[COLLISION_PACKETS] = FSCALE*(p_statsswtch.if_collisions - totcoll) *
				 1000 / msecs;
        totcoll = p_statsswtch.if_collisions;
        ans[ERROR_PACKETS] = FSCALE*(p_statsswtch.if_ierrors - toterr) *
			     1000 / msecs;
        toterr = p_statsswtch.if_ierrors;
 
        if (!getdata_init_done) {       
                pag = 0;
                spag = 0;
                intrs = 0;
                swtchs = 0;
                getdata_init_done = 1;
 
        } else {
                pag = p_statsswtch.v_pgpgout + p_statsswtch.v_pgpgin - oldp;
                pag = 1000*pag / msecs;
                spag = p_statsswtch.v_pswpout + p_statsswtch.v_pswpin - oldsp;
                spag = 1000*spag / msecs;
                intrs = p_statsswtch.v_intr - oldi;
                intrs = 1000*intrs / msecs;
                swtchs = p_statsswtch.v_swtch - olds;
                swtchs = 1000*swtchs / msecs;
        }
        oldp = p_statsswtch.v_pgpgin + p_statsswtch.v_pgpgout;
        oldsp = p_statsswtch.v_pswpin + p_statsswtch.v_pswpout;
        oldi = p_statsswtch.v_intr;
        olds = p_statsswtch.v_swtch;
        ans[PAGING] = pag;
        ans[INTERRUPTS] = intrs;
        ans[CONTEXT_SW] = swtchs;
        ans[LOAD_AVE] = p_statsswtch.avenrun[0]; /* use the 1 minute average */
	if (debug) {
		printf("ans[LOAD_AVE] = %d; load = %d\n",
			ans[LOAD_AVE], ans[LOAD_AVE]/FSCALE);
		printf("ans[PAGING] = %d\n", ans[PAGING]);
		printf("ans[CONTEXT_SW] = %d\n", ans[CONTEXT_SW]);
		printf("ans[INTERRUPTS] = %d\n", ans[INTERRUPTS]);
		printf("p_statsswtch.if_ierrors = %d\n", p_statsswtch.if_ierrors);
		printf("p_statsswtch.if_collisions = %d\n",
			p_statsswtch.if_collisions);
		printf("msecs = %d\n", msecs);
		printf("ans[PACKETS] = %d\n", ans[PACKETS]);
		printf("ans[COLLISION_PACKETS] = %d\n",
			ans[COLLISION_PACKETS]);
		printf("ans[ERROR_PACKETS] = %d\n\n", ans[ERROR_PACKETS]);
	}
        for (i = 0; i < DK_NDRIVE; i++) {
                t = p_statsswtch.dk_xfer[i];
                p_statsswtch.dk_xfer[i] -= xfer1[i];
                xfer1[i] = t;
        }
        maxtfer = p_statsswtch.dk_xfer[0];
        for (i = 1; i < DK_NDRIVE; i++) {
                if (p_statsswtch.dk_xfer[i] > maxtfer)
                        maxtfer = p_statsswtch.dk_xfer[i];
        }
        maxtfer = (1000*maxtfer) / msecs;
        ans[DISK_TRANSFERS] = maxtfer;
        oldtm = tm;
	for (i=0; i<NUM_POSSIBLE_STATS; i++) {
	    if (ans[i] < 0)
	        ans[i] = 0;
	}
        return (1);
}

getdata_var()
{
        register int i, t;
        register int msecs;
        int maxtfer;
        enum clnt_stat clnt_stat;
        int intrs, swtchs, pag, spag;
        int sum, ppersec;

	if (oldtime == (int *) NULL) {
		stats_var.dk_xfer.dk_xfer_val = (int *) NULL;
		stats_var.cp_time.cp_time_val = (int *) NULL;
	}
        clnt_stat = clnt_call(client, RSTATPROC_STATS, xdr_void, 0,
                xdr_statsvar,  &stats_var, TIMEOUT);
        if (clnt_stat == RPC_TIMEDOUT)
                return(NULL);
        if (clnt_stat != RPC_SUCCESS) {
		if (!sick) {
			sick = 1 ;
/*        clnt_perror(client, "cpugetdata"); -JCH- ignored until reason known */
		}
		redisplay();
                return(NULL);
        }

	if (oldtime == (int *)NULL) { /* allocate memory for structures */
		cpustates = stats_var.cp_time.cp_time_len;          
		dk_ndrive = stats_var.dk_xfer.dk_xfer_len;
		oldtime = (int *) malloc(cpustates * sizeof(int));
		xfer1 = (int *) malloc(dk_ndrive * sizeof(int));
		if ( (oldtime == NULL) || (xfer1 == NULL)) {
			fprintf(stderr,"failed in malloc()\n");
			exit(1);
		}
	}
        for (i = 0; i < cpustates; i++) {
                t = stats_var.cp_time.cp_time_val[i];
                stats_var.cp_time.cp_time_val[i] -= oldtime[i];
                oldtime[i] = t;
        }
        t = 0;
        for (i = 0; i < cpustates - 1; i++)   /* assume IDLE is last */
                t += stats_var.cp_time.cp_time_val[i];
        if (stats_var.cp_time.cp_time_val[cpustates - 1 ] + t <= 0) {
                t++;
                badcnt++;
                if (badcnt >= TRIES) {
			sick = 1 ;
			redisplay() ;
                }
        } else if (sick) {   
                badcnt = sick = 0;
		redisplay() ;
        } else {
		badcnt = 0 ;
        } 
	ans[USER_CPU_PERCENTAGE] = cpu_usage_var(CP_USER, &stats_var) +
				   cpu_usage_var(CP_NICE, &stats_var);

	ans[SYSTEM_CPU_PERCENTAGE] = cpu_usage_var(CP_SYS, &stats_var);
 
        if ( gettimeofday(&tm, (struct timezone *)0) == -1 )
		perror("perfmon: gettimeofday failed");
        msecs = (1000*(tm.tv_sec - oldtm.tv_sec) +
            (tm.tv_usec - oldtm.tv_usec)/1000);
	++msecs;		/* to avoid msecs == 0 */
	if (msecs == 0) msecs = 1;

        sum = stats_var.if_ipackets + stats_var.if_opackets;
        ppersec = 1000*(sum - total) / msecs;
        total = sum;
        ans[PACKETS] = ppersec;
        ans[COLLISION_PACKETS] = FSCALE*(stats_var.if_collisions - totcoll) *
				 1000 / msecs;
        totcoll = stats_var.if_collisions;
        ans[ERROR_PACKETS] = FSCALE*(stats_var.if_ierrors - toterr) *
			     1000 / msecs;
        toterr = stats_var.if_ierrors;
 
        if (!getdata_init_done) {       
                pag = 0;
                spag = 0;
                intrs = 0;
                swtchs = 0;
                getdata_init_done = 1;
 
        } else {
                pag = stats_var.v_pgpgout + stats_var.v_pgpgin - oldp;
                pag = 1000*pag / msecs;
                spag = stats_var.v_pswpout + stats_var.v_pswpin - oldsp;
                spag = 1000*spag / msecs;
                intrs = stats_var.v_intr - oldi;
                intrs = 1000*intrs / msecs;
                swtchs = stats_var.v_swtch - olds;
                swtchs = 1000*swtchs / msecs;
        }
        oldp = stats_var.v_pgpgin + stats_var.v_pgpgout;
        oldsp = stats_var.v_pswpin + stats_var.v_pswpout;
        oldi = stats_var.v_intr;
        olds = stats_var.v_swtch;
        ans[PAGING] = pag;
        ans[INTERRUPTS] = intrs;
        ans[CONTEXT_SW] = swtchs;
        ans[LOAD_AVE] = stats_var.avenrun[0]; /* use the 1 minute average */
	if (debug) {
		printf("ans[LOAD_AVE] = %d; load = %d\n",
			ans[LOAD_AVE], ans[LOAD_AVE]/FSCALE);
		printf("ans[PAGING] = %d\n", ans[PAGING]);
		printf("ans[CONTEXT_SW] = %d\n", ans[CONTEXT_SW]);
		printf("ans[INTERRUPTS] = %d\n", ans[INTERRUPTS]);
		printf("stats_var.if_ierrors = %d\n", stats_var.if_ierrors);
		printf("stats_var.if_collisions = %d\n",
			stats_var.if_collisions);
		printf("msecs = %d\n", msecs);
		printf("ans[PACKETS] = %d\n", ans[PACKETS]);
		printf("ans[COLLISION_PACKETS] = %d\n",
			ans[COLLISION_PACKETS]);
		printf("ans[ERROR_PACKETS] = %d\n\n", ans[ERROR_PACKETS]);
	}
        for (i = 0; i < DK_NDRIVE; i++) {
                t = stats_var.dk_xfer.dk_xfer_val[i];
                stats_var.dk_xfer.dk_xfer_val[i] -= xfer1[i];
                xfer1[i] = t;
        }
/*      Perfmeter Bug# 1028570 fix, old code commented out
 *
 *      maxtfer = stats_var.dk_xfer.dk_xfer_val[0];
 *      for (i = 1; i < DK_NDRIVE; i++) {
 *              if (stats_var.dk_xfer.dk_xfer_val[i] > maxtfer)
 *                      maxtfer = stats_var.dk_xfer.dk_xfer_val[i];
 *      }
*/

	for (i = 0, maxtfer = stats_var.dk_xfer.dk_xfer_val[0]; i < dk_ndrive; i++)
		maxtfer += stats_var.dk_xfer.dk_xfer_val[i];

        maxtfer = (1000*maxtfer) / msecs;
       	ans[DISK_TRANSFERS] = maxtfer;
        oldtm = tm;
	for (i=0; i<NUM_POSSIBLE_STATS; i++) {
	    if (ans[i] < 0)
	        ans[i] = 0;
	}
        return (1);
}

/*
 * cpu_usage(CP_which, stat)
 *	CP_which:  CP_USER, CP_NICE, CP_SYS, or CP_IDLE.
 *	stat:	   pointer to the statistics structure gotten from rpc call.
 *
 * cpu_usage calculates and returns the percentage of CPU usage.
 *
 */ 
int cpu_usage(CP_which, stat)
	int			CP_which;
	struct statsswtch	*stat;
{
	double		total_usage = 0;
	register	i = 0;

	if (CP_which<CP_USER || CP_which>CP_IDLE) {
		fprintf(stderr, "cpu_usage() error\n");
		exit(1);
	}
	for (i=0; i<CPUSTATES; i++)
		total_usage = total_usage + (*stat).cp_time[i];
	if (total_usage == 0.)
		total_usage = 1.;
	return ((*stat).cp_time[CP_which]*100./total_usage);
}

/*
 * cpu_usage_var(CP_which, stat)
 *	CP_which:  CP_USER, CP_NICE, CP_SYS, or CP_IDLE.
 *	stats_var:  pointer to the statistics structure gotten from rpc call.
 *
 * cpu_usage calculates and returns the percentage of CPU usage.
 *
 */ 
int cpu_usage_var(CP_which, stats_var)
	int			CP_which;
	struct statsvar 	*stats_var;
{
	double		total_usage = 0;
	register	i = 0;

	if (CP_which<CP_USER || CP_which>CP_IDLE) {
		fprintf(stderr, "cpu_usage() error\n");
		exit(1);
	}
	for (i=0; i<CPUSTATES; i++)
		total_usage = total_usage + (*stats_var).cp_time.cp_time_val[i];
	if (total_usage == 0.)
		total_usage = 1.;
	return ((*stats_var).cp_time.cp_time_val[CP_which]*100./total_usage);
}