aixiao/build
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dc60fd799b
build/packages/extras-buildpkgs/htop/debian/patches/avafinger-cpu-monitor.patch

3578 lines
101 KiB
Diff
Raw Blame History

This patch file contains code from @avafinger's htop_2.2.2 repository.
It is the result of diff between:
https://github.com/avafinger/htop_2.2.2/commit/dc21e5f6
and:
https://github.com/hishamhm/htop/tree/2.2.0
---
diff --git a/Armbian_Meter.c b/Armbian_Meter.c
new file mode 100644
index 0000000..183032b
--- /dev/null
+++ b/Armbian_Meter.c
@@ -0,0 +1,55 @@
+/*
+htop - Armbianversion_Meter.c
+(C) 2018 @lex
+*/
+
+#include "Armbian_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Armbianversion_Meter_attributes[] = {
+ ARMBIAN_VERSION
+};
+
+static void Armbianversion_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char version[256];
+ static unsigned int use_cached = 0;
+
+ if ((use_cached++ % 10)) {
+ xSnprintf(buffer, len, "%s", version);
+ return;
+ }
+
+ ret = ReadKeyValue( "/etc/armbian-release", "VERSION=", version);
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", version);
+ } else {
+ xSnprintf(buffer, len, "%s", "unknown");
+ }
+}
+
+MeterClass Armbianversion_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Armbianversion_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Armbianversion_Meter_attributes,
+ .name = "Armbianversion",
+ .uiName = "Armbian version",
+ .caption = "Armbian : ",
+};
+
+
diff --git a/Armbian_Meter.h b/Armbian_Meter.h
new file mode 100644
index 0000000..146a1ee
--- /dev/null
+++ b/Armbian_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Armbian_Meter
+#define HEADER_Armbian_Meter
+/*
+htop - Armbianversion_Meter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int Armbianversion_Meter_attributes[];
+
+extern MeterClass Armbianversion_Meter_class;
+
+
+#endif
diff --git a/AvailableMetersPanel.c b/AvailableMetersPanel.c
index ddb5536..01ee3cd 100644
--- a/AvailableMetersPanel.c
+++ b/AvailableMetersPanel.c
@@ -9,6 +9,8 @@ in the source distribution for its full text.
#include "MetersPanel.h"
#include "CPUMeter.h"
+#include "CpuFreqMeter.h"
+#include "CpuTempMeter.h"
#include "Header.h"
#include "ListItem.h"
#include "Platform.h"
@@ -100,6 +102,8 @@ PanelClass AvailableMetersPanel_class = {
};
AvailableMetersPanel* AvailableMetersPanel_new(Settings* settings, Header* header, Panel* leftMeters, Panel* rightMeters, ScreenManager* scr, ProcessList* pl) {
+ int i;
+
AvailableMetersPanel* this = AllocThis(AvailableMetersPanel);
Panel* super = (Panel*) this;
FunctionBar* fuBar = FunctionBar_newEnterEsc("Add ", "Done ");
@@ -114,7 +118,7 @@ AvailableMetersPanel* AvailableMetersPanel_new(Settings* settings, Header* heade
Panel_setHeader(super, "Available meters");
// Platform_meterTypes[0] should be always (&CPUMeter_class), which we will
// handle separately in the code below.
- for (int i = 1; Platform_meterTypes[i]; i++) {
+ for (i = 1; Platform_meterTypes[i]; i++) {
MeterClass* type = Platform_meterTypes[i];
assert(type != &CPUMeter_class);
const char* label = type->description ? type->description : type->uiName;
@@ -125,7 +129,7 @@ AvailableMetersPanel* AvailableMetersPanel_new(Settings* settings, Header* heade
int cpus = pl->cpuCount;
if (cpus > 1) {
Panel_add(super, (Object*) ListItem_new("CPU average", 0));
- for (int i = 1; i <= cpus; i++) {
+ for (i = 1; i <= cpus; i++) {
char buffer[50];
xSnprintf(buffer, 50, "%s %d", type->uiName, i);
Panel_add(super, (Object*) ListItem_new(buffer, i));
diff --git a/BlockDevice_ioStatsMeter.c b/BlockDevice_ioStatsMeter.c
new file mode 100644
index 0000000..9dccbde
--- /dev/null
+++ b/BlockDevice_ioStatsMeter.c
@@ -0,0 +1,711 @@
+/*
+htop - BlockDevice_ioStatsMeter.c
+(C) 2020 @lex
+*/
+
+#include "BlockDevice_ioStatsMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int BlockDevice_ioStatsMeter_attributes[] = {
+ ETH1_INTERFACE
+};
+
+static void BlockDevice_sda_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "sda");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("sda", 0, 0);
+ if (ret) {
+ if (Platform_BlockDevice_sda_stats.read_sectors_comp > Platform_BlockDevice_sda_stats.read_sectors)
+ Platform_BlockDevice_sda_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_sda_stats.write_sectors_comp > Platform_BlockDevice_sda_stats.write_sectors)
+ Platform_BlockDevice_sda_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_sda_stats.read_sectors - Platform_BlockDevice_sda_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_sda_stats.write_sectors - Platform_BlockDevice_sda_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_sda_stats.read_sectors_comp = Platform_BlockDevice_sda_stats.read_sectors;
+ Platform_BlockDevice_sda_stats.write_sectors_comp = Platform_BlockDevice_sda_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_sda_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_sda_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "sdastat",
+ .uiName = "sda speed stat",
+ .caption = "sda stat: ",
+};
+
+static void BlockDevice_sdb_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "sdb");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("sdb", 1, 0);
+ if (ret) {
+ if (Platform_BlockDevice_sdb_stats.read_sectors_comp > Platform_BlockDevice_sdb_stats.read_sectors)
+ Platform_BlockDevice_sdb_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_sdb_stats.write_sectors_comp > Platform_BlockDevice_sdb_stats.write_sectors)
+ Platform_BlockDevice_sdb_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_sdb_stats.read_sectors - Platform_BlockDevice_sdb_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_sdb_stats.write_sectors - Platform_BlockDevice_sdb_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_sdb_stats.read_sectors_comp = Platform_BlockDevice_sdb_stats.read_sectors;
+ Platform_BlockDevice_sdb_stats.write_sectors_comp = Platform_BlockDevice_sdb_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_sdb_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_sdb_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "sdbstat",
+ .uiName = "sdb speed stat",
+ .caption = "sdb stat: ",
+};
+
+static void BlockDevice_sdc_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "sdc");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("sdc", 2, 0);
+ if (ret) {
+ if (Platform_BlockDevice_sdc_stats.read_sectors_comp > Platform_BlockDevice_sdc_stats.read_sectors)
+ Platform_BlockDevice_sdc_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_sdc_stats.write_sectors_comp > Platform_BlockDevice_sdc_stats.write_sectors)
+ Platform_BlockDevice_sdc_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_sdc_stats.read_sectors - Platform_BlockDevice_sdc_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_sdc_stats.write_sectors - Platform_BlockDevice_sdc_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_sdc_stats.read_sectors_comp = Platform_BlockDevice_sdc_stats.read_sectors;
+ Platform_BlockDevice_sdc_stats.write_sectors_comp = Platform_BlockDevice_sdc_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_sdc_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_sdc_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "sdcstat",
+ .uiName = "sdc speed stat",
+ .caption = "sdc stat: ",
+};
+
+static void BlockDevice_sdd_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "sdd");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("sdd", 3, 0);
+ if (ret) {
+ if (Platform_BlockDevice_sdd_stats.read_sectors_comp > Platform_BlockDevice_sdd_stats.read_sectors)
+ Platform_BlockDevice_sdd_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_sdd_stats.write_sectors_comp > Platform_BlockDevice_sdd_stats.write_sectors)
+ Platform_BlockDevice_sdd_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_sdd_stats.read_sectors - Platform_BlockDevice_sdd_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_sdd_stats.write_sectors - Platform_BlockDevice_sdd_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_sdd_stats.read_sectors_comp = Platform_BlockDevice_sdd_stats.read_sectors;
+ Platform_BlockDevice_sdd_stats.write_sectors_comp = Platform_BlockDevice_sdd_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_sdd_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_sdd_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "sddstat",
+ .uiName = "sdd speed stat",
+ .caption = "sdd stat: ",
+};
+
+static void BlockDevice_mmcblk0_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "mmcblk0");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("mmcblk0", 4, 0);
+ if (ret) {
+ if (Platform_BlockDevice_mmcblk0_stats.read_sectors_comp > Platform_BlockDevice_mmcblk0_stats.read_sectors)
+ Platform_BlockDevice_mmcblk0_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_mmcblk0_stats.write_sectors_comp > Platform_BlockDevice_mmcblk0_stats.write_sectors)
+ Platform_BlockDevice_mmcblk0_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_mmcblk0_stats.read_sectors - Platform_BlockDevice_mmcblk0_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_mmcblk0_stats.write_sectors - Platform_BlockDevice_mmcblk0_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_mmcblk0_stats.read_sectors_comp = Platform_BlockDevice_mmcblk0_stats.read_sectors;
+ Platform_BlockDevice_mmcblk0_stats.write_sectors_comp = Platform_BlockDevice_mmcblk0_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_mmcblk0_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_mmcblk0_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "mmcblk0stat",
+ .uiName = "mmcblk0 speed stat",
+ .caption = "mmcblk0 stat: ",
+};
+
+static void BlockDevice_mmcblk1_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "mmcblk1");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("mmcblk1", 5, 0);
+ if (ret) {
+ if (Platform_BlockDevice_mmcblk1_stats.read_sectors_comp > Platform_BlockDevice_mmcblk1_stats.read_sectors)
+ Platform_BlockDevice_mmcblk1_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_mmcblk1_stats.write_sectors_comp > Platform_BlockDevice_mmcblk1_stats.write_sectors)
+ Platform_BlockDevice_mmcblk1_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_mmcblk1_stats.read_sectors - Platform_BlockDevice_mmcblk1_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_mmcblk1_stats.write_sectors - Platform_BlockDevice_mmcblk1_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_mmcblk1_stats.read_sectors_comp = Platform_BlockDevice_mmcblk1_stats.read_sectors;
+ Platform_BlockDevice_mmcblk1_stats.write_sectors_comp = Platform_BlockDevice_mmcblk1_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_mmcblk1_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_mmcblk1_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "mmcblk1stat",
+ .uiName = "mmcblk1 speed stat",
+ .caption = "mmcblk1 stat: ",
+};
+
+static void BlockDevice_mmcblk2_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "mmcblk2");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("mmcblk2", 6, 0);
+ if (ret) {
+ if (Platform_BlockDevice_mmcblk2_stats.read_sectors_comp > Platform_BlockDevice_mmcblk2_stats.read_sectors)
+ Platform_BlockDevice_mmcblk2_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_mmcblk2_stats.write_sectors_comp > Platform_BlockDevice_mmcblk2_stats.write_sectors)
+ Platform_BlockDevice_mmcblk2_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_mmcblk2_stats.read_sectors - Platform_BlockDevice_mmcblk2_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_mmcblk2_stats.write_sectors - Platform_BlockDevice_mmcblk2_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_mmcblk2_stats.read_sectors_comp = Platform_BlockDevice_mmcblk2_stats.read_sectors;
+ Platform_BlockDevice_mmcblk2_stats.write_sectors_comp = Platform_BlockDevice_mmcblk2_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_mmcblk2_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_mmcblk2_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "mmcblk2stat",
+ .uiName = "mmcblk2 speed stat",
+ .caption = "mmcblk2 stat: ",
+};
+
+static void BlockDevice_mmcblk3_ioStatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float readspeed;
+ float writespeed;
+ double refreshdelay;
+ char block_device[80];
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+ static unsigned long sec_size = 0;
+ FILE *fp;
+
+ if (sec_size == 0) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/queue/hw_sector_size", "mmcblk3");
+ if ((fp = fopen(block_device, "r")) == NULL) {
+ xSnprintf(buffer, len, "%s", "unavailable");
+ return;
+ }
+ if (fgets(block_device, 79, fp) != NULL) {
+ sscanf(block_device, "%lu", &sec_size);
+ }
+ fclose(fp);
+ if (sec_size == 0)
+ sec_size = 1;
+ }
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ ret = Platform_getIO_stats("mmcblk3", 7, 0);
+ if (ret) {
+ if (Platform_BlockDevice_mmcblk3_stats.read_sectors_comp > Platform_BlockDevice_mmcblk3_stats.read_sectors)
+ Platform_BlockDevice_mmcblk3_stats.read_sectors_comp = 0;
+ if (Platform_BlockDevice_mmcblk3_stats.write_sectors_comp > Platform_BlockDevice_mmcblk3_stats.write_sectors)
+ Platform_BlockDevice_mmcblk3_stats.write_sectors_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ readspeed = (Platform_BlockDevice_mmcblk3_stats.read_sectors - Platform_BlockDevice_mmcblk3_stats.read_sectors_comp) / refreshdelay;
+ writespeed = (Platform_BlockDevice_mmcblk3_stats.write_sectors - Platform_BlockDevice_mmcblk3_stats.write_sectors_comp) / refreshdelay;
+
+ writespeed = writespeed * sec_size / 1000;
+ readspeed = readspeed * sec_size / 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ if (writespeed >= 1000 || readspeed >= 1000) {
+ writespeed /= 1000;
+ readspeed /= 1000;
+ xSnprintf(buffer, len, "%.2f GB/s - %.2f GB/s (R/W)", (float) readspeed, (float) writespeed);
+ } else {
+ xSnprintf(buffer, len, "%.2f MB/s - %.2f MB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+ } else {
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (R/W)", (float) readspeed, (float) writespeed);
+ }
+
+ Platform_BlockDevice_mmcblk3_stats.read_sectors_comp = Platform_BlockDevice_mmcblk3_stats.read_sectors;
+ Platform_BlockDevice_mmcblk3_stats.write_sectors_comp = Platform_BlockDevice_mmcblk3_stats.write_sectors;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavailable");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass BlockDevice_mmcblk3_ioStatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = BlockDevice_mmcblk3_ioStatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = BlockDevice_ioStatsMeter_attributes,
+ .name = "mmcblk3stat",
+ .uiName = "mmcblk3 speed stat",
+ .caption = "mmcblk3 stat: ",
+};
+
+
+
+
diff --git a/BlockDevice_ioStatsMeter.h b/BlockDevice_ioStatsMeter.h
new file mode 100644
index 0000000..ce707c8
--- /dev/null
+++ b/BlockDevice_ioStatsMeter.h
@@ -0,0 +1,31 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_BlockDevice_ioStatsMeter
+#define HEADER_BlockDevice_ioStatsMeter
+/*
+htop - BlockDevice_ioStatsMeter.h
+(C) 2020 @lex
+*/
+
+#include "Meter.h"
+
+extern int BlockDevice_ioStatsMeter_attributes[];
+
+extern MeterClass BlockDevice_sda_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_sdb_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_sdc_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_sdd_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_mmcblk0_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_mmcblk1_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_mmcblk2_ioStatsMeter_class;
+
+extern MeterClass BlockDevice_mmcblk3_ioStatsMeter_class;
+
+
+#endif
diff --git a/CPUMeter.c b/CPUMeter.c
index de5490d..0825dba 100644
--- a/CPUMeter.c
+++ b/CPUMeter.c
@@ -6,6 +6,7 @@ in the source distribution for its full text.
*/
#include "CPUMeter.h"
+#include "CpuFreqMeter.h"
#include "CRT.h"
#include "Settings.h"
diff --git a/CRT.c b/CRT.c
index ca9a10d..1fefaff 100644
--- a/CRT.c
+++ b/CRT.c
@@ -128,6 +128,20 @@ typedef enum ColorElements_ {
CPU_SOFTIRQ,
CPU_STEAL,
CPU_GUEST,
+ CPU_TEMP,
+ CPU_FREQ,
+ CPU_VCORE,
+ GPU_TEMP,
+ ETH0_INTERFACE,
+ ETH1_INTERFACE,
+ WLAN0_INTERFACE,
+ WLAN1_INTERFACE,
+ KERNEL_VERSION,
+ DISTRO_VERSION,
+ OS_VERSION,
+ ARMBIAN_VERSION,
+ ETH0_STATS,
+ ETH1_STATS,
LAST_COLORELEMENT
} ColorElements;
@@ -232,6 +246,18 @@ int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
[CPU_SOFTIRQ] = ColorPair(Magenta,Black),
[CPU_STEAL] = ColorPair(Cyan,Black),
[CPU_GUEST] = ColorPair(Cyan,Black),
+ [CPU_FREQ] = A_BOLD | ColorPair(Yellow,Black),
+ [CPU_TEMP] = A_BOLD | ColorPair(Red,Black),
+ [CPU_VCORE] = A_BOLD | ColorPair(Yellow,Black),
+ [GPU_TEMP] = ColorPair(Cyan,Black),
+ [ETH0_INTERFACE] = A_BOLD | ColorPair(Cyan,Black),
+ [ETH1_INTERFACE] = A_BOLD | ColorPair(Cyan,Black),
+ [WLAN0_INTERFACE] = A_BOLD | ColorPair(Cyan,Black),
+ [WLAN1_INTERFACE] = A_BOLD | ColorPair(Cyan,Black),
+ [KERNEL_VERSION] = A_BOLD | ColorPair(Cyan,Black),
+ [DISTRO_VERSION] = A_BOLD | ColorPair(Cyan,Black),
+ [OS_VERSION] = A_BOLD | ColorPair(Cyan,Black),
+ [ARMBIAN_VERSION] = A_BOLD | ColorPair(Cyan,Black),
},
[COLORSCHEME_MONOCHROME] = {
[RESET_COLOR] = A_NORMAL,
@@ -291,6 +317,18 @@ int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
[CPU_SOFTIRQ] = A_BOLD,
[CPU_STEAL] = A_REVERSE,
[CPU_GUEST] = A_REVERSE,
+ [CPU_FREQ] = A_BOLD,
+ [CPU_TEMP] = A_BOLD,
+ [CPU_VCORE] = A_BOLD,
+ [GPU_TEMP] = A_BOLD,
+ [ETH0_INTERFACE] = A_BOLD,
+ [ETH1_INTERFACE] = A_BOLD,
+ [WLAN0_INTERFACE] = A_BOLD,
+ [WLAN1_INTERFACE] = A_BOLD,
+ [KERNEL_VERSION] = A_BOLD,
+ [DISTRO_VERSION] = A_BOLD,
+ [OS_VERSION] = A_BOLD,
+ [ARMBIAN_VERSION] = A_BOLD,
},
[COLORSCHEME_BLACKONWHITE] = {
[RESET_COLOR] = ColorPair(Black,White),
@@ -350,6 +388,18 @@ int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
[CPU_SOFTIRQ] = ColorPair(Blue,White),
[CPU_STEAL] = ColorPair(Cyan,White),
[CPU_GUEST] = ColorPair(Cyan,White),
+ [CPU_FREQ] = A_BOLD | ColorPair(Yellow,White),
+ [CPU_TEMP] = A_BOLD | ColorPair(Yellow,White),
+ [CPU_VCORE] = A_BOLD | ColorPair(Yellow,White),
+ [GPU_TEMP] = A_BOLD | ColorPair(Yellow,White),
+ [ETH0_INTERFACE] = A_BOLD | ColorPair(Yellow,White),
+ [ETH1_INTERFACE] = A_BOLD | ColorPair(Yellow,White),
+ [WLAN0_INTERFACE] = A_BOLD | ColorPair(Yellow,White),
+ [WLAN1_INTERFACE] = A_BOLD | ColorPair(Yellow,White),
+ [KERNEL_VERSION] = A_BOLD | ColorPair(Yellow,White),
+ [DISTRO_VERSION] = A_BOLD | ColorPair(Yellow,White),
+ [OS_VERSION] = A_BOLD | ColorPair(Yellow,White),
+ [ARMBIAN_VERSION] = A_BOLD | ColorPair(Yellow,White),
},
[COLORSCHEME_LIGHTTERMINAL] = {
[RESET_COLOR] = ColorPair(Black,Black),
@@ -409,6 +459,18 @@ int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
[CPU_SOFTIRQ] = ColorPair(Blue,Black),
[CPU_STEAL] = ColorPair(Black,Black),
[CPU_GUEST] = ColorPair(Black,Black),
+ [CPU_FREQ] = A_BOLD | ColorPair(Yellow,Black),
+ [CPU_TEMP] = A_BOLD | ColorPair(Yellow,Black),
+ [CPU_VCORE] = A_BOLD | ColorPair(Yellow,Black),
+ [GPU_TEMP] = A_BOLD | ColorPair(Yellow,Black),
+ [ETH0_INTERFACE] = A_BOLD | ColorPair(Yellow,Black),
+ [ETH1_INTERFACE] = A_BOLD | ColorPair(Yellow,Black),
+ [WLAN0_INTERFACE] = A_BOLD | ColorPair(Yellow,Black),
+ [WLAN1_INTERFACE] = A_BOLD | ColorPair(Yellow,Black),
+ [KERNEL_VERSION] = A_BOLD | ColorPair(Yellow,Black),
+ [DISTRO_VERSION] = A_BOLD | ColorPair(Yellow,Black),
+ [OS_VERSION] = A_BOLD | ColorPair(Yellow,Black),
+ [ARMBIAN_VERSION] = A_BOLD | ColorPair(Yellow,Black),
},
[COLORSCHEME_MIDNIGHT] = {
[RESET_COLOR] = ColorPair(White,Blue),
@@ -468,6 +530,18 @@ int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
[CPU_SOFTIRQ] = ColorPair(Black,Blue),
[CPU_STEAL] = ColorPair(White,Blue),
[CPU_GUEST] = ColorPair(White,Blue),
+ [CPU_FREQ] = A_BOLD | ColorPair(Red,Black),
+ [CPU_TEMP] = A_BOLD | ColorPair(Red,Black),
+ [CPU_VCORE] = A_BOLD | ColorPair(Yellow,Black),
+ [GPU_TEMP] = A_BOLD | ColorPair(Yellow,Black),
+ [ETH0_INTERFACE] = A_BOLD | ColorPair(Cyan,Blue),
+ [ETH1_INTERFACE] = A_BOLD | ColorPair(Cyan,Blue),
+ [WLAN0_INTERFACE] = A_BOLD | ColorPair(Cyan,Blue),
+ [WLAN1_INTERFACE] = A_BOLD | ColorPair(Cyan,Blue),
+ [KERNEL_VERSION] = A_BOLD | ColorPair(Cyan,Black),
+ [DISTRO_VERSION] = A_BOLD | ColorPair(Cyan,Black),
+ [OS_VERSION] = A_BOLD | ColorPair(Cyan,Black),
+ [ARMBIAN_VERSION] = A_BOLD | ColorPair(Cyan,Black),
},
[COLORSCHEME_BLACKNIGHT] = {
[RESET_COLOR] = ColorPair(Cyan,Black),
@@ -527,6 +601,18 @@ int CRT_colorSchemes[LAST_COLORSCHEME][LAST_COLORELEMENT] = {
[CPU_SOFTIRQ] = ColorPair(Blue,Black),
[CPU_STEAL] = ColorPair(Cyan,Black),
[CPU_GUEST] = ColorPair(Cyan,Black),
+ [CPU_FREQ] = A_BOLD | ColorPair(Red,Black),
+ [CPU_TEMP] = A_BOLD | ColorPair(Red,Black),
+ [CPU_VCORE] = A_BOLD | ColorPair(Yellow,Black),
+ [GPU_TEMP] = A_BOLD | ColorPair(Yellow,Black),
+ [ETH0_INTERFACE] = A_BOLD | ColorPair(Blue,Black),
+ [ETH1_INTERFACE] = A_BOLD | ColorPair(Blue,Black),
+ [WLAN0_INTERFACE] = A_BOLD | ColorPair(Blue,Black),
+ [WLAN1_INTERFACE] = A_BOLD | ColorPair(Blue,Black),
+ [KERNEL_VERSION] = A_BOLD | ColorPair(Blue,Black),
+ [DISTRO_VERSION] = A_BOLD | ColorPair(Blue,Black),
+ [OS_VERSION] = A_BOLD | ColorPair(Blue,Black),
+ [ARMBIAN_VERSION] = A_BOLD | ColorPair(Blue,Black),
},
[COLORSCHEME_BROKENGRAY] = { 0 } // dynamically generated.
};
@@ -596,6 +682,15 @@ void CRT_restorePrivileges() {
// TODO: pass an instance of Settings instead.
void CRT_init(int delay, int colorScheme) {
+#ifdef DEBUG
+ setenv("TERM", "xterm", 1);
+ CRT_termType = getenv("TERM");
+ if (String_eq(CRT_termType, "linux"))
+ CRT_scrollHAmount = 20;
+ else
+ CRT_scrollHAmount = 5;
+ setenv("TERM", "xterm", 1);
+#endif
initscr();
noecho();
CRT_delay = delay;
diff --git a/CRT.h b/CRT.h
index 933fe06..29ba16b 100644
--- a/CRT.h
+++ b/CRT.h
@@ -116,6 +116,20 @@ typedef enum ColorElements_ {
CPU_SOFTIRQ,
CPU_STEAL,
CPU_GUEST,
+ CPU_TEMP,
+ CPU_FREQ,
+ CPU_VCORE,
+ GPU_TEMP,
+ ETH0_INTERFACE,
+ ETH1_INTERFACE,
+ WLAN0_INTERFACE,
+ WLAN1_INTERFACE,
+ KERNEL_VERSION,
+ DISTRO_VERSION,
+ OS_VERSION,
+ ARMBIAN_VERSION,
+ ETH0_STATS,
+ ETH1_STATS,
LAST_COLORELEMENT
} ColorElements;
diff --git a/CpuFreqMeter.c b/CpuFreqMeter.c
new file mode 100644
index 0000000..6508180
--- /dev/null
+++ b/CpuFreqMeter.c
@@ -0,0 +1,109 @@
+/*
+htop - CpuFreqMeter.c
+(C) 2020 Alexander Finger
+*/
+
+#include "CpuFreqMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int CpuFreqMeter_attributes[] = {
+ CPU_FREQ
+};
+
+static void CpuFreqMeter_setValues(Meter* this, char* buffer, int len) {
+ int ghz,mhz,roundup;
+ int cpu, Freq;
+ int bigLITTLE;
+ char buf_b[32];
+ char buf_l[32];
+ int ln = sizeof(buf_l);
+ static int pulse = 0;
+
+ memset(buf_l, 0, sizeof(buf_l));
+ memset(buf_b, 0, sizeof(buf_b));
+
+ bigLITTLE = Platform_getCpuBigLITTLE();
+ if (bigLITTLE) {
+ cpu = bigLITTLE;
+ if (cpu < 0)
+ cpu = 0;
+ Freq = Platform_getCpuFreq(this, cpu);
+ if (Freq > 1000) {
+ Freq /= 1000;
+ }
+ if (Freq > 1000) {
+ ghz = Freq / 1000;
+ mhz = Freq % 1000;
+ roundup = ((mhz % 10) > 5);
+ mhz /= 10;
+ mhz += roundup;
+ xSnprintf(buf_b, ln, "%d.%02d GHz", ghz, mhz);
+ } else {
+ xSnprintf(buf_b, ln, "%4d MHz", Freq);
+ }
+
+ cpu--;
+ if (cpu < 0)
+ cpu = 0;
+ Freq = Platform_getCpuFreq(this, cpu);
+ if (Freq > 1000) {
+ Freq /= 1000;
+ }
+ if (Freq > 1000) {
+ ghz = Freq / 1000;
+ mhz = Freq % 1000;
+ roundup = ((mhz % 10) > 5);
+ mhz /= 10;
+ mhz += roundup;
+ xSnprintf(buf_l, ln, "%d.%02d GHz", ghz, mhz);
+ } else {
+ xSnprintf(buf_l, ln, "%4d MHz", Freq);
+ }
+
+ if (pulse)
+ xSnprintf(buffer, len, "%s %s (big.LITTLE)", buf_b, buf_l, pulse);
+ else
+ xSnprintf(buffer, len, "%s %s ", buf_b, buf_l, pulse);
+ pulse = !pulse;
+ return;
+ }
+
+ cpu = 0;
+ Freq = Platform_getCpuFreq(this, cpu);
+ if (Freq > 1000) {
+ Freq /= 1000;
+ }
+ if (Freq > 1000) {
+ ghz = Freq / 1000;
+ mhz = Freq % 1000;
+ roundup = ((mhz % 10) > 5);
+ mhz /= 10;
+ mhz += roundup;
+ xSnprintf(buffer, len, "%d.%02d GHz", ghz, mhz);
+ } else {
+ xSnprintf(buffer, len, "%4d MHz", Freq);
+ }
+ pulse = !pulse;
+}
+
+MeterClass CpuFreqMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = CpuFreqMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 1,
+ .total = 100.0,
+ .attributes = CpuFreqMeter_attributes,
+ .name = "CpuFreq",
+ .uiName = "CpuFreq",
+ .caption = "Cpu Freq: ",
+};
+
diff --git a/CpuFreqMeter.h b/CpuFreqMeter.h
new file mode 100644
index 0000000..151a58c
--- /dev/null
+++ b/CpuFreqMeter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_CpuFreqMeter
+#define HEADER_CpuFreqMeter
+/*
+htop - CpuFreqMeter.h
+(C) 2020 Alexander Finger
+*/
+
+#include "Meter.h"
+
+extern int CpuFreqMeter_attributes[];
+
+extern MeterClass CpuFreqMeter_class;
+
+
+#endif
diff --git a/CpuTempMeter.c b/CpuTempMeter.c
new file mode 100644
index 0000000..4052256
--- /dev/null
+++ b/CpuTempMeter.c
@@ -0,0 +1,39 @@
+/*
+htop - CpuTempMeter.c
+(C) 2020 @lex
+*/
+
+#include "CpuTempMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+int CpuTempMeter_attributes[] = {
+ CPU_TEMP
+};
+
+static void CpuTempMeter_setValues(Meter* this, char* buffer, int len) {
+ int Temp = Platform_getCpuTemp(this);
+ if (Temp > 1000) {
+ Temp /= 1000;
+ }
+ xSnprintf(buffer, len, "%4d C", Temp);
+}
+
+MeterClass CpuTempMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = CpuTempMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 1,
+ .total = 100.0,
+ .attributes = CpuTempMeter_attributes,
+ .name = "CpuTemp",
+ .uiName = "CpuTemp",
+ .caption = "Cpu Temp: "
+};
diff --git a/CpuTempMeter.h b/CpuTempMeter.h
new file mode 100644
index 0000000..3538ac3
--- /dev/null
+++ b/CpuTempMeter.h
@@ -0,0 +1,16 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_CpuTempMeter
+#define HEADER_CpuTempMeter
+/*
+htop - CpuTempMeter.h
+(C) 2020 @lex
+*/
+
+#include "Meter.h"
+
+extern int CpuTempMeter_attributes[];
+
+extern MeterClass CpuTempMeter_class;
+
+#endif
diff --git a/CpuVcoreMeter.c b/CpuVcoreMeter.c
new file mode 100644
index 0000000..03adb6d
--- /dev/null
+++ b/CpuVcoreMeter.c
@@ -0,0 +1,84 @@
+/*
+htop - CpuVcoreMeter.c
+(C) 2020 Alexander Finger
+*/
+
+#include "CpuVcoreMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int CpuVcoreMeter_attributes[] = {
+ CPU_VCORE
+};
+
+static void CpuVcoreMeter_setValues(Meter* this, char* buffer, int len) {
+ int v1,v2;
+ int Vcore, Vcore_l, Vcore_b;
+ char buf1[80], buf2[80];
+ int h;
+
+ if (Platform_getCpuBigLITTLE()) {
+ h = len / 2;
+ if (h > 79)
+ h = 79;
+ Vcore_b = Platform_getCpuVcore_b(this);
+ if (Vcore_b > 1000) {
+ Vcore_b /= 1000;
+ }
+ if (Vcore_b >= 1000) {
+ Vcore_b /= 10;
+ v1 = Vcore_b / 100;
+ v2 = Vcore_b % 100;
+ xSnprintf(buf1, h, "%d.%02d V ", v1, v2);
+ } else {
+ xSnprintf(buf1, h, "%4d mV", Vcore_b);
+ }
+ Vcore_l = Platform_getCpuVcore_l(this);
+ if (Vcore_l > 1000) {
+ Vcore_l /= 1000;
+ }
+ if (Vcore_l >= 1000) {
+ Vcore_l /= 10;
+ v1 = Vcore_l / 100;
+ v2 = Vcore_l % 100;
+ xSnprintf(buf2, h, "%d.%02d V ", v1, v2);
+ } else {
+ xSnprintf(buf2, h, "%4d mV", Vcore_l);
+ }
+ xSnprintf(buffer, len, "%s %s (big.LITTLE)", buf1, buf2);
+ return;
+ }
+
+ Vcore = Platform_getCpuVcore(this);
+ if (Vcore > 1000) {
+ Vcore /= 1000;
+ }
+ if (Vcore >= 1000) {
+ Vcore /= 10;
+ v1 = Vcore / 100;
+ v2 = Vcore % 100;
+ xSnprintf(buffer, len, "%d.%02d V", v1, v2);
+ } else {
+ xSnprintf(buffer, len, "%4d mV", Vcore);
+ }
+}
+
+MeterClass CpuVcoreMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = CpuVcoreMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 1,
+ .total = 100.0,
+ .attributes = CpuVcoreMeter_attributes,
+ .name = "CpuVcore",
+ .uiName = "CpuVcore",
+ .caption = "Cpu Vcor: "
+};
diff --git a/CpuVcoreMeter.h b/CpuVcoreMeter.h
new file mode 100644
index 0000000..603e8e2
--- /dev/null
+++ b/CpuVcoreMeter.h
@@ -0,0 +1,16 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_CpuVcoreMeter
+#define HEADER_CpuVcoreMeter
+/*
+htop - CpuVcoreMeter.h
+(C) 2020 Alexander Finger
+*/
+
+#include "Meter.h"
+
+extern int CpuVcoreMeter_attributes[];
+
+extern MeterClass CpuVcoreMeter_class;
+
+#endif
diff --git a/Eth0_Meter.c b/Eth0_Meter.c
new file mode 100644
index 0000000..90e512a
--- /dev/null
+++ b/Eth0_Meter.c
@@ -0,0 +1,60 @@
+/*
+htop - Eth0_Meter.c
+(C) 2018 @lex
+*/
+
+#include "Eth0_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Eth0_Meter_attributes[] = {
+ ETH0_INTERFACE
+};
+
+static void Eth0_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char szIP[48];
+ static unsigned int use_cached = 0;
+ Settings* settings = this->pl->settings;
+
+ if ((use_cached++ % 2)) {
+ xSnprintf(buffer, len, "%s", szIP);
+ return;
+ }
+
+ if (settings->eth0_alias[0] != 0) {
+ ret = findIP_interface(settings->eth0_alias, szIP, sizeof(szIP));
+ } else {
+ ret = findIP_interface("eth0", szIP, sizeof(szIP));
+ }
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", szIP);
+ } else {
+ xSnprintf(buffer, len, "%s", "down");
+ }
+}
+
+MeterClass Eth0_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Eth0_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Eth0_Meter_attributes,
+ .name = "Eth0",
+ .uiName = "Eth0 IP",
+ .caption = "Eth0 IP: ",
+};
+
+
diff --git a/Eth0_Meter.h b/Eth0_Meter.h
new file mode 100644
index 0000000..5443abc
--- /dev/null
+++ b/Eth0_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Eth0_Meter
+#define HEADER_Eth0_Meter
+/*
+htop - Eth0_Meter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int Eth0_Meter_attributes[];
+
+extern MeterClass Eth0_Meter_class;
+
+
+#endif
diff --git a/Eth0_StatsMeter.c b/Eth0_StatsMeter.c
new file mode 100644
index 0000000..974c656
--- /dev/null
+++ b/Eth0_StatsMeter.c
@@ -0,0 +1,83 @@
+/*
+htop - Eth0_StatsMeter.c
+(C) 2020 @lex
+*/
+
+#include "Eth0_StatsMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Eth0_StatsMeter_attributes[] = {
+ ETH0_INTERFACE
+};
+
+/* borrowed from slurm */
+static void Eth0_StatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float rxspeed;
+ float txspeed;
+ Settings* settings = this->pl->settings;
+ double refreshdelay;
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ if (settings->eth0_alias[0] != 0) {
+ ret = Platform_getEth_stats(settings->eth0_alias, 0, 0);
+ } else {
+ ret = Platform_getEth_stats("eth0", 0, 0);
+ }
+
+ if (ret) {
+ if (Platform_Eth0_stats.rx_bytes_comp > Platform_Eth0_stats.rx_bytes)
+ Platform_Eth0_stats.rx_bytes_comp = 0;
+ if (Platform_Eth0_stats.tx_bytes_comp > Platform_Eth0_stats.tx_bytes)
+ Platform_Eth0_stats.tx_bytes_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ rxspeed = (Platform_Eth0_stats.rx_bytes - Platform_Eth0_stats.rx_bytes_comp) / refreshdelay;
+ txspeed = (Platform_Eth0_stats.tx_bytes - Platform_Eth0_stats.tx_bytes_comp) / refreshdelay;
+
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (TX/RX)", (float) txspeed / 1024, (float) rxspeed / 1024);
+
+ Platform_Eth0_stats.rx_bytes_comp = Platform_Eth0_stats.rx_bytes;
+ Platform_Eth0_stats.tx_bytes_comp = Platform_Eth0_stats.tx_bytes;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavail");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass Eth0_StatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Eth0_StatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Eth0_StatsMeter_attributes,
+ .name = "Eth0stat",
+ .uiName = "Eth0 stat",
+ .caption = "Eth0 stat: ",
+};
+
+
diff --git a/Eth0_StatsMeter.h b/Eth0_StatsMeter.h
new file mode 100644
index 0000000..e44a5cc
--- /dev/null
+++ b/Eth0_StatsMeter.h
@@ -0,0 +1,18 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Eth0_StatsMeter
+#define HEADER_Eth0_StatsMeter
+/*
+htop - Eth0_StatsMeter.h
+(C) 2020 @lex
+*/
+
+#include "Meter.h"
+
+extern int Eth0_StatsMeter_attributes[];
+
+/* borrowed from slurm */
+extern MeterClass Eth0_StatsMeter_class;
+
+
+#endif
diff --git a/Eth1_Meter.c b/Eth1_Meter.c
new file mode 100644
index 0000000..41cfa05
--- /dev/null
+++ b/Eth1_Meter.c
@@ -0,0 +1,60 @@
+/*
+htop - Eth1_Meter.c
+(C) 2018 @lex
+*/
+
+#include "Eth1_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Eth1_Meter_attributes[] = {
+ ETH1_INTERFACE
+};
+
+static void Eth1_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char szIP[48];
+ static unsigned int use_cached = 0;
+ Settings* settings = this->pl->settings;
+
+ if ((use_cached++ % 2)) {
+ xSnprintf(buffer, len, "%s", szIP);
+ return;
+ }
+
+ if (settings->eth1_alias[0] != 0) {
+ ret = findIP_interface(settings->eth1_alias, szIP, sizeof(szIP));
+ } else {
+ ret = findIP_interface("eth1", szIP, sizeof(szIP));
+ }
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", szIP);
+ } else {
+ xSnprintf(buffer, len, "%s", "down");
+ }
+}
+
+MeterClass Eth1_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Eth1_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Eth1_Meter_attributes,
+ .name = "Eth1",
+ .uiName = "Eth1 IP",
+ .caption = "Eth1 IP: ",
+};
+
+
diff --git a/Eth1_Meter.h b/Eth1_Meter.h
new file mode 100644
index 0000000..7f7f4fc
--- /dev/null
+++ b/Eth1_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Eth1_Meter
+#define HEADER_Eth1_Meter
+/*
+htop - Eth1_Meter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int Eth1_Meter_attributes[];
+
+extern MeterClass Eth1_Meter_class;
+
+
+#endif
diff --git a/Eth1_StatsMeter.c b/Eth1_StatsMeter.c
new file mode 100644
index 0000000..85e6dc9
--- /dev/null
+++ b/Eth1_StatsMeter.c
@@ -0,0 +1,83 @@
+/*
+htop - Eth1_StatsMeter.c
+(C) 2020 @lex
+*/
+
+#include "Eth1_StatsMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Eth1_StatsMeter_attributes[] = {
+ ETH1_INTERFACE
+};
+
+/* borrowed from slurm */
+static void Eth1_StatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float rxspeed;
+ float txspeed;
+ Settings* settings = this->pl->settings;
+ double refreshdelay;
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ if (settings->eth1_alias[0] != 0) {
+ ret = Platform_getEth_stats(settings->eth1_alias, 1, 0);
+ } else {
+ ret = Platform_getEth_stats("eth1", 1, 0);
+ }
+
+ if (ret) {
+ if (Platform_Eth1_stats.rx_bytes_comp > Platform_Eth1_stats.rx_bytes)
+ Platform_Eth1_stats.rx_bytes_comp = 0;
+ if (Platform_Eth1_stats.tx_bytes_comp > Platform_Eth1_stats.tx_bytes)
+ Platform_Eth1_stats.tx_bytes_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ rxspeed = (Platform_Eth1_stats.rx_bytes - Platform_Eth1_stats.rx_bytes_comp) / refreshdelay;
+ txspeed = (Platform_Eth1_stats.tx_bytes - Platform_Eth1_stats.tx_bytes_comp) / refreshdelay;
+
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (TX/RX)", (float) txspeed / 1024, (float) rxspeed / 1024);
+
+ Platform_Eth1_stats.rx_bytes_comp = Platform_Eth1_stats.rx_bytes;
+ Platform_Eth1_stats.tx_bytes_comp = Platform_Eth1_stats.tx_bytes;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavail");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass Eth1_StatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Eth1_StatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Eth1_StatsMeter_attributes,
+ .name = "Eth1stat",
+ .uiName = "Eth1 stat",
+ .caption = "Eth1 stat: ",
+};
+
+
diff --git a/Eth1_StatsMeter.h b/Eth1_StatsMeter.h
new file mode 100644
index 0000000..c173b15
--- /dev/null
+++ b/Eth1_StatsMeter.h
@@ -0,0 +1,18 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Eth1_StatsMeter
+#define HEADER_Eth1_StatsMeter
+/*
+htop - Eth1_StatsMeter.h
+(C) 2020 @lex
+*/
+
+#include "Meter.h"
+
+extern int Eth1_StatsMeter_attributes[];
+
+/* borrowed from slurm */
+extern MeterClass Eth1_StatsMeter_class;
+
+
+#endif
diff --git a/GpuTempMeter.c b/GpuTempMeter.c
new file mode 100644
index 0000000..92394b3
--- /dev/null
+++ b/GpuTempMeter.c
@@ -0,0 +1,39 @@
+/*
+htop - GpuTempMeter.c
+(C) 2018 @lex
+*/
+
+#include "GpuTempMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+int GpuTempMeter_attributes[] = {
+ GPU_TEMP
+};
+
+static void GpuTempMeter_setValues(Meter* this, char* buffer, int len) {
+ int Temp = Platform_getGpuTemp(this);
+ if (Temp > 1000) {
+ Temp /= 1000;
+ }
+ xSnprintf(buffer, len, "%4d C", Temp);
+}
+
+MeterClass GpuTempMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = GpuTempMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 1,
+ .total = 100.0,
+ .attributes = GpuTempMeter_attributes,
+ .name = "GpuTemp",
+ .uiName = "GpuTemp",
+ .caption = "Gpu Temp: "
+};
diff --git a/GpuTempMeter.h b/GpuTempMeter.h
new file mode 100644
index 0000000..40dab90
--- /dev/null
+++ b/GpuTempMeter.h
@@ -0,0 +1,16 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_GpuTempMeter
+#define HEADER_GpuTempMeter
+/*
+htop - GpuTempMeter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int GpuTempMeter_attributes[];
+
+extern MeterClass GpuTempMeter_class;
+
+#endif
diff --git a/Kernel_Meter.c b/Kernel_Meter.c
new file mode 100644
index 0000000..45c675f
--- /dev/null
+++ b/Kernel_Meter.c
@@ -0,0 +1,55 @@
+/*
+htop - Kernelversion_Meter.c
+(C) 2018 @lex
+*/
+
+#include "Kernel_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Kernelversion_Meter_attributes[] = {
+ KERNEL_VERSION
+};
+
+static void Kernelversion_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char version[256];
+ static int use_cached = 0;
+
+ if ((use_cached++ % 10)) {
+ xSnprintf(buffer, len, "%s", version);
+ return;
+ }
+
+ ret = ReadTokenValue( "/proc/version", "Linux version", version);
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", version);
+ } else {
+ xSnprintf(buffer, len, "%s", "down");
+ }
+}
+
+MeterClass Kernelversion_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Kernelversion_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Kernelversion_Meter_attributes,
+ .name = "Kernelversion",
+ .uiName = "Kernel version",
+ .caption = "Kernel: ",
+};
+
+
diff --git a/Kernel_Meter.h b/Kernel_Meter.h
new file mode 100644
index 0000000..98f9a1f
--- /dev/null
+++ b/Kernel_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Kernel_Meter
+#define HEADER_Kernel_Meter
+/*
+htop - Kernelversion_Meter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int Kernelversion_Meter_attributes[];
+
+extern MeterClass Kernelversion_Meter_class;
+
+
+#endif
diff --git a/Makefile.am b/Makefile.am
index cd5209c..6557c6a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -21,7 +21,9 @@ ClockMeter.c ColorsPanel.c ColumnsPanel.c CPUMeter.c CRT.c MainPanel.c \
DisplayOptionsPanel.c FunctionBar.c Hashtable.c Header.c htop.c ListItem.c \
LoadAverageMeter.c MemoryMeter.c Meter.c MetersPanel.c Object.c Panel.c \
BatteryMeter.c Process.c ProcessList.c RichString.c ScreenManager.c Settings.c \
-SignalsPanel.c StringUtils.c SwapMeter.c TasksMeter.c UptimeMeter.c \
+SignalsPanel.c StringUtils.c SwapMeter.c TasksMeter.c UptimeMeter.c CpuFreqMeter.c CpuTempMeter.c GpuTempMeter.c CpuVcoreMeter.c \
+interfaces.c OS_Meter.c Eth0_Meter.c Eth1_Meter.c Wlan0_Meter.c Wlan1_Meter.c Kernel_Meter.c Armbian_Meter.c \
+Wlan0_StatsMeter.c Eth0_StatsMeter.c Eth1_StatsMeter.c BlockDevice_ioStatsMeter.c \
TraceScreen.c UsersTable.c Vector.c AvailableColumnsPanel.c AffinityPanel.c \
HostnameMeter.c OpenFilesScreen.c Affinity.c IncSet.c Action.c EnvScreen.c \
InfoScreen.c XAlloc.c
@@ -32,7 +34,9 @@ CPUMeter.h CRT.h MainPanel.h DisplayOptionsPanel.h FunctionBar.h \
Hashtable.h Header.h htop.h ListItem.h LoadAverageMeter.h MemoryMeter.h \
BatteryMeter.h Meter.h MetersPanel.h Object.h Panel.h ProcessList.h RichString.h \
ScreenManager.h Settings.h SignalsPanel.h StringUtils.h SwapMeter.h \
-TasksMeter.h UptimeMeter.h TraceScreen.h UsersTable.h Vector.h Process.h \
+TasksMeter.h UptimeMeter.h CpuFreqMeter.h CpuTempMeter.h GpuTempMeter.h CpuVcoreMeter.h TraceScreen.h UsersTable.h Vector.h Process.h \
+interfaces.h OS_Meter.h Eth0_Meter.h Eth1_Meter.h Wlan0_Meter.h Wlan1_Meter.h Kernel_Meter.h Armbian_Meter.h \
+Wlan0_StatsMeter.h Eth0_StatsMeter.h Eth1_StatsMeter.h BlockDevice_ioStatsMeter.h \
AffinityPanel.h HostnameMeter.h OpenFilesScreen.h Affinity.h IncSet.h Action.h \
EnvScreen.h InfoScreen.h XAlloc.h
diff --git a/OS_Meter.c b/OS_Meter.c
new file mode 100644
index 0000000..588c234
--- /dev/null
+++ b/OS_Meter.c
@@ -0,0 +1,55 @@
+/*
+htop - OSversion_Meter.c
+(C) 2018 @lex
+*/
+
+#include "OS_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int OSversion_Meter_attributes[] = {
+ OS_VERSION
+};
+
+static void OSversion_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char version[256];
+ static int use_cached = 0;
+
+ if ((use_cached++ % 10)) {
+ xSnprintf(buffer, len, "%s", version);
+ return;
+ }
+
+ ret = ReadKeyValue( "/etc/os-release", "PRETTY_NAME=", version);
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", version);
+ } else {
+ xSnprintf(buffer, len, "%s", "down");
+ }
+}
+
+MeterClass OSversion_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = OSversion_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = OSversion_Meter_attributes,
+ .name = "OSversion",
+ .uiName = "OS version",
+ .caption = "OS vers: ",
+};
+
+
diff --git a/OS_Meter.h b/OS_Meter.h
new file mode 100644
index 0000000..c5cccb2
--- /dev/null
+++ b/OS_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_OS_Meter
+#define HEADER_OS_Meter
+/*
+htop - OSversion_Meter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int OSversion_Meter_attributes[];
+
+extern MeterClass OSversion_Meter_class;
+
+
+#endif
diff --git a/Process.c b/Process.c
index 471f529..9ac5fa6 100644
--- a/Process.c
+++ b/Process.c
@@ -1,6 +1,7 @@
/*
htop - Process.c
(C) 2004-2015 Hisham H. Muhammad
+(C) 2020 Alexander Finger
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
diff --git a/Process.h b/Process.h
index f702ca0..fbd9ef5 100644
--- a/Process.h
+++ b/Process.h
@@ -5,6 +5,7 @@
/*
htop - Process.h
(C) 2004-2015 Hisham H. Muhammad
+(C) 2020 Alexander Finger
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
diff --git a/ProcessList.c b/ProcessList.c
index 7482b03..4ef1e83 100644
--- a/ProcessList.c
+++ b/ProcessList.c
@@ -69,6 +69,7 @@ typedef struct ProcessList_ {
unsigned long long int freeSwap;
int cpuCount;
+ int cpuBigLITTLE;
} ProcessList;
diff --git a/ProcessList.h b/ProcessList.h
index 572d484..aa0e6c0 100644
--- a/ProcessList.h
+++ b/ProcessList.h
@@ -63,6 +63,7 @@ typedef struct ProcessList_ {
unsigned long long int freeSwap;
int cpuCount;
+ int cpuBigLITTLE;
} ProcessList;
diff --git a/ScreenManager.c b/ScreenManager.c
index 05e1c02..3ae6670 100644
--- a/ScreenManager.c
+++ b/ScreenManager.c
@@ -130,6 +130,7 @@ static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTi
if (newTime < *oldTime) *rescan = true; // clock was adjusted?
if (*rescan) {
*oldTime = newTime;
+ Header_draw(this->header);
ProcessList_scan(pl);
if (*sortTimeout == 0 || this->settings->treeView) {
ProcessList_sort(pl);
@@ -139,7 +140,7 @@ static void checkRecalculation(ScreenManager* this, double* oldTime, int* sortTi
}
if (*redraw) {
ProcessList_rebuildPanel(pl);
- Header_draw(this->header);
+ // Header_draw(this->header);
}
*rescan = false;
}
diff --git a/Settings.c b/Settings.c
index db2fa06..912ad7d 100644
--- a/Settings.c
+++ b/Settings.c
@@ -59,6 +59,28 @@ typedef struct Settings_ {
bool accountGuestInCPUMeter;
bool headerMargin;
+ char CpuFreq_handler[256];
+ char CpuTemp_handler[256];
+ char CpuVCore_l_handler[256];
+ char CpuVCore_b_handler[256];
+
+ char GpuVCore_handler[256];
+ char GpuTemp_handler[256];
+
+ char BoardName[128];
+ char KernelVersionFull[256];
+ char KernelVersionShort[64];
+
+ char IP_wlan0[32];
+ char IP_wlan1[32];
+ char IP_eth0[32];
+ char IP_eth1[32];
+
+ char eth0_alias[32];
+ char eth1_alias[32];
+ char wlan0_alias[32];
+ char wlan1_alias[32];
+
bool changed;
} Settings;
@@ -141,6 +163,12 @@ static void Settings_defaultMeters(Settings* this) {
this->columns[1].modes[r++] = TEXT_METERMODE;
this->columns[1].names[r] = xStrdup("Uptime");
this->columns[1].modes[r++] = TEXT_METERMODE;
+
+ this->columns[1].names[r] = xStrdup("CpuTemp");
+ this->columns[1].modes[r++] = TEXT_METERMODE;
+ this->columns[1].names[r] = xStrdup("CpuFreq");
+ this->columns[1].modes[r++] = TEXT_METERMODE;
+
}
static void readFields(ProcessField* fields, int* flags, const char* line) {
@@ -244,7 +272,41 @@ static bool Settings_read(Settings* this, const char* fileName) {
} else if (String_eq(option[0], "right_meter_modes")) {
Settings_readMeterModes(this, option[1], 1);
didReadMeters = true;
- }
+ } else if (String_eq(option[0], "BoardName")) {
+ strcpy(this->BoardName,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "CpuFreq_handler")) {
+ strcpy(this->CpuFreq_handler,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "CpuTemp_handler")) {
+ strcpy(this->CpuTemp_handler,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "CpuVCore_l_handler")) {
+ strcpy(this->CpuVCore_l_handler,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "CpuVCore_b_handler")) {
+ strcpy(this->CpuVCore_b_handler,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "GpuVCore_handler")) {
+ strcpy(this->GpuVCore_handler,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "GpuTemp_handler")) {
+ strcpy(this->GpuTemp_handler,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "eth0_alias")) {
+ strcpy(this->eth0_alias,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "eth1_alias")) {
+ strcpy(this->eth1_alias,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "wlan0_alias")) {
+ strcpy(this->wlan0_alias,option[1]);
+ didReadMeters = true;
+ } else if (String_eq(option[0], "wlan1_alias")) {
+ strcpy(this->wlan1_alias,option[1]);
+ didReadMeters = true;
+ }
+
String_freeArray(option);
}
fclose(fd);
@@ -320,6 +382,23 @@ bool Settings_write(Settings* this) {
fprintf(fd, "left_meter_modes="); writeMeterModes(this, fd, 0);
fprintf(fd, "right_meters="); writeMeters(this, fd, 1);
fprintf(fd, "right_meter_modes="); writeMeterModes(this, fd, 1);
+
+ fprintf(fd, "# SBC hardware and Kernel specific path.\n");
+ fprintf(fd, "# Editable manually.\n");
+ fprintf(fd, "BoardName=%s\n", this->BoardName);
+ fprintf(fd, "CpuFreq_handler=%s\n", this->CpuFreq_handler);
+ fprintf(fd, "CpuTemp_handler=%s\n", this->CpuTemp_handler);
+ fprintf(fd, "CpuVCore_l_handler=%s\n", this->CpuVCore_l_handler);
+ fprintf(fd, "CpuVCore_b_handler=%s\n", this->CpuVCore_b_handler);
+ fprintf(fd, "GpuVCore_handler=%s\n", this->GpuVCore_handler);
+ fprintf(fd, "GpuTemp_handler=%s\n", this->GpuTemp_handler);
+
+ fprintf(fd, "# Wlan / Eth alias\n");
+ fprintf(fd, "eth0_alias=%s\n",this->eth0_alias);
+ fprintf(fd, "eth1_alias=%s\n",this->eth1_alias);
+ fprintf(fd, "wlan0_alias=%s\n",this->wlan0_alias);
+ fprintf(fd, "wlan1_alias=%s\n",this->wlan1_alias);
+
fclose(fd);
return true;
}
diff --git a/Settings.h b/Settings.h
index d9dc068..4fcd885 100644
--- a/Settings.h
+++ b/Settings.h
@@ -50,6 +50,28 @@ typedef struct Settings_ {
bool accountGuestInCPUMeter;
bool headerMargin;
+ char CpuFreq_handler[256];
+ char CpuTemp_handler[256];
+ char CpuVCore_l_handler[256];
+ char CpuVCore_b_handler[256];
+
+ char GpuVCore_handler[256];
+ char GpuTemp_handler[256];
+
+ char BoardName[128];
+ char KernelVersionFull[256];
+ char KernelVersionShort[64];
+
+ char IP_wlan0[32];
+ char IP_wlan1[32];
+ char IP_eth0[32];
+ char IP_eth1[32];
+
+ char eth0_alias[32];
+ char eth1_alias[32];
+ char wlan0_alias[32];
+ char wlan1_alias[32];
+
bool changed;
} Settings;
diff --git a/Wlan0_Meter.c b/Wlan0_Meter.c
new file mode 100644
index 0000000..bf75623
--- /dev/null
+++ b/Wlan0_Meter.c
@@ -0,0 +1,58 @@
+/*
+htop - Wlan0_Meter.c
+(C) 2020 @lex
+*/
+
+#include "Wlan0_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Wlan0_Meter_attributes[] = {
+ WLAN0_INTERFACE
+};
+
+static void Wlan0_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char szIP[48];
+ static unsigned int use_cached = 0;
+ Settings* settings = this->pl->settings;
+
+ if ((use_cached++ % 2)) {
+ xSnprintf(buffer, len, "%s", szIP);
+ return;
+ }
+
+ if (settings->wlan0_alias[0] != 0) {
+ ret = findIP_interface(settings->wlan0_alias, szIP, sizeof(szIP));
+ } else {
+ ret = findIP_interface("wlan0", szIP, sizeof(szIP));
+ }
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", szIP);
+ } else {
+ xSnprintf(buffer, len, "%s", "down");
+ }
+}
+
+MeterClass Wlan0_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Wlan0_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Wlan0_Meter_attributes,
+ .name = "Wlan0",
+ .uiName = "Wlan0 IP",
+ .caption = "Wlan0 IP: ",
+};
+
+
diff --git a/Wlan0_Meter.h b/Wlan0_Meter.h
new file mode 100644
index 0000000..59761ff
--- /dev/null
+++ b/Wlan0_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Wlan0_Meter
+#define HEADER_Wlan0_Meter
+/*
+htop - Wlan0_Meter.h
+(C) 2020 @lex
+*/
+
+#include "Meter.h"
+
+extern int Wlan0_Meter_attributes[];
+
+extern MeterClass Wlan0_Meter_class;
+
+
+#endif
diff --git a/Wlan0_StatsMeter.c b/Wlan0_StatsMeter.c
new file mode 100644
index 0000000..f920f9c
--- /dev/null
+++ b/Wlan0_StatsMeter.c
@@ -0,0 +1,83 @@
+/*
+htop - Wlan0_StatsMeter.c
+(C) 2020 @lex
+*/
+
+#include "Wlan0_StatsMeter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Wlan0_StatsMeter_attributes[] = {
+ ETH0_INTERFACE
+};
+
+/* borrowed from slurm */
+static void Wlan0_StatsMeter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ float rxspeed;
+ float txspeed;
+ Settings* settings = this->pl->settings;
+ double refreshdelay;
+ static double old = 0.;
+ static double now = 0.;
+ static int flash = 0;
+
+ now = get_wall_time();
+ refreshdelay = now - old;
+ if (old == 0.)
+ refreshdelay = 1.;
+ old = now;
+
+ if (settings->wlan0_alias[0] != 0) {
+ ret = Platform_getEth_stats(settings->wlan0_alias, 2, 0);
+ } else {
+ ret = Platform_getEth_stats("wlan0", 0, 0);
+ }
+
+ if (ret) {
+ if (Platform_Wlan0_stats.rx_bytes_comp > Platform_Wlan0_stats.rx_bytes)
+ Platform_Wlan0_stats.rx_bytes_comp = 0;
+ if (Platform_Wlan0_stats.tx_bytes_comp > Platform_Wlan0_stats.tx_bytes)
+ Platform_Wlan0_stats.tx_bytes_comp = 0;
+
+ /* we assume here the refresdelay is 1 sec which sometimes is 1.5, so we have a peak */
+ rxspeed = (Platform_Wlan0_stats.rx_bytes - Platform_Wlan0_stats.rx_bytes_comp) / refreshdelay;
+ txspeed = (Platform_Wlan0_stats.tx_bytes - Platform_Wlan0_stats.tx_bytes_comp) / refreshdelay;
+
+ xSnprintf(buffer, len, "%.2f KB/s - %.2f KB/s (TX/RX)", (float) txspeed / 1024, (float) rxspeed / 1024);
+
+ Platform_Wlan0_stats.rx_bytes_comp = Platform_Wlan0_stats.rx_bytes;
+ Platform_Wlan0_stats.tx_bytes_comp = Platform_Wlan0_stats.tx_bytes;
+
+ } else {
+ if (!(flash % 2))
+ xSnprintf(buffer, len, "%s", "unavail");
+ else
+ xSnprintf(buffer, len, "%s", "");
+ flash++;
+ }
+}
+
+MeterClass Wlan0_StatsMeter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Wlan0_StatsMeter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Wlan0_StatsMeter_attributes,
+ .name = "Wlan0stat",
+ .uiName = "Wlan0 stat",
+ .caption = "Wlan0 stat: ",
+};
+
+
diff --git a/Wlan0_StatsMeter.h b/Wlan0_StatsMeter.h
new file mode 100644
index 0000000..2880f9d
--- /dev/null
+++ b/Wlan0_StatsMeter.h
@@ -0,0 +1,18 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Wlan0_StatsMeter
+#define HEADER_Wlan0_StatsMeter
+/*
+htop - Wlan0_StatsMeter.h
+(C) 2020 @lex
+*/
+
+#include "Meter.h"
+
+extern int Wlan0_StatsMeter_attributes[];
+
+/* borrowed from slurm */
+extern MeterClass Wlan0_StatsMeter_class;
+
+
+#endif
diff --git a/Wlan1_Meter.c b/Wlan1_Meter.c
new file mode 100644
index 0000000..c5acd69
--- /dev/null
+++ b/Wlan1_Meter.c
@@ -0,0 +1,60 @@
+/*
+htop - Eth0_Meter.c
+(C) 2018 @lex
+*/
+
+#include "Wlan1_Meter.h"
+#include "Platform.h"
+#include "CRT.h"
+
+#include "interfaces.h"
+
+/*{
+#include "Meter.h"
+}*/
+
+
+int Wlan1_Meter_attributes[] = {
+ WLAN1_INTERFACE
+};
+
+static void Wlan1_Meter_setValues(Meter* this, char* buffer, int len) {
+ int ret;
+ static char szIP[48];
+ static unsigned int use_cached = 0;
+ Settings* settings = this->pl->settings;
+
+ if ((use_cached++ % 2)) {
+ xSnprintf(buffer, len, "%s", szIP);
+ return;
+ }
+
+ if (settings->wlan1_alias[0] != 0) {
+ ret = findIP_interface(settings->wlan1_alias, szIP, sizeof(szIP));
+ } else {
+ ret = findIP_interface("wlan1", szIP, sizeof(szIP));
+ }
+
+ if (ret) {
+ xSnprintf(buffer, len, "%s", szIP);
+ } else {
+ xSnprintf(buffer, len, "%s", "down");
+ }
+}
+
+MeterClass Wlan1_Meter_class = {
+ .super = {
+ .extends = Class(Meter),
+ .delete = Meter_delete
+ },
+ .updateValues = Wlan1_Meter_setValues,
+ .defaultMode = TEXT_METERMODE,
+ .maxItems = 8,
+ .total = 100.0,
+ .attributes = Wlan1_Meter_attributes,
+ .name = "Wlan1",
+ .uiName = "Wlan1 IP",
+ .caption = "Wlan1 IP: ",
+};
+
+
diff --git a/Wlan1_Meter.h b/Wlan1_Meter.h
new file mode 100644
index 0000000..4bba228
--- /dev/null
+++ b/Wlan1_Meter.h
@@ -0,0 +1,17 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_Wlan1_Meter
+#define HEADER_Wlan1_Meter
+/*
+htop - Eth0_Meter.h
+(C) 2018 @lex
+*/
+
+#include "Meter.h"
+
+extern int Wlan1_Meter_attributes[];
+
+extern MeterClass Wlan1_Meter_class;
+
+
+#endif
diff --git a/htop.c b/htop.c
index 6db81dd..0044eb8 100644
--- a/htop.c
+++ b/htop.c
@@ -1,6 +1,7 @@
/*
htop - htop.c
(C) 2004-2011 Hisham H. Muhammad
+(C) 2020 Alexander Finger
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
@@ -170,7 +171,6 @@ static void millisleep(unsigned long millisec) {
}
int main(int argc, char** argv) {
-
char *lc_ctype = getenv("LC_CTYPE");
if(lc_ctype != NULL)
setlocale(LC_CTYPE, lc_ctype);
@@ -193,6 +193,8 @@ int main(int argc, char** argv) {
UsersTable* ut = UsersTable_new();
ProcessList* pl = ProcessList_new(ut, flags.pidWhiteList, flags.userId);
+ Platform_findCpuBigLITTLE(pl->cpuCount, &pl->cpuBigLITTLE);
+
Settings* settings = Settings_new(pl->cpuCount);
pl->settings = settings;
@@ -243,7 +245,16 @@ int main(int argc, char** argv) {
mvhline(LINES-1, 0, ' ', COLS);
attroff(CRT_colors[RESET_COLOR]);
refresh();
-
+
+ Platform_getEth_stats("", -1, 1);
+ Platform_getIO_stats("", 0, 1);
+ Platform_getIO_stats("", 1, 1);
+ Platform_getIO_stats("", 2, 1);
+ Platform_getIO_stats("", 3, 1);
+ Platform_getIO_stats("", 4, 1);
+ Platform_getIO_stats("", 5, 1);
+ Platform_getIO_stats("", 6, 1);
+ Platform_getIO_stats("", 7, 1);
CRT_done();
if (settings->changed)
Settings_write(settings);
diff --git a/htop.h b/htop.h
index 7faa6c6..05d5fd4 100644
--- a/htop.h
+++ b/htop.h
@@ -5,6 +5,7 @@
/*
htop - htop.h
(C) 2004-2011 Hisham H. Muhammad
+(C) 2020 Alexander Finger
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
diff --git a/interfaces.c b/interfaces.c
new file mode 100644
index 0000000..aa41d2a
--- /dev/null
+++ b/interfaces.c
@@ -0,0 +1,206 @@
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <linux/i2c-dev.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <ifaddrs.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <linux/if_link.h>
+#include <linux/if.h>
+#include <signal.h>
+
+#include "interfaces.h"
+#include "Settings.h"
+
+#define BLEN 256
+/*
+ /etc/armbian-release
+ VERSION=20.02.1
+
+ /etc/debian_version
+ buster/sid
+
+ cat /etc/lsb-release
+ DISTRIB_DESCRIPTION="Ubuntu 18.04.5 LTS"
+
+ cat /etc/os-release
+ PRETTY_NAME="Ubuntu 18.04.5 LTS"
+ VERSION="18.04.5 LTS (Bionic Beaver)"
+ ID=ubuntu
+
+ cat /proc/version
+ Linux version 5.3.0-52-generic (buildd@lgw01-amd64-037) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #46~18.04.1-Ubuntu SMP Thu Apr 30 16:13:51 UTC 2020
+*/
+
+
+int ReadKeyValue( char *fname, char *key, char *value) {
+ FILE* fp;
+ char buffer[BLEN];
+ int fd = 0;
+ int len = strlen(key);
+ char *str;
+ char *str_end;
+
+ fp = fopen(fname, "r");
+ if (fp == NULL)
+ return fd;
+
+ while (fgets(buffer, BLEN, fp) != NULL) {
+ str = strstr(buffer, key);
+ if (str != NULL) {
+ fd = 1;
+ str += len;
+ if (*str == '\"') {
+ str++;
+ len = strlen(str);
+ str_end = str + len;
+ while (*str_end != '\"') {
+ *str_end = 0;
+ str_end--;
+ if (str_end == str)
+ break;
+ }
+ *str_end = 0;
+ strcpy(value, str);
+ fd = 1;
+ } else {
+ strcpy(value, str);
+ fd = 1;
+ }
+ }
+ }
+ fclose(fp);
+ return fd;
+}
+
+int ReadTokenValue( char *fname, char *key, char *value) {
+ FILE* fp;
+ char buffer[BLEN];
+ int fd = 0;
+ int len = strlen(key);
+ char *str;
+ char *str_end;
+
+ fp = fopen(fname, "r");
+ if (fp == NULL)
+ return fd;
+
+ while (fgets(buffer, BLEN, fp) != NULL) {
+ str = strstr(buffer, key);
+ if (str != NULL) {
+ fd = 1;
+ str += len;
+ str++;
+ str_end = str;
+ while (*str_end != ' ' && *str_end != 0) {
+ str_end++;
+ }
+ *str_end = 0;
+ strcpy(value, str);
+ fd = 1;
+ }
+ }
+ fclose(fp);
+ return fd;
+}
+
+char *ltrim(char *str) {
+ while(isspace(*str))
+ str++;
+ return str;
+}
+
+char *rtrim(char *str) {
+ char* end = str + strlen(str);
+ while (isspace(*--end))
+ ;
+ *(end + 1) = '\0';
+ return str;
+}
+
+char *trim(char *str) {
+ return rtrim(ltrim(str));
+}
+
+int FindDataValueFromKey( char *fname, char *key, char *value) {
+ FILE* fp;
+ char buffer[BLEN];
+ int fd = 0;
+ char *str;
+ char *str_end;
+ char *str_start;
+
+ fp = fopen(fname, "r");
+ if (fp == NULL)
+ return fd;
+
+ while (fgets(buffer, BLEN, fp) != NULL) {
+ str_start = buffer;
+ str_end = strchr(buffer, ':');
+ if (str_end != NULL) {
+ *str_end = 0;
+ str_start = trim(str_start);
+ if (strcasecmp(str_start, key) == 0) {
+ str = str_end + 1;
+ str = trim(str);
+ strcpy(value, str);
+ printf("key: %s, value: %s\n", str_start, str);
+ fd = 1;
+ break;
+ }
+ }
+ }
+ fclose(fp);
+ return fd;
+}
+
+
+int findIP_interface(char *dev, char *szIP, int bufsz) {
+ struct ifaddrs *ifaddr, *ifa;
+ int family, s, n;
+ char host[NI_MAXHOST];
+ int found_if = 0;
+ int len = strlen(dev);
+
+ /* get interface information */
+ if (getifaddrs(&ifaddr) != -1) {
+ for (ifa = ifaddr, n = 0; ifa != NULL; ifa = ifa->ifa_next, n++) {
+ if (ifa->ifa_addr == NULL)
+ continue;
+
+ family = ifa->ifa_addr->sa_family;
+ if ((strncmp (dev, ifa->ifa_name, len ) == 0) && (family == AF_INET || family == AF_INET6)) {
+ s = getnameinfo(ifa->ifa_addr,
+ (ifa->ifa_addr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) :
+ sizeof(struct sockaddr_in6),
+ host, NI_MAXHOST,
+ NULL, 0, NI_NUMERICHOST);
+ if (s != 0) {
+ break;
+ }
+ if ((ifa->ifa_flags & IFF_UP) == 0)
+ continue;
+ if ((ifa->ifa_flags & IFF_RUNNING) == 0)
+ continue;
+ found_if = 1;
+ break;
+ }
+ }
+ if (found_if) {
+ snprintf ( szIP, bufsz, "%s", host );
+ }
+ freeifaddrs(ifaddr);
+ }
+ return found_if;
+}
diff --git a/interfaces.h b/interfaces.h
new file mode 100644
index 0000000..adb4e5b
--- /dev/null
+++ b/interfaces.h
@@ -0,0 +1,40 @@
+/* Do not edit this file. It was automatically generated. */
+
+#ifndef HEADER_interfaces
+#define HEADER_interfaces
+
+#define BLEN 256
+/*
+ /etc/armbian-release
+ VERSION=20.02.1
+
+ /etc/debian_version
+ buster/sid
+
+ cat /etc/lsb-release
+ DISTRIB_DESCRIPTION="Ubuntu 18.04.5 LTS"
+
+ cat /etc/os-release
+ PRETTY_NAME="Ubuntu 18.04.5 LTS"
+ VERSION="18.04.5 LTS (Bionic Beaver)"
+ ID=ubuntu
+
+ cat /proc/version
+ Linux version 5.3.0-52-generic (buildd@lgw01-amd64-037) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #46~18.04.1-Ubuntu SMP Thu Apr 30 16:13:51 UTC 2020
+*/
+
+int ReadKeyValue( char *fname, char *key, char *value);
+
+int ReadTokenValue( char *fname, char *key, char *value);
+
+char *ltrim(char *str);
+
+char *rtrim(char *str);
+
+char *trim(char *str);
+
+int FindDataValueFromKey( char *fname, char *key, char *value);
+
+int findIP_interface(char *dev, char *szIP, int bufsz);
+
+#endif
diff --git a/linux/Platform.c b/linux/Platform.c
index ab90ca7..e87089c 100644
--- a/linux/Platform.c
+++ b/linux/Platform.c
@@ -1,6 +1,7 @@
/*
htop - linux/Platform.c
(C) 2014 Hisham H. Muhammad
+(C) 2020 Alexander Finger
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
@@ -14,6 +15,21 @@ in the source distribution for its full text.
#include "Meter.h"
#include "CPUMeter.h"
+#include "CpuFreqMeter.h"
+#include "CpuTempMeter.h"
+#include "GpuTempMeter.h"
+#include "CpuVcoreMeter.h"
+#include "Eth0_StatsMeter.h"
+#include "Eth1_StatsMeter.h"
+#include "Wlan0_StatsMeter.h"
+#include "BlockDevice_ioStatsMeter.h"
+#include "Eth0_Meter.h"
+#include "Eth1_Meter.h"
+#include "Wlan0_Meter.h"
+#include "Wlan1_Meter.h"
+#include "Armbian_Meter.h"
+#include "OS_Meter.h"
+#include "Kernel_Meter.h"
#include "MemoryMeter.h"
#include "SwapMeter.h"
#include "TasksMeter.h"
@@ -22,12 +38,23 @@ in the source distribution for its full text.
#include "ClockMeter.h"
#include "HostnameMeter.h"
#include "LinuxProcess.h"
+#include "Settings.h"
+#include "interfaces.h"
+
+#ifdef WIN32
+#include <windows.h>
+#elif _POSIX_C_SOURCE >= 199309L
+#include <time.h> /* for nanosleep */
+#else
+#include <unistd.h> /* for usleep */
+#endif
#include <math.h>
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
+#include <sys/time.h>
/*{
#include "Action.h"
@@ -35,6 +62,50 @@ in the source distribution for its full text.
#include "BatteryMeter.h"
#include "LinuxProcess.h"
#include "SignalsPanel.h"
+#ifdef WIN32
+#include <windows.h>
+#elif _POSIX_C_SOURCE >= 199309L
+#include <time.h>
+#else
+#include <unistd.h>
+#endif
+#include <string.h>
+
+
+typedef enum vendor_id_ {
+ VENDOR_INTEL,
+ VENDOR_AMD,
+ VENDOR_CYRIX,
+ VENDOR_VIA,
+ VENDOR_TRANSMETA,
+ VENDOR_UMC,
+ VENDOR_NEXGEN,
+ VENDOR_RISE,
+ VENDOR_SIS,
+ VENDOR_NSC,
+ VENDOR_VORTEX,
+ VENDOR_RDC,
+ VENDOR_UNKNOWN
+} vendor_id;
+
+typedef struct Stats_ {
+ int rx_over;
+ int tx_over;
+ double rx_bytes;
+ double tx_bytes;
+ double rx_bytes_comp;
+ double tx_bytes_comp;
+} Stats;
+
+typedef struct ioStats_ {
+ int read_over;
+ int write_over;
+ double read_sectors;
+ double write_sectors;
+ double read_sectors_comp;
+ double write_sectors_comp;
+} ioStats;
+
}*/
#ifndef CLAMP
@@ -45,6 +116,7 @@ ProcessField Platform_defaultFields[] = { PID, USER, PRIORITY, NICE, M_SIZE, M_R
//static ProcessField defaultIoFields[] = { PID, IO_PRIORITY, USER, IO_READ_RATE, IO_WRITE_RATE, IO_RATE, COMM, 0 };
+int Platform_cpuBigLITTLE = 0;
int Platform_numberOfFields = LAST_PROCESSFIELD;
const SignalItem Platform_signals[] = {
@@ -126,9 +198,270 @@ MeterClass* Platform_meterTypes[] = {
&LeftCPUs2Meter_class,
&RightCPUs2Meter_class,
&BlankMeter_class,
+ &CpuTempMeter_class,
+ &CpuFreqMeter_class,
+ /* --- fix me --- &AllCpuFreqMeter_class, */
+ &CpuVcoreMeter_class,
+ &GpuTempMeter_class,
+ /* interfaces */
+ &Eth0_Meter_class,
+ &Eth1_Meter_class,
+ &Wlan0_Meter_class,
+ &Wlan0_StatsMeter_class,
+ &Wlan1_Meter_class,
+ &OSversion_Meter_class,
+ &Kernelversion_Meter_class,
+ &Armbianversion_Meter_class,
+ &Eth0_StatsMeter_class,
+ &Eth1_StatsMeter_class,
+ &BlockDevice_sda_ioStatsMeter_class,
+ &BlockDevice_sdb_ioStatsMeter_class,
+ &BlockDevice_sdc_ioStatsMeter_class,
+ &BlockDevice_sdd_ioStatsMeter_class,
+ &BlockDevice_mmcblk0_ioStatsMeter_class,
+ &BlockDevice_mmcblk1_ioStatsMeter_class,
+ &BlockDevice_mmcblk2_ioStatsMeter_class,
+ &BlockDevice_mmcblk3_ioStatsMeter_class,
NULL
};
+/* cross-platform sleep function */
+void sleep_ms(int milliseconds) {
+#ifdef WIN32
+ Sleep(milliseconds);
+#elif _POSIX_C_SOURCE >= 199309L
+ struct timespec ts;
+ ts.tv_sec = milliseconds / 1000;
+ ts.tv_nsec = (milliseconds % 1000) * 1000000;
+ nanosleep(&ts, NULL);
+#else
+ usleep(milliseconds * 1000);
+#endif
+}
+
+int Platform_getGpuTemp(Meter* this) {
+ int Temp = 0;
+ char szbuf[256];
+ Settings* settings = this->pl->settings;
+ char *handler;
+ char *cpu_core_policy;
+
+ handler = settings->GpuTemp_handler;
+ if (handler[0] != 0) {
+ cpu_core_policy = strchr(handler, '%');
+ if (cpu_core_policy) {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/class/thermal/thermal_zone1/temp");
+ } else {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", handler);
+ }
+ } else {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/class/thermal/thermal_zone1/temp");
+ }
+
+ FILE* fd = fopen(szbuf, "r");
+ if (!fd) {
+ fd = fopen("/sys/devices/virtual/thermal/thermal_zone1/temp", "r");
+ }
+ if (fd) {
+ int n = fscanf(fd, "%d", &Temp);
+ fclose(fd);
+ if (n <= 0) return 0;
+ }
+ return Temp;
+}
+
+int Platform_getCpuTemp(Meter* this) {
+ int Temp = 0;
+ char szbuf[256];
+ Settings* settings = this->pl->settings;
+ char *handler;
+ char *cpu_core_policy;
+
+ handler = settings->CpuTemp_handler;
+ if (handler[0] != 0) {
+ cpu_core_policy = strchr(handler, '%');
+ if (cpu_core_policy) {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/class/thermal/thermal_zone0/temp");
+ } else {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", handler);
+ }
+ } else {
+ // sleep_ms(30);
+ // xSnprintf(szbuf, sizeof(szbuf), "/sys/devices/system/cpu/cpufreq/policy%d/cpuinfo_cur_freq", cpu);
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/class/thermal/thermal_zone0/temp");
+ }
+ FILE *fd = fopen(szbuf, "r");
+ if (!fd) {
+ fd = fopen("/sys/devices/virtual/thermal/thermal_zone0/temp", "r");
+ }
+ if (fd) {
+ int n = fscanf(fd, "%d", &Temp);
+ fclose(fd);
+ if (n <= 0) return 0;
+ }
+ return Temp;
+}
+
+int Platform_getCpuFreq(Meter* this, int cpu) {
+ int Freq = 0;
+ FILE* fd;
+ char szbuf[256];
+ Settings* settings = this->pl->settings;
+ char *handler;
+ char *cpu_core_policy;
+
+ handler = settings->CpuFreq_handler;
+ if (handler[0] != 0) {
+ cpu_core_policy = strchr(handler, '%');
+ if (cpu_core_policy) {
+ xSnprintf(szbuf, sizeof(szbuf), handler, cpu);
+ } else {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", handler);
+ }
+ } else {
+ // sleep_ms(30);
+ // xSnprintf(szbuf, sizeof(szbuf), "/sys/devices/system/cpu/cpufreq/policy%d/cpuinfo_cur_freq", cpu);
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/devices/system/cpu/cpufreq/policy0/cpuinfo_cur_freq");
+ }
+ fd = fopen(szbuf, "r");
+ if (fd) {
+ int n;
+ n = fscanf(fd, "%d", &Freq);
+ fclose(fd);
+ if (n <= 0) return 0;
+ }
+ return Freq;
+}
+
+int Platform_getCpuVcore(Meter* this) {
+ int Vcore = 0;
+ FILE* fd;
+ char szbuf[256];
+ Settings* settings = this->pl->settings;
+ char *handler;
+ char *cpu_core_policy;
+ handler = settings->CpuVCore_l_handler;
+ if (handler[0] != 0) {
+ cpu_core_policy = strchr(handler, '%');
+ if (cpu_core_policy) {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/devices/platform/ff3c0000.i2c/i2c-0/0-001b/regulator/regulator.13/microvolts");
+ } else {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", handler);
+ }
+ } else {
+ xSnprintf(szbuf, sizeof(szbuf), "%s", "/sys/devices/platform/ff3c0000.i2c/i2c-0/0-001b/regulator/regulator.13/microvolts");
+ }
+
+ // sleep_ms(10);
+ fd = fopen(szbuf, "r");
+ if (fd) {
+ int n;
+ n = fscanf(fd, "%d", &Vcore);
+ fclose(fd);
+ if (n <= 0) return 0;
+ }
+ return Vcore;
+}
+
+int Platform_getCpuVcore_l(Meter* this) {
+ int Vcore = 0;
+ FILE* fd;
+ char szbuf[256];
+ Settings* settings = this->pl->settings;
+ char *handler;
+ char *cpu_core_policy;
+ handler = settings->CpuVCore_l_handler;
+ if (handler[0] != 0) {
+ cpu_core_policy = strchr(handler, '%');
+ if (cpu_core_policy) {
+ strcpy(szbuf, "/sys/devices/platform/ff3c0000.i2c/i2c-0/0-001b/regulator/regulator.13/microvolts");
+ } else {
+ strcpy(szbuf, handler);
+ }
+ } else {
+ strcpy(szbuf, "/sys/devices/platform/ff3c0000.i2c/i2c-0/0-001b/regulator/regulator.13/microvolts");
+ }
+
+ // sleep_ms(10);
+ fd = fopen(szbuf, "r");
+ if (fd) {
+ int n;
+ n = fscanf(fd, "%d", &Vcore);
+ fclose(fd);
+ if (n <= 0) return 0;
+ }
+ return Vcore;
+}
+
+int Platform_getCpuVcore_b(Meter* this) {
+ int Vcore = 0;
+ FILE* fd;
+ char szbuf[256];
+ Settings* settings = this->pl->settings;
+ char *handler;
+ char *cpu_core_policy;
+ handler = settings->CpuVCore_b_handler;
+ if (handler[0] != 0) {
+ cpu_core_policy = strchr(handler, '%');
+ if (cpu_core_policy) {
+ strcpy(szbuf, "/sys/devices/platform/ff3c0000.i2c/i2c-0/0-0040/regulator/regulator.10/microvolts");
+ } else {
+ strcpy(szbuf, handler);
+ }
+ } else {
+ strcpy(szbuf, "/sys/devices/platform/ff3c0000.i2c/i2c-0/0-0040/regulator/regulator.10/microvolts");
+ }
+ // sleep_ms(10);
+ fd = fopen(szbuf, "r");
+ if (fd) {
+ int n;
+ n = fscanf(fd, "%d", &Vcore);
+ fclose(fd);
+ if (n <= 0) return 0;
+ }
+ return Vcore;
+}
+
+
+int Platform_getCpuBigLITTLE() {
+ return Platform_cpuBigLITTLE;
+}
+
+int Platform_findCpuBigLITTLE(int cpucount, int *cpuBigLITTLE) {
+ char buf[256];
+ int n, prev, next;
+ FILE* fd;
+
+ *cpuBigLITTLE = 0;
+ prev = next = -1;
+ int cpu = 0;
+ while (cpu < cpucount) {
+ xSnprintf(buf, sizeof(buf), "/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", cpu);
+ fd = fopen(buf, "r");
+ if (fd) {
+ n = fscanf(fd, "%d", &next);
+ fclose(fd);
+ if (n <= 0)
+ break;
+ if (prev == -1) {
+ prev = next;
+ } else {
+ if (prev != next) {
+ if (prev < next) {
+ Platform_cpuBigLITTLE = cpu;
+ } else {
+ Platform_cpuBigLITTLE = cpu * -1; /* fix me */
+ }
+ *cpuBigLITTLE = Platform_cpuBigLITTLE;
+ break;
+ }
+ }
+ }
+ cpu++;
+ }
+ return cpu;
+}
+
int Platform_getUptime() {
double uptime = 0;
FILE* fd = fopen(PROCDIR "/uptime", "r");
@@ -237,3 +570,177 @@ char* Platform_getProcessEnv(pid_t pid) {
}
return env;
}
+
+Stats Platform_Eth0_stats;
+Stats Platform_Eth1_stats;
+Stats Platform_Wlan0_stats;
+
+int Platform_getEth_stats(char *devname, int id, int close_fp) {
+ char buffer[BLEN];
+ char *str;
+ char *str_end;
+ char *str_start;
+ unsigned long dump;
+ int ifound;
+ unsigned long rx_o, tx_o;
+ Stats *Platform_Eth_stats;
+ static FILE *fp_proc_net_dev = NULL;
+
+ if (close_fp) {
+ if (fp_proc_net_dev)
+ fclose(fp_proc_net_dev);
+ return 0;
+ }
+
+ if (fp_proc_net_dev == NULL) {
+ if ((fp_proc_net_dev = fopen("/proc/net/dev", "r")) == NULL) {
+ return 0;
+ }
+ }
+ if (id == 0) {
+ Platform_Eth_stats = &Platform_Eth0_stats;
+ } else {
+ if (id == 1) {
+ Platform_Eth_stats = &Platform_Eth1_stats;
+ } else {
+ Platform_Eth_stats = &Platform_Wlan0_stats;
+ }
+ }
+
+ /* save rx/tx values */
+ rx_o = Platform_Eth_stats->rx_bytes;
+ tx_o = Platform_Eth_stats->tx_bytes;
+
+ /* do not parse the first two lines as they only contain static garbage */
+ fseek(fp_proc_net_dev, 0, SEEK_SET);
+ fgets(buffer, BLEN, fp_proc_net_dev);
+ fgets(buffer, BLEN, fp_proc_net_dev);
+
+ ifound = 0;
+ while (fgets(buffer, BLEN, fp_proc_net_dev) != NULL) {
+ str_start = buffer;
+ str_end = strchr(buffer, ':');
+ if (str_end != NULL) {
+ *str_end = 0;
+ str_start = trim(str_start);
+ if (strcasecmp(str_start, devname) == 0) {
+ str = str_end + 1;
+ str = ltrim(str);
+ sscanf(str,
+ "%lg %lu %lu %lu %lu %lu %lu %lu %lg %lu %lu %lu %lu %lu %lu %lu",
+ &Platform_Eth_stats->rx_bytes, &dump, &dump,
+ &dump, &dump, &dump, &dump, &dump, &Platform_Eth_stats->tx_bytes,
+ &dump, &dump, &dump, &dump, &dump, &dump, &dump);
+ ifound = 1;
+ continue;
+ }
+ }
+ }
+ if (ifound) {
+ if (rx_o > Platform_Eth_stats->rx_bytes)
+ Platform_Eth_stats->rx_over++;
+ if (tx_o > Platform_Eth_stats->tx_bytes)
+ Platform_Eth_stats->tx_over++;
+ }
+ return ifound;
+}
+
+double get_wall_time(void) {
+ struct timeval time;
+ if (gettimeofday(&time, NULL))
+ return 0.;
+ return (double) time.tv_sec + (double) time.tv_usec * .000001;
+}
+
+ioStats Platform_BlockDevice_sda_stats;
+ioStats Platform_BlockDevice_sdb_stats;
+ioStats Platform_BlockDevice_sdc_stats;
+ioStats Platform_BlockDevice_sdd_stats;
+ioStats Platform_BlockDevice_mmcblk0_stats;
+ioStats Platform_BlockDevice_mmcblk1_stats;
+ioStats Platform_BlockDevice_mmcblk2_stats;
+ioStats Platform_BlockDevice_mmcblk3_stats;
+
+FILE *fp_block_dev_a[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+
+int Platform_getIO_stats(char *devname, int idx, int close_fp) {
+ char block_device[80] = {0};
+ char buffer[BLEN] = {0};
+ unsigned long dump;
+ unsigned long read_o, write_o;
+ ioStats *Platform_io_stats;
+ FILE *fp_block_dev = NULL;
+
+ if (idx > 7)
+ idx = 0;
+
+ fp_block_dev = fp_block_dev_a[idx];
+
+ if (close_fp) {
+ if (fp_block_dev)
+ fclose(fp_block_dev);
+ return 0;
+ }
+ if (devname && *devname == 0)
+ return 0;
+
+ if (fp_block_dev == NULL) {
+ xSnprintf(block_device, sizeof(block_device), "/sys/block/%s/stat", devname);
+ if ((fp_block_dev = fopen(block_device, "r")) == NULL) {
+ return 0;
+ }
+ fp_block_dev_a[idx] = fp_block_dev;
+ }
+
+ switch(idx) {
+ case 0:
+ Platform_io_stats = &Platform_BlockDevice_sda_stats;
+ break;
+ case 1:
+ Platform_io_stats = &Platform_BlockDevice_sdb_stats;
+ break;
+ case 2:
+ Platform_io_stats = &Platform_BlockDevice_sdc_stats;
+ break;
+ case 3:
+ Platform_io_stats = &Platform_BlockDevice_sdd_stats;
+ break;
+ case 4:
+ Platform_io_stats = &Platform_BlockDevice_mmcblk0_stats;
+ break;
+ case 5:
+ Platform_io_stats = &Platform_BlockDevice_mmcblk1_stats;
+ break;
+ case 6:
+ Platform_io_stats = &Platform_BlockDevice_mmcblk2_stats;
+ break;
+ case 7:
+ Platform_io_stats = &Platform_BlockDevice_mmcblk3_stats;
+ break;
+ default:
+ Platform_io_stats = &Platform_BlockDevice_sda_stats;
+ break;
+ }
+ /* save read/write values */
+ read_o = Platform_io_stats->read_sectors;
+ write_o = Platform_io_stats->write_sectors;
+ fseek(fp_block_dev, 0, SEEK_SET);
+ if (fgets(buffer, BLEN - 1, fp_block_dev) != NULL) {
+ sscanf(buffer,
+ "%lu %lu %lg %lu %lu %lu %lg %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
+ &dump, &dump, &Platform_io_stats->read_sectors, &dump, &dump,
+ &dump, &Platform_io_stats->write_sectors, &dump, &dump, &dump, &dump,
+ &dump, &dump, &dump, &dump, &dump, &dump);
+ } else {
+ return 0;
+ }
+
+ while (fgets(buffer, BLEN - 1, fp_block_dev) != NULL)
+ ;
+
+ if (read_o > Platform_io_stats->read_sectors)
+ Platform_io_stats->read_over++;
+ if (write_o > Platform_io_stats->write_sectors)
+ Platform_io_stats->write_over++;
+ return 1;
+}
diff --git a/linux/Platform.h b/linux/Platform.h
index b0456e5..54dbf80 100644
--- a/linux/Platform.h
+++ b/linux/Platform.h
@@ -5,15 +5,65 @@
/*
htop - linux/Platform.h
(C) 2014 Hisham H. Muhammad
+(C) 2020 Alexander Finger
Released under the GNU GPL, see the COPYING file
in the source distribution for its full text.
*/
+#ifdef WIN32
+#elif _POSIX_C_SOURCE >= 199309L
+#else
+#endif
+
#include "Action.h"
#include "MainPanel.h"
#include "BatteryMeter.h"
#include "LinuxProcess.h"
#include "SignalsPanel.h"
+#ifdef WIN32
+#include <windows.h>
+#elif _POSIX_C_SOURCE >= 199309L
+#include <time.h>
+#else
+#include <unistd.h>
+#endif
+#include <string.h>
+
+
+typedef enum vendor_id_ {
+ VENDOR_INTEL,
+ VENDOR_AMD,
+ VENDOR_CYRIX,
+ VENDOR_VIA,
+ VENDOR_TRANSMETA,
+ VENDOR_UMC,
+ VENDOR_NEXGEN,
+ VENDOR_RISE,
+ VENDOR_SIS,
+ VENDOR_NSC,
+ VENDOR_VORTEX,
+ VENDOR_RDC,
+ VENDOR_UNKNOWN
+} vendor_id;
+
+typedef struct Stats_ {
+ int rx_over;
+ int tx_over;
+ double rx_bytes;
+ double tx_bytes;
+ double rx_bytes_comp;
+ double tx_bytes_comp;
+} Stats;
+
+typedef struct ioStats_ {
+ int read_over;
+ int write_over;
+ double read_sectors;
+ double write_sectors;
+ double read_sectors_comp;
+ double write_sectors_comp;
+} ioStats;
+
#ifndef CLAMP
#define CLAMP(x,low,high) (((x)>(high))?(high):(((x)<(low))?(low):(x)))
@@ -21,6 +71,7 @@ in the source distribution for its full text.
extern ProcessField Platform_defaultFields[];
+extern int Platform_cpuBigLITTLE;
extern int Platform_numberOfFields;
extern const SignalItem Platform_signals[];
@@ -31,6 +82,25 @@ void Platform_setBindings(Htop_Action* keys);
extern MeterClass* Platform_meterTypes[];
+/* cross-platform sleep function */
+void sleep_ms(int milliseconds);
+
+int Platform_getGpuTemp(Meter* this);
+
+int Platform_getCpuTemp(Meter* this);
+
+int Platform_getCpuFreq(Meter* this, int cpu);
+
+int Platform_getCpuVcore(Meter* this);
+
+int Platform_getCpuVcore_l(Meter* this);
+
+int Platform_getCpuVcore_b(Meter* this);
+
+int Platform_getCpuBigLITTLE();
+
+int Platform_findCpuBigLITTLE(int cpucount, int *cpuBigLITTLE);
+
int Platform_getUptime();
void Platform_getLoadAverage(double* one, double* five, double* fifteen);
@@ -45,4 +115,25 @@ void Platform_setSwapValues(Meter* this);
char* Platform_getProcessEnv(pid_t pid);
+Stats Platform_Eth0_stats;
+Stats Platform_Eth1_stats;
+Stats Platform_Wlan0_stats;
+
+int Platform_getEth_stats(char *devname, int id, int close_fp);
+
+double get_wall_time(void);
+
+ioStats Platform_BlockDevice_sda_stats;
+ioStats Platform_BlockDevice_sdb_stats;
+ioStats Platform_BlockDevice_sdc_stats;
+ioStats Platform_BlockDevice_sdd_stats;
+ioStats Platform_BlockDevice_mmcblk0_stats;
+ioStats Platform_BlockDevice_mmcblk1_stats;
+ioStats Platform_BlockDevice_mmcblk2_stats;
+ioStats Platform_BlockDevice_mmcblk3_stats;
+
+extern FILE *fp_block_dev_a[8];
+
+int Platform_getIO_stats(char *devname, int idx, int close_fp);
+
#endif
Reference in New Issue View Git Blame Copy Permalink