X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fmemory.c;h=b79a74b7cb42a307916eef911dbba3a968ac456a;hb=e7a75874a24c1bf19931d5b4b423a0daa7f9be6b;hp=d92ecf30550dd56097c41f9d0108f3b3b18193d6;hpb=cb7fed8bf0af2646dfcb32844933398c28e39be5;p=collectd.git diff --git a/src/memory.c b/src/memory.c index d92ecf30..b79a74b7 100644 --- a/src/memory.c +++ b/src/memory.c @@ -1,6 +1,8 @@ /** * collectd - src/memory.c - * Copyright (C) 2005-2007 Florian octo Forster + * Copyright (C) 2005-2008 Florian octo Forster + * Copyright (C) 2009 Simon Kuhnle + * Copyright (C) 2009 Manuel Sanmartin * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -17,12 +19,13 @@ * * Authors: * Florian octo Forster + * Simon Kuhnle + * Manuel Sanmartin **/ #include "collectd.h" #include "common.h" #include "plugin.h" -#include "utils_debug.h" #ifdef HAVE_SYS_SYSCTL_H # include @@ -44,31 +47,20 @@ # include #endif -#if defined (HOST_VM_INFO) || HAVE_SYSCTLBYNAME || KERNEL_LINUX || HAVE_LIBKSTAT -# define MEMORY_HAVE_READ 1 -#else -# define MEMORY_HAVE_READ 0 +#if HAVE_STATGRAB_H +# include #endif -/* 2^48 = 281474976710656 */ -static data_source_t dsrc[4] = -{ - {"used", DS_TYPE_GAUGE, 0, 281474976710656.0}, - {"free", DS_TYPE_GAUGE, 0, 281474976710656.0}, - {"buffers", DS_TYPE_GAUGE, 0, 281474976710656.0}, - {"cached", DS_TYPE_GAUGE, 0, 281474976710656.0} -}; - -static data_set_t ds = -{ - "memory", 4, dsrc -}; +#if HAVE_PERFSTAT +# include +# include +#endif /* HAVE_PERFSTAT */ /* vm_statistics_data_t */ -#if defined(HOST_VM_INFO) +#if HAVE_HOST_STATISTICS static mach_port_t port_host; static vm_size_t pagesize; -/* #endif HOST_VM_INFO */ +/* #endif HAVE_HOST_STATISTICS */ #elif HAVE_SYSCTLBYNAME /* no global variables */ @@ -81,15 +73,29 @@ static vm_size_t pagesize; #elif HAVE_LIBKSTAT static int pagesize; static kstat_t *ksp; -#endif /* HAVE_LIBKSTAT */ +/* #endif HAVE_LIBKSTAT */ + +#elif HAVE_SYSCTL +static int pagesize; +/* #endif HAVE_SYSCTL */ + +#elif HAVE_LIBSTATGRAB +/* no global variables */ +/* endif HAVE_LIBSTATGRAB */ +#elif HAVE_PERFSTAT +static int pagesize; +static perfstat_memory_total_t pmemory; +/* endif HAVE_PERFSTAT */ +#else +# error "No applicable input method." +#endif -#if MEMORY_HAVE_READ static int memory_init (void) { -#if defined(HOST_VM_INFO) +#if HAVE_HOST_STATISTICS port_host = mach_host_self (); host_page_size (port_host, &pagesize); -/* #endif HOST_VM_INFO */ +/* #endif HAVE_HOST_STATISTICS */ #elif HAVE_SYSCTLBYNAME /* no init stuff */ @@ -102,44 +108,60 @@ static int memory_init (void) #elif defined(HAVE_LIBKSTAT) /* getpagesize(3C) tells me this does not fail.. */ pagesize = getpagesize (); - if (get_kstat (&ksp, "unix", 0, "system_pages")) + if (get_kstat (&ksp, "unix", 0, "system_pages") != 0) + { ksp = NULL; -#endif /* HAVE_LIBKSTAT */ + return (-1); + } +/* #endif HAVE_LIBKSTAT */ + +#elif HAVE_SYSCTL + pagesize = getpagesize (); + if (pagesize <= 0) + { + ERROR ("memory plugin: Invalid pagesize: %i", pagesize); + return (-1); + } +/* #endif HAVE_SYSCTL */ +#elif HAVE_LIBSTATGRAB +/* no init stuff */ +/* #endif HAVE_LIBSTATGRAB */ + +#elif HAVE_PERFSTAT + pagesize = getpagesize (); +#endif /* HAVE_PERFSTAT */ return (0); } /* int memory_init */ -static void memory_submit (long long mem_used, long long mem_buffered, - long long mem_cached, long long mem_free) +static void memory_submit (const char *type_instance, gauge_t value) { - value_t values[4]; + value_t values[1]; value_list_t vl = VALUE_LIST_INIT; - values[0].gauge = mem_used; - values[1].gauge = mem_free; - values[2].gauge = mem_buffered; - values[3].gauge = mem_cached; + values[0].gauge = value; vl.values = values; - vl.values_len = 4; - vl.time = time (NULL); - strcpy (vl.host, hostname); - strcpy (vl.plugin, "memory"); + vl.values_len = 1; + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "memory", sizeof (vl.plugin)); + sstrncpy (vl.type, "memory", sizeof (vl.type)); + sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance)); - plugin_dispatch_values ("memory", &vl); + plugin_dispatch_values (&vl); } static int memory_read (void) { -#if defined(HOST_VM_INFO) +#if HAVE_HOST_STATISTICS kern_return_t status; vm_statistics_data_t vm_data; mach_msg_type_number_t vm_data_len; - long long wired; - long long active; - long long inactive; - long long free; + gauge_t wired; + gauge_t active; + gauge_t inactive; + gauge_t free; if (!port_host || !pagesize) return (-1); @@ -149,7 +171,7 @@ static int memory_read (void) (host_info_t) &vm_data, &vm_data_len)) != KERN_SUCCESS) { - syslog (LOG_ERR, "memory-plugin: host_statistics failed and returned the value %i", (int) status); + ERROR ("memory-plugin: host_statistics failed and returned the value %i", (int) status); return (-1); } @@ -173,13 +195,16 @@ static int memory_read (void) * This memory is not being used. */ - wired = vm_data.wire_count * pagesize; - active = vm_data.active_count * pagesize; - inactive = vm_data.inactive_count * pagesize; - free = vm_data.free_count * pagesize; + wired = (gauge_t) (((uint64_t) vm_data.wire_count) * ((uint64_t) pagesize)); + active = (gauge_t) (((uint64_t) vm_data.active_count) * ((uint64_t) pagesize)); + inactive = (gauge_t) (((uint64_t) vm_data.inactive_count) * ((uint64_t) pagesize)); + free = (gauge_t) (((uint64_t) vm_data.free_count) * ((uint64_t) pagesize)); - memory_submit (wired + active, -1, inactive, free); -/* #endif HOST_VM_INFO */ + memory_submit ("wired", wired); + memory_submit ("active", active); + memory_submit ("inactive", inactive); + memory_submit ("free", free); +/* #endif HAVE_HOST_STATISTICS */ #elif HAVE_SYSCTLBYNAME /* @@ -202,40 +227,43 @@ static int memory_read (void) "vm.stats.vm.v_cache_count", NULL }; - int sysctl_vals[8] = { -1, -1, -1, -1, -1, -1, -1, -1 }; + double sysctl_vals[8]; - size_t len; int i; - int status; for (i = 0; sysctl_keys[i] != NULL; i++) { - len = sizeof (int); - if ((status = sysctlbyname (sysctl_keys[i], - (void *) &sysctl_vals[i], &len, - NULL, 0)) < 0) + int value; + size_t value_len = sizeof (value); + + if (sysctlbyname (sysctl_keys[i], (void *) &value, &value_len, + NULL, 0) == 0) { - syslog (LOG_ERR, "memory plugin: sysctlbyname (%s): %s", - sysctl_keys[i], strerror (errno)); - return (-1); + sysctl_vals[i] = value; + DEBUG ("memory plugin: %26s: %g", sysctl_keys[i], sysctl_vals[i]); } - DBG ("%26s: %6i", sysctl_keys[i], sysctl_vals[i]); - } /* for i */ + else + { + sysctl_vals[i] = NAN; + } + } /* for (sysctl_keys) */ /* multiply all all page counts with the pagesize */ for (i = 1; sysctl_keys[i] != NULL; i++) - sysctl_vals[i] = sysctl_vals[i] * sysctl_vals[0]; - - memory_submit (sysctl_vals[3] + sysctl_vals[4], /* wired + active */ - sysctl_vals[6], /* cache */ - sysctl_vals[5], /* inactive */ - sysctl_vals[2]); /* free */ + if (!isnan (sysctl_vals[i])) + sysctl_vals[i] *= sysctl_vals[0]; + + memory_submit ("free", sysctl_vals[2]); + memory_submit ("wired", sysctl_vals[3]); + memory_submit ("active", sysctl_vals[4]); + memory_submit ("inactive", sysctl_vals[5]); + memory_submit ("cache", sysctl_vals[6]); /* #endif HAVE_SYSCTLBYNAME */ -#elif defined(KERNEL_LINUX) +#elif KERNEL_LINUX FILE *fh; char buffer[1024]; - + char *fields[8]; int numfields; @@ -246,7 +274,9 @@ static int memory_read (void) if ((fh = fopen ("/proc/meminfo", "r")) == NULL) { - syslog (LOG_WARNING, "memory: fopen: %s", strerror (errno)); + char errbuf[1024]; + WARNING ("memory: fopen: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } @@ -274,16 +304,23 @@ static int memory_read (void) } if (fclose (fh)) - syslog (LOG_WARNING, "memory: fclose: %s", strerror (errno)); + { + char errbuf[1024]; + WARNING ("memory: fclose: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + } if (mem_used >= (mem_free + mem_buffered + mem_cached)) { mem_used -= mem_free + mem_buffered + mem_cached; - memory_submit (mem_used, mem_buffered, mem_cached, mem_free); + memory_submit ("used", mem_used); + memory_submit ("buffered", mem_buffered); + memory_submit ("cached", mem_cached); + memory_submit ("free", mem_free); } -/* #endif defined(KERNEL_LINUX) */ +/* #endif KERNEL_LINUX */ -#elif defined(HAVE_LIBKSTAT) +#elif HAVE_LIBKSTAT long long mem_used; long long mem_free; long long mem_lock; @@ -305,26 +342,63 @@ static int memory_read (void) mem_free *= pagesize; /* memory.. Why not call me up and give me */ mem_lock *= pagesize; /* some? ;) */ - memory_submit (mem_used, mem_lock, 0LL, mem_free); -/* #endif defined(HAVE_LIBKSTAT) */ + memory_submit ("used", mem_used); + memory_submit ("free", mem_free); + memory_submit ("locked", mem_lock); +/* #endif HAVE_LIBKSTAT */ + +#elif HAVE_SYSCTL + int mib[] = {CTL_VM, VM_METER}; + struct vmtotal vmtotal; + size_t size; + + memset (&vmtotal, 0, sizeof (vmtotal)); + size = sizeof (vmtotal); -#elif defined(HAVE_LIBSTATGRAB) + if (sysctl (mib, 2, &vmtotal, &size, NULL, 0) < 0) { + char errbuf[1024]; + WARNING ("memory plugin: sysctl failed: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + return (-1); + } + + assert (pagesize > 0); + memory_submit ("active", vmtotal.t_arm * pagesize); + memory_submit ("inactive", (vmtotal.t_rm - vmtotal.t_arm) * pagesize); + memory_submit ("free", vmtotal.t_free * pagesize); +/* #endif HAVE_SYSCTL */ + +#elif HAVE_LIBSTATGRAB sg_mem_stats *ios; if ((ios = sg_get_mem_stats ()) != NULL) - memory_submit (ios->used, 0LL, ios->cache, ios->free); -#endif /* HAVE_LIBSTATGRAB */ + { + memory_submit ("used", ios->used); + memory_submit ("cached", ios->cache); + memory_submit ("free", ios->free); + } +/* #endif HAVE_LIBSTATGRAB */ + +#elif HAVE_PERFSTAT + if (perfstat_memory_total(NULL, &pmemory, sizeof(perfstat_memory_total_t), 1) < 0) + { + char errbuf[1024]; + WARNING ("memory plugin: perfstat_memory_total failed: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + return (-1); + } + memory_submit ("used", pmemory.real_inuse * pagesize); + memory_submit ("free", pmemory.real_free * pagesize); + memory_submit ("cached", pmemory.numperm * pagesize); + memory_submit ("system", pmemory.real_system * pagesize); + memory_submit ("user", pmemory.real_process * pagesize); +#endif /* HAVE_PERFSTAT */ return (0); } -#endif /* MEMORY_HAVE_READ */ void module_register (void) { - plugin_register_data_set (&ds); - -#if MEMORY_HAVE_READ plugin_register_init ("memory", memory_init); plugin_register_read ("memory", memory_read); -#endif /* MEMORY_HAVE_READ */ -} +} /* void module_register */