/*
* Retained from UCD implementation
*/
void
get_swapinfo(long *total, long *free, long *size)
{
struct pst_swapinfo pss;
netsnmp_memory_info *mem;
int i = 0;
char buf[1024];
while (pstat_getswap(&pss, sizeof(pss), (size_t) 1, i) != -1) {
if (pss.pss_idx == (unsigned) i) {
/*
* TODO - Skip if only one swap device
*/
mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SWAP+1+i, 1 );
if (!mem)
continue;
if (!mem->descr) {
sprintf(buf, "swap #%d %s", i, pss.pss_mntpt);
mem->descr = strdup( buf );
}
mem->units = 1024;
mem->size = (pss.pss_nblksavail * (DEV_BSIZE/512)) / 2; /* Or pss_nblks ? */
mem->free = 4*pss.pss_nfpgs; /* Or pss_nblksavail ? */
mem->other = -1;
*total +=mem->size;
*free +=mem->free;
*size = mem->units; /* Hopefully consistent! */
i++;
} else
return;
}
} /* end get_swapinfo */
int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
{
struct pst_swapinfo swapinfo;
struct pst_vminfo vminfo;
int i=0;
swap->total = swap->free = 0;
while (pstat_getswap(&swapinfo, sizeof(swapinfo), 1, i++) > 0) {
swapinfo.pss_nfpgs *= 4; /* nfpgs is in 512 byte blocks */
if (swapinfo.pss_nblksenabled == 0) {
swapinfo.pss_nblksenabled = swapinfo.pss_nfpgs;
}
swap->total += swapinfo.pss_nblksenabled;
swap->free += swapinfo.pss_nfpgs;
}
swap->used = swap->total - swap->free;
pstat_getvminfo(&vminfo, sizeof(vminfo), 1, 0);
swap->page_in = vminfo.psv_spgin;
swap->page_out = vminfo.psv_spgout;
return SIGAR_OK;
}
static int
get_swapinfo(struct swapinfo *swap)
{
struct pst_swapinfo pss;
int i = 0;
while (pstat_getswap(&pss, sizeof(pss), (size_t) 1, i) != -1) {
if (pss.pss_idx == (unsigned) i) {
swap->total_swap += pss.pss_nblksenabled;
swap->free_swap += 4 * pss.pss_nfpgs; /* nfpgs is in 4-byte blocks - who knows why? */
i++;
} else
return;
}
} /* end get_swapinfo */
int get_swap_stats(Digikam::KMemoryInfo::KMemoryInfoData* const data)
{
#ifdef Q_WS_MAC
Q_UNUSED(data);
#endif
#ifdef Q_OS_HPUX
struct pst_swapinfo pstat_swapinfo[SWAP_BATCH];
int swapidx = 0;
int num, i;
#endif // Q_OS_HPUX
#ifdef Q_OS_SOLARIS
struct anoninfo ai;
int pagesize;
#endif // Q_OS_SOLARIS
#if defined(Q_OS_LINUX) //|| defined(Q_OS_CYGWIN)
FILE* f = 0;
char* line_ptr = 0;
unsigned long long value;
#endif // defined(Q_OS_LINUX)
#if defined(Q_OS_FREEBSD)
int pagesize;
#ifdef Q_OS_FREEBSD5
struct xswdev xsw;
int mib[16], n;
size_t mibsize, size;
#else
struct kvm_swap swapinfo;
kvm_t* kvmd = 0;
#endif // Q_OS_FREEBSD5
#endif // defined(Q_OS_FREEBSD)
#if defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD)
struct uvmexp* uvm = 0;
#endif // defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD)
#ifdef Q_OS_WIN
MEMORYSTATUSEX memstats;
#endif // Q_OS_WIN
#ifdef Q_OS_HPUX
data->totalSwap = 0;
data->usedSwap = 0;
data->freeSwap = 0;
while (1)
{
num = pstat_getswap(pstat_swapinfo, sizeof pstat_swapinfo[0], SWAP_BATCH, swapidx);
if (num == -1)
{
//sg_set_error_with_errno(SG_ERROR_PSTAT,"pstat_getswap");
return 0;
}
else if (num == 0)
{
break;
}
for (i = 0; i < num; i++)
{
struct pst_swapinfo* si = &pstat_swapinfo[i];
if ((si->pss_flags & SW_ENABLED) != SW_ENABLED)
{
continue;
}
if ((si->pss_flags & SW_BLOCK) == SW_BLOCK)
{
data->totalSwap += ((long long) si->pss_nblksavail) * 1024LL;
data->usedSwap += ((long long) si->pss_nfpgs) * 1024LL;
data->freeSwap = data->totalSwap - data->usedSwap;
}
if ((si->pss_flags & SW_FS) == SW_FS)
{
data->totalSwap += ((long long) si->pss_limit) * 1024LL;
data->usedSwap += ((long long) si->pss_allocated) * 1024LL;
data->freeSwap = data->totalSwap - data->usedSwap;
}
}
swapidx = pstat_swapinfo[num - 1].pss_idx + 1;
}
return 1;
#endif // Q_OS_HPUX
#ifdef Q_OS_SOLARIS
if((pagesize=sysconf(_SC_PAGESIZE)) == -1)
{
//sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
return 0;
}
if (swapctl(SC_AINFO, &ai) == -1)
{
//sg_set_error_with_errno(SG_ERROR_SWAPCTL, NULL);
return 0;
}
data->totalSwap = (long long)ai.ani_max * (long long)pagesize;
data->usedSwap = (long long)ai.ani_resv * (long long)pagesize;
data->freeSwap = data->totalSwap - data->usedSwap;
return 1;
#endif // Q_OS_SOLARIS
#if defined(Q_OS_LINUX) || defined(Q_OS_CYGWIN)
if ((f = fopen("/proc/meminfo", "r")) == NULL)
{
//sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/meminfo");
return 0;
}
while ((line_ptr = sg_f_read_line(f, "")) != NULL)
{
if (sscanf(line_ptr, "%*s %llu kB", &value) != 1)
{
continue;
}
value *= 1024;
if (strncmp(line_ptr, "SwapTotal:", 10) == 0)
{
data->totalSwap = value;
}
else if (strncmp(line_ptr, "SwapFree:", 9) == 0)
{
data->freeSwap = value;
}
}
fclose(f);
data->usedSwap = data->totalSwap - data->freeSwap;
return 1;
#endif // defined(Q_OS_LINUX) || defined(Q_OS_CYGWIN)
#if defined(Q_OS_FREEBSD) || defined(Q_OS_DFBSD)
pagesize = getpagesize();
#ifdef Q_OS_FREEBSD5
data->totalSwap = 0;
data->usedSwap = 0;
mibsize = sizeof mib / sizeof mib[0];
if (sysctlnametomib("vm.swap_info", mib, &mibsize) < 0)
{
//sg_set_error_with_errno(SG_ERROR_SYSCTLNAMETOMIB, "vm.swap_info");
return 0;
}
for (n = 0; ; ++n)
{
mib[mibsize] = n;
size = sizeof xsw;
if (sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) < 0)
{
break;
}
if (xsw.xsw_version != XSWDEV_VERSION)
{
//sg_set_error(SG_ERROR_XSW_VER_MISMATCH, NULL);
return 0;
}
data->totalSwap += (long long) xsw.xsw_nblks;
data->usedSwap += (long long) xsw.xsw_used;
}
if (errno != ENOENT)
{
//sg_set_error_with_errno(SG_ERROR_SYSCTL, "vm.swap_info");
return 0;
}
#else // Q_OS_FREEBSD5
if((kvmd = sg_get_kvm()) == NULL)
{
return 0;
}
if ((kvm_getswapinfo(kvmd, &swapinfo, 1,0)) == -1)
{
//sg_set_error(SG_ERROR_KVM_GETSWAPINFO, NULL);
return 0;
}
data->totalSwap = (long long)swapinfo.ksw_total;
data->usedSwap = (long long)swapinfo.ksw_used;
#endif // Q_OS_FREEBSD5
data->totalSwap *= pagesize;
data->usedSwap *= pagesize;
data->freeSwap = data->totalSwap - data->usedSwap;
return 1;
#endif // defined(Q_OS_FREEBSD) || defined(Q_OS_DFBSD)
#if defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD)
if ((uvm = sg_get_uvmexp()) == NULL)
{
return 0;
}
data->totalSwap = (long long)uvm->pagesize * (long long)uvm->swpages;
data->usedSwap = (long long)uvm->pagesize * (long long)uvm->swpginuse;
data->freeSwap = data->totalSwap - data->usedSwap;
return 1;
#endif // defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD)
#ifdef Q_OS_WIN
memstats.dwLength = sizeof(memstats);
if (!GlobalMemoryStatusEx(&memstats))
{
//sg_set_error_with_errno(SG_ERROR_MEMSTATUS, "GloblaMemoryStatusEx");
return 0;
}
/* the PageFile stats include Phys memory "minus an overhead".
* Due to this unknown "overhead" there's no way to extract just page
* file use from these numbers */
data->totalSwap = memstats.ullTotalPageFile;
data->freeSwap = memstats.ullAvailPageFile;
data->usedSwap = data->totalSwap - data->freeSwap;
return 1;
#endif
return -1;
}
static sg_error
sg_get_swap_stats_int(sg_swap_stats *swap_stats_buf) {
#ifdef HPUX
#define SWAP_BATCH 5
struct pst_swapinfo pstat_swapinfo[SWAP_BATCH];
int swapidx = 0;
int num, i;
#elif defined(SOLARIS)
# if defined(HAVE_STRUCT_SWAPTABLE)
struct swaptable *swtbl;
int nswap, i;
# elif defined(HAVE_STRUCT_ANONINFO)
struct anoninfo ai;
# endif
#elif defined(LINUX) || defined(CYGWIN)
FILE *f;
#define LINE_BUF_SIZE 256
char line_buf[LINE_BUF_SIZE];
unsigned long long value;
unsigned matches = 0;
#elif defined(HAVE_STRUCT_XSWDEV)
struct xswdev xsw;
struct xswdev *xswbuf = NULL, *xswptr = NULL;
int n;
int mib[16];
size_t mibsize, size;
#elif defined(HAVE_STRUCT_XSW_USAGE)
int mib[2] = {CTL_VM, VM_SWAPUSAGE};
struct xsw_usage xsw;
size_t mibsize = 2, size = sizeof(xsw);
#elif defined(HAVE_STRUCT_UVMEXP_SYSCTL) && defined(VM_UVMEXP2)
int mib[2] = { CTL_VM, VM_UVMEXP2 };
struct uvmexp_sysctl uvm;
size_t size = sizeof(uvm);
#elif defined(HAVE_STRUCT_UVMEXP) && defined(VM_UVMEXP)
int mib[2] = { CTL_VM, VM_UVMEXP };
struct uvmexp uvm;
size_t size = sizeof(uvm);
#elif defined(ALLBSD)
/* fallback if no reasonable API is supported */
struct kvm_swap swapinfo;
kvm_t *kvmd;
#elif defined(AIX)
perfstat_memory_total_t mem;
#elif defined(WIN32)
MEMORYSTATUSEX memstats;
#endif
swap_stats_buf->total = 0;
swap_stats_buf->used = 0;
swap_stats_buf->free = 0;
#ifdef HPUX
for(;;) {
num = pstat_getswap(pstat_swapinfo, sizeof pstat_swapinfo[0],
SWAP_BATCH, swapidx);
if (num == -1) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_PSTAT, "pstat_getswap");
}
else if (num == 0) {
break;
}
for (i = 0; i < num; ++i) {
struct pst_swapinfo *si = &pstat_swapinfo[i];
if ((si->pss_flags & SW_ENABLED) != SW_ENABLED)
continue;
if ((si->pss_flags & SW_BLOCK) == SW_BLOCK) {
swap_stats_buf->total += ((long long) si->pss_nblksavail) * 1024LL;
swap_stats_buf->used += ((long long) si->pss_nfpgs) * 1024LL;
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
}
if ((si->pss_flags & SW_FS) == SW_FS) {
swap_stats_buf->total += ((long long) si->pss_limit) * 1024LL;
swap_stats_buf->used += ((long long) si->pss_allocated) * 1024LL;
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
}
}
swapidx = pstat_swapinfo[num - 1].pss_idx + 1;
}
#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("swap", SG_ERROR_SYSCTLBYNAME, "perfstat_memory_total");
}
swap_stats_buf->total = ((long long)mem.pgsp_total) * sys_page_size;
swap_stats_buf->free = ((long long)mem.pgsp_free) * sys_page_size;
swap_stats_buf->used = swap_stats_buf->total - swap_stats_buf->free;
#elif defined(SOLARIS)
# if defined(HAVE_STRUCT_SWAPTABLE)
again:
if( ( nswap = swapctl(SC_GETNSWP, 0) ) == -1 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SWAPCTL, NULL);
}
if( nswap != 0 ) {
char *buf = sg_malloc( nswap * sizeof(char) * (PATH_MAX+1) + 1 );
if( NULL == buf ) {
RETURN_FROM_PREVIOUS_ERROR( "swap", sg_get_error() );
}
swtbl = sg_malloc( sizeof(*swtbl) + ( nswap * sizeof(swtbl->swt_ent[0]) ) );
if( NULL == swtbl ) {
free(buf);
RETURN_FROM_PREVIOUS_ERROR( "swap", sg_get_error() );
}
memset( buf, 0, nswap * sizeof(char) * (PATH_MAX+1) + 1 );
memset( swtbl, 0, sizeof(*swtbl) + ( nswap * sizeof(swtbl->swt_ent[0]) ) );
for( i = 0; i < nswap; ++i )
swtbl->swt_ent[i].ste_path = buf + (i * (PATH_MAX+1));
swtbl->swt_n = nswap;
if ((i = swapctl(SC_LIST, swtbl)) < 0) {
free( buf );
free( swtbl );
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SWAPCTL, NULL);
}
if( i > nswap ) {
free( swtbl );
free( buf );
goto again;
}
for( i = 0; i < nswap; ++i ) {
swap_stats_buf->total = swtbl->swt_ent[i].ste_pages;
swap_stats_buf->free = swtbl->swt_ent[i].ste_free;
}
free( swtbl );
free( buf );
swap_stats_buf->total *= sys_page_size;
swap_stats_buf->free *= sys_page_size;
swap_stats_buf->used = swap_stats_buf->total - swap_stats_buf->free;
}
# elif defined(HAVE_STRUCT_ANONINFO)
if (swapctl(SC_AINFO, &ai) == -1) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SWAPCTL, NULL);
}
swap_stats_buf->total = ai.ani_max;
swap_stats_buf->total *= sys_page_size;
swap_stats_buf->used = ai.ani_resv;
swap_stats_buf->used *= sys_page_size;
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
# else
RETURN_WITH_SET_ERROR("swap", SG_ERROR_UNSUPPORTED, OS_TYPE);
# endif
#elif defined(LINUX) || defined(CYGWIN)
if ((f = fopen("/proc/meminfo", "r")) == NULL) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_OPEN, "/proc/meminfo");
}
while( (matches < 2) && (fgets(line_buf, sizeof(line_buf), f) != NULL) ) {
if (sscanf(line_buf, "%*s %llu kB", &value) != 1)
continue;
value *= 1024;
if (strncmp(line_buf, "SwapTotal:", 10) == 0) {
swap_stats_buf->total = value;
++matches;
}
else if (strncmp(line_buf, "SwapFree:", 9) == 0) {
swap_stats_buf->free = value;
++matches;
}
}
fclose(f);
if( matches < 2 ) {
RETURN_WITH_SET_ERROR( "swap", SG_ERROR_PARSE, "/proc/meminfo" );
}
swap_stats_buf->used = swap_stats_buf->total - swap_stats_buf->free;
#elif defined(HAVE_STRUCT_XSWDEV)
mibsize = 2;
if( swapinfo_array ) {
size = 0;
if( sysctl( swapinfo_mib, 2, NULL, &size, NULL, 0 ) < 0 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SYSCTL, swapinfo_sysctl_name);
}
if( NULL == ( xswbuf = sg_malloc( size ) ) ) {
RETURN_FROM_PREVIOUS_ERROR( "swap", sg_get_error() );
}
if( sysctl( swapinfo_mib, 2, xswbuf, &size, NULL, 0 ) < 0 ) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SYSCTL, swapinfo_sysctl_name);
}
}
else {
mib[0] = swapinfo_mib[0];
mib[1] = swapinfo_mib[1];
}
for (n = 0; ; ++n) {
if( !swapinfo_array ) {
mib[mibsize] = n;
size = sizeof(xsw);
if (sysctl(mib, (unsigned)(mibsize + 1), &xsw, &size, NULL, 0) < 0) {
if (errno == ENOENT)
break;
free( xswbuf );
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SYSCTL, swapinfo_sysctl_name);
}
xswptr = &xsw;
}
# if defined(HAVE_STRUCT_XSWDEV_SIZE)
else {
if( ((size_t)n) >= (size / xswbuf->xsw_size) )
break;
xswptr = xswbuf + n;
}
if( xswptr == NULL ) {
RETURN_WITH_SET_ERROR("swap", SG_ERROR_MEMSTATUS, "no swap status");
}
# ifdef XSWDEV_VERSION
if( xswptr->xsw_version != XSWDEV_VERSION ) {
free( xswbuf );
RETURN_WITH_SET_ERROR("swap", SG_ERROR_XSW_VER_MISMATCH, NULL);
}
# endif
# endif
swap_stats_buf->total += (unsigned long long) xswptr->xsw_nblks;
swap_stats_buf->used += (unsigned long long) xswptr->xsw_used;
}
free( xswbuf );
swap_stats_buf->total *= (size_t)sys_page_size;
swap_stats_buf->used *= (size_t)sys_page_size;
if( 0 == swap_stats_buf->free )
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
else
swap_stats_buf->free *= (size_t)sys_page_size;
#elif defined(HAVE_STRUCT_XSW_USAGE)
if (sysctl(mib, (unsigned)mibsize, &xsw, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SYSCTL, "CTL_VM.VM_SWAPUSAGE" );
}
swap_stats_buf->total = (unsigned long long) xsw.xsu_total;
swap_stats_buf->used = (unsigned long long) xsw.xsu_used;
swap_stats_buf->free = (unsigned long long) xsw.xsu_avail;
#elif defined(HAVE_STRUCT_UVMEXP_SYSCTL) && defined(VM_UVMEXP2)
if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP2");
}
swap_stats_buf->total = uvm.pagesize * uvm.swpages;
swap_stats_buf->used = uvm.pagesize * uvm.swpginuse; /* XXX swpgonly ? */
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
#elif defined(HAVE_STRUCT_UVMEXP) && defined(VM_UVMEXP)
if (sysctl(mib, 2, &uvm, &size, NULL, 0) < 0) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_SYSCTL, "CTL_VM.VM_UVMEXP");
}
swap_stats_buf->total = (unsigned long long)uvm.pagesize * (unsigned long long)uvm.swpages;
swap_stats_buf->used = (unsigned long long)uvm.pagesize * (unsigned long long)uvm.swpginuse; /* XXX swpgonly ? */
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
#elif defined(ALLBSD)
/* XXX probably not mt-safe! */
kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
if(kvmd == NULL) {
RETURN_WITH_SET_ERROR("swap", SG_ERROR_KVM_OPENFILES, NULL);
}
if ((kvm_getswapinfo(kvmd, &swapinfo, 1,0)) == -1) {
kvm_close( kvmd );
RETURN_WITH_SET_ERROR("swap", SG_ERROR_KVM_GETSWAPINFO, NULL);
}
swap_stats_buf->total = (long long)swapinfo.ksw_total;
swap_stats_buf->used = (long long)swapinfo.ksw_used;
kvm_close( kvmd );
swap_stats_buf->total *= sys_page_size;
swap_stats_buf->used *= sys_page_size;
swap_stats_buf->free = swap_stats_buf->total - swap_stats_buf->used;
#elif defined(WIN32)
memstats.dwLength = sizeof(memstats);
if (!GlobalMemoryStatusEx(&memstats)) {
RETURN_WITH_SET_ERROR_WITH_ERRNO("swap", SG_ERROR_MEMSTATUS, "GloblaMemoryStatusEx");
}
/* the PageFile stats include Phys memory "minus an overhead".
* Due to this unknown "overhead" there's no way to extract just page
* file use from these numbers */
swap_stats_buf->total = memstats.ullTotalPageFile;
swap_stats_buf->free = memstats.ullAvailPageFile;
swap_stats_buf->used = swap_stats_buf->total - swap_stats_buf->free;
#else
RETURN_WITH_SET_ERROR("swap", SG_ERROR_UNSUPPORTED, OS_TYPE);
#endif
swap_stats_buf->systime = time(NULL);
return SG_ERROR_NONE;
}