hr_storage.c

包含一下内容: * An extensible agent * An SNMP library * tools to request or set information from SNMP a

	/*********************
	 *
	 *  System specific implementation functions
	 *
	 *********************/

static const char *hrs_descr[] = {
	NULL,
	"Real Memory",		/* HRS_TYPE_MEM */
	"Swap Space",		/* HRS_TYPE_SWAP */
	"Memory Buffers"	/* HRS_TYPE_MBUF */
};



u_char *
var_hrstore(struct variable *vp,
	    oid *name,
	    size_t *length,
	    int exact,
	    size_t *var_len,
	    WriteMethod **write_method)
{
    int store_idx=0;
#ifndef linux
#ifndef solaris2
#if defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
    struct vmtotal memory_totals;
#endif
#if HAVE_SYS_POOL_H
    struct pool mbpool, mclpool;
    int i;
#endif
#ifdef MBSTAT_SYMBOL
    struct mbstat  mbstat;
#endif
#endif	/* solaris2 */
#endif	/* linux */
    static char string[100];
    struct HRFS_statfs stat_buf;

    if ( vp->magic == HRSTORE_MEMSIZE ) {
        if (header_hrstore(vp, name, length, exact, var_len, write_method) == MATCH_FAILED )
	    return NULL;
    }
    else {
        
        store_idx = header_hrstoreEntry(vp, name, length, exact, var_len, write_method);
        if ( store_idx == MATCH_FAILED )
	    return NULL;

	if ( store_idx < HRS_TYPE_FS_MAX ) {
	    if ( HRFS_statfs( HRFS_entry->HRFS_mount, &stat_buf) < 0 )
		return NULL;
	}
#if !defined(linux) && !defined(solaris2)
	else switch ( store_idx ) {
		case HRS_TYPE_MEM:
		case HRS_TYPE_SWAP:
#ifdef USE_SYSCTL_VM
			{   int mib[2];
			    size_t len = sizeof(memory_totals);
			    mib[0] = CTL_VM;
			    mib[1] = VM_METER;
			    sysctl(mib, 2, &memory_totals, &len, NULL, 0);
			}
#elif defined(TOTAL_MEMORY_SYMBOL)
			auto_nlist(TOTAL_MEMORY_SYMBOL, (char *)&memory_totals, sizeof (struct vmtotal));
#endif
			break;
		case HRS_TYPE_MBUF:
#if HAVE_SYS_POOL_H
			auto_nlist(MBPOOL_SYMBOL, (char *)&mbpool, sizeof(mbpool));
			auto_nlist(MCLPOOL_SYMBOL, (char *)&mclpool, sizeof(mclpool));
#endif
			auto_nlist(MBSTAT_SYMBOL, (char *)&mbstat, sizeof (mbstat));
			break;
		default:
			break;
	}
#endif
    }
        


    switch (vp->magic){
	case HRSTORE_MEMSIZE:
	    long_return = physmem * (pagesize / 1024);
	    return (u_char *)&long_return;

	case HRSTORE_INDEX:
	    long_return = store_idx;
	    return (u_char *)&long_return;
	case HRSTORE_TYPE:
	    if ( store_idx < HRS_TYPE_FS_MAX )
		storage_type_id[storage_type_len-1] = 4;	/* Assume fixed */
	    else switch ( store_idx ) {
		case HRS_TYPE_MEM:
			storage_type_id[storage_type_len-1] = 2;	/* RAM */
			break;
		case HRS_TYPE_SWAP:
			storage_type_id[storage_type_len-1] = 3;	/* Virtual Mem */
			break;
		case HRS_TYPE_MBUF:
			storage_type_id[storage_type_len-1] = 1;	/* Other */
			break;
		default:
			storage_type_id[storage_type_len-1] = 1;	/* Other */
			break;
	    }
            *var_len = sizeof(storage_type_id);
	    return (u_char *)storage_type_id;
	case HRSTORE_DESCR:
	    if (store_idx<HRS_TYPE_FS_MAX) {
	        strcpy(string, HRFS_entry->HRFS_mount);
	        *var_len = strlen(string);
	        return (u_char *) string;
	    }
	    else {
	        store_idx = store_idx-HRS_TYPE_FS_MAX;
	        *var_len = strlen( hrs_descr[store_idx] );
	        return (u_char *)hrs_descr[store_idx];
	    }
	case HRSTORE_UNITS:
	    if ( store_idx < HRS_TYPE_FS_MAX )
#if STRUCT_STATVFS_HAS_F_FRSIZE
		long_return = stat_buf.f_frsize;
#else
		long_return = stat_buf.f_bsize;
#endif
	    else switch ( store_idx ) {
		case HRS_TYPE_MEM:
		case HRS_TYPE_SWAP:
#ifdef USE_SYSCTL
			long_return = pagesize;
#elif defined(NBPG)
			long_return = NBPG;
#else
			long_return = 1024;	/* Report in Kb */
#endif
			break;
		case HRS_TYPE_MBUF:
#ifdef MSIZE
			long_return = MSIZE;
#else
			long_return = 256;
#endif
			break;
		default:
#if NO_DUMMY_VALUES
			return NULL;
#endif
			long_return = 1024;	/* As likely as any! */
			break;
	    }
	    return (u_char *)&long_return;
	case HRSTORE_SIZE:
	    if ( store_idx < HRS_TYPE_FS_MAX )
		long_return = stat_buf.f_blocks;
	    else switch ( store_idx ) {
#if !defined(linux) && !defined(solaris2)
#if defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
		case HRS_TYPE_MEM:
			long_return = memory_totals.t_rm;
			break;
		case HRS_TYPE_SWAP:
			long_return = memory_totals.t_vm;
			break;
#else
		case HRS_TYPE_MEM:
			long_return = physmem;
			break;
		case HRS_TYPE_SWAP:
#if NO_DUMMY_VALUES
			return NULL;
#endif
			break;
#endif
		case HRS_TYPE_MBUF:
#if HAVE_SYS_POOL_H
			long_return = 0;
			for (i = 0; i < sizeof(mbstat.m_mtypes)/sizeof(mbstat.m_mtypes[0]); i++)
			    long_return += mbstat.m_mtypes[i];
#elif defined(MBSTAT_SYMBOL)
			long_return = mbstat.m_mbufs;
#else
			return NULL;
#endif
			break;
#else	/* linux */
#ifdef linux
		case HRS_TYPE_MEM:
		case HRS_TYPE_SWAP:
			long_return = linux_mem( store_idx, HRSTORE_SIZE);
			break;
#endif
#endif
		default:
#if NO_DUMMY_VALUES
			return NULL;
#endif
			long_return = 1024;
			break;
	    }
	    return (u_char *)&long_return;
	case HRSTORE_USED:
	    if ( store_idx < HRS_TYPE_FS_MAX )
		long_return = (stat_buf.f_blocks - stat_buf.f_bfree);
	    else switch ( store_idx ) {
#if !defined(linux) && !defined(solaris2)
#if defined(TOTAL_MEMORY_SYMBOL) || defined(USE_SYSCTL_VM)
		case HRS_TYPE_MEM:
			long_return = memory_totals.t_arm;
			break;
		case HRS_TYPE_SWAP:
			long_return = memory_totals.t_avm;
			break;
#endif
		case HRS_TYPE_MBUF:
#if HAVE_SYS_POOL_H
			long_return = (mbpool.pr_nget - mbpool.pr_nput)*mbpool.pr_size
				+ (mclpool.pr_nget - mclpool.pr_nput)*mclpool.pr_size;
#elif defined(MBSTAT_SYMBOL)
			long_return = mbstat.m_clusters - mbstat.m_clfree;	/* unlikely, but... */
#else
			return NULL;
#endif
			break;
#else	/* linux */
#ifdef linux
		case HRS_TYPE_MEM:
		case HRS_TYPE_SWAP:
			long_return = linux_mem( store_idx, HRSTORE_USED);
			break;
#endif
#endif
		default:
#if NO_DUMMY_VALUES
			return NULL;
#endif
			long_return = 1024;
			break;
	    }
	    return (u_char *)&long_return;
	case HRSTORE_FAILS:
	    if ( store_idx < HRS_TYPE_FS_MAX )
		long_return = 0;
	    else switch ( store_idx ) {
		case HRS_TYPE_MEM:
		case HRS_TYPE_SWAP:
#if NO_DUMMY_VALUES
			return NULL;
#endif
			long_return = 0;
			break;
#if !defined(linux) && !defined(solaris2) && defined(MBSTAT_SYMBOL)
		case HRS_TYPE_MBUF:
			long_return = mbstat.m_drops;
			break;
#endif
		default:
#if NO_DUMMY_VALUES
			return NULL;
#endif
			long_return = 0;
			break;
	    }
	    return (u_char *)&long_return;
	default:
	    DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrstore\n", vp->magic));
    }
    return NULL;
}


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

static int FS_storage;
static int HRS_index;

void
Init_HR_Store (void)
{
   HRS_index = -1;
   Init_HR_FileSys();
   FS_storage = 1;	/* Start with file-based storage */
}

int
Get_Next_HR_Store(void)
{
		/* File-based storage */
    long_return = -1;
    if ( FS_storage == 1 ) {
	HRS_index = Get_Next_HR_FileSys();

        if ( HRS_index >= 0 ) 
            return HRS_index;
	FS_storage = 0;		/* End of filesystems */
	HRS_index = HRS_TYPE_FS_MAX;
    }

		/* 'Other' storage types */
    ++HRS_index;
#ifndef solaris2
    if ( HRS_index < HRS_TYPE_MAX )
	return HRS_index;
    else
#endif
	return -1;
}

#ifdef linux
int
linux_mem(int mem_type, 
	  int size_or_used)
{
    FILE *fp;
    char buf[100];
    int size = -1, used = -1;

    if ((fp = fopen( "/proc/meminfo", "r")) == NULL )
	return -1;

    while ( fgets( buf, sizeof(buf), fp ) != NULL ) {
	if (( !strncmp( buf, "Mem:", 4 ) && mem_type == HRS_TYPE_MEM ) ||
	    ( !strncmp( buf, "Swap:", 5 ) && mem_type == HRS_TYPE_SWAP )) {
		sscanf( buf, "%*s %d %d", &size, &used );
		break;
	}
    }

    fclose(fp);
    return ( size_or_used == HRSTORE_SIZE ? size : used )/1024;

}
#endif