blob: 8c189c5778cc68e80eb79a0798b85b3b98692c8d [file] [log] [blame]
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/hardware/memory.h>
#include <unistd.h>
#include <fcntl.h>
/*
* Try to use an initial size that will cover default cases. We aren't talking
* about huge files, so why fiddle about with reallocs?
* I checked /proc/meminfo sizes on 3 different systems: 598, 644, 654
*
* On newer systems, the size is up to around 930 (2.6.27 kernel)
* or 1160 (2.6.28 kernel)
*/
#define MEMINFO_INIT_SIZE 1279
#define MEMINFO_STEP_SIZE 256
#define MEMINFO_FILE "/proc/meminfo"
/*
* Load the latest memory usage statistics
*/
int netsnmp_mem_arch_load( netsnmp_cache *cache, void *magic ) {
int statfd;
static char *buff = NULL;
static int bsize = 0;
static int first = 1;
ssize_t bytes_read;
char *b;
unsigned long memtotal = 0, memfree = 0, memshared = 0,
buffers = 0, cached = 0,
swaptotal = 0, swapfree = 0;
netsnmp_memory_info *mem;
/*
* Retrieve the memory information from the underlying O/S...
*/
if ((statfd = open(MEMINFO_FILE, O_RDONLY, 0)) == -1) {
snmp_log_perror(MEMINFO_FILE);
return -1;
}
if (bsize == 0) {
bsize = MEMINFO_INIT_SIZE;
buff = (char*)malloc(bsize+1);
if (NULL == buff) {
snmp_log(LOG_ERR, "malloc failed\n");
close(statfd);
return -1;
}
}
while ((bytes_read = read(statfd, buff, bsize)) == bsize) {
b = (char*)realloc(buff, bsize + MEMINFO_STEP_SIZE + 1);
if (NULL == b) {
snmp_log(LOG_ERR, "malloc failed\n");
close(statfd);
return -1;
}
buff = b;
bsize += MEMINFO_STEP_SIZE;
DEBUGMSGTL(("mem", "/proc/meminfo buffer increased to %d\n", bsize));
close(statfd);
statfd = open(MEMINFO_FILE, O_RDONLY, 0);
if (statfd == -1) {
snmp_log_perror(MEMINFO_FILE);
return -1;
}
}
close(statfd);
if (bytes_read <= 0) {
snmp_log_perror(MEMINFO_FILE);
} else {
buff[bytes_read] = '\0';
}
/*
* ... parse this into a more useable form...
*/
b = strstr(buff, "MemTotal: ");
if (b)
sscanf(b, "MemTotal: %lu", &memtotal);
else {
if (first)
snmp_log(LOG_ERR, "No MemTotal line in /proc/meminfo\n");
}
b = strstr(buff, "MemFree: ");
if (b)
sscanf(b, "MemFree: %lu", &memfree);
else {
if (first)
snmp_log(LOG_ERR, "No MemFree line in /proc/meminfo\n");
}
if (0 == netsnmp_os_prematch("Linux","2.4")) {
b = strstr(buff, "MemShared: ");
if (b)
sscanf(b, "MemShared: %lu", &memshared);
else if (first)
snmp_log(LOG_ERR, "No MemShared line in /proc/meminfo\n");
}
else {
b = strstr(buff, "Shmem: ");
if (b)
sscanf(b, "Shmem: %lu", &memshared);
else if (first)
snmp_log(LOG_ERR, "No Shmem line in /proc/meminfo\n");
}
b = strstr(buff, "Buffers: ");
if (b)
sscanf(b, "Buffers: %lu", &buffers);
else {
if (first)
snmp_log(LOG_ERR, "No Buffers line in /proc/meminfo\n");
}
b = strstr(buff, "Cached: ");
if (b)
sscanf(b, "Cached: %lu", &cached);
else {
if (first)
snmp_log(LOG_ERR, "No Cached line in /proc/meminfo\n");
}
b = strstr(buff, "SwapTotal: ");
if (b)
sscanf(b, "SwapTotal: %lu", &swaptotal);
else {
if (first)
snmp_log(LOG_ERR, "No SwapTotal line in /proc/meminfo\n");
}
b = strstr(buff, "SwapFree: ");
if (b)
sscanf(b, "SwapFree: %lu", &swapfree);
else {
if (first)
snmp_log(LOG_ERR, "No SwapFree line in /proc/meminfo\n");
}
first = 0;
/*
* ... and save this in a standard form.
*/
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_PHYSMEM, 1 );
if (!mem) {
snmp_log_perror("No Physical Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Physical memory");
mem->units = 1024;
mem->size = memtotal;
mem->free = memfree;
mem->other = -1;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_VIRTMEM, 1 );
if (!mem) {
snmp_log_perror("No Virtual Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Virtual memory");
mem->units = 1024;
mem->size = memtotal+swaptotal;
mem->free = memfree +swapfree;
mem->other = -1;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED, 1 );
if (!mem) {
snmp_log_perror("No Shared Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Shared memory");
mem->units = 1024;
mem->size = memshared;
mem->free = 0; /* All in use */
mem->other = -1;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_CACHED, 1 );
if (!mem) {
snmp_log_perror("No Cached Memory info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Cached memory");
mem->units = 1024;
mem->size = cached;
mem->free = 0; /* Report cached size/used as equal */
mem->other = -1;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SWAP, 1 );
if (!mem) {
snmp_log_perror("No Swap info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Swap space");
mem->units = 1024;
mem->size = swaptotal;
mem->free = swapfree;
mem->other = -1;
}
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_MBUF, 1 );
if (!mem) {
snmp_log_perror("No Buffer, etc info entry");
} else {
if (!mem->descr)
mem->descr = strdup("Memory buffers");
mem->units = 1024;
mem->size = memtotal; /* Traditionally we've always regarded
all memory as potentially available
for memory buffers. */
mem->free = memtotal - buffers;
mem->other = -1;
}
return 0;
}