system/resmonitor/showinfo.c (554 lines of code) (raw):
/****************************************************************************
* apps/system/resmonitor/showinfo.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <malloc.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/statfs.h>
#include <sys/time.h>
#include <syslog.h>
#include <time.h>
#include <unistd.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define PATH "/proc"
#define CPULOAD "cpuload"
#define HEAP "heap"
#define STACK "stack"
#define LOADAVG "loadavg"
#define GROUP "group/status"
#define FILELEN 100
/****************************************************************************
* Private Type Declarations
****************************************************************************/
struct t_info
{
unsigned long mem_total;
unsigned long mem_used;
unsigned long mem_maxused;
unsigned long mem_free;
unsigned long mem_largest;
unsigned long mem_nused;
unsigned long mem_nfree;
char total_cpu[8];
};
struct p_info
{
unsigned long stack_used;
unsigned long heap_used;
char cpu[8];
};
/****************************************************************************
* Private Data
****************************************************************************/
static int go = 1;
static int p_head = 1;
static int d_head = 1;
/****************************************************************************
* Private Functions
****************************************************************************/
static void handler(int sig)
{
go = 0;
}
static void show_usages(void)
{
syslog(LOG_WARNING,
"Usage: CMD [-i <interval>] [-p <pid>] [-a] [-d <dir>] [-l "
"<logpath>] [-k <logpath>]\n"
"\t\t-i: set refresh interval (s), default 1s\n"
"\t\t-p: set pid to monitor, show stack, head and cpu used by pid\n"
"\t\t-a: work only if -p is set, show stack, head and cpu used by "
"pid group\n"
"\t\t-d: print the diskinfo of the dir\n"
"\t\t-l: the memory and cpu info output to logpath\n"
"\t\t-k: the diskinfo output to logpath\n");
exit(1);
}
static void get_cpu(int pid, char *buf)
{
char filepath[FILELEN];
int ret;
if (pid <= 0)
{
ret = snprintf(filepath, FILELEN, "%s/%s", PATH, CPULOAD);
}
else
{
ret = snprintf(filepath, FILELEN, "%s/%d/%s", PATH, pid, LOADAVG);
}
if (ret < 0)
{
/* syslog(LOG_ERR, "snprintf error\n"); */
snprintf(buf, 8, "%.1f%%", 0.0);
return;
}
FILE *fp = fopen(filepath, "r");
if (!fp)
{
snprintf(buf, 8, "%.1f%%", 0.0);
return;
}
fgets(buf, 8, fp);
/* sscanf(buf, "%f", &cpu); */
buf[strlen(buf) - 1] = '\0';
fclose(fp);
}
static void add_cpu(char *a, char *b, char *buf)
{
if (a == NULL || b == NULL)
{
return;
}
float fa = 0;
float fb = 0;
sscanf(a, "%f", &fa);
sscanf(b, "%f", &fb);
float sum = fa + fb;
int ret = snprintf(buf, 8, "%.1f%%", sum);
if (ret < 0)
{
syslog(LOG_ERR, "add_cpu error\n");
}
}
static unsigned long get_heap(int pid)
{
unsigned long heap = 0;
char filepath[FILELEN];
int ret = snprintf(filepath, FILELEN, "%s/%d/%s", PATH, pid, HEAP);
if (ret < 0)
{
return heap;
}
FILE *fp = fopen(filepath, "r");
if (!fp)
{
return heap;
}
char buf[25];
while (fgets(buf, 25, fp) != NULL)
{
if (strstr(buf, "AllocSize"))
{
int idx = strcspn(buf, "0123456789");
heap = strtoul(&buf[idx], NULL, 10);
break;
}
}
fclose(fp);
return heap;
}
static unsigned long get_stack(int pid)
{
unsigned long stack = 0;
char filepath[FILELEN];
int ret = snprintf(filepath, FILELEN, "%s/%d/%s", PATH, pid, STACK);
if (ret < 0)
{
return stack;
}
FILE *fp = fopen(filepath, "r");
if (!fp)
{
return stack;
}
char buf[25];
while (fgets(buf, 25, fp) != NULL)
{
if (strstr(buf, "StackUsed"))
{
int idx = strcspn(buf, "0123456789");
stack = strtoul(&buf[idx], NULL, 10);
break;
}
}
fclose(fp);
return stack;
}
static int get_total_info(struct t_info *t_info)
{
memset(t_info, 0, sizeof(struct t_info));
struct mallinfo g_alloc_info = mallinfo();
t_info->mem_total = g_alloc_info.arena;
t_info->mem_used = g_alloc_info.uordblks;
t_info->mem_free = g_alloc_info.fordblks;
t_info->mem_largest = g_alloc_info.mxordblk;
t_info->mem_nused = g_alloc_info.aordblks;
t_info->mem_nfree = g_alloc_info.ordblks;
t_info->mem_maxused = g_alloc_info.usmblks;
get_cpu(0, t_info->total_cpu);
return 0;
}
static int get_pid_info(struct p_info *p_info, int pid, bool all)
{
memset(p_info, 0, sizeof(struct p_info));
if (!all)
{
get_cpu(pid, p_info->cpu);
p_info->heap_used = get_heap(pid);
p_info->stack_used = get_stack(pid);
}
else
{
char filepath[FILELEN];
int ret = snprintf(filepath, FILELEN, "%s/%d/%s", PATH, pid, GROUP);
if (ret < 0)
{
return -1;
}
FILE *fp = fopen(filepath, "r");
if (!fp)
{
return -1;
}
char buf[100];
while (fgets(buf, 100, fp) != NULL)
{
if (strstr(buf, "Member IDs"))
{
int idx = strcspn(buf, ":");
char *p = strtok(&buf[idx], " ");
while ((p = strtok(NULL, " ")) != NULL)
{
int gpid = strtoul(p, NULL, 10);
char gcpu[8] = "0.0%%";
if (gpid > 0)
{
get_cpu(gpid, gcpu);
}
add_cpu(p_info->cpu, gcpu, p_info->cpu);
p_info->heap_used += get_heap(gpid);
p_info->stack_used += get_stack(gpid);
}
break;
}
}
fclose(fp);
}
return 0;
}
static void
print_result(struct t_info *t_info, struct p_info *p_info, char *logpath)
{
if (strlen(logpath) != 0)
{
time_t rawtime = 0;
struct tm info;
char date[30];
time(&rawtime);
localtime_r(&rawtime, &info);
strftime(date, 30, "[%Y-%m-%d %H:%M:%S] ", &info);
FILE *f;
if ((f = fopen(logpath, "a+")) != NULL)
{
if (p_head == 1)
{
p_head = 0;
if (p_info == NULL)
{
fprintf(f,
"%22s%13s%11s%11s%11s%11s%7s%7s%7s\n",
"",
"total",
"used",
"free",
"maxused",
"largest",
"nused",
"nfree",
"cpu");
}
else
{
fprintf(f,
"%22s%13s%11s%11s%11s%11s%7s%7s%7s%7s%11s%7s\n",
"",
"total",
"used",
"free",
"maxused",
"largest",
"nused",
"nfree",
"cpu",
"pstack",
"pheap",
"pcpu");
}
}
if (p_info == NULL)
{
fprintf(f,
"%-22s%13lu%11lu%11lu%11lu%11lu%7lu%7lu%7s\n",
date,
t_info->mem_total,
t_info->mem_used,
t_info->mem_free,
t_info->mem_maxused,
t_info->mem_largest,
t_info->mem_nused,
t_info->mem_nfree,
t_info->total_cpu);
}
else
{
fprintf(
f,
"%-22s%13lu%11lu%11lu%11lu%11lu%7lu%7lu%7s%7lu%11lu%7s\n",
date,
t_info->mem_total,
t_info->mem_used,
t_info->mem_free,
t_info->mem_maxused,
t_info->mem_largest,
t_info->mem_nused,
t_info->mem_nfree,
t_info->total_cpu,
p_info->stack_used,
p_info->heap_used,
p_info->cpu);
}
fclose(f);
}
else
{
syslog(LOG_ERR, "fopen logpath %s error \n", logpath);
}
return;
}
if (p_info == NULL)
{
syslog(LOG_INFO,
"%11s%11s%11s%11s%11s%7s%7s%7s\n",
"total",
"used",
"free",
"maxused",
"largest",
"nused",
"nfree",
"cpu");
syslog(LOG_INFO,
"%11lu%11lu%11lu%11lu%11lu%7lu%7lu%7s\n\n",
t_info->mem_total,
t_info->mem_used,
t_info->mem_free,
t_info->mem_maxused,
t_info->mem_largest,
t_info->mem_nused,
t_info->mem_nfree,
t_info->total_cpu);
}
else
{
syslog(LOG_INFO,
"%11s%11s%11s%11s%11s%7s%7s%7s%7s%11s%7s\n",
"total",
"used",
"free",
"maxused",
"largest",
"nused",
"nfree",
"cpu",
"pstack",
"pheap",
"pcpu");
syslog(LOG_INFO,
"%11lu%11lu%11lu%11lu%11lu%7lu%7lu%7s%7lu%11lu%7s\n\n",
t_info->mem_total,
t_info->mem_used,
t_info->mem_free,
t_info->mem_maxused,
t_info->mem_largest,
t_info->mem_nused,
t_info->mem_nfree,
t_info->total_cpu,
p_info->stack_used,
p_info->heap_used,
p_info->cpu);
}
}
static void transfer(uintmax_t value, char *res, int len)
{
memset(res, 0, len);
if (value > 1024 * 1024)
{
int ret = snprintf(res, len, "%ju", value / 1024 / 1024);
if (ret < 0)
{
return;
}
strcat(res, "M");
}
else if (value > 1024)
{
int ret = snprintf(res, len, "%ju", value / 1024);
if (ret < 0)
{
return;
}
strcat(res, "K");
}
else
{
int ret = snprintf(res, len, "%ju", value);
if (ret < 0)
{
return;
}
strcat(res, "B");
}
}
static void print_diskinfo(char *path, char *logpath)
{
struct statfs diskinfo;
int ret = statfs(path, &diskinfo);
if (ret != 0)
{
syslog(LOG_ERR, "statfs fail!\n");
return;
}
char c_tsize[20];
char c_asize[20];
char c_bsize[20];
char c_fsize[20];
uintmax_t bsize = (uintmax_t)diskinfo.f_bsize;
uintmax_t bavail = (uintmax_t)diskinfo.f_bavail;
uintmax_t blocks = (uintmax_t)diskinfo.f_blocks;
uintmax_t bfree = (uintmax_t)diskinfo.f_bfree;
transfer(bsize * blocks, c_tsize, 20);
transfer(bsize * bavail, c_asize, 20);
transfer(bsize * bfree, c_fsize, 20);
transfer(bsize, c_bsize, 20);
if (strlen(logpath) != 0)
{
time_t rawtime = 0;
struct tm info;
char date[30];
time(&rawtime);
localtime_r(&rawtime, &info);
strftime(date, 30, "[%Y-%m-%d %H:%M:%S] ", &info);
FILE *f;
if ((f = fopen(logpath, "a+")) != NULL)
{
if (d_head == 1)
{
d_head = 0;
fprintf(f,
"%22s%11s%11s%11s%11s%11s\n",
"",
"dir",
"total size",
"free size",
"avail size",
"block size");
}
fprintf(f,
"%-22s%11s%11s%11s%11s%11s\n",
date,
path,
c_tsize,
c_fsize,
c_asize,
c_bsize);
fclose(f);
}
else
{
syslog(LOG_ERR, "fopen logpath %s error \n", logpath);
}
}
else
{
syslog(LOG_INFO,
"%11s%11s%11s%11s%11s\n",
"dir",
"total size",
"free size",
"avail size",
"block size");
syslog(LOG_INFO,
"%11s%11s%11s%11s%11s\n\n",
path,
c_tsize,
c_fsize,
c_asize,
c_bsize);
}
}
int main(int argc, char *argv[])
{
if (argc == 1)
{
show_usages();
}
char filepath[FILELEN];
char logpath_l[FILELEN];
char logpath_k[FILELEN];
struct timeval sleeptime;
struct t_info total_info;
struct p_info pid_info;
int interval = 1;
int pid = -1;
bool all = false;
int ret;
int o;
memset(filepath, 0, FILELEN);
memset(logpath_l, 0, FILELEN);
memset(logpath_k, 0, FILELEN);
go = 1;
p_head = 1;
d_head = 1;
while ((o = getopt(argc, argv, "i:p:ad:l:k:")) != EOF)
{
switch (o)
{
case 'i':
interval = atoi(optarg);
break;
case 'p':
pid = atoi(optarg);
break;
case 'a':
all = true;
break;
case 'd':
snprintf(filepath, FILELEN, "%s", optarg);
break;
case 'l':
snprintf(logpath_l, FILELEN, "%s", optarg);
break;
case 'k':
snprintf(logpath_k, FILELEN, "%s", optarg);
break;
default:
show_usages();
break;
}
}
signal(SIGINT, handler);
signal(SIGKILL, handler);
while (go)
{
ret = get_total_info(&total_info);
if (ret < 0)
{
syslog(LOG_ERR, "get total info fail\n");
break;
}
if (pid > 0)
{
ret = get_pid_info(&pid_info, pid, all);
if (ret < 0)
{
syslog(LOG_ERR, "get pid info fail\n");
break;
}
}
if (all || pid > 0)
{
print_result(&total_info, &pid_info, logpath_l);
}
else
{
print_result(&total_info, NULL, logpath_l);
}
if (strlen(filepath) != 0)
{
print_diskinfo(filepath, logpath_k);
}
sleeptime.tv_sec = interval;
sleeptime.tv_usec = 0;
select(0, NULL, NULL, NULL, &sleeptime);
}
syslog(LOG_INFO, "program complete!\n");
return 0;
}