Disk: move physicalType to module DiskIO

Physical type applies to physical disks, not partitions

src/detection/disk/disk.h

@@ -5,21 +5,13 @@
 
 #include "fastfetch.h"
 
-typedef enum FFDiskPhysicalType
-{
-    FF_DISK_PHYSICAL_TYPE_UNKNOWN,
-    FF_DISK_PHYSICAL_TYPE_HDD,
-    FF_DISK_PHYSICAL_TYPE_SSD,
-} FFDiskPhysicalType;
-
 typedef struct FFDisk
 {
     FFstrbuf mountFrom;
     FFstrbuf mountpoint;
     FFstrbuf filesystem;
     FFstrbuf name;
     FFDiskVolumeType type;
-    FFDiskPhysicalType physicalType;
 
     uint64_t bytesUsed;
     uint64_t bytesFree;

src/detection/disk/disk_bsd.c

@@ -25,60 +25,13 @@ static void detectFsInfo(struct statfs* fs, FFDisk* disk)
 
 #include <sys/attr.h>
 #include <unistd.h>
-#include <IOKit/IOKitLib.h>
-#include <IOKit/storage/IOStorageDeviceCharacteristics.h>
 
 struct VolAttrBuf {
     uint32_t       length;
     attrreference_t volNameRef;
     char            volNameSpace[MAXPATHLEN];
 } __attribute__((aligned(4), packed));
 
-void detectDiskType(FFDisk* disk) // Not thread safe
-{
-    if (!ffStrbufStartsWithS(&disk->mountFrom, "/dev/disk")) return;
-
-    static uint8_t cache[100]; // disk_id => physical_type + 1
-    const char* numStart = disk->mountFrom.chars + strlen("/dev/disk");
-    char* numEnd = NULL;
-    unsigned long diskId = strtoul(numStart, &numEnd, 10);
-    if (numEnd == numStart || diskId >= 100)
-        return;
-
-    if (cache[diskId])
-    {
-        disk->physicalType = cache[diskId] - 1;
-        return;
-    }
-
-    io_iterator_t iterator;
-    char temp = *numEnd; *numEnd = '\0'; // Check for root disk directly
-    *numEnd = temp;
-    if(IOServiceGetMatchingServices(MACH_PORT_NULL, IOBSDNameMatching(MACH_PORT_NULL, 0, disk->mountFrom.chars + strlen("/dev/")), &iterator) == kIOReturnSuccess)
-    {
-        for (io_registry_entry_t registryEntry = IOIteratorNext(iterator); registryEntry; IORegistryEntryGetParentEntry(registryEntry, kIOServicePlane, &registryEntry))
-        {
-            FF_CFTYPE_AUTO_RELEASE CFDictionaryRef deviceCharacteristics = (CFDictionaryRef) IORegistryEntryCreateCFProperty(registryEntry, CFSTR(kIOPropertyDeviceCharacteristicsKey), kCFAllocatorDefault, kNilOptions);
-            if (!deviceCharacteristics)
-                continue;
-
-            CFStringRef diskType = (CFStringRef) CFDictionaryGetValue(deviceCharacteristics, CFSTR(kIOPropertyMediumTypeKey));
-            if (diskType)
-            {
-                if (CFStringCompare(diskType, CFSTR(kIOPropertyMediumTypeSolidStateKey), 0) == 0)
-                    disk->physicalType = FF_DISK_PHYSICAL_TYPE_SSD;
-                else if (CFStringCompare(diskType, CFSTR(kIOPropertyMediumTypeRotationalKey), 0) == 0)
-                    disk->physicalType = FF_DISK_PHYSICAL_TYPE_HDD;
-            }
-            break;
-        }
-
-        IOObjectRelease(iterator);
-    }
-
-    cache[diskId] = (uint8_t) (disk->physicalType + 1);
-}
-
 void detectFsInfo(struct statfs* fs, FFDisk* disk)
 {
     if(fs->f_flags & MNT_DONTBROWSE)
@@ -94,8 +47,6 @@ void detectFsInfo(struct statfs* fs, FFDisk* disk)
         .volattr = ATTR_VOL_INFO | ATTR_VOL_NAME,
     }, &attrBuf, sizeof(attrBuf), 0) == 0)
         ffStrbufInitNS(&disk->name, attrBuf.volNameRef.attr_length - 1 /* excluding '\0' */, attrBuf.volNameSpace);
-
-    detectDiskType(disk);
 }
 #endif
 
@@ -122,7 +73,6 @@ const char* ffDetectDisksImpl(FFlist* disks)
         #endif
 
         FFDisk* disk = ffListAdd(disks);
-        disk->physicalType = FF_DISK_PHYSICAL_TYPE_UNKNOWN;
 
         disk->bytesTotal = fs->f_blocks * fs->f_bsize;
         disk->bytesFree = (uint64_t)fs->f_bfree * fs->f_bsize;

src/detection/disk/disk_linux.c

@@ -195,7 +195,7 @@ static bool isSubvolume(const FFlist* disks, FFDisk* currentDisk)
     return false;
 }
 
-static bool detectPhysicalTypeAndReturnRemovable(FFDisk* currentDisk)
+static bool isRemovable(FFDisk* currentDisk)
 {
     // https://stackoverflow.com/a/73302025
     // Note my USB mobile hard disk isn't detected as removable, but my USB flash disk does.
@@ -218,20 +218,10 @@ static bool detectPhysicalTypeAndReturnRemovable(FFDisk* currentDisk)
 
         if (!ffStrStartsWith(partitionName, entry->d_name)) continue;
 
-        ffStrbufAppendS(&basePath, entry->d_name);
-        index = basePath.length;
-        // /sys/block/sdx/queue/rotational
-        ffStrbufAppendS(&basePath, "/queue/rotational");
-        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
-        if (ffReadFileBuffer(basePath.chars, &buffer))
-            currentDisk->physicalType = ffStrbufEqualS(&buffer, "1") ? FF_DISK_PHYSICAL_TYPE_HDD : FF_DISK_PHYSICAL_TYPE_SSD;
-        else
-            currentDisk->physicalType = FF_DISK_PHYSICAL_TYPE_UNKNOWN;
-        ffStrbufSubstrBefore(&basePath, index);
-
         // /sys/block/sdx/removable
+        ffStrbufAppendS(&basePath, entry->d_name);
         ffStrbufAppendS(&basePath, "/removable");
-
+        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
         return ffReadFileBuffer(basePath.chars, &buffer) && ffStrbufEqualS(&buffer, "1");
     }
 
@@ -240,10 +230,9 @@ static bool detectPhysicalTypeAndReturnRemovable(FFDisk* currentDisk)
 
 static void detectType(const FFlist* disks, FFDisk* currentDisk)
 {
-    bool isRemovable = detectPhysicalTypeAndReturnRemovable(currentDisk);
-
     if(currentDisk->type != FF_DISK_VOLUME_TYPE_NONE) return;
-    if(isRemovable)
+
+    if(isRemovable(currentDisk))
         currentDisk->type = FF_DISK_VOLUME_TYPE_EXTERNAL_BIT;
     else if(isSubvolume(disks, currentDisk))
         currentDisk->type = FF_DISK_VOLUME_TYPE_SUBVOLUME_BIT;
@@ -289,7 +278,6 @@ const char* ffDetectDisksImpl(FFlist* disks)
         //We have a valid device, add it to the list
         FFDisk* disk = ffListAdd(disks);
         disk->type = FF_DISK_VOLUME_TYPE_NONE;
-        disk->physicalType = FF_DISK_PHYSICAL_TYPE_UNKNOWN;
 
         //detect mountFrom
         ffStrbufInitS(&disk->mountFrom, device->mnt_fsname);

src/detection/disk/disk_windows.c

@@ -28,34 +28,6 @@ const char* ffDetectDisksImpl(FFlist* disks)
         ffStrbufInitWS(&disk->mountpoint, mountpoint);
 
         wchar_t volumeName[64];
-
-        disk->physicalType = FF_DISK_PHYSICAL_TYPE_UNKNOWN;
-        if(mountpoint[1] == ':')
-        {
-            memcpy(volumeName, L"\\\\.\\ :", sizeof(L"\\\\.\\ :"));
-            volumeName[4] = mountpoint[0];
-            FF_AUTO_CLOSE_FD HANDLE handle = CreateFileW(volumeName, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
-            if (handle != INVALID_HANDLE_VALUE)
-            {
-                DEVICE_SEEK_PENALTY_DESCRIPTOR dspd = {};
-                DWORD retSize = 0;
-                if(DeviceIoControl(
-                    handle,
-                    IOCTL_STORAGE_QUERY_PROPERTY,
-                    &(STORAGE_PROPERTY_QUERY) {
-                        .PropertyId = StorageDeviceSeekPenaltyProperty,
-                        .QueryType = PropertyStandardQuery,
-                    },
-                    sizeof(STORAGE_PROPERTY_QUERY),
-                    &dspd,
-                    sizeof(dspd),
-                    &retSize,
-                    NULL
-                ) && retSize == sizeof(dspd))
-                    disk->physicalType = dspd.IncursSeekPenalty ? FF_DISK_PHYSICAL_TYPE_HDD : FF_DISK_PHYSICAL_TYPE_SSD;
-            }
-        }
-
         if(GetVolumeNameForVolumeMountPointW(mountpoint, volumeName, sizeof(volumeName) / sizeof(*volumeName)))
             ffStrbufInitWS(&disk->mountFrom, volumeName);
         else

src/detection/diskio/diskio.h

@@ -2,10 +2,18 @@
 
 #include "fastfetch.h"
 
+typedef enum FFDiskIOPhysicalType
+{
+    FF_DISKIO_PHYSICAL_TYPE_UNKNOWN,
+    FF_DISKIO_PHYSICAL_TYPE_HDD,
+    FF_DISKIO_PHYSICAL_TYPE_SSD,
+} FFDiskIOPhysicalType;
+
 typedef struct FFDiskIOResult
 {
     FFstrbuf name;
-    FFstrbuf type;
+    FFstrbuf interconnect;
+    FFDiskIOPhysicalType type;
     FFstrbuf devPath;
     uint64_t bytesRead;
     uint64_t readCount;

src/detection/diskio/diskio_apple.c

@@ -5,6 +5,7 @@
 #include <IOKit/IOBSD.h>
 #include <IOKit/storage/IOMedia.h>
 #include <IOKit/storage/IOBlockStorageDriver.h>
+#include <IOKit/storage/IOStorageDeviceCharacteristics.h>
 #include <IOKit/storage/IOStorageProtocolCharacteristics.h>
 
 static inline void wrapIoObjectRelease(io_service_t* service)
@@ -47,7 +48,8 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
         FFDiskIOResult* device = (FFDiskIOResult*) ffListAdd(result);
         ffStrbufInitS(&device->name, deviceName);
         ffStrbufInit(&device->devPath);
-        ffStrbufInit(&device->type);
+        device->type = FF_DISKIO_PHYSICAL_TYPE_UNKNOWN;
+
         ffCfDictGetInt64(statistics, CFSTR(kIOBlockStorageDriverStatisticsBytesReadKey), (int64_t*) &device->bytesRead);
         ffCfDictGetInt64(statistics, CFSTR(kIOBlockStorageDriverStatisticsBytesWrittenKey), (int64_t*) &device->bytesWritten);
         ffCfDictGetInt64(statistics, CFSTR(kIOBlockStorageDriverStatisticsReadsKey), (int64_t*) &device->readCount);
@@ -60,12 +62,26 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
             ffStrbufPrependS(&device->devPath, "/dev/");
         }
 
+        ffStrbufInit(&device->interconnect);
         FF_IOOBJECT_AUTO_RELEASE io_registry_entry_t entryPhysical = 0;
         if (IORegistryEntryGetParentEntry(entryDriver, kIOServicePlane, &entryPhysical) == KERN_SUCCESS)
         {
             FF_CFTYPE_AUTO_RELEASE CFDictionaryRef protocolCharacteristics = IORegistryEntryCreateCFProperty(entryPhysical, CFSTR(kIOPropertyProtocolCharacteristicsKey), kCFAllocatorDefault, kNilOptions);
             if (protocolCharacteristics)
-                ffCfDictGetString(protocolCharacteristics, CFSTR("Physical Interconnect"), &device->type);
+                ffCfDictGetString(protocolCharacteristics, CFSTR("Physical Interconnect"), &device->interconnect);
+
+            FF_CFTYPE_AUTO_RELEASE CFDictionaryRef deviceCharacteristics = IORegistryEntryCreateCFProperty(entryPhysical, CFSTR(kIOPropertyDeviceCharacteristicsKey), kCFAllocatorDefault, kNilOptions);
+            if (deviceCharacteristics)
+            {
+                CFStringRef mediumType = (CFStringRef) CFDictionaryGetValue(deviceCharacteristics, CFSTR(kIOPropertyMediumTypeKey));
+                if (mediumType)
+                {
+                    if (CFStringCompare(mediumType, CFSTR(kIOPropertyMediumTypeSolidStateKey), 0) == 0)
+                        device->type = FF_DISKIO_PHYSICAL_TYPE_SSD;
+                    else if (CFStringCompare(mediumType, CFSTR(kIOPropertyMediumTypeRotationalKey), 0) == 0)
+                        device->type = FF_DISKIO_PHYSICAL_TYPE_HDD;
+                }
+            }
         }
     }
 

src/detection/diskio/diskio_bsd.c

@@ -29,13 +29,13 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
         FFDiskIOResult* device = (FFDiskIOResult*) ffListAdd(result);
         ffStrbufInitS(&device->name, deviceName);
         ffStrbufInitF(&device->devPath, "/dev/%s", deviceName);
-
-        ffStrbufInit(&device->type);
+        device->type = FF_DISKIO_PHYSICAL_TYPE_UNKNOWN;
+        ffStrbufInit(&device->interconnect);
         switch (current->device_type & DEVSTAT_TYPE_IF_MASK)
         {
-            case DEVSTAT_TYPE_IF_SCSI: ffStrbufAppendS(&device->type, "SCSI"); break;
-            case DEVSTAT_TYPE_IF_IDE: ffStrbufAppendS(&device->type, "IDE"); break;
-            case DEVSTAT_TYPE_IF_OTHER: ffStrbufAppendS(&device->type, "OTHER"); break;
+            case DEVSTAT_TYPE_IF_SCSI: ffStrbufAppendS(&device->interconnect, "SCSI"); break;
+            case DEVSTAT_TYPE_IF_IDE: ffStrbufAppendS(&device->interconnect, "IDE"); break;
+            case DEVSTAT_TYPE_IF_OTHER: ffStrbufAppendS(&device->interconnect, "OTHER"); break;
         }
         device->bytesRead = current->bytes[DEVSTAT_READ];
         device->readCount = current->operations[DEVSTAT_READ];

src/detection/diskio/diskio_linux.c

@@ -53,10 +53,10 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
         }
         if (flag) continue;
 
-        char pathSysBlockStat[PATH_MAX];
-        snprintf(pathSysBlockStat, PATH_MAX, "/sys/block/%s/stat", devName);
+        char pathSysBlock[PATH_MAX];
+        snprintf(pathSysBlock, PATH_MAX, "/sys/block/%s/stat", devName);
 
-        FF_AUTO_CLOSE_FILE FILE* sysBlockStat = fopen(pathSysBlockStat, "r");
+        FF_AUTO_CLOSE_FILE FILE* sysBlockStat = fopen(pathSysBlock, "r");
         if (!sysBlockStat) continue;
 
         // I/Os merges sectors ticks ...
@@ -73,19 +73,19 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
                 ffStrbufInitNS(&device->name, (uint32_t) (slash2 - slash - 1), slash + 1);
             else
                 ffStrbufInitS(&device->name, slash + 1);
-            ffStrbufInitNS(&device->type, (uint32_t) (slash - entry->d_name), entry->d_name);
+            ffStrbufInitNS(&device->interconnect, (uint32_t) (slash - entry->d_name), entry->d_name);
         }
         else
         {
             ffStrbufInitS(&device->name, entry->d_name);
-            ffStrbufInit(&device->type);
+            ffStrbufInit(&device->interconnect);
         }
         ffStrbufReplaceAllC(&device->name, '_', ' ');
 
         if (options->namePrefix.length && !ffStrbufStartsWith(&device->name, &options->namePrefix))
         {
             ffStrbufDestroy(&device->name);
-            ffStrbufDestroy(&device->type);
+            ffStrbufDestroy(&device->interconnect);
             result->length--;
             continue;
         }
@@ -95,6 +95,13 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
         device->bytesWritten = sectorWritten * 512;
         device->readCount = nRead;
         device->writeCount = nWritten;
+
+        snprintf(pathSysBlock, PATH_MAX, "/sys/block/%s/queue/rotational", devName);
+        FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+        if (ffReadFileBuffer(pathSysBlock, &buffer))
+            device->type = ffStrbufEqualS(&buffer, "1") ? FF_DISKIO_PHYSICAL_TYPE_HDD : FF_DISKIO_PHYSICAL_TYPE_SSD;
+        else
+            device->type = FF_DISKIO_PHYSICAL_TYPE_UNKNOWN;
     }
 
     return NULL;

src/detection/diskio/diskio_windows.c

@@ -31,14 +31,14 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
         {
             FFDiskIOResult* device = (FFDiskIOResult*) ffListAdd(result);
             ffStrbufInit(&device->name);
-            ffStrbufInit(&device->type);
+            ffStrbufInit(&device->interconnect);
             if (ffRegReadStrbuf(hKey, pNum, &device->name, NULL))
             {
                 // SCSI\Disk&Ven_NVMe&Prod_WDC_PC_SN810_SDC\5&19cebb7&0&000000
                 uint32_t index = ffStrbufFirstIndexC(&device->name, '\\');
                 if (index != device->name.length)
                 {
-                    ffStrbufAppendNS(&device->type, index, device->name.chars); // SCSI
+                    ffStrbufAppendNS(&device->interconnect, index, device->name.chars); // SCSI
                     ffStrbufSubstrAfter(&device->name, index + 1);
                 }
                 ffStrbufSubstrBeforeLastC(&device->name, '\\');
@@ -53,7 +53,7 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
             if (options->namePrefix.length && !ffStrbufStartsWith(&device->name, &options->namePrefix))
             {
                 ffStrbufDestroy(&device->name);
-                ffStrbufDestroy(&device->type);
+                ffStrbufDestroy(&device->interconnect);
                 result->length--;
                 continue;
             }
@@ -63,6 +63,25 @@ const char* ffDiskIOGetIoCounters(FFlist* result, FFDiskIOOptions* options)
             device->readCount = (uint64_t) diskPerformance.ReadCount;
             device->bytesWritten = (uint64_t) diskPerformance.BytesWritten.QuadPart;
             device->writeCount = (uint64_t) diskPerformance.WriteCount;
+
+            DEVICE_SEEK_PENALTY_DESCRIPTOR dspd = {};
+            DWORD retSize = 0;
+            if(DeviceIoControl(
+                hDevice,
+                IOCTL_STORAGE_QUERY_PROPERTY,
+                &(STORAGE_PROPERTY_QUERY) {
+                    .PropertyId = StorageDeviceSeekPenaltyProperty,
+                    .QueryType = PropertyStandardQuery,
+                },
+                sizeof(STORAGE_PROPERTY_QUERY),
+                &dspd,
+                sizeof(dspd),
+                &retSize,
+                NULL
+            ) && retSize == sizeof(dspd))
+                device->type = dspd.IncursSeekPenalty ? FF_DISKIO_PHYSICAL_TYPE_HDD : FF_DISKIO_PHYSICAL_TYPE_SSD;
+            else
+                device->type = FF_DISKIO_PHYSICAL_TYPE_UNKNOWN;
         }
     }