PCP: support for 'dynamic columns' added at runtime

Implements support for arbitrary Performance Co-Pilot
metrics with per-process instance domains to form new
htop columns.  The column-to-metric mappings are setup
using configuration files which will be documented via
man pages as part of a follow-up commit.

We provide an initial set of column configurations so
as to provide new capabilities to pcp-htop: including
configs for containers, open fd counts, scheduler run
queue time, tcp/udp bytes/calls sent/recv, delay acct,
virtual machine guests, detailed virtual memory, swap.

Note there is a change to the configuration file path
resolution algorithm introduced for 'dynamic meters'.
First, look in any custom PCP_HTOP_DIR location.  Then
iterate, in priority order, users home directory, then
local sysadmins files in /etc/pcp/htop, then readonly
configuration files below /usr/share/pcp/htop.  This
final location becomes the preferred place for our own
shipped meter and column files.

The Settings file (htoprc) writing code is updated to
not using the numeric identifier for dynamic columns.
The same strategy used for dynamic meters is used here
where we write Dynamic(name) so the name can be setup
once more at start.  Regular (static) columns writing
to htoprc - i.e. numerically indexed - is unchanged.

1 files changed, 326 insertions, 0 deletions

diff --git a/pcp/PCPDynamicColumn.c b/pcp/PCPDynamicColumn.c
new file mode 100644
index 00000000..2848490e
--- /dev/null
+++ b/pcp/PCPDynamicColumn.c
@@ -0,0 +1,326 @@
+/*
+htop - PCPDynamicColumn.c
+(C) 2021 Sohaib Mohammed
+(C) 2021 htop dev team
+(C) 2021 Red Hat, Inc.
+Released under the GNU GPLv2, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h" // IWYU pragma: keep
+
+#include "pcp/PCPDynamicColumn.h"
+
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "CRT.h"
+#include "Macros.h"
+#include "Platform.h"
+#include "Process.h"
+#include "RichString.h"
+#include "XUtils.h"
+
+#include "pcp/PCPProcess.h"
+
+
+static bool PCPDynamicColumn_addMetric(PCPDynamicColumns* columns, PCPDynamicColumn* column) {
+   if (!column->super.name[0])
+      return false;
+
+   size_t bytes = 16 + strlen(column->super.name);
+   char* metricName = xMalloc(bytes);
+   xSnprintf(metricName, bytes, "htop.column.%s", column->super.name);
+
+   column->metricName = metricName;
+   column->id = columns->offset + columns->cursor;
+   columns->cursor++;
+
+   Platform_addMetric(column->id, metricName);
+   return true;
+}
+
+static void PCPDynamicColumn_parseMetric(PCPDynamicColumns* columns, PCPDynamicColumn* column, const char* path, unsigned int line, char* value) {
+   /* lookup a dynamic metric with this name, else create */
+   if (PCPDynamicColumn_addMetric(columns, column) == false)
+      return;
+
+   /* derived metrics in all dynamic columns for simplicity */
+   char* error;
+   if (pmRegisterDerivedMetric(column->metricName, value, &error) < 0) {
+      char* note;
+      xAsprintf(&note,
+                "%s: failed to parse expression in %s at line %u\n%s\n",
+                pmGetProgname(), path, line, error);
+      free(error);
+      errno = EINVAL;
+      CRT_fatalError(note);
+      free(note);
+   }
+}
+
+// Ensure a valid name for use in a PCP metric name and in htoprc
+static bool PCPDynamicColumn_validateColumnName(char* key, const char* path, unsigned int line) {
+   char* p = key;
+   char* end = strrchr(key, ']');
+
+   if (end) {
+      *end = '\0';
+   } else {
+      fprintf(stderr,
+                "%s: no closing brace on column name at %s line %u\n\"%s\"",
+                pmGetProgname(), path, line, key);
+      return false;
+   }
+
+   while (*p) {
+      if (p == key) {
+         if (!isalpha(*p) && *p != '_')
+            break;
+      } else {
+         if (!isalnum(*p) && *p != '_')
+            break;
+      }
+      p++;
+   }
+   if (*p != '\0') { /* badness */
+      fprintf(stderr,
+                "%s: invalid column name at %s line %u\n\"%s\"",
+                pmGetProgname(), path, line, key);
+      return false;
+   }
+   return true;
+}
+
+// Ensure a column name has not been defined previously
+static bool PCPDynamicColumn_uniqueName(char* key, PCPDynamicColumns* columns) {
+   return DynamicColumn_search(columns->table, key, NULL) == NULL;
+}
+
+static PCPDynamicColumn* PCPDynamicColumn_new(PCPDynamicColumns* columns, const char* name) {
+   PCPDynamicColumn* column = xCalloc(1, sizeof(*column));
+   String_safeStrncpy(column->super.name, name, sizeof(column->super.name));
+
+   size_t id = columns->count + LAST_PROCESSFIELD;
+   Hashtable_put(columns->table, id, column);
+   columns->count++;
+
+   return column;
+}
+
+static void PCPDynamicColumn_parseFile(PCPDynamicColumns* columns, const char* path) {
+   FILE* file = fopen(path, "r");
+   if (!file)
+      return;
+
+   PCPDynamicColumn* column = NULL;
+   unsigned int lineno = 0;
+   bool ok = true;
+   for (;;) {
+      char* line = String_readLine(file);
+      if (!line)
+         break;
+      lineno++;
+
+      /* cleanup whitespace, skip comment lines */
+      char* trimmed = String_trim(line);
+      free(line);
+      if (!trimmed || !trimmed[0] || trimmed[0] == '#') {
+         free(trimmed);
+         continue;
+      }
+
+      size_t n;
+      char** config = String_split(trimmed, '=', &n);
+      free(trimmed);
+      if (config == NULL)
+         continue;
+
+      char* key = String_trim(config[0]);
+      char* value = n > 1 ? String_trim(config[1]) : NULL;
+      if (key[0] == '[') {  /* new section heading - i.e. new column */
+         ok = PCPDynamicColumn_validateColumnName(key + 1, path, lineno);
+         if (ok)
+            ok = PCPDynamicColumn_uniqueName(key + 1, columns);
+         if (ok)
+            column = PCPDynamicColumn_new(columns, key + 1);
+      } else if (value && column && String_eq(key, "caption")) {
+         free_and_xStrdup(&column->super.caption, value);
+      } else if (value && column && String_eq(key, "heading")) {
+         free_and_xStrdup(&column->super.heading, value);
+      } else if (value && column && String_eq(key, "description")) {
+         free_and_xStrdup(&column->super.description, value);
+      } else if (value && column && String_eq(key, "width")) {
+         column->super.width = strtoul(value, NULL, 10);
+      } else if (value && column && String_eq(key, "metric")) {
+         PCPDynamicColumn_parseMetric(columns, column, path, lineno, value);
+      }
+      String_freeArray(config);
+      free(value);
+      free(key);
+   }
+   fclose(file);
+}
+
+static void PCPDynamicColumn_scanDir(PCPDynamicColumns* columns, char* path) {
+   DIR* dir = opendir(path);
+   if (!dir)
+      return;
+
+   struct dirent* dirent;
+   while ((dirent = readdir(dir)) != NULL) {
+      if (dirent->d_name[0] == '.')
+         continue;
+
+      char* file = String_cat(path, dirent->d_name);
+      PCPDynamicColumn_parseFile(columns, file);
+      free(file);
+   }
+   closedir(dir);
+}
+
+void PCPDynamicColumns_init(PCPDynamicColumns* columns) {
+   const char* share = pmGetConfig("PCP_SHARE_DIR");
+   const char* sysconf = pmGetConfig("PCP_SYSCONF_DIR");
+   const char* xdgConfigHome = getenv("XDG_CONFIG_HOME");
+   const char* override = getenv("PCP_HTOP_DIR");
+   const char* home = getenv("HOME");
+   char* path;
+
+   columns->table = Hashtable_new(0, true);
+
+   /* developer paths - PCP_HTOP_DIR=./pcp ./pcp-htop */
+   if (override) {
+      path = String_cat(override, "/columns/");
+      PCPDynamicColumn_scanDir(columns, path);
+      free(path);
+   }
+
+   /* next, search in home directory alongside htoprc */
+   if (xdgConfigHome)
+      path = String_cat(xdgConfigHome, "/htop/columns/");
+   else if (home)
+      path = String_cat(home, "/.config/htop/columns/");
+   else
+      path = NULL;
+   if (path) {
+      PCPDynamicColumn_scanDir(columns, path);
+      free(path);
+   }
+
+   /* next, search in the system columns directory */
+   path = String_cat(sysconf, "/htop/columns/");
+   PCPDynamicColumn_scanDir(columns, path);
+   free(path);
+
+   /* next, try the readonly system columns directory */
+   path = String_cat(share, "/htop/columns/");
+   PCPDynamicColumn_scanDir(columns, path);
+   free(path);
+}
+
+void PCPDynamicColumn_writeField(PCPDynamicColumn* this, const Process* proc, RichString* str) {
+   const PCPProcess* pp = (const PCPProcess*) proc;
+   unsigned int type = Metric_type(this->id);
+
+   pmAtomValue atom;
+   if (!Metric_instance(this->id, proc->pid, pp->offset, &atom, type)) {
+      RichString_appendAscii(str, CRT_colors[METER_VALUE_ERROR], "no data");
+      return;
+   }
+
+   int width = this->super.width;
+   if (!width || abs(width) > DYNAMIC_MAX_COLUMN_WIDTH)
+      width = DYNAMIC_DEFAULT_COLUMN_WIDTH;
+   int abswidth = abs(width);
+   if (abswidth > DYNAMIC_MAX_COLUMN_WIDTH) {
+      abswidth = DYNAMIC_MAX_COLUMN_WIDTH;
+      width = -abswidth;
+   }
+
+   char buffer[DYNAMIC_MAX_COLUMN_WIDTH + /* space */ 1 + /* null terminator */ + 1];
+   int attr = CRT_colors[DEFAULT_COLOR];
+   switch (type) {
+      case PM_TYPE_STRING:
+         attr = CRT_colors[PROCESS_SHADOW];
+         Process_printLeftAlignedField(str, attr, atom.cp, abswidth);
+         free(atom.cp);
+         break;
+      case PM_TYPE_32:
+         xSnprintf(buffer, sizeof(buffer), "%*d ", width, atom.l);
+         RichString_appendAscii(str, attr, buffer);
+         break;
+      case PM_TYPE_U32:
+         xSnprintf(buffer, sizeof(buffer), "%*u ", width, atom.ul);
+         RichString_appendAscii(str, attr, buffer);
+         break;
+      case PM_TYPE_64:
+         xSnprintf(buffer, sizeof(buffer), "%*lld ", width, (long long) atom.ll);
+         RichString_appendAscii(str, attr, buffer);
+         break;
+      case PM_TYPE_U64:
+         xSnprintf(buffer, sizeof(buffer), "%*llu ", width, (unsigned long long) atom.ull);
+         RichString_appendAscii(str, attr, buffer);
+         break;
+      case PM_TYPE_FLOAT:
+         xSnprintf(buffer, sizeof(buffer), "%*.2f ", width, (double) atom.f);
+         RichString_appendAscii(str, attr, buffer);
+         break;
+      case PM_TYPE_DOUBLE:
+         xSnprintf(buffer, sizeof(buffer), "%*.2f ", width, atom.d);
+         RichString_appendAscii(str, attr, buffer);
+         break;
+      default:
+         attr = CRT_colors[METER_VALUE_ERROR];
+         RichString_appendAscii(str, attr, "no type");
+         break;
+   }
+}
+
+int PCPDynamicColumn_compareByKey(const PCPProcess* p1, const PCPProcess* p2, ProcessField key) {
+   const PCPDynamicColumn* column = Hashtable_get(p1->super.processList->dynamicColumns, key);
+
+   size_t metric = column->id;
+   unsigned int type = Metric_type(metric);
+
+   pmAtomValue atom1 = {0}, atom2 = {0};
+   if (!Metric_instance(metric, p1->super.pid, p1->offset, &atom1, type) ||
+       !Metric_instance(metric, p2->super.pid, p2->offset, &atom2, type)) {
+      if (type == PM_TYPE_STRING) {
+         free(atom1.cp);
+         free(atom2.cp);
+      }
+      return -1;
+   }
+
+   switch (type) {
+      case PM_TYPE_STRING: {
+         int cmp = SPACESHIP_NULLSTR(atom2.cp, atom1.cp);
+         free(atom2.cp);
+         free(atom1.cp);
+         return cmp;
+      }
+      case PM_TYPE_32:
+         return SPACESHIP_NUMBER(atom2.l, atom1.l);
+      case PM_TYPE_U32:
+         return SPACESHIP_NUMBER(atom2.ul, atom1.ul);
+      case PM_TYPE_64:
+         return SPACESHIP_NUMBER(atom2.ll, atom1.ll);
+      case PM_TYPE_U64:
+         return SPACESHIP_NUMBER(atom2.ull, atom1.ull);
+      case PM_TYPE_FLOAT:
+         return SPACESHIP_NUMBER(atom2.f, atom1.f);
+      case PM_TYPE_DOUBLE:
+         return SPACESHIP_NUMBER(atom2.d, atom1.d);
+      default:
+         break;
+   }
+   return -1;
+}