Swap: split module code from memory.c

src/detection/memory/memory.h

@@ -3,8 +3,14 @@
 #ifndef FF_INCLUDED_detection_memory_memory
 #define FF_INCLUDED_detection_memory_memory
 
-#include "detection/storage.h"
+#include "fastfetch.h"
 
-void ffDetectMemory(FFMemoryStorage* result);
+typedef struct FFMemoryResult
+{
+    uint64_t bytesUsed;
+    uint64_t bytesTotal;
+} FFMemoryResult;
+
+const char* ffDetectMemory(FFMemoryResult* result);
 
 #endif

src/detection/memory/memory_apple.c

@@ -3,31 +3,25 @@
 #include <string.h>
 #include <mach/mach.h>
 #include <sys/sysctl.h>
+#include <unistd.h>
 
-void ffDetectMemory(FFMemoryStorage* ram)
+const char* ffDetectMemory(FFMemoryResult* ram)
 {
     size_t length = sizeof(ram->bytesTotal);
     if (sysctl((int[]){ CTL_HW, HW_MEMSIZE }, 2, &ram->bytesTotal, &length, NULL, 0))
-    {
-        ffStrbufAppendS(&ram->error, "Failed to read hw.memsize");
-        return;
-    }
+        return "Failed to read hw.memsize";
 
     uint32_t pagesize;
     length = sizeof(pagesize);
     if (sysctl((int[]){ CTL_HW, HW_PAGESIZE }, 2, &pagesize, &length, NULL, 0))
-    {
-        ffStrbufAppendS(&ram->error, "Failed to read hw.pagesize");
-        return;
-    }
+        return "Failed to read hw.pagesize";
 
     mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
     vm_statistics64_data_t vmstat;
     if(host_statistics64(mach_host_self(), HOST_VM_INFO64, (host_info64_t) (&vmstat), &count) != KERN_SUCCESS)
-    {
-        ffStrbufAppendS(&ram->error, "Failed to read host_statistics64");
-        return;
-    }
+        return "Failed to read host_statistics64";
 
     ram->bytesUsed = ((uint64_t) vmstat.active_count + vmstat.wire_count) * pagesize;
+
+    return NULL;
 }

src/detection/memory/memory_bsd.c

@@ -1,24 +1,21 @@
 #include "memory.h"
 #include "common/sysctl.h"
 
-void ffDetectMemory(FFMemoryStorage* ram)
+const char* ffDetectMemory(FFMemoryResult* ram)
 {
-    uint32_t pageSize = (uint32_t) ffSysctlGetInt("hw.pagesize", 0);
-    if(pageSize == 0)
-    {
-        ffStrbufAppendS(&ram->error, "Failed to read hw.pagesize");
-        return;
-    }
+    uint32_t pageSize;
+    uint64_t length = sizeof(pageSize);
+    if (sysctl((int[]){ CTL_HW, HW_PAGESIZE }, 2, &pageSize, &length, NULL, 0))
+        return "Failed to read hw.pagesize";
 
     ram->bytesTotal = (uint64_t) ffSysctlGetInt64("vm.stats.vm.v_page_count", 0) * pageSize;
     if(ram->bytesTotal == 0)
-    {
-        ffStrbufAppendS(&ram->error, "Failed to read vm.stats.vm.v_page_count");
-        return;
-    }
+        return "Failed to read vm.stats.vm.v_page_count";
 
     ram->bytesUsed = ram->bytesTotal
         - (uint64_t) ffSysctlGetInt64("vm.stats.vm.v_free_count", 0) * pageSize
         - (uint64_t) ffSysctlGetInt64("vm.stats.vm.v_inactive_count", 0) * pageSize
     ;
+
+    return NULL;
 }

src/detection/memory/memory_linux.c

@@ -1,18 +1,16 @@
 #include "memory.h"
+#include "util/mallocHelper.h"
 
 #include <stdlib.h>
 #include <string.h>
 
-void ffDetectMemory(FFMemoryStorage* ram)
+const char* ffDetectMemory(FFMemoryResult* ram)
 {
     FILE* meminfo = fopen("/proc/meminfo", "r");
     if(meminfo == NULL)
-    {
-        ffStrbufAppendS(&ram->error, "Failed to open /proc/meminfo");
-        return;
-    }
+        return "Failed to open /proc/meminfo";
 
-    char* line = NULL;
+    char* FF_AUTO_FREE line = NULL;
     size_t len = 0;
 
     uint32_t memTotal = 0,
@@ -32,14 +30,13 @@ void ffDetectMemory(FFMemoryStorage* ram)
             sscanf(line, "SReclaimable: %u", &sReclaimable);
     }
 
-    if(line != NULL)
-        free(line);
-
     fclose(meminfo);
 
     ram->bytesTotal = memTotal * (uint64_t) 1024;
     if(ram->bytesTotal == 0)
-        ffStrbufAppendS(&ram->error, "Failed to read MemTotal");
+        return "Failed to read MemTotal";
     else
         ram->bytesUsed = (memTotal + shmem - memFree - buffers - cached - sReclaimable) * (uint64_t) 1024;
+
+    return NULL;
 }

src/detection/memory/memory_windows.c

@@ -2,16 +2,15 @@
 
 #include <windows.h>
 
-void ffDetectMemory(FFMemoryStorage* ram)
+const char* ffDetectMemory(FFMemoryResult* ram)
 {
     MEMORYSTATUSEX statex = {
         .dwLength = sizeof(statex),
     };
     if (!GlobalMemoryStatusEx(&statex))
-    {
-        ffStrbufAppendS(&ram->error, "GlobalMemoryStatusEx() failed");
-        return;
-    }
+        return "GlobalMemoryStatusEx() failed";
+
     ram->bytesTotal = statex.ullTotalPhys;
     ram->bytesUsed = statex.ullTotalPhys - statex.ullAvailPhys;
+    return NULL;
 }

src/detection/storage.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#ifndef FF_INCLUDED_detection_storage
-#define FF_INCLUDED_detection_storage
-
-#include "fastfetch.h"
-
-typedef struct FFMemoryStorage
-{
-    FFstrbuf error;
-    uint64_t bytesUsed;
-    uint64_t bytesTotal;
-} FFMemoryStorage;
-
-#endif

src/detection/swap/swap.h

@@ -3,8 +3,14 @@
 #ifndef FF_INCLUDED_detection_swap_swap
 #define FF_INCLUDED_detection_swap_swap
 
-#include "detection/storage.h"
+#include "fastfetch.h"
 
-void ffDetectSwap(FFMemoryStorage* result);
+typedef struct FFSwapResult
+{
+    uint64_t bytesUsed;
+    uint64_t bytesTotal;
+} FFSwapResult;
+
+const char* ffDetectSwap(FFSwapResult* result);
 
 #endif

src/detection/swap/swap_apple.c

@@ -3,16 +3,14 @@
 #include <mach/mach.h>
 #include <sys/sysctl.h>
 
-void ffDetectSwap(FFMemoryStorage* swap)
+const char* ffDetectSwap(FFSwapResult* swap)
 {
     struct xsw_usage xsw;
     size_t size = sizeof(xsw);
     if(sysctl((int[]){ CTL_VM, VM_SWAPUSAGE }, 2, &xsw, &size, NULL, 0) != 0)
-    {
-        ffStrbufAppendS(&swap->error, "Failed to read vm.swapusage");
-        return;
-    }
+        return "Failed to read vm.swapusage";
 
     swap->bytesTotal = xsw.xsu_total;
     swap->bytesUsed = xsw.xsu_used;
+    return NULL;
 }

src/detection/swap/swap_bsd.c

@@ -1,8 +1,9 @@
 #include "swap.h"
 #include "common/sysctl.h"
 
-void ffDetectSwap(FFMemoryStorage* swap)
+const char* ffDetectSwap(FFSwapResult* swap)
 {
     swap->bytesTotal = (uint64_t)ffSysctlGetInt64("vm.swap_total", 0);
     swap->bytesUsed = (uint64_t)ffSysctlGetInt64("vm.swap_reserved", 0);
+    return NULL;
 }

src/detection/swap/swap_linux.c

@@ -2,12 +2,14 @@
 
 #include <sys/sysinfo.h>
 
-void ffDetectSwap(FFMemoryStorage* swap)
+const char* ffDetectSwap(FFSwapResult* swap)
 {
     struct sysinfo info;
     if(sysinfo(&info) != 0)
-        ffStrbufAppendS(&swap->error, "sysinfo() failed");
+        return "sysinfo() failed";
 
     swap->bytesTotal = info.totalswap * (uint64_t) info.mem_unit;
     swap->bytesUsed = (info.totalswap - info.freeswap) * (uint64_t) info.mem_unit;
+
+    return NULL;
 }

src/detection/swap/swap_windows.c

@@ -5,7 +5,7 @@
 #include <ntstatus.h>
 #include <windows.h>
 
-void ffDetectSwap(FFMemoryStorage* swap)
+const char* ffDetectSwap(FFSwapResult* swap)
 {
     SYSTEM_INFO sysInfo;
     GetNativeSystemInfo(&sysInfo);
@@ -18,16 +18,10 @@ void ffDetectSwap(FFMemoryStorage* swap)
         if(status == STATUS_INFO_LENGTH_MISMATCH)
         {
             if(!(pstart = (SYSTEM_PAGEFILE_INFORMATION*)realloc(pstart, size)))
-            {
-                ffStrbufAppendF(&swap->error, "realloc(pstart, %lu) failed", size);
-                return;
-            }
+                return "realloc(pstart, size) failed";
         }
         else if(!NT_SUCCESS(status))
-        {
-            ffStrbufAppendF(&swap->error, "NtQuerySystemInformation(SystemPagefileInformation, %lu) failed", size);
-            return;
-        }
+            return "NtQuerySystemInformation(SystemPagefileInformation, size) failed";
         break;
     }
     swap->bytesUsed = (uint64_t)pstart->TotalUsed * sysInfo.dwPageSize;