nuttx-apps/system/resmonitor/showinfo.c

/****************************************************************************
 * 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 Types
 ****************************************************************************/

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;
}