cpustat.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

				default:   /* any other charcter will refresh
					    * screen with latest data */

					break;  
				}
			}
		} else  {
			if(interval == 0)
				done();
			else
				sleep(interval);
		}
	}
}

	/* initializes the screen */

init_screen()
{
	initscr();	/* init curses package */
	crmode();	/* set terminal into cbreak mode */
	noecho();       /* set terminal into no-echo mode */
	return(0);
}

	/* set up the headers for displaying cpu state information */
setup_vecstate()
{
#ifdef vax
	register int y;

	if(vptotal == 0) {
		return(0);
	}

	if(cflg || sflg || deflt)
		y = YTWO+(2 * total_cpus)+3;
	else {
		y = YTWO;
		setup_init();
	}
	standout(); 
	mvprintw(y,XZERO,vp_hdr);
	standend(); 
#endif /* vax */
	return(0);
}

	/* set up the headers for displaying cpu state information */
setup_state()
{
	register int y;
	if(vflg || sflg || deflt)
		y = YTWO+total_cpus+2;
	else {
		y = YTWO;
		setup_init();
	}
	standout(); 
	mvprintw(y,XZERO,state_hdr);
	standend(); 
	return(0);
}

	/* set up the headers for displaying cpu statistics */
setup_statistics()
{
	setup_init();
	standout();
	mvprintw(YTWO,XZERO,statistics_hdr);
	standend();
	return(0);
}

setup_init()
{
	clear();
	standout();
	mvprintw(YZERO,0,hname);
	standend();
	return(0);
}

/* update_info() picks up the latest statistics from the kernel */

update_info()
{
	register int i,t,j;
	register struct cpudata *save_p0, *save_p1;
#ifdef vax
	struct vpdata *save_v0, *save_v1;
#endif /* vax */
	struct cpudata *cpu_ptr;

#define X(fld) t = save_p0->fld[j]; save_p0->fld[j] -= save_p1->fld[j];save_p1->fld[j] = t
#define Y(fld) t = save_p0->fld; save_p0->fld -= save_p1->fld; save_p1->fld = t

#ifdef vax
#define VY(fld) t = save_v0->fld; save_v0->fld -= save_v1->fld; save_v1->fld = t
#endif /* vax */


	if(fflg) {
		lseek(kmem,(long)namelist[C_AVENRUN].n_value,0);
		read(kmem,loadav,sizeof(loadav));
		time(&cur_time);
		users = user_count();
	}
	save_p0 = cpudata_p0;
	save_p1 = cpudata_p1;
#ifdef vax
	if(vptotal > 0) {
		save_v0 = vpdata_p0;
		save_v1 = vpdata_p1;
	}
#endif /* vax */
	for(i=0; i<MAXCPU; i++) {
		if(activecpu & (1<<i)) {
			lseek(kmem,(long)namelist[C_CPUDATA].n_value + (4*i),0);
			read(kmem,&cpu_ptr,4);
			lseek(kmem, (long)cpu_ptr,0);
			read(kmem,save_p0,sizeof(struct cpudata));
#ifdef vax
			if((vptotal > 0) && (vpmask & (1<<i)) &&
						(save_p0->cpu_vpdata)) {
				lseek(kmem, (long)save_p0->cpu_vpdata, 0);
				read(kmem, save_v0, sizeof(struct vpdata));
				VY(vpd_ccsw);
				VY(vpd_ecsw);
				VY(vpd_success);
				VY(vpd_failed);
			}
#endif /* vax */
			for(j=0; j<CPUSTATES; j++)  {
				X(cpu_cptime);
			}
			Y(cpu_ttyin);
			Y(cpu_ttyout);
			Y(cpu_switch);
			Y(cpu_trap);
			Y(cpu_syscall);
			Y(cpu_intr);
			Y(cpu_ip_intr);
			save_p0++;
			save_p1++;
#ifdef vax
			save_v0++;
			save_v1++;
#endif /* vax */
		}
	}

	return(0);
}

upd_statistics_scrn()
{
	register int i;
	register struct cpudata *cpu_ptr;
	cpu_ptr = cpudata_p0;
	for(i=0; i<total_cpus; i++) {
		format_statistics(cpu_ptr);
		mvprintw(YTHREE+i,XZERO," %d  %4.1f %4.1f %4.1f %4.1f ",cpu_ptr->cpu_num,stats.st_usr,stats.st_nice,stats.st_sys,stats.st_idle);
		mvprintw(YTHREE+i,XZERO+24,printbuf+24,stats.st_csw,stats.st_calls,stats.st_trap,stats.st_intr,stats.st_ipi,stats.st_ttyin,stats.st_ttyout);
		cpu_ptr++;
	}
	return(0);
}

format_statistics(cpu_ptr)
register struct cpudata *cpu_ptr;
{
	register i;
	double time;
	static char tmp_buf[] = " %4d   ";

	printbuf[0] = NULL;  /* initialize the print buffer */
	time = 0;
	for(i=0; i<CPUSTATES; i++)
		time += cpu_ptr->cpu_cptime[i];
	if(time == 0.0)
		time = 1;
	stats.st_usr = (100.0 * cpu_ptr->cpu_cptime[CP_USER])/time;
	stats.st_nice = (100.0 * cpu_ptr->cpu_cptime[CP_NICE])/time;
	stats.st_sys = (100.0 * cpu_ptr->cpu_cptime[CP_SYS])/time;
	stats.st_idle = (100.0 * cpu_ptr->cpu_cptime[CP_IDLE])/time;
	strcat(printbuf," %4.1f %4.1f %4.1f %4.1f ");
	tmp_buf[4] = scale_data(cpu_ptr->cpu_switch,&stats.st_csw);
	strcat(printbuf,tmp_buf);
	tmp_buf[4] = scale_data(cpu_ptr->cpu_syscall,&stats.st_calls);
	strcat(printbuf,tmp_buf);
	tmp_buf[4] = scale_data(cpu_ptr->cpu_trap,&stats.st_trap);
	strcat(printbuf,tmp_buf);
	tmp_buf[4] = scale_data(cpu_ptr->cpu_intr,&stats.st_intr);
	strcat(printbuf,tmp_buf);
	tmp_buf[4] = scale_data(cpu_ptr->cpu_ip_intr,&stats.st_ipi);
	strcat(printbuf,tmp_buf);
	tmp_buf[4] = scale_data(cpu_ptr->cpu_ttyin,&stats.st_ttyin);
	strcat(printbuf,tmp_buf);
	tmp_buf[4] = scale_data(cpu_ptr->cpu_ttyout,&stats.st_ttyout);
	strcat(printbuf,tmp_buf);
	
	return(0);
}

char
scale_data(input,output)
unsigned input;
int *output;
{
	if(input >= 1048576) {
		*output = input/1048576;
		return('m'); }
	if(input >= 1024) {
		*output = input/1024;
		return('k');
	}
	*output = input;
	return(' ');
}


pr_statistics()
{
	register int i;
	register struct cpudata *cpu_ptr;
	cpu_ptr = cpudata_p0;
	for(i=0; i<total_cpus; i++) {
		printf(" %d ",cpu_ptr->cpu_num);
		format_statistics(cpu_ptr);
		printf(printbuf,stats.st_usr,stats.st_nice,stats.st_sys,stats.st_idle,stats.st_csw,stats.st_calls,stats.st_trap,stats.st_intr,stats.st_ipi,stats.st_ttyin,stats.st_ttyout);
		cpu_ptr++;
		printf("\n");
	}
	return(0);
}

done()
{
	if(fflg) {
		mvprintw(LINES-1,0,"\n");
		refresh();
		endwin();
	}
	free((char *)cpudata_p0);
	free((char *)cpudata_p1);
	exit(0);
}

#ifdef vax
char * get_vp_state();
#endif /* vax */

upd_vec_scrn()
{
#ifdef vax
	register int i,y;
	register struct cpudata *cpu_ptr;
	register struct vpdata *vp_ptr;
	struct proc tmp_proc;

	if(vptotal == 0) {
		return(0);
	}

	if(cflg || sflg || deflt)
		y = YTHREE+(2 * total_cpus)+3;
	else
		y = YTHREE;
	cpu_ptr = cpudata_p0;
	vp_ptr = vpdata_p0;

	for(i=0; i<total_cpus; i++) {
	    if(cpu_ptr->cpu_vpdata) {
		if (vp_ptr->vpd_proc) {
		    lseek(kmem,(long)vp_ptr->vpd_proc,0);
		      read(kmem,&tmp_proc,sizeof(struct proc));
		    sprintf(printbuf,
		      "%3d    %8s    %8d    %8d    %8d    %8d   %8d",
		      cpu_ptr->cpu_num, get_vp_state(vp_ptr->vpd_state),
		      tmp_proc.p_pid, vp_ptr->vpd_ccsw, vp_ptr->vpd_ecsw,
		      vp_ptr->vpd_success, vp_ptr->vpd_failed);
		} else {
		    sprintf(printbuf,
		      "%3d    %8s    %8x    %8d    %8d    %8d   %8d",
		      cpu_ptr->cpu_num, get_vp_state(vp_ptr->vpd_state),
		      vp_ptr->vpd_proc, vp_ptr->vpd_ccsw, vp_ptr->vpd_ecsw,
		      vp_ptr->vpd_success, vp_ptr->vpd_failed);
		}


		mvprintw(y+i,XZERO,printbuf);
	    }
	    else {
		mvprintw(y+i,XZERO,"%3d",cpu_ptr->cpu_num);
		clrtoeol();
	    }
	    cpu_ptr++;
	    vp_ptr++;
	}
#endif /* vax */
	return(0);
}

pr_vecstate()
{
#ifdef vax
	register int i,y;
	register struct cpudata *cpu_ptr;
	register struct vpdata *vp_ptr;
	struct proc tmp_proc;

	cpu_ptr = cpudata_p0;
	vp_ptr = vpdata_p0;
	for(i=0; i<total_cpus; i++) {
	    if(cpu_ptr->cpu_vpdata) {
		if (vp_ptr->vpd_proc) {
		    lseek(kmem,(long)vp_ptr->vpd_proc,0);
		      read(kmem,&tmp_proc,sizeof(struct proc));
		    printf("%3d    %8s    %8d    %8d    %8d    %8d   %8d\n",
		      cpu_ptr->cpu_num, get_vp_state(vp_ptr->vpd_state),
		      tmp_proc.p_pid, vp_ptr->vpd_ccsw, vp_ptr->vpd_ecsw,
		      vp_ptr->vpd_success, vp_ptr->vpd_failed);
		} else {
		    printf("%3d    %8s    %8d    %8d    %8d    %8d   %8d\n",
		      cpu_ptr->cpu_num, get_vp_state(vp_ptr->vpd_state),
		      vp_ptr->vpd_proc, vp_ptr->vpd_ccsw, vp_ptr->vpd_ecsw,
		      vp_ptr->vpd_success, vp_ptr->vpd_failed);
		}

	    }
	    else {
		printf("%3d",cpu_ptr->cpu_num);
	    }
	    cpu_ptr++;
	    vp_ptr++;
	}
#endif /* vax */
	return(0);
}

#ifdef vax
char	vp_state_string[9];

char * 
get_vp_state(s)
int s;
{
	if(s == VPD_ABSENT) {
		return("ABSENT");
	}

	vp_state_string[0] = '\0';

	if(s & VPD_ALIVE) {
		strcat(vp_state_string, "OK");
	}
	if(s & VPD_DEAD) {
		strcat(vp_state_string, *vp_state_string ? ",DEAD" : "DEAD");
	}
	if(s & VPD_ENABLED) {
		strcat(vp_state_string, *vp_state_string ? ",ENA" : "ENA");
	}
	if(s & VPD_DISABLED) {
		strcat(vp_state_string, *vp_state_string ? ",DIS" : "DIS");
	}
	return(vp_state_string);
}
#endif /* vax */

upd_state_scrn()
{
	register int i,y;
	register struct cpudata *cpu_ptr;
	if(sflg || deflt)
		y = YTHREE+total_cpus+2;
	else
		y = YTHREE;
	cpu_ptr = cpudata_p0;
	for(i=0; i<total_cpus; i++) {
		mvprintw(y+i,XZERO," %d ",cpu_ptr->cpu_num);
		format_state(cpu_ptr);
		mvprintw(y+i,XZERO+6,cpu_states.cps_state);
		mvprintw(y+i,XZERO+16,cpu_states.cps_ipi);
		mvprintw(y+i,XZERO+33,"%c",cpu_states.cps_proc);
		if(cpu_states.cps_pid != -1) {
			mvprintw(y+i,XZERO+40,"%d",cpu_states.cps_pid);
			clrtoeol();
		} else
			clrtoeol();
		cpu_ptr++;
	}
	return(0);
}

format_state(cpu_ptr)
register struct cpudata *cpu_ptr;
{

	register int i;
	struct proc tmp_proc;

	cpu_states.cps_state[0] = NULL;
	if(cpu_ptr->cpu_state & CPU_BOOT)
		strcat(cpu_states.cps_state,"B");
	else
		strcat(cpu_states.cps_state," ");
	if(cpu_ptr->cpu_state & CPU_RUN)
		strcat(cpu_states.cps_state,"R");
	else
		strcat(cpu_states.cps_state," ");
	if(cpu_ptr->cpu_state & CPU_TBI)
		strcat(cpu_states.cps_state,"T");
	else
		strcat(cpu_states.cps_state," ");
	if(cpu_ptr->cpu_state & CPU_PANIC)
		strcat(cpu_states.cps_state,"P");
	else
		strcat(cpu_states.cps_state," ");
	if(cpu_ptr->cpu_state & CPU_SOFT_DISABLE)
		strcat(cpu_states.cps_state,"D");
	else
		strcat(cpu_states.cps_state," ");
	if(cpu_ptr->cpu_state & CPU_STOP)
		strcat(cpu_states.cps_state,"S");
	else
		strcat(cpu_states.cps_state," ");
	cpu_states.cps_ipi[0] = NULL;
	if(cpu_ptr->cpu_int_req & IPIMSK_PANIC)
		strcat(cpu_states.cps_ipi,"P");
	if(cpu_ptr->cpu_int_req & IPIMSK_PRINT)
		strcat(cpu_states.cps_ipi,"R");
	else
		strcat(cpu_states.cps_ipi," ");
	if(cpu_ptr->cpu_int_req & IPIMSK_SCHED)
		strcat(cpu_states.cps_ipi,"S");
	else
		strcat(cpu_states.cps_ipi," ");
	if(cpu_ptr->cpu_int_req & IPIMSK_TBFLUSH)
		strcat(cpu_states.cps_ipi,"T");
	else
		strcat(cpu_states.cps_ipi," ");
	if(cpu_ptr->cpu_int_req & IPIMSK_KDB)
		strcat(cpu_states.cps_ipi,"K");
	else
		strcat(cpu_states.cps_ipi," ");
	if(cpu_ptr->cpu_int_req & IPIMSK_STOP)
		strcat(cpu_states.cps_ipi,"H");
	else
		strcat(cpu_states.cps_ipi," ");
	if(cpu_ptr->cpu_noproc) {
		cpu_states.cps_proc = 'N';
		cpu_states.cps_pid = -1;
	} else {
		cpu_states.cps_proc = 'Y';
		if(cpu_ptr->cpu_proc != NULL) {
			lseek(kmem,(long)cpu_ptr->cpu_proc,0);
			read(kmem,&tmp_proc,sizeof(struct proc));
			cpu_states.cps_pid = tmp_proc.p_pid;
		} else
			cpu_states.cps_pid = -1;
	}
	
	return(0);
}

pr_state()
{
	register int i;
	register struct cpudata *cpu_ptr;
	cpu_ptr = cpudata_p0;
	for(i=0; i<total_cpus; i++) {
		printf(" %d ",cpu_ptr->cpu_num);
		format_state(cpu_ptr);
		printf(st_format,cpu_states.cps_state,cpu_states.cps_ipi,cpu_states.cps_proc);
		if(cpu_states.cps_pid != -1)
			printf("%d",cpu_states.cps_pid);
		cpu_ptr++;
		printf("\n");
	}
	return(0);
}

display_help()
{
	register int i,j;
	register char **hlp_ptr;
	clear();
	mvprintw(YZERO,COLS/2-strlen(help_0)/2,help_0);
	hlp_ptr = help_stats;
	for(i=0; hlp_ptr[i]; i++)
		mvprintw(i,XZERO,hlp_ptr[i]);
	hlp_ptr = help_info;
	for(j=0; hlp_ptr[j]; j++)
		mvprintw(i+j,XZERO,hlp_ptr[j]);
	mvprintw(i+j,XZERO,help_1);
	refresh();
	return(0);
}

print_help()
{
	register int i;
	register char **hlp_ptr;
	usage();
	hlp_ptr = help_state;
	for(i=0; hlp_ptr[i];i++)
		printf("%s\n",hlp_ptr[i]);
	hlp_ptr = help_info;
	for(i=0; hlp_ptr[i];i++)
		printf("%s\n",hlp_ptr[i]);
	return(0);
}

usage()
{
	printf("Usage: cpustat [-fcsh] [interval [count]]\n");
	return(0);
}

/*
 *	int user_count()
 *		Return a count of the number of users on.  Returns -1 on
 *		error
 *
 *	int first;
 *		-1 on error; 1 on first time; 0 otherwise
 *
 *	time_t mtime;
 *		last time file was modified
 *
 *	FILE *strm;
 *		stream for /etc/utmp (And file descriptor for fstat)
 *
 *	int count;
 *		last calculated count of number of users on.  Only
 *		recalculated when /etc/utmp is modified
 */


user_count ()
{
    static int  first = 1;
    static time_t  mtime;
    static FILE *strm;
    static int  count;
    struct utmp utmp;
    struct stat statbuf;

/*
 *  If we already had an error once, don't even bother
 */
    if (first == -1)
	return (1);

/*
 *  The first time through the loop, open the file.  If there is an
 *  error; give up
 */
    if (first)
    {
	strm = fopen ("/etc/utmp", "r");
	if (strm == NULL)
	{
	    first = -1;
	    return (-1);
	}
    }

/*
 *  Find last modifed time of file
 */
    if (fstat (strm -> _file, &statbuf))
    {
	first = -1;
	return (-1);
    }

/*
 *  If this is the first time, or the file has been modified, calculate
 *  the number of users on (also clear the first time flag)
 */
    if (first || mtime != statbuf.st_mtime)
    {
	first = 0;
	mtime = statbuf.st_mtime;

	rewind (strm);
	count = 0;
	while (fread (&utmp, sizeof (utmp), 1, strm))
	{
	    if (utmp.ut_name[0] != '\0')
		count++;
	}
    }

    return (count);
}