static sg_error
sg_get_mem_stats_int(sg_mem_stats *mem_stats_buf) {
#ifdef HPUX
struct pst_static pstat_static;
struct pst_dynamic pstat_dynamic;
#elif defined(SOLARIS)
# ifdef _SC_PHYS_PAGES
long phystotal;
long physav;
# else
kstat_ctl_t *kc;
kstat_t *ksp;
kstat_named_t *kn;
# endif
#elif defined(LINUX) || defined(CYGWIN)
#define LINE_BUF_SIZE 256
char *line_ptr, line_buf[LINE_BUF_SIZE];
long long value;
FILE *f;
#elif defined(HAVE_HOST_STATISTICS) || defined(HAVE_HOST_STATISTICS64)
# if defined(HAVE_HOST_STATISTICS64)
struct vm_statistics64 vm_stats;
# else
struct vm_statistics vm_stats;
# endif
mach_msg_type_number_t count;
kern_return_t rc;
#elif defined(HAVE_STRUCT_UVMEXP_SYSCTL) && defined(VM_UVMEXP2)
int mib[2];
struct uvmexp_sysctl uvm;
size_t size = sizeof(uvm);
#elif defined(HAVE_STRUCT_UVMEXP) && defined(VM_UVMEXP)
int mib[2];
struct uvmexp uvm;
size_t size = sizeof(uvm);
#elif defined(FREEBSD) || defined(DFBSD)
size_t size;
unsigned int total_count;
unsigned int free_count;
unsigned int cache_count;
unsigned int inactive_count;
#elif defined(HAVE_STRUCT_VMTOTAL)
struct vmtotal vmtotal;
size_t size;
#if defined(HW_PHYSMEM) || defined(HW_USERMEM)
int mib[2];
# if defined(HW_PHYSMEM)
u_long total_mem;
# endif
# if defined(HW_USERMEM)
u_long user_mem;
# endif
#endif
#elif defined(AIX)
perfstat_memory_total_t mem;
#elif defined(WIN32)
MEMORYSTATUSEX memstats;
#endif
#if defined(HPUX)
if (pstat_getdynamic(&pstat_dynamic, sizeof(pstat_dynamic), 1, 0) == -1) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_PSTAT, "pstat_dynamic");
}
/*
* from man pstat_getstatic:
*
* pstat_getstatic() returns information about the system. Although
* this data usually does not change frequently, it may change while
* the system is running due to manually or automatically generated
* administrative changes in the associated kernel tunables, online
* addition/deletion of resources, or other events. There is one
* global instance of this context.
*
* ==> Can't hold this value globally static.
*/
if( pstat_getstatic(&pstat_static, sizeof(pstat_static), 1, 0) == -1 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_PSTAT, "pstat_static");
}
mem_stats_buf->total = ((long long) pstat_static.physical_memory) * pstat_static.page_size;
mem_stats_buf->free = ((long long) pstat_dynamic.psd_free) * pstat_static.page_size;
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
#elif defined(AIX)
/* return code is number of structures returned */
if(perfstat_memory_total(NULL, &mem, sizeof(perfstat_memory_total_t), 1) != 1) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTLBYNAME, "perfstat_memory_total");
}
mem_stats_buf->total = (unsigned long long) mem.real_total;
mem_stats_buf->total *= sys_page_size;
mem_stats_buf->used = (unsigned long long) mem.real_inuse;
mem_stats_buf->used *= sys_page_size;
mem_stats_buf->cache = (unsigned long long) mem.numperm;
mem_stats_buf->cache *= sys_page_size;
mem_stats_buf->free = (unsigned long long) mem.real_free;
mem_stats_buf->free *= sys_page_size;
#elif defined(SOLARIS)
# ifdef _SC_PHYS_PAGES
if( ( phystotal = sysconf(_SC_PHYS_PAGES) ) < 0 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCONF, "_SC_PHYS_PAGES");
}
if( ( physav = sysconf(_SC_AVPHYS_PAGES) ) < 0 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCONF, "_SC_AVPHYS_PAGES");
}
mem_stats_buf->total = ((unsigned long long)phystotal) * ((unsigned long long)sys_page_size);
mem_stats_buf->free = ((unsigned long long)physav) * ((unsigned long long)sys_page_size);
# else
if( (kc = kstat_open()) == NULL ) {
RETURN_WITH_SET_ERROR("mem", SG_ERROR_KSTAT_OPEN, NULL);
}
if((ksp=kstat_lookup(kc, "unix", 0, "system_pages")) == NULL) {
RETURN_WITH_SET_ERROR("mem", SG_ERROR_KSTAT_LOOKUP, "unix,0,system_pages");
}
if (kstat_read(kc, ksp, 0) == -1) {
RETURN_WITH_SET_ERROR("mem", SG_ERROR_KSTAT_READ, NULL);
}
if((kn=kstat_data_lookup(ksp, "physmem")) == NULL) {
RETURN_WITH_SET_ERROR("mem", SG_ERROR_KSTAT_DATA_LOOKUP, "physmem");
}
mem_stats_buf->total = ((unsigned long long)kn->value.ul) * ((unsigned long long)sys_page_size);
if((kn=kstat_data_lookup(ksp, "freemem")) == NULL) {
RETURN_WITH_SET_ERROR("mem", SG_ERROR_KSTAT_DATA_LOOKUP, "freemem");
}
mem_stats_buf->free = ((unsigned long long)kn->value.ul) * ((unsigned long long)sys_page_size);
kstat_close(kc);
# endif
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
mem_stats_buf->cache = 0;
#elif defined(LINUX) || defined(CYGWIN)
if ((f = fopen("/proc/meminfo", "r")) == NULL) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_OPEN, "/proc/meminfo");
}
#define MEM_TOTAL_PREFIX "MemTotal:"
#define MEM_FREE_PREFIX "MemFree:"
#define MEM_CACHED_PREFIX "Cached:"
while ((line_ptr = fgets(line_buf, sizeof(line_buf), f)) != NULL) {
if ( sscanf(line_buf, "%*s %lld kB", &value) != 1)
continue;
if (strncmp(line_buf, MEM_TOTAL_PREFIX, sizeof(MEM_TOTAL_PREFIX) - 1) == 0)
mem_stats_buf->total = value;
else if (strncmp(line_buf, MEM_FREE_PREFIX, sizeof(MEM_FREE_PREFIX) - 1) == 0)
mem_stats_buf->free = value;
else if (strncmp(line_buf, MEM_CACHED_PREFIX, sizeof(MEM_CACHED_PREFIX) - 1) == 0)
mem_stats_buf->cache = value;
}
mem_stats_buf->free += mem_stats_buf->cache;
mem_stats_buf->total *= 1024;
mem_stats_buf->free *= 1024;
mem_stats_buf->cache *= 1024;
#undef MEM_TOTAL_PREFIX
#undef MEM_FREE_PREFIX
#undef MEM_CACHED_PREFIX
fclose(f);
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
#elif defined(HAVE_STRUCT_UVMEXP_SYSCTL) && defined(VM_UVMEXP2)
mib[0] = CTL_VM;
mib[1] = VM_UVMEXP2;
if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP2");
}
mem_stats_buf->total = uvm.npages;
mem_stats_buf->cache = uvm.filepages + uvm.execpages;
mem_stats_buf->free = uvm.free + mem_stats_buf->cache;
mem_stats_buf->total *= uvm.pagesize;
mem_stats_buf->cache *= uvm.pagesize;
mem_stats_buf->free *= uvm.pagesize;
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
#elif defined(HAVE_STRUCT_UVMEXP) && defined(VM_UVMEXP)
mib[0] = CTL_VM;
mib[1] = VM_UVMEXP;
if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP");
}
mem_stats_buf->total = uvm.npages;
mem_stats_buf->cache = 0;
# if defined(HAVE_STRUCT_UVMEXP_FILEPAGES)
mem_stats_buf->cache += uvm.filepages;
# endif
# if defined(HAVE_STRUCT_UVMEXP_EXECPAGES)
mem_stats_buf->cache += uvm.execpages;
# endif
mem_stats_buf->free = uvm.free + mem_stats_buf->cache;
mem_stats_buf->total *= uvm.pagesize;
mem_stats_buf->cache *= uvm.pagesize;
mem_stats_buf->free *= uvm.pagesize;
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
#elif defined(HAVE_HOST_STATISTICS) || defined(HAVE_HOST_STATISTICS64)
# if defined(HAVE_HOST_STATISTICS64)
count = HOST_VM_INFO64_COUNT;
rc = host_statistics64(self_host_port, HOST_VM_INFO64, (host_info64_t)(&vm_stats), &count);
# else
count = HOST_VM_INFO_COUNT;
rc = host_statistics(self_host_port, HOST_VM_INFO, (host_info_t)(&vm_stats), &count);
# endif
if( rc != KERN_SUCCESS ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO_CODE( "mem", SG_ERROR_MACHCALL, rc, "host_statistics" );
}
/*
* XXX check host_info(host_basic_info) ... for memory_size */
mem_stats_buf->free = vm_stats.free_count - vm_stats.speculative_count;
mem_stats_buf->free += vm_stats.inactive_count;
mem_stats_buf->free *= (size_t)sys_page_size;
mem_stats_buf->total = vm_stats.active_count + vm_stats.wire_count +
vm_stats.inactive_count + vm_stats.free_count;
mem_stats_buf->total *= (size_t)sys_page_size;
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
mem_stats_buf->cache = 0;
#elif defined(FREEBSD) || defined(DFBSD)
/*returns pages*/
size = sizeof(total_count);
if (sysctlbyname("vm.stats.vm.v_page_count", &total_count, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_page_count");
}
/*returns pages*/
size = sizeof(free_count);
if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_free_count");
}
size = sizeof(inactive_count);
if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_inactive_count");
}
size = sizeof(cache_count);
if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_cache_count");
}
/* Of couse nothing is ever that simple :) And I have inactive pages to
* deal with too. So I'm going to add them to free memory :)
*/
mem_stats_buf->cache = (size_t)cache_count;
mem_stats_buf->cache *= (size_t)sys_page_size;
mem_stats_buf->total = (size_t)total_count;
mem_stats_buf->total *= (size_t)sys_page_size;
mem_stats_buf->free = (size_t)free_count + inactive_count + cache_count;
mem_stats_buf->free *= (size_t)sys_page_size;
mem_stats_buf->used = mem_stats_buf->total - mem_stats_buf->free;
#elif defined(WIN32)
memstats.dwLength = sizeof(memstats);
if (!GlobalMemoryStatusEx(&memstats)) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_MEMSTATUS, NULL);
}
mem_stats_buf->free = memstats.ullAvailPhys;
mem_stats_buf->total = memstats.ullTotalPhys;
mem_stats_buf->used = mem_stat.total - mem_stat.free;
if(read_counter_large(SG_WIN32_MEM_CACHE, &mem_stats_buf->cache))
mem_stats_buf->cache = 0;
#elif defined(HAVE_STRUCT_VMTOTAL)
/* The code in this section is based on the code in the OpenBSD
* top utility, located at src/usr.bin/top/machine.c in the
* OpenBSD source tree.
*
* For fun, and like OpenBSD top, we will do the multiplication
* converting the memory stats in pages to bytes in base 2.
*/
size = sizeof(vmtotal);
if (sysctl(vmtotal_mib, 2, &vmtotal, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTLBYNAME, "vm.vmtotal");
}
/* Convert the raw stats to bytes, and return these to the caller
*/
mem_stats_buf->used = (unsigned long long)vmtotal.t_rm; /* total real mem in use */
mem_stats_buf->used *= sys_page_size;
/* XXX scan top source to look how it determines cache size */
mem_stats_buf->cache = 0; /* no cache stats */
mem_stats_buf->free = (unsigned long long)vmtotal.t_free; /* free memory pages */
mem_stats_buf->free *= sys_page_size;
# ifdef HW_PHYSMEM
mib[0] = CTL_HW;
mib[1] = HW_PHYSMEM;
size = sizeof(total_mem);
if (sysctl(mib, 2, &total_mem, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTL, "CTL_HW.HW_PHYSMEM");
}
mem_stats_buf->total = total_mem;
# else
mem_stats_buf->total = (mem_stats_buf->used + mem_stats_buf->free);
# endif
# ifdef HW_USERMEM
mib[0] = CTL_HW;
mib[1] = HW_USERMEM;
size = sizeof(user_mem);
if (sysctl(mib, 2, &user_mem, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTL, "CTL_HW.HW_USERMEM");
}
mem_stats_buf->used += total_mem - user_mem;
# endif
#else
RETURN_WITH_SET_ERROR("mem", SG_ERROR_UNSUPPORTED, OS_TYPE);
#endif
mem_stats_buf->systime = time(NULL);
return SG_ERROR_NONE;
}
void ProcessList_getVMStats(vm_statistics64_t p) {
mach_msg_type_number_t info_size = HOST_VM_INFO64_COUNT;
if (host_statistics64(mach_host_self(), HOST_VM_INFO64, (host_info_t)p, &info_size) != 0)
err(9, "Unable to retrieve VM statistics\n");
}
double VMPI_SystemMemoryFree()
{
double result_free = 0;
#ifdef AVMPLUS_MAC
vm_size_t page_size;
mach_port_t mach_port;
mach_msg_type_number_t count;
vm_statistics64_data_t vm_stats;
mach_port = mach_host_self();
count = sizeof(vm_stats) / sizeof(natural_t);
if( (host_page_size(mach_port, &page_size) == KERN_SUCCESS) &&
(host_statistics64(mach_port, HOST_VM_INFO,(host_info64_t)&vm_stats, &count) == KERN_SUCCESS) )
{
long long free_memory = (int64_t)vm_stats.free_count;
free_memory *= (int64_t)page_size;
result_free = (double)free_memory;
}
#else
//alternative1
/*
struct sysinfo info;
sysinfo( &info );
size_t free_ram = (size_t)info.freeram;
size_t mem_unit = (size_t)info.mem_unit;
result_free = (double)(free_ram * mem_unit);
*/
//alternative2
/*
size_t pagesize = (size_t)sysconf( _SC_PAGESIZE );
size_t availpages = (size_t)sysconf( _SC_AVPHYS_PAGES );
result_free = (double)(availpages * pagesize);
*/
//the Linux way
FILE* fp = fopen( "/proc/meminfo", "r" );
if( fp != NULL )
{
size_t bufsize = 1024 * sizeof(char);
char* buf = (char*)malloc( bufsize );
uint64_t value = 0;
while( getline( &buf, &bufsize, fp ) >= 0 )
{
if( strncmp( buf, "MemAvailable", 12 ) != 0 )
{
continue;
}
sscanf( buf, "%*s%" SCNu64, &value );
break;
}
fclose( fp );
free( (void*)buf );
if( value != 0 )
{
result_free = (double)(value * 1024);
}
}
#endif
return result_free;
}
/* Update infos to be displayed */
void RamModule::updateInfos(void) {
#ifdef __APPLE__
// struct task_basic_info t_info;
// mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;
/* if (KERN_SUCCESS != task_info(mach_task_self(),
TASK_BASIC_INFO, (task_info_t)&t_info,
&t_info_count))
return -1;
*/ int mib[2];
int64_t physical_memory;
size_t length;
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
length = sizeof(int64_t);
sysctl(mib, 2, &physical_memory, &length, NULL, 0);
vm_size_t page_size;
mach_port_t mach_port;
mach_msg_type_number_t count;
vm_statistics64_data_t vm_stats;
mach_port = mach_host_self();
count = sizeof(vm_stats) / sizeof(natural_t);
if (KERN_SUCCESS == host_page_size(mach_port, &page_size) &&
KERN_SUCCESS == host_statistics64(mach_port, HOST_VM_INFO,
(host_info64_t)&vm_stats, &count))
{
long long free_memory = (int64_t)vm_stats.free_count * (int64_t)page_size;
long long used_memory = ((int64_t)vm_stats.active_count +
(int64_t)vm_stats.inactive_count +
(int64_t)vm_stats.wire_count) * (int64_t)page_size;
std::stringstream ss1;
ss1 << free_memory;
std::string sfree_memory = ss1.str();
_infos.push_back(sfree_memory);
std::stringstream ss2;
ss2 << used_memory;
std::string sused_memory = ss2.str();
_infos.push_back(sused_memory);
long long total_memory = free_memory + used_memory;
std::stringstream ss3;
ss3 << total_memory;
std::string stotal_memory = ss3.str();
_infos.push_back(stotal_memory);
std::stringstream percent_used;
float percent = static_cast<float>(used_memory) / total_memory * 100;
percent_used << percent;
_infos.push_back(percent_used.str());
// std::cout << "free memory: " << free_memory << "used memory: " << used_memory << std::endl;
}
long count2 = 0;
size_t usrStack = sizeof(count2);
sysctlbyname("kern.usrstack",&count2,&usrStack,NULL,0);
std::stringstream ss4;
ss4 << count2;
std::string str = ss4.str();
_infos.push_back(str);
int who = RUSAGE_SELF;
struct rusage usage;
int ret;
ret = getrusage(who, &usage);
std::stringstream ss5;
ss5 << usage.ru_maxrss;
std::string useinfo = ss5.str();
_infos.push_back(useinfo);
/* Ne fonctionne pas
struct rusage usage1;
ret1 = getrusage(whoc, &usage1);
std::stringstream ss6;
ss6 << usage1.ru_nswap;
std::string useSwap = ss6.str();
_infos.push_back(useSwap);
ret = getrusage(who, &usage);
std::stringstream ss8;
ss8 << usage.ru_msgsnd;
std::string messSend = ss8.str();
_infos.push_back(messSend);
ret = getrusage(who, &usage);
std::stringstream ss7;
ss7 << usage.ru_msgrcv;
std::string messRecev = ss7.str();
_infos.push_back(messRecev);
*/
#endif
}
static sg_error
sg_get_page_stats_int(sg_page_stats *page_stats_buf){
#ifdef SOLARIS
kstat_ctl_t *kc;
kstat_t *ksp;
cpu_stat_t cs;
#elif defined(LINUX) || defined(CYGWIN)
FILE *f;
#define LINE_BUF_SIZE 256
char line_buf[LINE_BUF_SIZE];
#elif defined(HAVE_HOST_STATISTICS) || defined(HAVE_HOST_STATISTICS64)
# if defined(HAVE_HOST_STATISTICS64)
struct vm_statistics64 vm_stats;
# else
struct vm_statistics vm_stats;
# endif
mach_msg_type_number_t count;
kern_return_t rc;
#elif defined(HAVE_STRUCT_UVMEXP_SYSCTL) && defined(VM_UVMEXP2)
int mib[2];
struct uvmexp_sysctl uvm;
size_t size = sizeof(uvm);
#elif defined(HAVE_STRUCT_UVMEXP) && defined(VM_UVMEXP)
int mib[2];
struct uvmexp uvm;
size_t size = sizeof(uvm);
#elif defined(FREEBSD) || defined(DFBSD)
size_t size;
#elif defined(NETBSD) || defined(OPENBSD)
int mib[2];
struct uvmexp uvm;
size_t size = sizeof(uvm);
#elif defined(AIX)
perfstat_memory_total_t mem;
#elif defined(HPUX)
struct pst_vminfo vminfo;
#endif
page_stats_buf->systime = time(NULL);
page_stats_buf->pages_pagein=0;
page_stats_buf->pages_pageout=0;
#ifdef SOLARIS
if ((kc = kstat_open()) == NULL) {
RETURN_WITH_SET_ERROR("page", SG_ERROR_KSTAT_OPEN, NULL);
}
for (ksp = kc->kc_chain; ksp!=NULL; ksp = ksp->ks_next) {
if ((strcmp(ksp->ks_module, "cpu_stat")) != 0)
continue;
if (kstat_read(kc, ksp, &cs) == -1)
continue;
page_stats_buf->pages_pagein += (long long)cs.cpu_vminfo.pgpgin;
page_stats_buf->pages_pageout += (long long)cs.cpu_vminfo.pgpgout;
}
kstat_close(kc);
#elif defined(LINUX) || defined(CYGWIN)
if ((f = fopen("/proc/vmstat", "r")) != NULL) {
unsigned matches = 0;
while( (matches < 2) && (fgets(line_buf, sizeof(line_buf), f) != NULL) ) {
unsigned long long value;
if (sscanf(line_buf, "%*s %llu", &value) != 1)
continue;
if (strncmp(line_buf, "pgpgin ", 7) == 0) {
page_stats_buf->pages_pagein = value;
++matches;
}
else if (strncmp(line_buf, "pgpgout ", 8) == 0) {
page_stats_buf->pages_pageout = value;
++matches;
}
}
fclose(f);
if( matches < 2 ) {
RETURN_WITH_SET_ERROR( "page", SG_ERROR_PARSE, "/proc/vmstat" );
}
}
else if ((f = fopen("/proc/stat", "r")) != NULL) {
if (sg_f_read_line(f, line_buf, sizeof(line_buf), "page") == NULL) {
fclose(f);
RETURN_FROM_PREVIOUS_ERROR( "page", sg_get_error() );
}
fclose(f);
if( sscanf( line_buf, "page %llu %llu", &page_stats_buf->pages_pagein, &page_stats_buf->pages_pageout ) != 2 ) {
RETURN_WITH_SET_ERROR("page", SG_ERROR_PARSE, "page");
}
}
else {
RETURN_WITH_SET_ERROR_WITH_ERRNO("page", SG_ERROR_OPEN, "/proc/stat");
}
#elif defined(HAVE_HOST_STATISTICS) || defined(HAVE_HOST_STATISTICS64)
self_host_port = mach_host_self();
# if defined(HAVE_HOST_STATISTICS64)
count = HOST_VM_INFO64_COUNT;
rc = host_statistics64(self_host_port, HOST_VM_INFO64, (host_info64_t)(&vm_stats), &count);
# else
count = HOST_VM_INFO_COUNT;
rc = host_statistics(self_host_port, HOST_VM_INFO, (host_info_t)(&vm_stats), &count);
# endif
if( rc != KERN_SUCCESS ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO_CODE( "mem", SG_ERROR_MACHCALL, rc, "host_statistics" );
}
page_stats_buf->pages_pagein = vm_stats.pageins;
page_stats_buf->pages_pageout = vm_stats.pageouts;
#elif defined(HAVE_STRUCT_UVMEXP_SYSCTL) && defined(VM_UVMEXP2)
mib[0] = CTL_VM;
mib[1] = VM_UVMEXP2;
if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP2");
}
page_stats_buf->pages_pagein = uvm.pgswapin;
page_stats_buf->pages_pageout = uvm.pgswapout;
#elif defined(HAVE_STRUCT_UVMEXP) && defined(VM_UVMEXP)
mib[0] = CTL_VM;
mib[1] = VM_UVMEXP;
if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("mem", SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP");
}
page_stats_buf->pages_pagein = uvm.pgswapin;
page_stats_buf->pages_pageout = uvm.pgswapout;
#elif defined(FREEBSD) || defined(DFBSD)
size = sizeof(page_stats_buf->pages_pagein);
if (sysctlbyname("vm.stats.vm.v_swappgsin", &page_stats_buf->pages_pagein, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("page", SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_swappgsin");
}
size = sizeof(page_stats_buf->pages_pageout);
if (sysctlbyname("vm.stats.vm.v_swappgsout", &page_stats_buf->pages_pageout, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("page", SG_ERROR_SYSCTLBYNAME, "vm.stats.vm.v_swappgsout");
}
#elif defined(AIX)
/* return code is number of structures returned */
if(perfstat_memory_total(NULL, &mem, sizeof(perfstat_memory_total_t), 1) != 1) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("page", SG_ERROR_SYSCTLBYNAME, "perfstat_memory_total");
}
page_stats_buf->pages_pagein = mem.pgins;
page_stats_buf->pages_pageout = mem.pgouts;
#elif defined(HPUX)
if( pstat_getvminfo( &vminfo, sizeof(vminfo), 1, 0 ) == -1 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("page", SG_ERROR_SYSCTLBYNAME, "pstat_getswap");
}
page_stats_buf->pages_pagein = vminfo.psv_spgin;
page_stats_buf->pages_pageout = vminfo.psv_spgout;
#else
RETURN_WITH_SET_ERROR("page", SG_ERROR_UNSUPPORTED, OS_TYPE);
#endif
return SG_ERROR_NONE;
}
int do_macos_mach_smi(int update_every, usec_t dt) {
(void)dt;
static int do_cpu = -1, do_ram = - 1, do_swapio = -1, do_pgfaults = -1;
if (unlikely(do_cpu == -1)) {
do_cpu = config_get_boolean("plugin:macos:mach_smi", "cpu utilization", 1);
do_ram = config_get_boolean("plugin:macos:mach_smi", "system ram", 1);
do_swapio = config_get_boolean("plugin:macos:mach_smi", "swap i/o", 1);
do_pgfaults = config_get_boolean("plugin:macos:mach_smi", "memory page faults", 1);
}
RRDSET *st;
kern_return_t kr;
mach_msg_type_number_t count;
host_t host;
vm_size_t system_pagesize;
// NEEDED BY: do_cpu
natural_t cp_time[CPU_STATE_MAX];
// NEEDED BY: do_ram, do_swapio, do_pgfaults
vm_statistics64_data_t vm_statistics;
host = mach_host_self();
kr = host_page_size(host, &system_pagesize);
if (unlikely(kr != KERN_SUCCESS))
return -1;
// --------------------------------------------------------------------
if (likely(do_cpu)) {
if (unlikely(HOST_CPU_LOAD_INFO_COUNT != 4)) {
error("MACOS: There are %d CPU states (4 was expected)", HOST_CPU_LOAD_INFO_COUNT);
do_cpu = 0;
error("DISABLED: system.cpu");
} else {
count = HOST_CPU_LOAD_INFO_COUNT;
kr = host_statistics(host, HOST_CPU_LOAD_INFO, (host_info_t)cp_time, &count);
if (unlikely(kr != KERN_SUCCESS)) {
error("MACOS: host_statistics() failed: %s", mach_error_string(kr));
do_cpu = 0;
error("DISABLED: system.cpu");
} else {
st = rrdset_find_bytype("system", "cpu");
if (unlikely(!st)) {
st = rrdset_create("system", "cpu", NULL, "cpu", "system.cpu", "Total CPU utilization", "percentage", 100, update_every, RRDSET_TYPE_STACKED);
rrddim_add(st, "user", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "nice", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "system", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_add(st, "idle", NULL, 1, 1, RRDDIM_PCENT_OVER_DIFF_TOTAL);
rrddim_hide(st, "idle");
}
else rrdset_next(st);
rrddim_set(st, "user", cp_time[CPU_STATE_USER]);
rrddim_set(st, "nice", cp_time[CPU_STATE_NICE]);
rrddim_set(st, "system", cp_time[CPU_STATE_SYSTEM]);
rrddim_set(st, "idle", cp_time[CPU_STATE_IDLE]);
rrdset_done(st);
}
}
}
// --------------------------------------------------------------------
if (likely(do_ram || do_swapio || do_pgfaults)) {
count = sizeof(vm_statistics64_data_t);
kr = host_statistics64(host, HOST_VM_INFO64, (host_info64_t)&vm_statistics, &count);
if (unlikely(kr != KERN_SUCCESS)) {
error("MACOS: host_statistics64() failed: %s", mach_error_string(kr));
do_ram = 0;
error("DISABLED: system.ram");
do_swapio = 0;
error("DISABLED: system.swapio");
do_pgfaults = 0;
error("DISABLED: mem.pgfaults");
} else {
if (likely(do_ram)) {
st = rrdset_find("system.ram");
if (unlikely(!st)) {
st = rrdset_create("system", "ram", NULL, "ram", NULL, "System RAM", "MB", 200, update_every, RRDSET_TYPE_STACKED);
rrddim_add(st, "active", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "wired", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "throttled", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "compressor", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "inactive", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "purgeable", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "speculative", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
rrddim_add(st, "free", NULL, system_pagesize, 1048576, RRDDIM_ABSOLUTE);
}
else rrdset_next(st);
rrddim_set(st, "active", vm_statistics.active_count);
rrddim_set(st, "wired", vm_statistics.wire_count);
rrddim_set(st, "throttled", vm_statistics.throttled_count);
rrddim_set(st, "compressor", vm_statistics.compressor_page_count);
rrddim_set(st, "inactive", vm_statistics.inactive_count);
rrddim_set(st, "purgeable", vm_statistics.purgeable_count);
rrddim_set(st, "speculative", vm_statistics.speculative_count);
rrddim_set(st, "free", (vm_statistics.free_count - vm_statistics.speculative_count));
rrdset_done(st);
}
// --------------------------------------------------------------------
if (likely(do_swapio)) {
st = rrdset_find("system.swapio");
if (unlikely(!st)) {
st = rrdset_create("system", "swapio", NULL, "swap", NULL, "Swap I/O", "kilobytes/s", 250, update_every, RRDSET_TYPE_AREA);
rrddim_add(st, "in", NULL, system_pagesize, 1024, RRDDIM_INCREMENTAL);
rrddim_add(st, "out", NULL, -system_pagesize, 1024, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "in", vm_statistics.swapins);
rrddim_set(st, "out", vm_statistics.swapouts);
rrdset_done(st);
}
// --------------------------------------------------------------------
if (likely(do_pgfaults)) {
st = rrdset_find("mem.pgfaults");
if (unlikely(!st)) {
st = rrdset_create("mem", "pgfaults", NULL, "system", NULL, "Memory Page Faults", "page faults/s", 500, update_every, RRDSET_TYPE_LINE);
st->isdetail = 1;
rrddim_add(st, "memory", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "cow", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "pagein", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "pageout", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "compress", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "decompress", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "zero_fill", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "reactivate", NULL, 1, 1, RRDDIM_INCREMENTAL);
rrddim_add(st, "purge", NULL, 1, 1, RRDDIM_INCREMENTAL);
}
else rrdset_next(st);
rrddim_set(st, "memory", vm_statistics.faults);
rrddim_set(st, "cow", vm_statistics.cow_faults);
rrddim_set(st, "pagein", vm_statistics.pageins);
rrddim_set(st, "pageout", vm_statistics.pageouts);
rrddim_set(st, "compress", vm_statistics.compressions);
rrddim_set(st, "decompress", vm_statistics.decompressions);
rrddim_set(st, "zero_fill", vm_statistics.zero_fill_count);
rrddim_set(st, "reactivate", vm_statistics.reactivations);
rrddim_set(st, "purge", vm_statistics.purges);
rrdset_done(st);
}
}
}
// --------------------------------------------------------------------
return 0;
}