procps/proc/meminfo.c
Jim Warner 74beff80ff library: make reads & unref logic a little more robust
Since we are not using a higher level standard C fopen
all of the read requests were made signal sensitive as
that can result in a 'temporarily' failed i/o request.

Also, protection against some user calling the 'unref'
function on already free memory has been incorporated.
This will protect us from some nasty 'Abort' surprise.

Signed-off-by: Jim Warner <james.warner@comcast.net>
2015-06-29 21:30:48 +10:00

371 lines
11 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;
}
for (;;) {
if ((size = read(info->meminfo_fd, buf, sizeof(buf)-1)) < 0) {
if (errno == EINTR || errno == EAGAIN)
continue;
return -errno;
}
break;
}
if (size == 0)
return 0;
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 || info->refcount == 0)
return NULL;
info->refcount--;
if (info->refcount > 0)
return info;
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;
}
PROCPS_EXPORT int procps_meminfo_get_chain (
struct procps_meminfo *info,
struct meminfo_result *item)
{
if (item == NULL)
return -EINVAL;
do {
switch (item->item) {
case PROCPS_MEM_ACTIVE:
item->result = info->data.active;
break;
case PROCPS_MEM_INACTIVE:
item->result = info->data.inactive;
break;
case PROCPS_MEMHI_FREE:
item->result = info->data.high_free;
break;
case PROCPS_MEMHI_TOTAL:
item->result = info->data.high_total;
break;
case PROCPS_MEMHI_USED:
if (info->data.high_free > info->data.high_total)
item->result = 0;
else
item->result = info->data.high_total - info->data.high_free;
break;
case PROCPS_MEMLO_FREE:
item->result = info->data.low_free;
break;
case PROCPS_MEMLO_TOTAL:
item->result = info->data.low_total;
break;
case PROCPS_MEMLO_USED:
if (info->data.low_free > info->data.low_total)
item->result = 0;
else
item->result = info->data.low_total - info->data.low_free;
break;
case PROCPS_MEM_AVAILABLE:
item->result = info->data.available;
break;
case PROCPS_MEM_BUFFERS:
item->result = info->data.buffers;
break;
case PROCPS_MEM_CACHED:
item->result = info->data.cached;
break;
case PROCPS_MEM_FREE:
item->result = info->data.free;
break;
case PROCPS_MEM_SHARED:
item->result = info->data.shared;
break;
case PROCPS_MEM_TOTAL:
item->result = info->data.total;
break;
case PROCPS_MEM_USED:
item->result = info->data.used;
break;
case PROCPS_SWAP_FREE:
item->result = info->data.swap_free;
break;
case PROCPS_SWAP_TOTAL:
item->result = info->data.swap_total;
break;
case PROCPS_SWAP_USED:
if (info->data.swap_free > info->data.swap_total)
item->result = 0;
else
item->result = info->data.swap_total - info->data.swap_free;
break;
default:
return -EINVAL;
}
item = item->next;
} while (item);
return 0;
}