hr_swrun.c

ucd-snmp源代码

	    }
#endif
#else
	    sprintf( string, "/proc/%d/stat", pid );
	    if ((fp = fopen( string, "r")) != NULL) {
		fgets( buf, sizeof(buf), fp );
		cp = buf;
		for ( i = 0 ; i < 2 ; ++i ) {	/* skip two fields */
		    while ( *cp != ' ')
			++cp;
		    ++cp;
		}

		switch ( *cp ) {
		    case 'R':
	    		long_return = 1;	/* running */
			break;
		    case 'S':
	    		long_return = 2;	/* runnable */
			break;
		    case 'D':
		    case 'T':
	    		long_return = 3;	/* notRunnable */
			break;
		    case 'Z':
		    default:
	    		long_return = 4;	/* invalid */
			break;
		}
                fclose(fp);
	    } else
		long_return = 4;		/* invalid */
#endif
	    return (u_char *)&long_return;

	case HRSWRUNPERF_CPU:
#ifdef HAVE_SYS_PSTAT_H
	    long_return = proc_buf.pst_cptickstotal;
				/*
				 * Not convinced this is right, but....
				 */
#elif defined(dynix)
	    long_return = lowpsinfo.pr_time.tv_sec * 100 +
                          lowpsinfo.pr_time.tv_nsec/10000000;
#elif defined(solaris2)
#if _SLASH_PROC_METHOD_
	    long_return = proc_buf ? proc_buf->pr_time.tv_sec * 100 +
			  proc_buf->pr_time.tv_nsec/10000000 : 0;
#else
	    long_return = proc_buf->p_utime*100 +
	    		  proc_buf->p_stime*100;
#endif
#elif HAVE_KVM_GETPROCS
	    long_return = proc_table[LowProcIndex].kp_proc.p_uticks +
	    		  proc_table[LowProcIndex].kp_proc.p_sticks +
	    		  proc_table[LowProcIndex].kp_proc.p_iticks;
#elif defined(linux)
	    sprintf( string, "/proc/%d/stat", pid );
	    if ((fp = fopen( string, "r")) == NULL) return NULL;
	    fgets( buf, sizeof(buf), fp );
	    cp = buf;
	    for ( i = 0 ; i < 13 ; ++i ) {	/* skip 13 fields */
		while ( *cp != ' ')
		    ++cp;
		++cp;
	    }

	    long_return = atoi( cp );		/* utime */

	    while ( *cp != ' ' )
		++cp;
	    ++cp;
	    long_return += atoi( cp );		/* + stime */
            fclose(fp);
#elif defined(sunos4)
	    long_return = proc_table[LowProcIndex].p_time;
#elif defined(cygwin)
	    {
		DWORD n = lowproc.dwProcessId;
		HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
				       FALSE, n);
		FILETIME ct, et, kt, ut;

		if (h) {
		    if (GetProcessTimes(h, &ct, &et, &kt, &ut))
			long_return = (to_msec(&kt) + to_msec(&ut))/10;
		    else {
		        snmp_log(LOG_INFO, "no process times for %lu (%lu)\n", lowproc.pid, n);
			long_return = 0;
		    }
		    CloseHandle(h);
		}
		else {
		    snmp_log(LOG_INFO, "no process handle for %lu (%lu)\n", lowproc.pid, n);
		    long_return = 0;
		}
	    }
#elif defined(aix4)
	    long_return = proc_table[LowProcIndex].p_ru.ru_utime.tv_sec*100 +
			  proc_table[LowProcIndex].p_ru.ru_utime.tv_usec/10000 +
	    		  proc_table[LowProcIndex].p_ru.ru_stime.tv_sec*100 +
			  proc_table[LowProcIndex].p_ru.ru_stime.tv_usec/10000;
#else
	    long_return = proc_table[LowProcIndex].p_utime.tv_sec*100 +
			  proc_table[LowProcIndex].p_utime.tv_usec/10000 +
	    		  proc_table[LowProcIndex].p_stime.tv_sec*100 +
			  proc_table[LowProcIndex].p_stime.tv_usec/10000;
#endif
	    return (u_char *)&long_return;
	case HRSWRUNPERF_MEM:
#ifdef HAVE_SYS_PSTAT_H
	    long_return = (proc_buf.pst_rssize << PGSHIFT)/1024;
#elif defined(dynix)
            long_return = (lowpsinfo.pr_rssize * MMU_PAGESIZE)/1024;
#elif defined(solaris2)
#if _SLASH_PROC_METHOD_
	    long_return = proc_buf ? proc_buf->pr_rssize : 0;
#else
	    long_return = proc_buf->p_swrss;
#endif
#elif HAVE_KVM_GETPROCS
#if defined(freebsd3) && !defined(darwin)
	    long_return = proc_table[LowProcIndex].kp_eproc.e_vm.vm_map.size/1024;
#else
	    long_return = proc_table[LowProcIndex].kp_eproc.e_vm.vm_tsize +
			  proc_table[LowProcIndex].kp_eproc.e_vm.vm_ssize +
			  proc_table[LowProcIndex].kp_eproc.e_vm.vm_dsize;
	    long_return = long_return * (getpagesize() / 1024);
#endif
#elif defined(linux)
	    sprintf( string, "/proc/%d/stat", pid );
	    if ((fp = fopen( string, "r")) == NULL) return NULL;
	    fgets( buf, sizeof(buf), fp );
	    cp = buf;
	    for ( i = 0 ; i < 23 ; ++i ) {	/* skip 23 fields */
		while ( *cp != ' ')
		    ++cp;
	        ++cp;
	    }
	    long_return = atoi( cp ) * (getpagesize()/1024);		/* rss */
            fclose(fp);
#elif defined(cygwin)
	    {
		DWORD n = lowproc.dwProcessId;
		HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
				       FALSE, n);
		PROCESS_MEMORY_COUNTERS pmc;

		if (h) {
		    if (myGetProcessMemoryInfo && myGetProcessMemoryInfo(h, &pmc, sizeof pmc))
			long_return = pmc.WorkingSetSize / 1024;
		    else {
		        snmp_log(LOG_INFO, "no process times for %lu (%lu)\n", lowproc.pid, n);
			long_return = 0;
		    }
		    CloseHandle(h);
		}
		else {
		    snmp_log(LOG_INFO, "no process handle for %lu (%lu)\n", lowproc.pid, n);
		    long_return = 0;
		}
	    }
#else
#if NO_DUMMY_VALUES
	    return NULL;
#endif
	    long_return = 16*1024;	/* XXX - 16M! */
#endif
	    return (u_char *)&long_return;
	default:
	    DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrswrun\n", vp->magic));
    }
    return NULL;
}


	/*********************
	 *
	 *  Internal implementation functions
	 *
	 *********************/

#if defined(linux)

DIR *procdir = NULL;
struct dirent *procentry_p;

void
Init_HR_SWRun (void)
{
    if ( procdir != NULL )
        closedir( procdir );
    procdir = opendir("/proc");
}

int
Get_Next_HR_SWRun (void)
{
    int pid;
    procentry_p = readdir( procdir );

    if ( procentry_p == NULL )
	return -1;

    pid = atoi(procentry_p->d_name);
    if ( pid == 0 )
	return( Get_Next_HR_SWRun());
    return pid;
}

void
End_HR_SWRun (void)
{
    if (procdir) closedir( procdir );
    procdir = NULL;
}

#elif defined(cygwin)

static pid_t curpid;

void
Init_HR_SWRun(void)
{
    cygwin_internal(CW_LOCK_PINFO, 1000);
    curpid = 0;
}

int
Get_Next_HR_SWRun(void)
{
    curproc = (struct external_pinfo *) cygwin_internal(query, curpid|CW_NEXTPID);
    if (curproc)
	curpid = curproc->pid;
    else {
	curpid = -1;
    }
    return curpid;
}

void
End_HR_SWRun(void)
{
    cygwin_internal(CW_UNLOCK_PINFO);
}

#elif defined(dynix)

void
Init_HR_SWRun(void)
{
    nextproc = 0;
}

int
Get_Next_HR_SWRun(void)
{
    getprpsinfo_t *select = 0;

    DEBUGMSGTL(("host/hr_swrun::GetNextHR_SWRun", "nextproc == %d... &nextproc = %u\n", nextproc, &nextproc));
    if ( (nextproc = getprpsinfo(nextproc, select, &mypsinfo)) < 0 ) {
        return -1;
    } else {
        DEBUGMSGTL(("host/hr_swrun::GetNextHR_SWRun", "getprpsinfo returned %d\n", nextproc));
        return mypsinfo.pr_pid;
    }

}

void
End_HR_SWRun (void)
{
    /* just a stub... because it's declared */
}

#else /* linux */

static int nproc;

void
Init_HR_SWRun (void)
{
    size_t bytes;
    static time_t iwhen = 0;
    time_t now;

    time(&now);
    if (now == iwhen) {
	current_proc_entry = 0;
	return;
    }
    iwhen = now;

#if defined(hpux10) || defined(hpux11)
    pstat_getdynamic( &pst_dyn, sizeof( struct pst_dynamic ),
			1, 0 );
    nproc = pst_dyn.psd_activeprocs ;
    bytes = nproc*sizeof(struct pst_status);
    if ((proc_table=(struct pst_status *) realloc(proc_table, bytes)) == NULL ) {
	current_proc_entry = nproc+1;
	return;
    }
    pstat_getproc( proc_table, sizeof( struct pst_status ),
			nproc, 0 );

#elif defined(solaris2)
    if (!getKstatInt("unix", "system_misc", "nproc", &nproc)) {
    	current_proc_entry = nproc+1;
	return;
    }
    bytes = nproc*sizeof(int);
    if ((proc_table=(int *) realloc(proc_table, bytes)) == NULL ) {
	current_proc_entry = nproc+1;
	return;
    }
    {
	DIR *f;
	struct dirent *dp;
#if _SLASH_PROC_METHOD_ == 0
	if (kd == NULL) {
	    current_proc_entry = nproc+1;
	    return;
	}
#endif
	f = opendir("/proc");
	current_proc_entry = 0;
	while ((dp = readdir(f)) != NULL && current_proc_entry < nproc)
	    if (dp->d_name[0] != '.')
		proc_table[current_proc_entry++] = atoi(dp->d_name);
	closedir(f);
    }
#elif HAVE_KVM_GETPROCS
    {
	if (kd == NULL) {
	    nproc = 0;
	    return;
	}
	proc_table = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc);
    }
#else

    current_proc_entry = 1;
#ifndef bsdi2
    nproc = 0;

    if (auto_nlist(NPROC_SYMBOL, (char *)&nproc, sizeof(int)) == 0) {
        snmp_log_perror("Init_HR_SWRun-auto_nlist NPROC");
        return;
    }
#endif
    bytes = nproc*sizeof(struct proc);

    if (proc_table) free((char *)proc_table);
    if ((proc_table=(struct proc *) malloc(bytes)) == NULL ) {
        nproc = 0;
        snmp_log_perror("Init_HR_SWRun-malloc");
        return;
    }

    {   int proc_table_base;
        if (auto_nlist(PROC_SYMBOL, (char *)&proc_table_base, sizeof(proc_table_base)) == 0) {
            nproc = 0;
            snmp_log_perror("Init_HR_SWRun-auto_nlist PROC");
            return;
        }
        if (klookup( proc_table_base, (char *)proc_table, bytes) == 0) {
            nproc = 0;
            snmp_log_perror("Init_HR_SWRun-klookup");
            return;
        }
    }
#endif
    current_proc_entry = 0;
}

int
Get_Next_HR_SWRun (void)
{
    while ( current_proc_entry < nproc ) {
#if defined(hpux10) || defined(hpux11)
	return proc_table[current_proc_entry++].pst_pid;
#elif defined(solaris2)
	return proc_table[current_proc_entry++];
#elif HAVE_KVM_GETPROCS
	if ( proc_table[current_proc_entry].kp_proc.p_stat != 0 )
	    return proc_table[current_proc_entry++].kp_proc.p_pid;
#else
	if ( proc_table[current_proc_entry].p_stat != 0 )
	    return proc_table[current_proc_entry++].p_pid;
	else
	    ++current_proc_entry;
#endif

    }
    return -1;
}

void
End_HR_SWRun (void)
{
    current_proc_entry = nproc+1;
}
#endif

int count_processes (void)
{
#if !(defined(linux) || defined(cygwin)) || defined(hpux10) || defined(hpux11) || defined(solaris2) || HAVE_KVM_GETPROCS
    int i;
#endif
    int total=0;

    Init_HR_SWRun();
#if defined(hpux10) || defined(hpux11) || HAVE_KVM_GETPROCS || defined(solaris2)
    total = nproc;
#else
#if !defined(linux) && !defined(cygwin) && !defined(dynix)
    for ( i = 0 ; i<nproc ; ++i ) {
	if ( proc_table[i].p_stat != 0 )
#else
    while ( Get_Next_HR_SWRun() != -1  ) {
#endif
	    ++total;
    }
#endif	/* !hpux10 && !hpux11 && !HAVE_KVM_GETPROCS && !solaris2 */
    End_HR_SWRun();
    return total;
}