New upstream version 3.3.0

9 files changed, 817 insertions, 703 deletions

diff --git a/freebsd/FreeBSDMachine.c b/freebsd/FreeBSDMachine.c
new file mode 100644
index 0000000..d781414
--- /dev/null
+++ b/freebsd/FreeBSDMachine.c
@@ -0,0 +1,393 @@
+/*
+htop - FreeBSDMachine.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPLv2+, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h" // IWYU pragma: keep
+
+#include "freebsd/FreeBSDMachine.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/_iovec.h>
+#include <sys/errno.h>
+#include <sys/param.h> // needs to be included before <sys/jail.h> for MAXPATHLEN
+#include <sys/jail.h>
+#include <sys/priority.h>
+#include <sys/proc.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/vmmeter.h>
+
+#include "CRT.h"
+#include "Compat.h"
+#include "Macros.h"
+#include "Object.h"
+#include "Scheduling.h"
+#include "Settings.h"
+#include "XUtils.h"
+#include "generic/openzfs_sysctl.h"
+#include "zfs/ZfsArcStats.h"
+
+
+static int MIB_hw_physmem[2];
+static int MIB_vm_stats_vm_v_page_count[4];
+
+static int MIB_vm_stats_vm_v_wire_count[4];
+static int MIB_vm_stats_vm_v_active_count[4];
+static int MIB_vm_stats_vm_v_cache_count[4];
+static int MIB_vm_stats_vm_v_inactive_count[4];
+static int MIB_vm_stats_vm_v_free_count[4];
+static int MIB_vm_vmtotal[2];
+
+static int MIB_vfs_bufspace[2];
+
+static int MIB_kern_cp_time[2];
+static int MIB_kern_cp_times[2];
+
+Machine* Machine_new(UsersTable* usersTable, uid_t userId) {
+   FreeBSDMachine* this = xCalloc(1, sizeof(FreeBSDMachine));
+   Machine* super = &this->super;
+   char errbuf[_POSIX2_LINE_MAX];
+   size_t len;
+
+   Machine_init(super, usersTable, userId);
+
+   // physical memory in system: hw.physmem
+   // physical page size: hw.pagesize
+   // usable pagesize : vm.stats.vm.v_page_size
+   len = 2; sysctlnametomib("hw.physmem", MIB_hw_physmem, &len);
+
+   len = sizeof(this->pageSize);
+   if (sysctlbyname("vm.stats.vm.v_page_size", &this->pageSize, &len, NULL, 0) == -1)
+      CRT_fatalError("Cannot get pagesize by sysctl");
+   this->pageSizeKb = this->pageSize / ONE_K;
+
+   // usable page count vm.stats.vm.v_page_count
+   // actually usable memory : vm.stats.vm.v_page_count * vm.stats.vm.v_page_size
+   len = 4; sysctlnametomib("vm.stats.vm.v_page_count", MIB_vm_stats_vm_v_page_count, &len);
+
+   len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", MIB_vm_stats_vm_v_wire_count, &len);
+   len = 4; sysctlnametomib("vm.stats.vm.v_active_count", MIB_vm_stats_vm_v_active_count, &len);
+   len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len);
+   len = 4; sysctlnametomib("vm.stats.vm.v_inactive_count", MIB_vm_stats_vm_v_inactive_count, &len);
+   len = 4; sysctlnametomib("vm.stats.vm.v_free_count", MIB_vm_stats_vm_v_free_count, &len);
+   len = 2; sysctlnametomib("vm.vmtotal", MIB_vm_vmtotal, &len);
+
+   len = 2; sysctlnametomib("vfs.bufspace", MIB_vfs_bufspace, &len);
+
+   openzfs_sysctl_init(&this->zfs);
+   openzfs_sysctl_updateArcStats(&this->zfs);
+
+   int smp = 0;
+   len = sizeof(smp);
+
+   if (sysctlbyname("kern.smp.active", &smp, &len, NULL, 0) != 0 || len != sizeof(smp)) {
+      smp = 0;
+   }
+
+   int cpus = 1;
+   len = sizeof(cpus);
+
+   if (smp) {
+      int err = sysctlbyname("kern.smp.cpus", &cpus, &len, NULL, 0);
+      if (err) {
+         cpus = 1;
+      }
+   } else {
+      cpus = 1;
+   }
+
+   size_t sizeof_cp_time_array = sizeof(unsigned long) * CPUSTATES;
+   len = 2; sysctlnametomib("kern.cp_time", MIB_kern_cp_time, &len);
+   this->cp_time_o = xCalloc(CPUSTATES, sizeof(unsigned long));
+   this->cp_time_n = xCalloc(CPUSTATES, sizeof(unsigned long));
+   len = sizeof_cp_time_array;
+
+   // fetch initial single (or average) CPU clicks from kernel
+   sysctl(MIB_kern_cp_time, 2, this->cp_time_o, &len, NULL, 0);
+
+   // on smp box, fetch rest of initial CPU's clicks
+   if (cpus > 1) {
+      len = 2; sysctlnametomib("kern.cp_times", MIB_kern_cp_times, &len);
+      this->cp_times_o = xCalloc(cpus, sizeof_cp_time_array);
+      this->cp_times_n = xCalloc(cpus, sizeof_cp_time_array);
+      len = cpus * sizeof_cp_time_array;
+      sysctl(MIB_kern_cp_times, 2, this->cp_times_o, &len, NULL, 0);
+   }
+
+   super->existingCPUs = MAXIMUM(cpus, 1);
+   // TODO: support offline CPUs and hot swapping
+   super->activeCPUs = super->existingCPUs;
+
+   if (cpus == 1 ) {
+      this->cpus = xRealloc(this->cpus, sizeof(CPUData));
+   } else {
+      // on smp we need CPUs + 1 to store averages too (as kernel kindly provides that as well)
+      this->cpus = xRealloc(this->cpus, (super->existingCPUs + 1) * sizeof(CPUData));
+   }
+
+   len = sizeof(this->kernelFScale);
+   if (sysctlbyname("kern.fscale", &this->kernelFScale, &len, NULL, 0) == -1 || this->kernelFScale <= 0) {
+      //sane default for kernel provided CPU percentage scaling, at least on x86 machines, in case this sysctl call failed
+      this->kernelFScale = 2048;
+   }
+
+   this->kd = kvm_openfiles(NULL, "/dev/null", NULL, 0, errbuf);
+   if (this->kd == NULL) {
+      CRT_fatalError("kvm_openfiles() failed");
+   }
+
+   return super;
+}
+
+void Machine_delete(Machine* super) {
+   FreeBSDMachine* this = (FreeBSDMachine*) super;
+
+   Machine_done(super);
+
+   if (this->kd) {
+      kvm_close(this->kd);
+   }
+
+   free(this->cp_time_o);
+   free(this->cp_time_n);
+   free(this->cp_times_o);
+   free(this->cp_times_n);
+   free(this->cpus);
+
+   free(this);
+}
+
+static inline void FreeBSDMachine_scanCPU(Machine* super) {
+   const FreeBSDMachine* this = (FreeBSDMachine*) super;
+
+   unsigned int cpus   = super->existingCPUs; // actual CPU count
+   unsigned int maxcpu = cpus;             // max iteration (in case we have average + smp)
+   int cp_times_offset;
+
+   assert(cpus > 0);
+
+   size_t sizeof_cp_time_array;
+
+   unsigned long* cp_time_n; // old clicks state
+   unsigned long* cp_time_o; // current clicks state
+
+   unsigned long cp_time_d[CPUSTATES];
+   double        cp_time_p[CPUSTATES];
+
+   // get averages or single CPU clicks
+   sizeof_cp_time_array = sizeof(unsigned long) * CPUSTATES;
+   sysctl(MIB_kern_cp_time, 2, this->cp_time_n, &sizeof_cp_time_array, NULL, 0);
+
+   // get rest of CPUs
+   if (cpus > 1) {
+      // on smp systems FreeBSD kernel concats all CPU states into one long array in
+      // kern.cp_times sysctl OID
+      // we store averages in this->cpus[0], and actual cores after that
+      maxcpu = cpus + 1;
+      sizeof_cp_time_array = cpus * sizeof(unsigned long) * CPUSTATES;
+      sysctl(MIB_kern_cp_times, 2, this->cp_times_n, &sizeof_cp_time_array, NULL, 0);
+   }
+
+   for (unsigned int i = 0; i < maxcpu; i++) {
+      if (cpus == 1) {
+         // single CPU box
+         cp_time_n = this->cp_time_n;
+         cp_time_o = this->cp_time_o;
+      } else {
+         if (i == 0 ) {
+            // average
+            cp_time_n = this->cp_time_n;
+            cp_time_o = this->cp_time_o;
+         } else {
+            // specific smp cores
+            cp_times_offset = i - 1;
+            cp_time_n = this->cp_times_n + (cp_times_offset * CPUSTATES);
+            cp_time_o = this->cp_times_o + (cp_times_offset * CPUSTATES);
+         }
+      }
+
+      // diff old vs new
+      unsigned long long total_o = 0;
+      unsigned long long total_n = 0;
+      unsigned long long total_d = 0;
+      for (int s = 0; s < CPUSTATES; s++) {
+         cp_time_d[s] = cp_time_n[s] - cp_time_o[s];
+         total_o += cp_time_o[s];
+         total_n += cp_time_n[s];
+      }
+
+      // totals
+      total_d = total_n - total_o;
+      if (total_d < 1 ) {
+         total_d = 1;
+      }
+
+      // save current state as old and calc percentages
+      for (int s = 0; s < CPUSTATES; ++s) {
+         cp_time_o[s] = cp_time_n[s];
+         cp_time_p[s] = ((double)cp_time_d[s]) / ((double)total_d) * 100;
+      }
+
+      CPUData* cpuData = &(this->cpus[i]);
+      cpuData->userPercent      = cp_time_p[CP_USER];
+      cpuData->nicePercent      = cp_time_p[CP_NICE];
+      cpuData->systemPercent    = cp_time_p[CP_SYS];
+      cpuData->irqPercent       = cp_time_p[CP_INTR];
+      cpuData->systemAllPercent = cp_time_p[CP_SYS] + cp_time_p[CP_INTR];
+      // this one is not really used
+      //cpuData->idlePercent      = cp_time_p[CP_IDLE];
+
+      cpuData->temperature = NAN;
+      cpuData->frequency = NAN;
+
+      const int coreId = (cpus == 1) ? 0 : ((int)i - 1);
+      if (coreId < 0)
+         continue;
+
+      // TODO: test with hyperthreading and multi-cpu systems
+      if (super->settings->showCPUTemperature) {
+         int temperature;
+         size_t len = sizeof(temperature);
+         char mibBuffer[32];
+         xSnprintf(mibBuffer, sizeof(mibBuffer), "dev.cpu.%d.temperature", coreId);
+         int r = sysctlbyname(mibBuffer, &temperature, &len, NULL, 0);
+         if (r == 0)
+            cpuData->temperature = (double)(temperature - 2732) / 10.0; // convert from deci-Kelvin to Celsius
+      }
+
+      // TODO: test with hyperthreading and multi-cpu systems
+      if (super->settings->showCPUFrequency) {
+         int frequency;
+         size_t len = sizeof(frequency);
+         char mibBuffer[32];
+         xSnprintf(mibBuffer, sizeof(mibBuffer), "dev.cpu.%d.freq", coreId);
+         int r = sysctlbyname(mibBuffer, &frequency, &len, NULL, 0);
+         if (r == 0)
+            cpuData->frequency = frequency; // keep in MHz
+      }
+   }
+
+   // calculate max temperature and avg frequency for average meter and
+   // propagate frequency to all cores if only supplied for CPU 0
+   if (cpus > 1) {
+      if (super->settings->showCPUTemperature) {
+         double maxTemp = -HUGE_VAL;
+         for (unsigned int i = 1; i < maxcpu; i++) {
+            if (isgreater(this->cpus[i].temperature, maxTemp)) {
+               maxTemp = this->cpus[i].temperature;
+               this->cpus[0].temperature = maxTemp;
+            }
+         }
+      }
+
+      if (super->settings->showCPUFrequency) {
+         const double coreZeroFreq = this->cpus[1].frequency;
+         double freqSum = coreZeroFreq;
+         if (isNonnegative(coreZeroFreq)) {
+            for (unsigned int i = 2; i < maxcpu; i++) {
+               if (!isNonnegative(this->cpus[i].frequency))
+                  this->cpus[i].frequency = coreZeroFreq;
+
+               freqSum += this->cpus[i].frequency;
+            }
+
+            this->cpus[0].frequency = freqSum / (maxcpu - 1);
+         }
+      }
+   }
+}
+
+static void FreeBSDMachine_scanMemoryInfo(Machine* super) {
+   FreeBSDMachine* this = (FreeBSDMachine*) super;
+
+   // @etosan:
+   // memory counter relationships seem to be these:
+   //  total = active + wired + inactive + cache + free
+   //  htop_used (unavail to anybody) = active + wired
+   //  htop_cache (for cache meter)   = buffers + cache
+   //  user_free (avail to procs)     = buffers + inactive + cache + free
+   //
+   // with ZFS ARC situation becomes bit muddled, as ARC behaves like "user_free"
+   // and belongs into cache, but is reported as wired by kernel
+   //
+   // htop_used   = active + (wired - arc)
+   // htop_cache  = buffers + cache + arc
+   u_long totalMem;
+   u_int memActive, memWire, cachedMem;
+   long buffersMem;
+   size_t len;
+   struct vmtotal vmtotal;
+
+   //disabled for now, as it is always smaller than phycal amount of memory...
+   //...to avoid "where is my memory?" questions
+   //sysctl(MIB_vm_stats_vm_v_page_count, 4, &(super->totalMem), &len, NULL, 0);
+   //super->totalMem *= this->pageSizeKb;
+   len = sizeof(totalMem);
+   sysctl(MIB_hw_physmem, 2, &(totalMem), &len, NULL, 0);
+   totalMem /= 1024;
+   super->totalMem = totalMem;
+
+   len = sizeof(memActive);
+   sysctl(MIB_vm_stats_vm_v_active_count, 4, &(memActive), &len, NULL, 0);
+   memActive *= this->pageSizeKb;
+   this->memActive = memActive;
+
+   len = sizeof(memWire);
+   sysctl(MIB_vm_stats_vm_v_wire_count, 4, &(memWire), &len, NULL, 0);
+   memWire *= this->pageSizeKb;
+   this->memWire = memWire;
+
+   len = sizeof(buffersMem);
+   sysctl(MIB_vfs_bufspace, 2, &(buffersMem), &len, NULL, 0);
+   buffersMem /= 1024;
+   super->buffersMem = buffersMem;
+
+   len = sizeof(cachedMem);
+   sysctl(MIB_vm_stats_vm_v_cache_count, 4, &(cachedMem), &len, NULL, 0);
+   cachedMem *= this->pageSizeKb;
+   super->cachedMem = cachedMem;
+
+   len = sizeof(vmtotal);
+   sysctl(MIB_vm_vmtotal, 2, &(vmtotal), &len, NULL, 0);
+   super->sharedMem = vmtotal.t_rmshr * this->pageSizeKb;
+
+   super->usedMem = this->memActive + this->memWire;
+
+   struct kvm_swap swap[16];
+   int nswap = kvm_getswapinfo(this->kd, swap, ARRAYSIZE(swap), 0);
+   super->totalSwap = 0;
+   super->usedSwap = 0;
+   for (int i = 0; i < nswap; i++) {
+      super->totalSwap += swap[i].ksw_total;
+      super->usedSwap += swap[i].ksw_used;
+   }
+   super->totalSwap *= this->pageSizeKb;
+   super->usedSwap *= this->pageSizeKb;
+}
+
+void Machine_scan(Machine* super) {
+   FreeBSDMachine* this = (FreeBSDMachine*) super;
+
+   openzfs_sysctl_updateArcStats(&this->zfs);
+   FreeBSDMachine_scanMemoryInfo(super);
+   FreeBSDMachine_scanCPU(super);
+}
+
+bool Machine_isCPUonline(const Machine* host, unsigned int id) {
+   assert(id < host->existingCPUs);
+
+   // TODO: support offline CPUs and hot swapping
+   (void) host; (void) id;
+
+   return true;
+}
diff --git a/freebsd/FreeBSDProcessList.h b/freebsd/FreeBSDMachine.h
index adc70e4..f34b568 100644
--- a/freebsd/FreeBSDProcessList.h
+++ b/freebsd/FreeBSDMachine.h
@@ -1,7 +1,7 @@
-#ifndef HEADER_FreeBSDProcessList
-#define HEADER_FreeBSDProcessList
+#ifndef HEADER_FreeBSDMachine
+#define HEADER_FreeBSDMachine
 /*
-htop - FreeBSDProcessList.h
+htop - FreeBSDMachine.h
 (C) 2014 Hisham H. Muhammad
 Released under the GNU GPLv2+, see the COPYING file
 in the source distribution for its full text.
@@ -12,7 +12,7 @@ in the source distribution for its full text.
 #include <sys/types.h>
 
 #include "Hashtable.h"
-#include "ProcessList.h"
+#include "Machine.h"
 #include "UsersTable.h"
 #include "zfs/ZfsArcStats.h"
 
@@ -28,10 +28,14 @@ typedef struct CPUData_ {
    double temperature;
 } CPUData;
 
-typedef struct FreeBSDProcessList_ {
-   ProcessList super;
+typedef struct FreeBSDMachine_ {
+   Machine super;
    kvm_t* kd;
 
+   int pageSize;
+   int pageSizeKb;
+   int kernelFScale;
+
    unsigned long long int memWire;
    unsigned long long int memActive;
 
@@ -45,14 +49,6 @@ typedef struct FreeBSDProcessList_ {
    unsigned long* cp_times_o;
    unsigned long* cp_times_n;
 
-} FreeBSDProcessList;
-
-ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, Hashtable* dynamicColumns, Hashtable* pidMatchList, uid_t userId);
-
-void ProcessList_delete(ProcessList* this);
-
-void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate);
-
-bool ProcessList_isCPUonline(const ProcessList* super, unsigned int id);
+} FreeBSDMachine;
 
 #endif
diff --git a/freebsd/FreeBSDProcess.c b/freebsd/FreeBSDProcess.c
index 4eccfe7..e7582a7 100644
--- a/freebsd/FreeBSDProcess.c
+++ b/freebsd/FreeBSDProcess.c
@@ -5,6 +5,8 @@ Released under the GNU GPLv2+, see the COPYING file
 in the source distribution for its full text.
 */
 
+#include "config.h" // IWYU pragma: keep
+
 #include "freebsd/FreeBSDProcess.h"
 
 #include <stdlib.h>
@@ -13,6 +15,7 @@ in the source distribution for its full text.
 #include "Macros.h"
 #include "Process.h"
 #include "RichString.h"
+#include "Scheduling.h"
 #include "XUtils.h"
 
 
@@ -47,15 +50,18 @@ const ProcessFieldData Process_fields[LAST_PROCESSFIELD] = {
    [PROC_COMM] = { .name = "COMM", .title = "COMM            ", .description = "comm string of the process", .flags = 0, },
    [PROC_EXE] = { .name = "EXE", .title = "EXE             ", .description = "Basename of exe of the process", .flags = 0, },
    [CWD] = { .name = "CWD", .title = "CWD                       ", .description = "The current working directory of the process", .flags = PROCESS_FLAG_CWD, },
+#ifdef SCHEDULER_SUPPORT
+   [SCHEDULERPOLICY] = { .name = "SCHEDULERPOLICY", .title = "SCHED ", .description = "Current scheduling policy of the process", .flags = PROCESS_FLAG_SCHEDPOL, },
+#endif
    [JID] = { .name = "JID", .title = "JID", .description = "Jail prison ID", .flags = 0, .pidColumn = true, },
    [JAIL] = { .name = "JAIL", .title = "JAIL        ", .description = "Jail prison name", .flags = 0, },
    [EMULATION] = { .name = "EMULATION", .title = "EMULATION        ", .description = "System call emulation environment (ABI)", .flags = 0, },
 };
 
-Process* FreeBSDProcess_new(const Settings* settings) {
+Process* FreeBSDProcess_new(const Machine* machine) {
    FreeBSDProcess* this = xCalloc(1, sizeof(FreeBSDProcess));
    Object_setClass(this, Class(FreeBSDProcess));
-   Process_init(&this->super, settings);
+   Process_init(&this->super, machine);
    return &this->super;
 }
 
@@ -67,25 +73,27 @@ void Process_delete(Object* cast) {
    free(this);
 }
 
-static void FreeBSDProcess_writeField(const Process* this, RichString* str, ProcessField field) {
-   const FreeBSDProcess* fp = (const FreeBSDProcess*) this;
-   char buffer[256];
-   size_t n = sizeof(buffer);
+static void FreeBSDProcess_rowWriteField(const Row* super, RichString* str, ProcessField field) {
+   const FreeBSDProcess* fp = (const FreeBSDProcess*) super;
+
+   char buffer[256]; buffer[255] = '\0';
    int attr = CRT_colors[DEFAULT_COLOR];
+   size_t n = sizeof(buffer) - 1;
 
    switch (field) {
    // add FreeBSD-specific fields here
    case JID: xSnprintf(buffer, n, "%*d ", Process_pidDigits, fp->jid); break;
    case JAIL:
-      Process_printLeftAlignedField(str, attr, fp->jname ? fp->jname : "N/A", 11);
+      Row_printLeftAlignedField(str, attr, fp->jname ? fp->jname : "N/A", 11);
       return;
    case EMULATION:
-      Process_printLeftAlignedField(str, attr, fp->emul ? fp->emul : "N/A", 16);
+      Row_printLeftAlignedField(str, attr, fp->emul ? fp->emul : "N/A", 16);
       return;
    default:
-      Process_writeField(this, str, field);
+      Process_writeField(&fp->super, str, field);
       return;
    }
+
    RichString_appendWide(str, attr, buffer);
 }
 
@@ -108,11 +116,18 @@ static int FreeBSDProcess_compareByKey(const Process* v1, const Process* v2, Pro
 
 const ProcessClass FreeBSDProcess_class = {
    .super = {
-      .extends = Class(Process),
-      .display = Process_display,
-      .delete = Process_delete,
-      .compare = Process_compare
+      .super = {
+         .extends = Class(Process),
+         .display = Row_display,
+         .delete = Process_delete,
+         .compare = Process_compare
+      },
+      .isHighlighted = Process_rowIsHighlighted,
+      .isVisible = Process_rowIsVisible,
+      .matchesFilter = Process_rowMatchesFilter,
+      .compareByParent = Process_compareByParent,
+      .sortKeyString = Process_rowGetSortKey,
+      .writeField = FreeBSDProcess_rowWriteField
    },
-   .writeField = FreeBSDProcess_writeField,
    .compareByKey = FreeBSDProcess_compareByKey
 };
diff --git a/freebsd/FreeBSDProcess.h b/freebsd/FreeBSDProcess.h
index 654f9cf..012cfa2 100644
--- a/freebsd/FreeBSDProcess.h
+++ b/freebsd/FreeBSDProcess.h
@@ -11,7 +11,7 @@ in the source distribution for its full text.
 
 #include "Object.h"
 #include "Process.h"
-#include "Settings.h"
+#include "Machine.h"
 
 
 typedef struct FreeBSDProcess_ {
@@ -25,7 +25,7 @@ extern const ProcessClass FreeBSDProcess_class;
 
 extern const ProcessFieldData Process_fields[LAST_PROCESSFIELD];
 
-Process* FreeBSDProcess_new(const Settings* settings);
+Process* FreeBSDProcess_new(const Machine* host);
 
 void Process_delete(Object* cast);
 
diff --git a/freebsd/FreeBSDProcessList.c b/freebsd/FreeBSDProcessList.c
deleted file mode 100644
index f58f338..0000000
--- a/freebsd/FreeBSDProcessList.c
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
-htop - FreeBSDProcessList.c
-(C) 2014 Hisham H. Muhammad
-Released under the GNU GPLv2+, see the COPYING file
-in the source distribution for its full text.
-*/
-
-#include "config.h" // IWYU pragma: keep
-
-#include "freebsd/FreeBSDProcessList.h"
-
-#include <assert.h>
-#include <limits.h>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/_iovec.h>
-#include <sys/errno.h>
-#include <sys/param.h> // needs to be included before <sys/jail.h> for MAXPATHLEN
-#include <sys/jail.h>
-#include <sys/priority.h>
-#include <sys/proc.h>
-#include <sys/resource.h>
-#include <sys/sysctl.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/user.h>
-
-#include "CRT.h"
-#include "Compat.h"
-#include "FreeBSDProcess.h"
-#include "Macros.h"
-#include "Object.h"
-#include "Process.h"
-#include "ProcessList.h"
-#include "Settings.h"
-#include "XUtils.h"
-#include "generic/openzfs_sysctl.h"
-#include "zfs/ZfsArcStats.h"
-
-
-static int MIB_hw_physmem[2];
-static int MIB_vm_stats_vm_v_page_count[4];
-static int pageSize;
-static int pageSizeKb;
-
-static int MIB_vm_stats_vm_v_wire_count[4];
-static int MIB_vm_stats_vm_v_active_count[4];
-static int MIB_vm_stats_vm_v_cache_count[4];
-static int MIB_vm_stats_vm_v_inactive_count[4];
-static int MIB_vm_stats_vm_v_free_count[4];
-
-static int MIB_vfs_bufspace[2];
-
-static int MIB_kern_cp_time[2];
-static int MIB_kern_cp_times[2];
-static int kernelFScale;
-
-ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, Hashtable* DynamicColumns, Hashtable* pidMatchList, uid_t userId) {
-   size_t len;
-   char errbuf[_POSIX2_LINE_MAX];
-   FreeBSDProcessList* fpl = xCalloc(1, sizeof(FreeBSDProcessList));
-   ProcessList* pl = (ProcessList*) fpl;
-   ProcessList_init(pl, Class(FreeBSDProcess), usersTable, dynamicMeters, DynamicColumns, pidMatchList, userId);
-
-   // physical memory in system: hw.physmem
-   // physical page size: hw.pagesize
-   // usable pagesize : vm.stats.vm.v_page_size
-   len = 2; sysctlnametomib("hw.physmem", MIB_hw_physmem, &len);
-
-   len = sizeof(pageSize);
-   if (sysctlbyname("vm.stats.vm.v_page_size", &pageSize, &len, NULL, 0) == -1)
-      CRT_fatalError("Cannot get pagesize by sysctl");
-   pageSizeKb = pageSize / ONE_K;
-
-   // usable page count vm.stats.vm.v_page_count
-   // actually usable memory : vm.stats.vm.v_page_count * vm.stats.vm.v_page_size
-   len = 4; sysctlnametomib("vm.stats.vm.v_page_count", MIB_vm_stats_vm_v_page_count, &len);
-
-   len = 4; sysctlnametomib("vm.stats.vm.v_wire_count", MIB_vm_stats_vm_v_wire_count, &len);
-   len = 4; sysctlnametomib("vm.stats.vm.v_active_count", MIB_vm_stats_vm_v_active_count, &len);
-   len = 4; sysctlnametomib("vm.stats.vm.v_cache_count", MIB_vm_stats_vm_v_cache_count, &len);
-   len = 4; sysctlnametomib("vm.stats.vm.v_inactive_count", MIB_vm_stats_vm_v_inactive_count, &len);
-   len = 4; sysctlnametomib("vm.stats.vm.v_free_count", MIB_vm_stats_vm_v_free_count, &len);
-
-   len = 2; sysctlnametomib("vfs.bufspace", MIB_vfs_bufspace, &len);
-
-   openzfs_sysctl_init(&fpl->zfs);
-   openzfs_sysctl_updateArcStats(&fpl->zfs);
-
-   int smp = 0;
-   len = sizeof(smp);
-
-   if (sysctlbyname("kern.smp.active", &smp, &len, NULL, 0) != 0 || len != sizeof(smp)) {
-      smp = 0;
-   }
-
-   int cpus = 1;
-   len = sizeof(cpus);
-
-   if (smp) {
-      int err = sysctlbyname("kern.smp.cpus", &cpus, &len, NULL, 0);
-      if (err) {
-         cpus = 1;
-      }
-   } else {
-      cpus = 1;
-   }
-
-   size_t sizeof_cp_time_array = sizeof(unsigned long) * CPUSTATES;
-   len = 2; sysctlnametomib("kern.cp_time", MIB_kern_cp_time, &len);
-   fpl->cp_time_o = xCalloc(CPUSTATES, sizeof(unsigned long));
-   fpl->cp_time_n = xCalloc(CPUSTATES, sizeof(unsigned long));
-   len = sizeof_cp_time_array;
-
-   // fetch initial single (or average) CPU clicks from kernel
-   sysctl(MIB_kern_cp_time, 2, fpl->cp_time_o, &len, NULL, 0);
-
-   // on smp box, fetch rest of initial CPU's clicks
-   if (cpus > 1) {
-      len = 2; sysctlnametomib("kern.cp_times", MIB_kern_cp_times, &len);
-      fpl->cp_times_o = xCalloc(cpus, sizeof_cp_time_array);
-      fpl->cp_times_n = xCalloc(cpus, sizeof_cp_time_array);
-      len = cpus * sizeof_cp_time_array;
-      sysctl(MIB_kern_cp_times, 2, fpl->cp_times_o, &len, NULL, 0);
-   }
-
-   pl->existingCPUs = MAXIMUM(cpus, 1);
-   // TODO: support offline CPUs and hot swapping
-   pl->activeCPUs = pl->existingCPUs;
-
-   if (cpus == 1 ) {
-      fpl->cpus = xRealloc(fpl->cpus, sizeof(CPUData));
-   } else {
-      // on smp we need CPUs + 1 to store averages too (as kernel kindly provides that as well)
-      fpl->cpus = xRealloc(fpl->cpus, (pl->existingCPUs + 1) * sizeof(CPUData));
-   }
-
-
-   len = sizeof(kernelFScale);
-   if (sysctlbyname("kern.fscale", &kernelFScale, &len, NULL, 0) == -1) {
-      //sane default for kernel provided CPU percentage scaling, at least on x86 machines, in case this sysctl call failed
-      kernelFScale = 2048;
-   }
-
-   fpl->kd = kvm_openfiles(NULL, "/dev/null", NULL, 0, errbuf);
-   if (fpl->kd == NULL) {
-      CRT_fatalError("kvm_openfiles() failed");
-   }
-
-   return pl;
-}
-
-void ProcessList_delete(ProcessList* this) {
-   const FreeBSDProcessList* fpl = (FreeBSDProcessList*) this;
-
-   if (fpl->kd) {
-      kvm_close(fpl->kd);
-   }
-
-   free(fpl->cp_time_o);
-   free(fpl->cp_time_n);
-   free(fpl->cp_times_o);
-   free(fpl->cp_times_n);
-   free(fpl->cpus);
-
-   ProcessList_done(this);
-   free(this);
-}
-
-static inline void FreeBSDProcessList_scanCPU(ProcessList* pl) {
-   const FreeBSDProcessList* fpl = (FreeBSDProcessList*) pl;
-
-   unsigned int cpus   = pl->existingCPUs; // actual CPU count
-   unsigned int maxcpu = cpus;             // max iteration (in case we have average + smp)
-   int cp_times_offset;
-
-   assert(cpus > 0);
-
-   size_t sizeof_cp_time_array;
-
-   unsigned long* cp_time_n; // old clicks state
-   unsigned long* cp_time_o; // current clicks state
-
-   unsigned long cp_time_d[CPUSTATES];
-   double        cp_time_p[CPUSTATES];
-
-   // get averages or single CPU clicks
-   sizeof_cp_time_array = sizeof(unsigned long) * CPUSTATES;
-   sysctl(MIB_kern_cp_time, 2, fpl->cp_time_n, &sizeof_cp_time_array, NULL, 0);
-
-   // get rest of CPUs
-   if (cpus > 1) {
-      // on smp systems FreeBSD kernel concats all CPU states into one long array in
-      // kern.cp_times sysctl OID
-      // we store averages in fpl->cpus[0], and actual cores after that
-      maxcpu = cpus + 1;
-      sizeof_cp_time_array = cpus * sizeof(unsigned long) * CPUSTATES;
-      sysctl(MIB_kern_cp_times, 2, fpl->cp_times_n, &sizeof_cp_time_array, NULL, 0);
-   }
-
-   for (unsigned int i = 0; i < maxcpu; i++) {
-      if (cpus == 1) {
-         // single CPU box
-         cp_time_n = fpl->cp_time_n;
-         cp_time_o = fpl->cp_time_o;
-      } else {
-         if (i == 0 ) {
-            // average
-            cp_time_n = fpl->cp_time_n;
-            cp_time_o = fpl->cp_time_o;
-         } else {
-            // specific smp cores
-            cp_times_offset = i - 1;
-            cp_time_n = fpl->cp_times_n + (cp_times_offset * CPUSTATES);
-            cp_time_o = fpl->cp_times_o + (cp_times_offset * CPUSTATES);
-         }
-      }
-
-      // diff old vs new
-      unsigned long long total_o = 0;
-      unsigned long long total_n = 0;
-      unsigned long long total_d = 0;
-      for (int s = 0; s < CPUSTATES; s++) {
-         cp_time_d[s] = cp_time_n[s] - cp_time_o[s];
-         total_o += cp_time_o[s];
-         total_n += cp_time_n[s];
-      }
-
-      // totals
-      total_d = total_n - total_o;
-      if (total_d < 1 ) {
-         total_d = 1;
-      }
-
-      // save current state as old and calc percentages
-      for (int s = 0; s < CPUSTATES; ++s) {
-         cp_time_o[s] = cp_time_n[s];
-         cp_time_p[s] = ((double)cp_time_d[s]) / ((double)total_d) * 100;
-      }
-
-      CPUData* cpuData = &(fpl->cpus[i]);
-      cpuData->userPercent      = cp_time_p[CP_USER];
-      cpuData->nicePercent      = cp_time_p[CP_NICE];
-      cpuData->systemPercent    = cp_time_p[CP_SYS];
-      cpuData->irqPercent       = cp_time_p[CP_INTR];
-      cpuData->systemAllPercent = cp_time_p[CP_SYS] + cp_time_p[CP_INTR];
-      // this one is not really used
-      //cpuData->idlePercent      = cp_time_p[CP_IDLE];
-
-      cpuData->temperature = NAN;
-      cpuData->frequency = NAN;
-
-      const int coreId = (cpus == 1) ? 0 : ((int)i - 1);
-      if (coreId < 0)
-         continue;
-
-      // TODO: test with hyperthreading and multi-cpu systems
-      if (pl->settings->showCPUTemperature) {
-         int temperature;
-         size_t len = sizeof(temperature);
-         char mibBuffer[32];
-         xSnprintf(mibBuffer, sizeof(mibBuffer), "dev.cpu.%d.temperature", coreId);
-         int r = sysctlbyname(mibBuffer, &temperature, &len, NULL, 0);
-         if (r == 0)
-            cpuData->temperature = (double)(temperature - 2732) / 10.0; // convert from deci-Kelvin to Celsius
-      }
-
-      // TODO: test with hyperthreading and multi-cpu systems
-      if (pl->settings->showCPUFrequency) {
-         int frequency;
-         size_t len = sizeof(frequency);
-         char mibBuffer[32];
-         xSnprintf(mibBuffer, sizeof(mibBuffer), "dev.cpu.%d.freq", coreId);
-         int r = sysctlbyname(mibBuffer, &frequency, &len, NULL, 0);
-         if (r == 0)
-            cpuData->frequency = frequency; // keep in MHz
-      }
-   }
-
-   // calculate max temperature and avg frequency for average meter and
-   // propagate frequency to all cores if only supplied for CPU 0
-   if (cpus > 1) {
-      if (pl->settings->showCPUTemperature) {
-         double maxTemp = NAN;
-         for (unsigned int i = 1; i < maxcpu; i++) {
-            const double coreTemp = fpl->cpus[i].temperature;
-            if (isnan(coreTemp))
-               continue;
-
-            maxTemp = MAXIMUM(maxTemp, coreTemp);
-         }
-
-         fpl->cpus[0].temperature = maxTemp;
-      }
-
-      if (pl->settings->showCPUFrequency) {
-         const double coreZeroFreq = fpl->cpus[1].frequency;
-         double freqSum = coreZeroFreq;
-         if (!isnan(coreZeroFreq)) {
-            for (unsigned int i = 2; i < maxcpu; i++) {
-               if (isnan(fpl->cpus[i].frequency))
-                  fpl->cpus[i].frequency = coreZeroFreq;
-
-               freqSum += fpl->cpus[i].frequency;
-            }
-
-            fpl->cpus[0].frequency = freqSum / (maxcpu - 1);
-         }
-      }
-   }
-}
-
-static inline void FreeBSDProcessList_scanMemoryInfo(ProcessList* pl) {
-   FreeBSDProcessList* fpl = (FreeBSDProcessList*) pl;
-
-   // @etosan:
-   // memory counter relationships seem to be these:
-   //  total = active + wired + inactive + cache + free
-   //  htop_used (unavail to anybody) = active + wired
-   //  htop_cache (for cache meter)   = buffers + cache
-   //  user_free (avail to procs)     = buffers + inactive + cache + free
-   //
-   // with ZFS ARC situation becomes bit muddled, as ARC behaves like "user_free"
-   // and belongs into cache, but is reported as wired by kernel
-   //
-   // htop_used   = active + (wired - arc)
-   // htop_cache  = buffers + cache + arc
-   u_long totalMem;
-   u_int memActive, memWire, cachedMem;
-   long buffersMem;
-   size_t len;
-
-   //disabled for now, as it is always smaller than phycal amount of memory...
-   //...to avoid "where is my memory?" questions
-   //sysctl(MIB_vm_stats_vm_v_page_count, 4, &(pl->totalMem), &len, NULL, 0);
-   //pl->totalMem *= pageSizeKb;
-   len = sizeof(totalMem);
-   sysctl(MIB_hw_physmem, 2, &(totalMem), &len, NULL, 0);
-   totalMem /= 1024;
-   pl->totalMem = totalMem;
-
-   len = sizeof(memActive);
-   sysctl(MIB_vm_stats_vm_v_active_count, 4, &(memActive), &len, NULL, 0);
-   memActive *= pageSizeKb;
-   fpl->memActive = memActive;
-
-   len = sizeof(memWire);
-   sysctl(MIB_vm_stats_vm_v_wire_count, 4, &(memWire), &len, NULL, 0);
-   memWire *= pageSizeKb;
-   fpl->memWire = memWire;
-
-   len = sizeof(buffersMem);
-   sysctl(MIB_vfs_bufspace, 2, &(buffersMem), &len, NULL, 0);
-   buffersMem /= 1024;
-   pl->buffersMem = buffersMem;
-
-   len = sizeof(cachedMem);
-   sysctl(MIB_vm_stats_vm_v_cache_count, 4, &(cachedMem), &len, NULL, 0);
-   cachedMem *= pageSizeKb;
-   pl->cachedMem = cachedMem;
-
-   if (fpl->zfs.enabled) {
-      fpl->memWire -= fpl->zfs.size;
-      pl->cachedMem += fpl->zfs.size;
-   }
-
-   pl->usedMem = fpl->memActive + fpl->memWire;
-
-   struct kvm_swap swap[16];
-   int nswap = kvm_getswapinfo(fpl->kd, swap, ARRAYSIZE(swap), 0);
-   pl->totalSwap = 0;
-   pl->usedSwap = 0;
-   for (int i = 0; i < nswap; i++) {
-      pl->totalSwap += swap[i].ksw_total;
-      pl->usedSwap += swap[i].ksw_used;
-   }
-   pl->totalSwap *= pageSizeKb;
-   pl->usedSwap *= pageSizeKb;
-}
-
-static void FreeBSDProcessList_updateExe(const struct kinfo_proc* kproc, Process* proc) {
-   if (Process_isKernelThread(proc)) {
-      Process_updateExe(proc, NULL);
-      return;
-   }
-
-   const int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, kproc->ki_pid };
-   char buffer[2048];
-   size_t size = sizeof(buffer);
-   if (sysctl(mib, 4, buffer, &size, NULL, 0) != 0) {
-      Process_updateExe(proc, NULL);
-      return;
-   }
-
-   Process_updateExe(proc, buffer);
-}
-
-static void FreeBSDProcessList_updateCwd(const struct kinfo_proc* kproc, Process* proc) {
-   const int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_CWD, kproc->ki_pid };
-   char buffer[2048];
-   size_t size = sizeof(buffer);
-   if (sysctl(mib, 4, buffer, &size, NULL, 0) != 0) {
-      free(proc->procCwd);
-      proc->procCwd = NULL;
-      return;
-   }
-
-   /* Kernel threads return an empty buffer */
-   if (buffer[0] == '\0') {
-      free(proc->procCwd);
-      proc->procCwd = NULL;
-      return;
-   }
-
-   free_and_xStrdup(&proc->procCwd, buffer);
-}
-
-static void FreeBSDProcessList_updateProcessName(kvm_t* kd, const struct kinfo_proc* kproc, Process* proc) {
-   Process_updateComm(proc, kproc->ki_comm);
-
-   char** argv = kvm_getargv(kd, kproc, 0);
-   if (!argv || !argv[0]) {
-      Process_updateCmdline(proc, kproc->ki_comm, 0, strlen(kproc->ki_comm));
-      return;
-   }
-
-   size_t len = 0;
-   for (int i = 0; argv[i]; i++) {
-      len += strlen(argv[i]) + 1;
-   }
-
-   char* cmdline = xMalloc(len);
-   char* at = cmdline;
-   int end = 0;
-   for (int i = 0; argv[i]; i++) {
-      at = stpcpy(at, argv[i]);
-      if (end == 0) {
-         end = at - cmdline;
-      }
-      *at++ = ' ';
-   }
-   at--;
-   *at = '\0';
-
-   Process_updateCmdline(proc, cmdline, 0, end);
-
-   free(cmdline);
-}
-
-static char* FreeBSDProcessList_readJailName(const struct kinfo_proc* kproc) {
-   if (kproc->ki_jid == 0)
-      return xStrdup("-");
-
-   char jnamebuf[MAXHOSTNAMELEN] = {0};
-   struct iovec jiov[4];
-
-IGNORE_WCASTQUAL_BEGIN
-   *(const void**)&jiov[0].iov_base = "jid";
-   jiov[0].iov_len = sizeof("jid");
-   jiov[1].iov_base = (void*) &kproc->ki_jid;
-   jiov[1].iov_len = sizeof(kproc->ki_jid);
-   *(const void**)&jiov[2].iov_base = "name";
-   jiov[2].iov_len = sizeof("name");
-   jiov[3].iov_base = jnamebuf;
-   jiov[3].iov_len = sizeof(jnamebuf);
-IGNORE_WCASTQUAL_END
-
-   int jid = jail_get(jiov, 4, 0);
-   if (jid == kproc->ki_jid)
-      return xStrdup(jnamebuf);
-
-   return NULL;
-}
-
-void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
-   FreeBSDProcessList* fpl = (FreeBSDProcessList*) super;
-   const Settings* settings = super->settings;
-   bool hideKernelThreads = settings->hideKernelThreads;
-   bool hideUserlandThreads = settings->hideUserlandThreads;
-
-   openzfs_sysctl_updateArcStats(&fpl->zfs);
-   FreeBSDProcessList_scanMemoryInfo(super);
-   FreeBSDProcessList_scanCPU(super);
-
-   // in pause mode only gather global data for meters (CPU/memory/...)
-   if (pauseProcessUpdate) {
-      return;
-   }
-
-   int count = 0;
-   const struct kinfo_proc* kprocs = kvm_getprocs(fpl->kd, KERN_PROC_PROC, 0, &count);
-
-   for (int i = 0; i < count; i++) {
-      const struct kinfo_proc* kproc = &kprocs[i];
-      bool preExisting = false;
-      Process* proc = ProcessList_getProcess(super, kproc->ki_pid, &preExisting, FreeBSDProcess_new);
-      FreeBSDProcess* fp = (FreeBSDProcess*) proc;
-
-      if (!preExisting) {
-         fp->jid = kproc->ki_jid;
-         proc->pid = kproc->ki_pid;
-         proc->isKernelThread = kproc->ki_pid != 1 && (kproc->ki_flag & P_SYSTEM);
-         proc->isUserlandThread = false;
-         proc->ppid = kproc->ki_ppid;
-         proc->tpgid = kproc->ki_tpgid;
-         proc->tgid = kproc->ki_pid;
-         proc->session = kproc->ki_sid;
-         proc->pgrp = kproc->ki_pgid;
-         proc->st_uid = kproc->ki_uid;
-         proc->starttime_ctime = kproc->ki_start.tv_sec;
-         if (proc->starttime_ctime < 0) {
-            proc->starttime_ctime = super->realtimeMs / 1000;
-         }
-         Process_fillStarttimeBuffer(proc);
-         proc->user = UsersTable_getRef(super->usersTable, proc->st_uid);
-         ProcessList_add(super, proc);
-
-         FreeBSDProcessList_updateExe(kproc, proc);
-         FreeBSDProcessList_updateProcessName(fpl->kd, kproc, proc);
-
-         if (settings->ss->flags & PROCESS_FLAG_CWD) {
-            FreeBSDProcessList_updateCwd(kproc, proc);
-         }
-
-         fp->jname = FreeBSDProcessList_readJailName(kproc);
-
-         proc->tty_nr = kproc->ki_tdev;
-         const char* name = (kproc->ki_tdev != NODEV) ? devname(kproc->ki_tdev, S_IFCHR) : NULL;
-         if (!name) {
-            free(proc->tty_name);
-            proc->tty_name = NULL;
-         } else {
-            free_and_xStrdup(&proc->tty_name, name);
-         }
-      } else {
-         if (fp->jid != kproc->ki_jid) {
-            // process can enter jail anytime
-            fp->jid = kproc->ki_jid;
-            free(fp->jname);
-            fp->jname = FreeBSDProcessList_readJailName(kproc);
-         }
-         // if there are reapers in the system, process can get reparented anytime
-         proc->ppid = kproc->ki_ppid;
-         if (proc->st_uid != kproc->ki_uid) {
-            // some processes change users (eg. to lower privs)
-            proc->st_uid = kproc->ki_uid;
-            proc->user = UsersTable_getRef(super->usersTable, proc->st_uid);
-         }
-         if (settings->updateProcessNames) {
-            FreeBSDProcessList_updateProcessName(fpl->kd, kproc, proc);
-         }
-      }
-
-      free_and_xStrdup(&fp->emul, kproc->ki_emul);
-
-      // from FreeBSD source /src/usr.bin/top/machine.c
-      proc->m_virt = kproc->ki_size / ONE_K;
-      proc->m_resident = kproc->ki_rssize * pageSizeKb;
-      proc->nlwp = kproc->ki_numthreads;
-      proc->time = (kproc->ki_runtime + 5000) / 10000;
-
-      proc->percent_cpu = 100.0 * ((double)kproc->ki_pctcpu / (double)kernelFScale);
-      proc->percent_mem = 100.0 * proc->m_resident / (double)(super->totalMem);
-      Process_updateCPUFieldWidths(proc->percent_cpu);
-
-      if (kproc->ki_stat == SRUN && kproc->ki_oncpu != NOCPU) {
-         proc->processor = kproc->ki_oncpu;
-      } else {
-         proc->processor = kproc->ki_lastcpu;
-      }
-
-      proc->majflt = kproc->ki_cow;
-
-      proc->priority = kproc->ki_pri.pri_level - PZERO;
-
-      if (String_eq("intr", kproc->ki_comm) && (kproc->ki_flag & P_SYSTEM)) {
-         proc->nice = 0; //@etosan: intr kernel process (not thread) has weird nice value
-      } else if (kproc->ki_pri.pri_class == PRI_TIMESHARE) {
-         proc->nice = kproc->ki_nice - NZERO;
-      } else if (PRI_IS_REALTIME(kproc->ki_pri.pri_class)) {
-         proc->nice = PRIO_MIN - 1 - (PRI_MAX_REALTIME - kproc->ki_pri.pri_level);
-      } else {
-         proc->nice = PRIO_MAX + 1 + kproc->ki_pri.pri_level - PRI_MIN_IDLE;
-      }
-
-      /* Taken from: https://github.com/freebsd/freebsd-src/blob/1ad2d87778970582854082bcedd2df0394fd4933/sys/sys/proc.h#L851 */
-      switch (kproc->ki_stat) {
-      case SIDL:   proc->state = IDLE; break;
-      case SRUN:   proc->state = RUNNING; break;
-      case SSLEEP: proc->state = SLEEPING; break;
-      case SSTOP:  proc->state = STOPPED; break;
-      case SZOMB:  proc->state = ZOMBIE; break;
-      case SWAIT:  proc->state = WAITING; break;
-      case SLOCK:  proc->state = BLOCKED; break;
-      default:     proc->state = UNKNOWN;
-      }
-
-      if (Process_isKernelThread(proc))
-         super->kernelThreads++;
-
-      proc->show = ! ((hideKernelThreads && Process_isKernelThread(proc)) || (hideUserlandThreads && Process_isUserlandThread(proc)));
-
-      super->totalTasks++;
-      if (proc->state == RUNNING)
-         super->runningTasks++;
-      proc->updated = true;
-   }
-}
-
-bool ProcessList_isCPUonline(const ProcessList* super, unsigned int id) {
-   assert(id < super->existingCPUs);
-
-   // TODO: support offline CPUs and hot swapping
-   (void) super; (void) id;
-
-   return true;
-}
diff --git a/freebsd/FreeBSDProcessTable.c b/freebsd/FreeBSDProcessTable.c
new file mode 100644
index 0000000..9e18b8a
--- /dev/null
+++ b/freebsd/FreeBSDProcessTable.c
@@ -0,0 +1,288 @@
+/*
+htop - FreeBSDProcessTable.c
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPLv2+, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h" // IWYU pragma: keep
+
+#include "freebsd/FreeBSDProcessTable.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/_iovec.h>
+#include <sys/errno.h>
+#include <sys/param.h> // needs to be included before <sys/jail.h> for MAXPATHLEN
+#include <sys/jail.h>
+#include <sys/priority.h>
+#include <sys/proc.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/vmmeter.h>
+
+#include "CRT.h"
+#include "Compat.h"
+#include "Macros.h"
+#include "Object.h"
+#include "Process.h"
+#include "ProcessTable.h"
+#include "Scheduling.h"
+#include "Settings.h"
+#include "XUtils.h"
+
+#include "freebsd/FreeBSDMachine.h"
+#include "freebsd/FreeBSDProcess.h"
+
+
+ProcessTable* ProcessTable_new(Machine* host, Hashtable* pidMatchList) {
+   FreeBSDProcessTable* this = xCalloc(1, sizeof(FreeBSDProcessTable));
+   Object_setClass(this, Class(ProcessTable));
+
+   ProcessTable* super = &this->super;
+   ProcessTable_init(super, Class(FreeBSDProcess), host, pidMatchList);
+
+   return super;
+}
+
+void ProcessTable_delete(Object* cast) {
+   FreeBSDProcessTable* this = (FreeBSDProcessTable*) cast;
+   ProcessTable_done(&this->super);
+   free(this);
+}
+
+static void FreeBSDProcessTable_updateExe(const struct kinfo_proc* kproc, Process* proc) {
+   if (Process_isKernelThread(proc)) {
+      Process_updateExe(proc, NULL);
+      return;
+   }
+
+   const int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, kproc->ki_pid };
+   char buffer[2048];
+   size_t size = sizeof(buffer);
+   if (sysctl(mib, 4, buffer, &size, NULL, 0) != 0) {
+      Process_updateExe(proc, NULL);
+      return;
+   }
+
+   Process_updateExe(proc, buffer);
+}
+
+static void FreeBSDProcessTable_updateCwd(const struct kinfo_proc* kproc, Process* proc) {
+#ifdef KERN_PROC_CWD
+   const int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_CWD, kproc->ki_pid };
+   char buffer[2048];
+   size_t size = sizeof(buffer);
+   if (sysctl(mib, 4, buffer, &size, NULL, 0) != 0) {
+      free(proc->procCwd);
+      proc->procCwd = NULL;
+      return;
+   }
+
+   /* Kernel threads return an empty buffer */
+   if (buffer[0] == '\0') {
+      free(proc->procCwd);
+      proc->procCwd = NULL;
+      return;
+   }
+
+   free_and_xStrdup(&proc->procCwd, buffer);
+#else
+   proc->procCwd = NULL;
+#endif
+}
+
+static void FreeBSDProcessTable_updateProcessName(kvm_t* kd, const struct kinfo_proc* kproc, Process* proc) {
+   Process_updateComm(proc, kproc->ki_comm);
+
+   char** argv = kvm_getargv(kd, kproc, 0);
+   if (!argv || !argv[0]) {
+      Process_updateCmdline(proc, kproc->ki_comm, 0, strlen(kproc->ki_comm));
+      return;
+   }
+
+   size_t len = 0;
+   for (int i = 0; argv[i]; i++) {
+      len += strlen(argv[i]) + 1;
+   }
+
+   char* cmdline = xMalloc(len);
+   char* at = cmdline;
+   int end = 0;
+   for (int i = 0; argv[i]; i++) {
+      at = stpcpy(at, argv[i]);
+      if (end == 0) {
+         end = at - cmdline;
+      }
+      *at++ = ' ';
+   }
+   at--;
+   *at = '\0';
+
+   Process_updateCmdline(proc, cmdline, 0, end);
+
+   free(cmdline);
+}
+
+static char* FreeBSDProcessTable_readJailName(const struct kinfo_proc* kproc) {
+   if (kproc->ki_jid == 0)
+      return xStrdup("-");
+
+   char jnamebuf[MAXHOSTNAMELEN] = {0};
+   struct iovec jiov[4];
+
+IGNORE_WCASTQUAL_BEGIN
+   *(const void**)&jiov[0].iov_base = "jid";
+   jiov[0].iov_len = sizeof("jid");
+   jiov[1].iov_base = (void*) &kproc->ki_jid;
+   jiov[1].iov_len = sizeof(kproc->ki_jid);
+   *(const void**)&jiov[2].iov_base = "name";
+   jiov[2].iov_len = sizeof("name");
+   jiov[3].iov_base = jnamebuf;
+   jiov[3].iov_len = sizeof(jnamebuf);
+IGNORE_WCASTQUAL_END
+
+   int jid = jail_get(jiov, 4, 0);
+   if (jid == kproc->ki_jid)
+      return xStrdup(jnamebuf);
+
+   return NULL;
+}
+
+void ProcessTable_goThroughEntries(ProcessTable* super) {
+   const Machine* host = super->super.host;
+   const FreeBSDMachine* fhost = (const FreeBSDMachine*) host;
+   const Settings* settings = host->settings;
+   bool hideKernelThreads = settings->hideKernelThreads;
+   bool hideUserlandThreads = settings->hideUserlandThreads;
+
+   int count = 0;
+   const struct kinfo_proc* kprocs = kvm_getprocs(fhost->kd, KERN_PROC_PROC, 0, &count);
+
+   for (int i = 0; i < count; i++) {
+      const struct kinfo_proc* kproc = &kprocs[i];
+      bool preExisting = false;
+      Process* proc = ProcessTable_getProcess(super, kproc->ki_pid, &preExisting, FreeBSDProcess_new);
+      FreeBSDProcess* fp = (FreeBSDProcess*) proc;
+
+      if (!preExisting) {
+         fp->jid = kproc->ki_jid;
+         Process_setPid(proc, kproc->ki_pid);
+         Process_setThreadGroup(proc, kproc->ki_pid);
+         Process_setParent(proc, kproc->ki_ppid);
+         proc->isKernelThread = kproc->ki_pid != 1 && (kproc->ki_flag & P_SYSTEM);
+         proc->isUserlandThread = false;
+         proc->tpgid = kproc->ki_tpgid;
+         proc->session = kproc->ki_sid;
+         proc->pgrp = kproc->ki_pgid;
+         proc->st_uid = kproc->ki_uid;
+         proc->starttime_ctime = kproc->ki_start.tv_sec;
+         if (proc->starttime_ctime < 0) {
+            proc->starttime_ctime = host->realtimeMs / 1000;
+         }
+         Process_fillStarttimeBuffer(proc);
+         proc->user = UsersTable_getRef(host->usersTable, proc->st_uid);
+         ProcessTable_add(super, proc);
+
+         FreeBSDProcessTable_updateExe(kproc, proc);
+         FreeBSDProcessTable_updateProcessName(fhost->kd, kproc, proc);
+
+         if (settings->ss->flags & PROCESS_FLAG_CWD) {
+            FreeBSDProcessTable_updateCwd(kproc, proc);
+         }
+
+         fp->jname = FreeBSDProcessTable_readJailName(kproc);
+
+         proc->tty_nr = kproc->ki_tdev;
+         const char* name = (kproc->ki_tdev != NODEV) ? devname(kproc->ki_tdev, S_IFCHR) : NULL;
+         if (!name) {
+            free(proc->tty_name);
+            proc->tty_name = NULL;
+         } else {
+            free_and_xStrdup(&proc->tty_name, name);
+         }
+      } else {
+         if (fp->jid != kproc->ki_jid) {
+            // process can enter jail anytime
+            fp->jid = kproc->ki_jid;
+            free(fp->jname);
+            fp->jname = FreeBSDProcessTable_readJailName(kproc);
+         }
+         // if there are reapers in the system, process can get reparented anytime
+         Process_setParent(proc, kproc->ki_ppid);
+         if (proc->st_uid != kproc->ki_uid) {
+            // some processes change users (eg. to lower privs)
+            proc->st_uid = kproc->ki_uid;
+            proc->user = UsersTable_getRef(host->usersTable, proc->st_uid);
+         }
+         if (settings->updateProcessNames) {
+            FreeBSDProcessTable_updateProcessName(fhost->kd, kproc, proc);
+         }
+      }
+
+      free_and_xStrdup(&fp->emul, kproc->ki_emul);
+
+      // from FreeBSD source /src/usr.bin/top/machine.c
+      proc->m_virt = kproc->ki_size / ONE_K;
+      proc->m_resident = kproc->ki_rssize * fhost->pageSizeKb;
+      proc->nlwp = kproc->ki_numthreads;
+      proc->time = (kproc->ki_runtime + 5000) / 10000;
+
+      proc->percent_cpu = 100.0 * ((double)kproc->ki_pctcpu / (double)fhost->kernelFScale);
+      proc->percent_mem = 100.0 * proc->m_resident / (double)(host->totalMem);
+      Process_updateCPUFieldWidths(proc->percent_cpu);
+
+      if (kproc->ki_stat == SRUN && kproc->ki_oncpu != NOCPU) {
+         proc->processor = kproc->ki_oncpu;
+      } else {
+         proc->processor = kproc->ki_lastcpu;
+      }
+
+      proc->majflt = kproc->ki_cow;
+
+      proc->priority = kproc->ki_pri.pri_level - PZERO;
+
+      if (String_eq("intr", kproc->ki_comm) && (kproc->ki_flag & P_SYSTEM)) {
+         proc->nice = 0; //@etosan: intr kernel process (not thread) has weird nice value
+      } else if (kproc->ki_pri.pri_class == PRI_TIMESHARE) {
+         proc->nice = kproc->ki_nice - NZERO;
+      } else if (PRI_IS_REALTIME(kproc->ki_pri.pri_class)) {
+         proc->nice = PRIO_MIN - 1 - (PRI_MAX_REALTIME - kproc->ki_pri.pri_level);
+      } else {
+         proc->nice = PRIO_MAX + 1 + kproc->ki_pri.pri_level - PRI_MIN_IDLE;
+      }
+
+      /* Taken from: https://github.com/freebsd/freebsd-src/blob/1ad2d87778970582854082bcedd2df0394fd4933/sys/sys/proc.h#L851 */
+      switch (kproc->ki_stat) {
+         case SIDL:   proc->state = IDLE; break;
+         case SRUN:   proc->state = RUNNING; break;
+         case SSLEEP: proc->state = SLEEPING; break;
+         case SSTOP:  proc->state = STOPPED; break;
+         case SZOMB:  proc->state = ZOMBIE; break;
+         case SWAIT:  proc->state = WAITING; break;
+         case SLOCK:  proc->state = BLOCKED; break;
+         default:     proc->state = UNKNOWN;
+      }
+
+      if (Process_isKernelThread(proc))
+         super->kernelThreads++;
+
+#ifdef SCHEDULER_SUPPORT
+      if (settings->ss->flags & PROCESS_FLAG_SCHEDPOL)
+         Scheduling_readProcessPolicy(proc);
+#endif
+
+      proc->super.show = ! ((hideKernelThreads && Process_isKernelThread(proc)) || (hideUserlandThreads && Process_isUserlandThread(proc)));
+
+      super->totalTasks++;
+      if (proc->state == RUNNING)
+         super->runningTasks++;
+      proc->super.updated = true;
+   }
+}
diff --git a/freebsd/FreeBSDProcessTable.h b/freebsd/FreeBSDProcessTable.h
new file mode 100644
index 0000000..23a6ab2
--- /dev/null
+++ b/freebsd/FreeBSDProcessTable.h
@@ -0,0 +1,21 @@
+#ifndef HEADER_FreeBSDProcessTable
+#define HEADER_FreeBSDProcessTable
+/*
+htop - FreeBSDProcessTable.h
+(C) 2014 Hisham H. Muhammad
+Released under the GNU GPLv2+, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include <stdbool.h>
+#include <sys/types.h>
+
+#include "Hashtable.h"
+#include "ProcessTable.h"
+#include "UsersTable.h"
+
+typedef struct FreeBSDProcessTable_ {
+   ProcessTable super;
+} FreeBSDProcessTable;
+
+#endif
diff --git a/freebsd/Platform.c b/freebsd/Platform.c
index 1a731b7..9be7195 100644
--- a/freebsd/Platform.c
+++ b/freebsd/Platform.c
@@ -31,22 +31,23 @@ in the source distribution for its full text.
 #include "DateMeter.h"
 #include "DateTimeMeter.h"
 #include "DiskIOMeter.h"
+#include "FileDescriptorMeter.h"
 #include "HostnameMeter.h"
 #include "LoadAverageMeter.h"
+#include "Machine.h"
 #include "Macros.h"
 #include "MemoryMeter.h"
 #include "MemorySwapMeter.h"
 #include "Meter.h"
 #include "NetworkIOMeter.h"
-#include "ProcessList.h"
 #include "Settings.h"
 #include "SwapMeter.h"
 #include "SysArchMeter.h"
 #include "TasksMeter.h"
 #include "UptimeMeter.h"
 #include "XUtils.h"
-#include "freebsd/FreeBSDProcess.h"
-#include "freebsd/FreeBSDProcessList.h"
+#include "freebsd/FreeBSDMachine.h"
+#include "generic/fdstat_sysctl.h"
 #include "zfs/ZfsArcMeter.h"
 #include "zfs/ZfsCompressedArcMeter.h"
 
@@ -130,6 +131,7 @@ const MeterClass* const Platform_meterTypes[] = {
    &ZfsArcMeter_class,
    &ZfsCompressedArcMeter_class,
    &DiskIOMeter_class,
+   &FileDescriptorMeter_class,
    &NetworkIOMeter_class,
    NULL
 };
@@ -148,7 +150,7 @@ void Platform_setBindings(Htop_Action* keys) {
    (void) keys;
 }
 
-int Platform_getUptime() {
+int Platform_getUptime(void) {
    struct timeval bootTime, currTime;
    const int mib[2] = { CTL_KERN, KERN_BOOTTIME };
    size_t size = sizeof(bootTime);
@@ -179,7 +181,7 @@ void Platform_getLoadAverage(double* one, double* five, double* fifteen) {
    *fifteen = (double) loadAverage.ldavg[2] / loadAverage.fscale;
 }
 
-int Platform_getMaxPid() {
+pid_t Platform_getMaxPid(void) {
    int maxPid;
    size_t size = sizeof(maxPid);
    int err = sysctlbyname("kern.pid_max", &maxPid, &size, NULL, 0);
@@ -190,31 +192,27 @@ int Platform_getMaxPid() {
 }
 
 double Platform_setCPUValues(Meter* this, unsigned int cpu) {
-   const FreeBSDProcessList* fpl = (const FreeBSDProcessList*) this->pl;
-   unsigned int cpus = this->pl->activeCPUs;
-   const CPUData* cpuData;
+   const Machine* host = this->host;
+   const FreeBSDMachine* fhost = (const FreeBSDMachine*) host;
+   unsigned int cpus = host->activeCPUs;
 
-   if (cpus == 1) {
-      // single CPU box has everything in fpl->cpus[0]
-      cpuData = &(fpl->cpus[0]);
-   } else {
-      cpuData = &(fpl->cpus[cpu]);
-   }
+   // single CPU box has everything in fhost->cpus[0]
+   const CPUData* cpuData = cpus == 1 ? &fhost->cpus[0] : &fhost->cpus[cpu];
 
    double  percent;
    double* v = this->values;
 
    v[CPU_METER_NICE]   = cpuData->nicePercent;
    v[CPU_METER_NORMAL] = cpuData->userPercent;
-   if (this->pl->settings->detailedCPUTime) {
+   if (host->settings->detailedCPUTime) {
       v[CPU_METER_KERNEL]  = cpuData->systemPercent;
       v[CPU_METER_IRQ]     = cpuData->irqPercent;
       this->curItems = 4;
-      percent = v[0] + v[1] + v[2] + v[3];
+      percent = v[CPU_METER_NICE] + v[CPU_METER_NORMAL] + v[CPU_METER_KERNEL] + v[CPU_METER_IRQ];
    } else {
-      v[2] = cpuData->systemAllPercent;
+      v[CPU_METER_NORMAL] = cpuData->systemAllPercent;
       this->curItems = 3;
-      percent = v[0] + v[1] + v[2];
+      percent = v[CPU_METER_NICE] + v[CPU_METER_NORMAL] + v[CPU_METER_KERNEL];
    }
 
    percent = CLAMP(percent, 0.0, 100.0);
@@ -226,44 +224,47 @@ double Platform_setCPUValues(Meter* this, unsigned int cpu) {
 }
 
 void Platform_setMemoryValues(Meter* this) {
-   const ProcessList* pl = this->pl;
-   const FreeBSDProcessList* fpl = (const FreeBSDProcessList*) pl;
-
-   this->total = pl->totalMem;
-   this->values[0] = pl->usedMem;
-   this->values[1] = pl->buffersMem;
-   // this->values[2] = "shared memory, like tmpfs and shm"
-   this->values[3] = pl->cachedMem;
-   // this->values[4] = "available memory"
-
-   if (fpl->zfs.enabled) {
+   const Machine* host = this->host;
+   const FreeBSDMachine* fhost = (const FreeBSDMachine*) host;
+
+   this->total = host->totalMem;
+   this->values[MEMORY_METER_USED] = host->usedMem;
+   this->values[MEMORY_METER_SHARED] = host->sharedMem;
+   // this->values[MEMORY_METER_COMPRESSED] = "compressed memory, like zswap on linux"
+   this->values[MEMORY_METER_BUFFERS] = host->buffersMem;
+   this->values[MEMORY_METER_CACHE] = host->cachedMem;
+   // this->values[MEMORY_METER_AVAILABLE] = "available memory"
+
+   if (fhost->zfs.enabled) {
       // ZFS does not shrink below the value of zfs_arc_min.
       unsigned long long int shrinkableSize = 0;
-      if (fpl->zfs.size > fpl->zfs.min)
-         shrinkableSize = fpl->zfs.size - fpl->zfs.min;
-      this->values[0] -= shrinkableSize;
-      this->values[3] += shrinkableSize;
-      // this->values[4] += shrinkableSize;
+      if (fhost->zfs.size > fhost->zfs.min)
+         shrinkableSize = fhost->zfs.size - fhost->zfs.min;
+      this->values[MEMORY_METER_USED] -= shrinkableSize;
+      this->values[MEMORY_METER_CACHE] += shrinkableSize;
+      // this->values[MEMORY_METER_AVAILABLE] += shrinkableSize;
    }
 }
 
 void Platform_setSwapValues(Meter* this) {
-   const ProcessList* pl = this->pl;
-   this->total = pl->totalSwap;
-   this->values[0] = pl->usedSwap;
-   this->values[1] = NAN;
+   const Machine* host = this->host;
+
+   this->total = host->totalSwap;
+   this->values[SWAP_METER_USED] = host->usedSwap;
+   // this->values[SWAP_METER_CACHE] = "pages that are both in swap and RAM, like SwapCached on linux"
+   // this->values[SWAP_METER_FRONTSWAP] = "pages that are accounted to swap but stored elsewhere, like frontswap on linux"
 }
 
 void Platform_setZfsArcValues(Meter* this) {
-   const FreeBSDProcessList* fpl = (const FreeBSDProcessList*) this->pl;
+   const FreeBSDMachine* fhost = (const FreeBSDMachine*) this->host;
 
-   ZfsArcMeter_readStats(this, &(fpl->zfs));
+   ZfsArcMeter_readStats(this, &fhost->zfs);
 }
 
 void Platform_setZfsCompressedArcValues(Meter* this) {
-   const FreeBSDProcessList* fpl = (const FreeBSDProcessList*) this->pl;
+   const FreeBSDMachine* fhost = (const FreeBSDMachine*) this->host;
 
-   ZfsCompressedArcMeter_readStats(this, &(fpl->zfs));
+   ZfsCompressedArcMeter_readStats(this, &fhost->zfs);
 }
 
 char* Platform_getProcessEnv(pid_t pid) {
@@ -287,15 +288,13 @@ char* Platform_getProcessEnv(pid_t pid) {
    return env;
 }
 
-char* Platform_getInodeFilename(pid_t pid, ino_t inode) {
+FileLocks_ProcessData* Platform_getProcessLocks(pid_t pid) {
    (void)pid;
-   (void)inode;
    return NULL;
 }
 
-FileLocks_ProcessData* Platform_getProcessLocks(pid_t pid) {
-   (void)pid;
-   return NULL;
+void Platform_getFileDescriptors(double* used, double* max) {
+   Generic_getFileDescriptors_sysctl(used, max);
 }
 
 bool Platform_getDiskIO(DiskIOData* data) {
diff --git a/freebsd/Platform.h b/freebsd/Platform.h
index c0292d9..c358d85 100644
--- a/freebsd/Platform.h
+++ b/freebsd/Platform.h
@@ -45,7 +45,7 @@ int Platform_getUptime(void);
 
 void Platform_getLoadAverage(double* one, double* five, double* fifteen);
 
-int Platform_getMaxPid(void);
+pid_t Platform_getMaxPid(void);
 
 double Platform_setCPUValues(Meter* this, unsigned int cpu);
 
@@ -59,10 +59,10 @@ void Platform_setZfsCompressedArcValues(Meter* this);
 
 char* Platform_getProcessEnv(pid_t pid);
 
-char* Platform_getInodeFilename(pid_t pid, ino_t inode);
-
 FileLocks_ProcessData* Platform_getProcessLocks(pid_t pid);
 
+void Platform_getFileDescriptors(double* used, double* max);
+
 bool Platform_getDiskIO(DiskIOData* data);
 
 bool Platform_getNetworkIO(NetworkIOData* data);
@@ -93,7 +93,9 @@ static inline void Platform_gettime_monotonic(uint64_t* msec) {
    Generic_gettime_monotonic(msec);
 }
 
-static inline Hashtable* Platform_dynamicMeters(void) { return NULL; }
+static inline Hashtable* Platform_dynamicMeters(void) {
+   return NULL;
+}
 
 static inline void Platform_dynamicMetersDone(ATTR_UNUSED Hashtable* table) { }
 
@@ -103,12 +105,30 @@ static inline void Platform_dynamicMeterUpdateValues(ATTR_UNUSED Meter* meter) {
 
 static inline void Platform_dynamicMeterDisplay(ATTR_UNUSED const Meter* meter, ATTR_UNUSED RichString* out) { }
 
-static inline Hashtable* Platform_dynamicColumns(void) { return NULL; }
+static inline Hashtable* Platform_dynamicColumns(void) {
+   return NULL;
+}
 
-static inline const char* Platform_dynamicColumnInit(ATTR_UNUSED unsigned int key) { return NULL; }
+static inline const char* Platform_dynamicColumnName(ATTR_UNUSED unsigned int key) {
+   return NULL;
+}
 
 static inline void Platform_dynamicColumnsDone(ATTR_UNUSED Hashtable* table) { }
 
-static inline bool Platform_dynamicColumnWriteField(ATTR_UNUSED const Process* proc, ATTR_UNUSED RichString* str, ATTR_UNUSED unsigned int key) { return false; }
+static inline bool Platform_dynamicColumnWriteField(ATTR_UNUSED const Process* proc, ATTR_UNUSED RichString* str, ATTR_UNUSED unsigned int key) {
+   return false;
+}
+
+static inline Hashtable* Platform_dynamicScreens(void) {
+   return NULL;
+}
+
+static inline void Platform_defaultDynamicScreens(ATTR_UNUSED Settings* settings) { }
+
+static inline void Platform_addDynamicScreen(ATTR_UNUSED ScreenSettings* ss) { }
+
+static inline void Platform_addDynamicScreenAvailableColumns(ATTR_UNUSED Panel* availableColumns, ATTR_UNUSED const char* screen) { }
+
+static inline void Platform_dynamicScreensDone(ATTR_UNUSED Hashtable* screens) { }
 
 #endif