CpuUsage: support JSON config

src/detection/cpuusage/cpuusage.c

@@ -0,0 +1,43 @@
+#include "fastfetch.h"
+#include "detection/cpuusage/cpuusage.h"
+#include "common/time.h"
+
+#include <stdint.h>
+
+// We need to use uint64_t because sizeof(long) == 4 on Windows
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll);
+
+static uint64_t inUseAll1, totalAll1;
+
+void ffPrepareCPUUsage()
+{
+    ffGetCpuUsageInfo(&inUseAll1, &totalAll1);
+}
+
+const char* ffGetCpuUsageResult(double* result)
+{
+    const char* error = NULL;
+    if(inUseAll1 == 0 && totalAll1 == 0)
+    {
+        error = ffGetCpuUsageInfo(&inUseAll1, &totalAll1);
+        if(error)
+            return error;
+        ffTimeSleep(200);
+    }
+
+    while(true)
+    {
+        uint64_t inUseAll2, totalAll2;
+        error = ffGetCpuUsageInfo(&inUseAll2, &totalAll2);
+        if(error)
+            return error;
+
+        if(inUseAll2 != inUseAll1)
+        {
+            *result = (double)(inUseAll2 - inUseAll1) / (double)(totalAll2 - totalAll1) * 100;
+            return NULL;
+        }
+        else
+            ffTimeSleep(200);
+    }
+}

src/detection/cpuusage/cpuusage.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_cpuusage_cpuusage
+#define FF_INCLUDED_detection_cpuusage_cpuusage
+
+const char* ffGetCpuUsageResult(double* result);
+
+#endif

src/detection/cpuusage/cpuusage_apple.c

@@ -0,0 +1,23 @@
+#include "fastfetch.h"
+#include "detection/cpuusage/cpuusage.h"
+
+#include <mach/processor_info.h>
+#include <mach/mach_host.h>
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+	host_cpu_load_info_data_t cpustats;
+	mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
+
+    *inUseAll = *totalAll = 0;
+
+    if (host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)(&cpustats), &count) != KERN_SUCCESS)
+        return "host_statistics() failed";
+
+    *inUseAll = cpustats.cpu_ticks[CPU_STATE_USER]
+        + cpustats.cpu_ticks[CPU_STATE_SYSTEM]
+        + cpustats.cpu_ticks[CPU_STATE_NICE];
+    *totalAll = *inUseAll + cpustats.cpu_ticks[CPU_STATE_IDLE];
+
+    return NULL;
+}

src/detection/cpuusage/cpuusage_bsd.c

@@ -0,0 +1,19 @@
+#include "detection/cpuusage/cpuusage.h"
+
+#include <sys/types.h>
+#include <sys/user.h>
+#include <sys/sysctl.h>
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+    // interrupt processing, user processes, system processing, lock spinning, and idling
+    uint64_t cpTime[5];
+    size_t neededLength = sizeof(cpTime);
+    if(sysctlbyname("kern.cp_time", cpTime, &neededLength, NULL, 0) != 0)
+        return "sysctlbyname(kern.cp_time) failed";
+
+    *inUseAll = cpTime[0] + cpTime[1] + cpTime[2] + cpTime[3];
+    *totalAll = *inUseAll + cpTime[4];
+
+    return NULL;
+}

src/detection/cpuusage/cpuusage_linux.c

@@ -0,0 +1,32 @@
+#include "fastfetch.h"
+#include "detection/cpuusage/cpuusage.h"
+
+#include <stdio.h>
+#include <inttypes.h>
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+    uint64_t user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0, softirq = 0;
+
+    FILE* procStat = fopen("/proc/stat", "r");
+    if(procStat == NULL)
+    {
+        #ifdef __ANDROID__
+        return "Accessing \"/proc/stat\" is restricted on Android O+";
+        #else
+        return "fopen(\"""/proc/stat\", \"r\") == NULL";
+        #endif
+    }
+
+    if (fscanf(procStat, "cpu%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64, &user, &nice, &system, &idle, &iowait, &irq, &softirq) < 0)
+    {
+        fclose(procStat);
+        return "fscanf() failed";
+    }
+    *inUseAll = user + nice + system;
+    *totalAll = *inUseAll + idle + iowait + irq + softirq;
+
+    fclose(procStat);
+
+    return NULL;
+}

src/detection/cpuusage/cpuusage_windows.c

@@ -0,0 +1,37 @@
+#include "fastfetch.h"
+#include "detection/cpuusage/cpuusage.h"
+
+#include "util/mallocHelper.h"
+
+#include <ntstatus.h>
+#include <winternl.h>
+
+const char* ffGetCpuUsageInfo(uint64_t* inUseAll, uint64_t* totalAll)
+{
+    ULONG size = 0;
+    if(NtQuerySystemInformation(SystemProcessorPerformanceInformation, NULL, 0, &size) != STATUS_INFO_LENGTH_MISMATCH)
+        return "NtQuerySystemInformation(SystemProcessorPerformanceInformation, NULL) failed";
+
+    SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* FF_AUTO_FREE pinfo = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION*)malloc(size);
+    if(!NT_SUCCESS(NtQuerySystemInformation(SystemProcessorPerformanceInformation, pinfo, size, &size)))
+        return "NtQuerySystemInformation(SystemProcessorPerformanceInformation, size) failed";
+
+    *inUseAll = *totalAll = 0;
+
+    for (uint32_t i = 0; i < size / sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION); ++i)
+    {
+        SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* coreInfo = pinfo + i;
+
+        // KernelTime includes idle time.
+        LONGLONG dpcTime = coreInfo->Reserved1[0].QuadPart;
+        LONGLONG interruptTime = coreInfo->Reserved1[1].QuadPart;
+        coreInfo->KernelTime.QuadPart -= coreInfo->IdleTime.QuadPart;
+        coreInfo->KernelTime.QuadPart += dpcTime + interruptTime;
+
+        LONGLONG inUse = coreInfo->UserTime.QuadPart + coreInfo->KernelTime.QuadPart;
+        *inUseAll += (uint64_t)inUse;
+        *totalAll += (uint64_t)(inUse + coreInfo->IdleTime.QuadPart);
+    }
+
+    return NULL;
+}