7a98cab187
This patch fills in some missing fields which have top dependencies. Additionally, I've tried to mirror those calculations Jaromir added for release 3.3.10. The one calculation that remains missing is 'available' memory for some kernels. For this API, we'll use a fall-back. Lastly the lxc safeguards which were recently added to the old procps library were incorporated here as well. Signed-off-by: Jim Warner <james.warner@comcast.net>
282 lines
8.4 KiB
C
282 lines
8.4 KiB
C
/*
|
|
* meminfo - Memory statistics part of procps
|
|
*
|
|
* Copyright (C) 1992-1998 by Michael K. Johnson <johnsonm@redhat.com>
|
|
* Copyright (C) 1998-2003 Albert Cahalan
|
|
* Copyright (C) 2015 Craig Small <csmall@enc.com.au>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
|
|
#include <proc/meminfo.h>
|
|
#include "procps-private.h"
|
|
|
|
#define MEMINFO_FILE "/proc/meminfo"
|
|
|
|
struct meminfo_data {
|
|
unsigned long active;
|
|
unsigned long inactive;
|
|
unsigned long high_free;
|
|
unsigned long high_total;
|
|
unsigned long low_free;
|
|
unsigned long low_total;
|
|
unsigned long available;
|
|
unsigned long buffers;
|
|
unsigned long cached;
|
|
unsigned long free;
|
|
unsigned long shared;
|
|
unsigned long total;
|
|
unsigned long used;
|
|
unsigned long slab;
|
|
unsigned long swap_free;
|
|
unsigned long swap_total;
|
|
unsigned long swap_used;
|
|
};
|
|
|
|
struct procps_meminfo {
|
|
int refcount;
|
|
int meminfo_fd;
|
|
struct meminfo_data data;
|
|
};
|
|
|
|
|
|
/*
|
|
* procps_meminfo_new:
|
|
*
|
|
* Create a new container to hold the meminfo information
|
|
*
|
|
* The initial refcount is 1, and needs to be decremented
|
|
* to release the resources of the structure.
|
|
*
|
|
* Returns: a new meminfo info container
|
|
*/
|
|
PROCPS_EXPORT int procps_meminfo_new (
|
|
struct procps_meminfo **info)
|
|
{
|
|
struct procps_meminfo *m;
|
|
m = calloc(1, sizeof(struct procps_meminfo));
|
|
if (!m)
|
|
return -ENOMEM;
|
|
|
|
m->refcount = 1;
|
|
m->meminfo_fd = -1;
|
|
*info = m;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* procps_meminfo_read:
|
|
*
|
|
* Read the data out of /proc/meminfo putting the information
|
|
* into the supplied info structure
|
|
*/
|
|
PROCPS_EXPORT int procps_meminfo_read (
|
|
struct procps_meminfo *info)
|
|
{
|
|
char buf[8192];
|
|
char *head, *tail;
|
|
int size;
|
|
unsigned long *valptr;
|
|
signed long mem_used;
|
|
|
|
if (info == NULL)
|
|
return -1;
|
|
|
|
memset(&(info->data), 0, sizeof(struct meminfo_data));
|
|
/* read in the data */
|
|
|
|
if (-1 == info->meminfo_fd && (info->meminfo_fd = open(MEMINFO_FILE, O_RDONLY)) == -1) {
|
|
return -errno;
|
|
}
|
|
if (lseek(info->meminfo_fd, 0L, SEEK_SET) == -1) {
|
|
return -errno;
|
|
}
|
|
if ((size = read(info->meminfo_fd, buf, sizeof(buf)-1)) < 0) {
|
|
return -1;
|
|
}
|
|
buf[size] = '\0';
|
|
|
|
/* Scan the file */
|
|
head = buf;
|
|
do {
|
|
tail = strchr(head, ' ');
|
|
if (!tail)
|
|
break;
|
|
*tail = '\0';
|
|
valptr = NULL;
|
|
switch (*head) {
|
|
case 'A':
|
|
if (0 == strcmp(head, "Active:"))
|
|
valptr = &(info->data.active);
|
|
break;
|
|
case 'B':
|
|
if (0 == strcmp(head, "Buffers:"))
|
|
valptr = &(info->data.buffers);
|
|
break;
|
|
case 'C':
|
|
if (0 == strcmp(head, "Cached:"))
|
|
valptr = &(info->data.cached);
|
|
break;
|
|
case 'H':
|
|
if (0 == strcmp(head, "HighFree:"))
|
|
valptr = &(info->data.high_free);
|
|
else if (0 == strcmp(head, "HighTotal:"))
|
|
valptr = &(info->data.high_total);
|
|
break;
|
|
case 'I':
|
|
if (0 == strcmp(head, "Inactive:"))
|
|
valptr = &(info->data.inactive);
|
|
break;
|
|
case 'L':
|
|
if (0 == strcmp(head, "LowFree:"))
|
|
valptr = &(info->data.low_free);
|
|
else if (0 == strcmp(head, "LowTotal:"))
|
|
valptr = &(info->data.low_total);
|
|
break;
|
|
case 'M':
|
|
if (0 == strcmp(head, "MemAvailable:"))
|
|
valptr = &(info->data.available);
|
|
else if (0 == strcmp(head, "MemFree:"))
|
|
valptr = &(info->data.free);
|
|
else if (0 == strcmp(head, "MemTotal:"))
|
|
valptr = &(info->data.total);
|
|
break;
|
|
case 'S':
|
|
if (0 == strcmp(head, "Slab:"))
|
|
valptr = &(info->data.slab);
|
|
else if (0 == strcmp(head, "SwapFree:"))
|
|
valptr = &(info->data.swap_free);
|
|
else if (0 == strcmp(head, "SwapTotal:"))
|
|
valptr = &(info->data.swap_total);
|
|
else if (0 == strcmp(head, "Shmem:"))
|
|
valptr = &(info->data.shared);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
head = tail+1;
|
|
if (valptr) {
|
|
*valptr = strtoul(head, &tail, 10);
|
|
}
|
|
tail = strchr(head, '\n');
|
|
if (!tail)
|
|
break;
|
|
head = tail + 1;
|
|
} while(tail);
|
|
|
|
if (0 == info->data.low_total) {
|
|
info->data.low_total = info->data.total;
|
|
info->data.low_free = info->data.free;
|
|
}
|
|
if (0 == info->data.available) {
|
|
info->data.available = info->data.free;
|
|
}
|
|
info->data.cached += info->data.slab;
|
|
info->data.swap_used = info->data.swap_total - info->data.swap_free;
|
|
|
|
/* if 'available' is greater than 'total' or our calculation of mem_used
|
|
overflows, that's symptomatic of running within a lxc container where
|
|
such values will be dramatically distorted over those of the host. */
|
|
if (info->data.available > info->data.total)
|
|
info->data.available = info->data.free;
|
|
mem_used = info->data.total - info->data.free - info->data.cached - info->data.buffers;
|
|
if (mem_used < 0)
|
|
mem_used = info->data.total - info->data.free;
|
|
info->data.used = (unsigned long)mem_used;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
PROCPS_EXPORT struct procps_meminfo *procps_meminfo_ref (
|
|
struct procps_meminfo *info)
|
|
{
|
|
if (info == NULL)
|
|
return NULL;
|
|
info->refcount++;
|
|
return info;
|
|
}
|
|
|
|
PROCPS_EXPORT struct procps_meminfo *procps_meminfo_unref (
|
|
struct procps_meminfo *info)
|
|
{
|
|
if (info == NULL)
|
|
return NULL;
|
|
info->refcount--;
|
|
if (info->refcount > 0)
|
|
return NULL;
|
|
free(info);
|
|
return NULL;
|
|
}
|
|
|
|
/* Accessor functions */
|
|
PROCPS_EXPORT unsigned long procps_meminfo_get (
|
|
struct procps_meminfo *info,
|
|
enum meminfo_item item)
|
|
{
|
|
switch (item) {
|
|
case PROCPS_MEM_ACTIVE:
|
|
return info->data.active;
|
|
case PROCPS_MEM_INACTIVE:
|
|
return info->data.inactive;
|
|
case PROCPS_MEMHI_FREE:
|
|
return info->data.high_free;
|
|
case PROCPS_MEMHI_TOTAL:
|
|
return info->data.high_total;
|
|
case PROCPS_MEMHI_USED:
|
|
if (info->data.high_free > info->data.high_total)
|
|
return 0;
|
|
return info->data.high_total - info->data.high_free;
|
|
case PROCPS_MEMLO_FREE:
|
|
return info->data.low_free;
|
|
case PROCPS_MEMLO_TOTAL:
|
|
return info->data.low_total;
|
|
case PROCPS_MEMLO_USED:
|
|
if (info->data.low_free > info->data.low_total)
|
|
return 0;
|
|
return info->data.low_total - info->data.low_free;
|
|
case PROCPS_MEM_AVAILABLE:
|
|
return info->data.available;
|
|
case PROCPS_MEM_BUFFERS:
|
|
return info->data.buffers;
|
|
case PROCPS_MEM_CACHED:
|
|
return info->data.cached;
|
|
case PROCPS_MEM_FREE:
|
|
return info->data.free;
|
|
case PROCPS_MEM_SHARED:
|
|
return info->data.shared;
|
|
case PROCPS_MEM_TOTAL:
|
|
return info->data.total;
|
|
case PROCPS_MEM_USED:
|
|
return info->data.used;
|
|
case PROCPS_SWAP_FREE:
|
|
return info->data.swap_free;
|
|
case PROCPS_SWAP_TOTAL:
|
|
return info->data.swap_total;
|
|
case PROCPS_SWAP_USED:
|
|
if (info->data.swap_free > info->data.swap_total)
|
|
return 0;
|
|
return info->data.swap_total - info->data.swap_free;
|
|
}
|
|
return 0;
|
|
}
|