faf6d4dc93
The earlier attempt at protecting these functions from
already freed memory worked just fine until the memory
was, in fact, reused by the OS. At that point, the ref
count would most likely fail an existing a test for 0.
So this commit will take control of the 'info' pointer
and force it to NULL when a reference count reaches 0.
Plus, since it makes little sense returning an address
that a caller already has, henceforth we will return a
reference count out of the 'ref' and 'unref functions.
Reference(s):
commit 74beff80ff
Signed-off-by: Jim Warner <james.warner@comcast.net>
373 lines
11 KiB
C
373 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 int procps_meminfo_ref (
|
|
struct procps_meminfo *info)
|
|
{
|
|
if (info == NULL)
|
|
return -EINVAL;
|
|
info->refcount++;
|
|
return info->refcount;
|
|
}
|
|
|
|
PROCPS_EXPORT int procps_meminfo_unref (
|
|
struct procps_meminfo **info)
|
|
{
|
|
if (info == NULL || *info == NULL)
|
|
return -EINVAL;
|
|
(*info)->refcount--;
|
|
if ((*info)->refcount == 0) {
|
|
free(*info);
|
|
*info = NULL;
|
|
return 0;
|
|
}
|
|
return (*info)->refcount;
|
|
}
|
|
|
|
/* 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;
|
|
}
|