linux/LinuxDiskList.c - htop - Rivoreo Source Code Repositories

 /*
 htop - linux/LinuxDiskList.c
 Copyright 2015-2022 Rivoreo
 Released under the GNU GPL, see the COPYING file
 in the source distribution for its full text.
 */

 /*{
 #include "Object.h"
 #include "DiskList.h"
 #include "Vector.h"
 #include <stdio.h>

 typedef struct {
 	Object super;
 	char *orig_name;
 	char *alt_name;
 } AltDiskName;

 typedef struct {
 	DiskList super;
 	FILE *diskstats_file;
 	Vector *disk_id_cache;
 	Vector *disk_path_cache;
 } LinuxDiskList;
 }*/

 #include "config.h"
 #include "LinuxDiskList.h"
 #include "LinuxDisk.h"
 #include "CRT.h"
 #include "XAlloc.h"
 #include "StringUtils.h"
 #include <stdint.h>
 #include <sys/types.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <ctype.h>

 /* Linux is broken in case of reporting the 'number of sectors', as it hard-
  * coded these 'sector sizes' to be 512 byte, no matter what logical/physical
  * sector size a disk actually using. The documentation misleadingly stating
  * that some fields in 'diskstats' file are 'number of sectors', without
  * mentioning this 'sector' is neither a 'logical sector' nor a 'physical
  * sector', which is very confusing for user space programs. Correct this
  * confusing 'number of sectors' value based on the corresponding logical
  * sector size of the disk.
  * References:
  * https://lkml.org/lkml/2015/8/17/269
  * https://kernel.org/doc/Documentation/iostats.txt
  */
 #define FIXUP_SECTOR_COUNT(N,SECTOR_SIZE) ((uint64_t)(N)*512/(SECTOR_SIZE))

 DiskList *DiskList_new(const Settings *settings) {
 	LinuxDiskList *disk_list = xMalloc(sizeof(LinuxDiskList));
 	DiskList_init(&disk_list->super, Class(LinuxDisk), settings);
 	disk_list->diskstats_file = fopen(PROCDIR "/diskstats", "r");
 	if(!disk_list->diskstats_file) CRT_fatalError("fopen: " PROCDIR "/diskstats", 0);
 	disk_list->disk_id_cache = NULL;
 	disk_list->disk_path_cache = NULL;
 	return (DiskList *)disk_list;
 }

 void DiskList_delete(DiskList *super) {
 	DiskList_done(super);
 	LinuxDiskList *this = (LinuxDiskList *)super;
 	fclose(this->diskstats_file);
 	if(this->disk_id_cache) Vector_delete(this->disk_id_cache);
 	if(this->disk_path_cache) Vector_delete(this->disk_path_cache);
 	free(this);
 }

 static uint32_t get_block_size(const char *name, size_t len) {
 	char path[11 + len + 26];
 	memcpy(path, "/sys/block/", 11);
 	memcpy(path + 11, name, len);
 	strcpy(path + 11 + len, "/queue/logical_block_size");
 	FILE *f = fopen(path, "r");
 	if(!f) {
 		strcpy(path + 11 + len + 7, "hw_sector_size");
 		f = fopen(path, "r");
 		if(!f) return 0;
 	}
 	char buffer[8];
 	if(!fgets(buffer, sizeof buffer, f)) {
 		fclose(f);
 		return 0;
 	}
 	fclose(f);
 	char *end_p;
 	unsigned long int size = strtoul(buffer, &end_p, 10);
 	if((*end_p && *end_p != '\n') || !size) return 0;
 	return size;
 }

 static time_t get_creation_time(const char *name, size_t len) {
 	char path[5 + len + 1];
 	memcpy(path, "/dev/", 5);
 	memcpy(path + 5, name, len + 1);
 	struct stat st;
 	if(stat(path, &st) < 0) return -1;
 	return st.st_mtime;
 }

 static long int AltDiskName_compare(const void *o1, const void *o2) {
 	const AltDiskName *n1 = o1;
 	const AltDiskName *n2 = o2;
 	return strcmp(n1->orig_name, n2->orig_name);
 }

 static void AltDiskName_delete(Object *super) {
 	AltDiskName *this = (AltDiskName *)super;
 	free(this->orig_name);
 	free(this->alt_name);
 	free(this);
 }

 ObjectClass AltDiskName_class = {
 	.compare = AltDiskName_compare,
 	.delete = AltDiskName_delete
 };

 static char *get_alternative_name_from_cache(const char *name, const Vector *cache) {
 	int i = Vector_size(cache);
 	while(i > 0) {
 		const AltDiskName *n = (const AltDiskName *)Vector_get(cache, --i);
 		if(strcmp(name, n->orig_name) == 0) return xStrdup(n->alt_name);
 	}
 	return NULL;
 }

 static char *get_alternative_name(const char *name, size_t len, const char *disk_link_dir_path, Vector **cache) {
 	if(*cache) {
 		char *alt_name = get_alternative_name_from_cache(name, *cache);
 		if(alt_name) return alt_name;
 		Vector_prune(*cache);
 	} else {
 		*cache = Vector_new(Class(AltDiskName), true, DEFAULT_SIZE);
 	}

 	char *r = NULL;
 	DIR *dir = opendir(disk_link_dir_path);
 	if(!dir) return NULL;
 	struct dirent *e;
 	while((e = readdir(dir))) {
 		if(e->d_name[0] == '.') continue;
 		char *path = String_cat(disk_link_dir_path, e->d_name);
 		char buffer[32];
 		int target_len = readlink(path, buffer, sizeof buffer);
 		free(path);
 		if(target_len < 7 || memcmp(buffer, "../../", 6)) continue;
 		target_len -= 6;
 		char *orig_name = xMalloc(target_len + 1);
 		memcpy(orig_name, buffer + 6, target_len);
 		orig_name[target_len] = 0;
 		if(!r && (size_t)target_len == len && memcmp(orig_name, name, len) == 0) {
 			r = xStrdup(e->d_name);
 		}
 		char *alt_name = xStrdup(e->d_name);
 		AltDiskName *n = xMalloc(sizeof(AltDiskName));
 		Object_setClass(n, Class(AltDiskName));
 		n->orig_name = orig_name;
 		n->alt_name = alt_name;
 		Vector_add(*cache, n);
 	}
 	closedir(dir);
 	return r;
 }

 static char *get_phys_path(LinuxDiskList *disk_list, const char *name, size_t len) {
 	return get_alternative_name(name, len, "/dev/disk/by-path/", &disk_list->disk_path_cache);
 }

 static char *get_devid(LinuxDiskList *disk_list, const char *name, size_t len) {
 	return get_alternative_name(name, len, "/dev/disk/by-id/", &disk_list->disk_id_cache);
 }

 static void fill_from_device_node(Disk *disk, const char *name, size_t len, int flags) {
 	char path[5 + len + 1];
 	memcpy(path, "/dev/", 5);
 	memcpy(path + 5, disk->name, len);
 	path[5 + len] = 0;
 	int fd = open(path, O_RDONLY);
 	if(fd == -1) return;
 #ifdef BLKSSZGET
 	if(!disk->block_size) {
 		int size;
 		if(ioctl(fd, BLKSSZGET, &size) == 0 && size) disk->block_size = size;
 	}
 #endif
 	if(flags & HTOP_DISK_CAPACITY_FLAG) {
 #ifdef BLKGETSIZE64
 		uint64_t size;
 		if(ioctl(fd, BLKGETSIZE64, &size) == 0) {
 			disk->block_count = size / (disk->block_size ? : 512);
 		} else
 #endif
 		{
 #ifdef BLKGETSIZE
 			unsigned long int sector_count;
 			if(ioctl(fd, BLKGETSIZE, &sector_count) == 0) {
 				disk->block_count = sector_count;
 				// Fixup broken sector size in Linux
 				if(disk->block_size && disk->block_size != 512) {
 					disk->block_count =
 						FIXUP_SECTOR_COUNT(disk->block_count, disk->block_size);
 				}
 			}
 #endif
 		}
 	}
 	close(fd);
 }

 void DiskList_internalScan(DiskList *super, double interval) {
 	LinuxDiskList *this = (LinuxDiskList *)super;
 	if(interval < 0) interval = 0.000001;
 	char last_name[32];
 	*last_name = 0;
 	size_t last_name_len = 0;
 	char *line;
 	rewind(this->diskstats_file);
 	while((line = String_readLine(this->diskstats_file))) {
 		int major, minor;
 		char name[32];
 		unsigned long int read_op_count, read_merge_count, read_512byte_count;
 		unsigned int read_time;
 		unsigned long int write_op_count, write_merge_count, write_512byte_count;
 		unsigned int write_time;
 		unsigned int pending_op_count, operation_time, queue_time;
 		int n = sscanf(line, "%d %d %31s %lu %lu %lu %u %lu %lu %lu %u %u %u %u",
 			&major, &minor, name,
 			&read_op_count, &read_merge_count, &read_512byte_count, &read_time,
 			&write_op_count, &write_merge_count, &write_512byte_count, &write_time,
 			&pending_op_count, &operation_time, &queue_time);
 		free(line);
 		if(n < 11) continue;
 		size_t name_len = strlen(name);
 		if(*last_name && name_len > 2) {
 			if(last_name_len > 2 && name_len > 3 && name_len > last_name_len && islower(name[0]) && name[1] == 'd' && islower(name[2]) && strncmp(name, last_name, last_name_len) == 0) {
 				unsigned int i = 3;
 				while(islower(name[i])) i++;
 				if(i == last_name_len && i < name_len) {
 					while(isdigit(name[i])) i++;
 					if(i >= name_len) continue;
 				}
 			} else if(isdigit(name[name_len - 1])) {
 				unsigned int i = name_len - 2;
 				while(isdigit(name[i]) && i) i--;
 				if(i && name[i] == 'p' && i == last_name_len && strncmp(name, last_name, last_name_len) == 0) {
 					continue;
 				}
 			}
 		}
 		memcpy(last_name, name, name_len + 1);
 		last_name_len = name_len;

 		bool is_existing;
 		Disk *disk = DiskList_getOrCreate(super, name, &is_existing, (DiskConstructor)LinuxDisk_new);
 		LinuxDisk *linux_disk = (LinuxDisk *)disk;
 		if(!is_existing) {
 			disk->block_size = get_block_size(name, name_len);
 			disk->creation_time = get_creation_time(name, name_len);
 			if(super->settings->disk_flags & HTOP_DISK_PHYS_PATH_FLAG) {
 				disk->phys_path = get_phys_path(this, name, name_len);
 			}
 			if(super->settings->disk_flags & HTOP_DISK_DEVID_FLAG) {
 				disk->devid = get_devid(this, name, name_len);
 			}
 			if(!disk->block_size || (super->settings->disk_flags & HTOP_DISK_CAPACITY_FLAG)) {
 				fill_from_device_node(disk, name, name_len, super->settings->disk_flags);
 				if(!disk->block_size) disk->block_size = 512;
 			}
 			DiskList_add(super, disk);
 		}
 		uint64_t read_block_count = FIXUP_SECTOR_COUNT(read_512byte_count, disk->block_size);
 		uint64_t write_block_count = FIXUP_SECTOR_COUNT(write_512byte_count, disk->block_size);
 		disk->queue_length = pending_op_count;
 		uint64_t operation_count = read_op_count + write_op_count;
 		disk->operation_rate = (operation_count - disk->operation_count) / interval;
 		disk->read_operation_rate = (read_op_count - disk->read_operation_count) / interval;
 		disk->write_operation_rate = (write_op_count - disk->write_operation_count) / interval;
 		disk->read_block_rate = (read_block_count - disk->read_block_count) / interval;
 		disk->write_block_rate = (write_block_count - disk->write_block_count) / interval;
 		disk->operation_count = operation_count;
 		disk->read_operation_count = read_op_count;
 		disk->write_operation_count = write_op_count;
 		disk->read_block_count = read_block_count;
 		disk->write_block_count = write_block_count;
 		if(super->settings->disk_flags & HTOP_DISK_PERCENT_UTIL_FLAG) {
 			disk->percent_util =
 				(operation_time - linux_disk->oper_time_msec) / interval / 10;
 		}
 		linux_disk->oper_time_msec = operation_time;
 		disk->oper_time = operation_time / 10;
 		disk->updated = true;
 	}
 }
	/*
	htop - linux/LinuxDiskList.c
	Copyright 2015-2022 Rivoreo
	Released under the GNU GPL, see the COPYING file
	in the source distribution for its full text.
	*/

	/*{
	#include "Object.h"
	#include "DiskList.h"
	#include "Vector.h"
	#include <stdio.h>

	typedef struct {
	Object super;
	char *orig_name;
	char *alt_name;
	} AltDiskName;

	typedef struct {
	DiskList super;
	FILE *diskstats_file;
	Vector *disk_id_cache;
	Vector *disk_path_cache;
	} LinuxDiskList;
	}*/

	#include "config.h"
	#include "LinuxDiskList.h"
	#include "LinuxDisk.h"
	#include "CRT.h"
	#include "XAlloc.h"
	#include "StringUtils.h"
	#include <stdint.h>
	#include <sys/types.h>
	#include <sys/mount.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <dirent.h>
	#include <fcntl.h>
	#include <string.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <ctype.h>

	/* Linux is broken in case of reporting the 'number of sectors', as it hard-
	* coded these 'sector sizes' to be 512 byte, no matter what logical/physical
	* sector size a disk actually using. The documentation misleadingly stating
	* that some fields in 'diskstats' file are 'number of sectors', without
	* mentioning this 'sector' is neither a 'logical sector' nor a 'physical
	* sector', which is very confusing for user space programs. Correct this
	* confusing 'number of sectors' value based on the corresponding logical
	* sector size of the disk.
	* References:
	* https://lkml.org/lkml/2015/8/17/269
	* https://kernel.org/doc/Documentation/iostats.txt
	*/
	#define FIXUP_SECTOR_COUNT(N,SECTOR_SIZE) ((uint64_t)(N)*512/(SECTOR_SIZE))

	DiskList DiskList_new(const Settings settings) {
	LinuxDiskList *disk_list = xMalloc(sizeof(LinuxDiskList));
	DiskList_init(&disk_list->super, Class(LinuxDisk), settings);
	disk_list->diskstats_file = fopen(PROCDIR "/diskstats", "r");
	if(!disk_list->diskstats_file) CRT_fatalError("fopen: " PROCDIR "/diskstats", 0);
	disk_list->disk_id_cache = NULL;
	disk_list->disk_path_cache = NULL;
	return (DiskList *)disk_list;
	}

	void DiskList_delete(DiskList *super) {
	DiskList_done(super);
	LinuxDiskList this = (LinuxDiskList )super;
	fclose(this->diskstats_file);
	if(this->disk_id_cache) Vector_delete(this->disk_id_cache);
	if(this->disk_path_cache) Vector_delete(this->disk_path_cache);
	free(this);
	}

	static uint32_t get_block_size(const char *name, size_t len) {
	char path[11 + len + 26];
	memcpy(path, "/sys/block/", 11);
	memcpy(path + 11, name, len);
	strcpy(path + 11 + len, "/queue/logical_block_size");
	FILE *f = fopen(path, "r");
	if(!f) {
	strcpy(path + 11 + len + 7, "hw_sector_size");
	f = fopen(path, "r");
	if(!f) return 0;
	}
	char buffer[8];
	if(!fgets(buffer, sizeof buffer, f)) {
	fclose(f);
	return 0;
	}
	fclose(f);
	char *end_p;
	unsigned long int size = strtoul(buffer, &end_p, 10);
	if((end_p && end_p != '\n') \|\| !size) return 0;
	return size;
	}

	static time_t get_creation_time(const char *name, size_t len) {
	char path[5 + len + 1];
	memcpy(path, "/dev/", 5);
	memcpy(path + 5, name, len + 1);
	struct stat st;
	if(stat(path, &st) < 0) return -1;
	return st.st_mtime;
	}

	static long int AltDiskName_compare(const void o1, const void o2) {
	const AltDiskName *n1 = o1;
	const AltDiskName *n2 = o2;
	return strcmp(n1->orig_name, n2->orig_name);
	}

	static void AltDiskName_delete(Object *super) {
	AltDiskName this = (AltDiskName )super;
	free(this->orig_name);
	free(this->alt_name);
	free(this);
	}

	ObjectClass AltDiskName_class = {
	.compare = AltDiskName_compare,
	.delete = AltDiskName_delete
	};

	static char get_alternative_name_from_cache(const char name, const Vector *cache) {
	int i = Vector_size(cache);
	while(i > 0) {
	const AltDiskName n = (const AltDiskName )Vector_get(cache, --i);
	if(strcmp(name, n->orig_name) == 0) return xStrdup(n->alt_name);
	}
	return NULL;
	}

	static char get_alternative_name(const char name, size_t len, const char disk_link_dir_path, Vector *cache) {
	if(*cache) {
	char alt_name = get_alternative_name_from_cache(name, cache);
	if(alt_name) return alt_name;
	Vector_prune(*cache);
	} else {
	*cache = Vector_new(Class(AltDiskName), true, DEFAULT_SIZE);
	}

	char *r = NULL;
	DIR *dir = opendir(disk_link_dir_path);
	if(!dir) return NULL;
	struct dirent *e;
	while((e = readdir(dir))) {
	if(e->d_name[0] == '.') continue;
	char *path = String_cat(disk_link_dir_path, e->d_name);
	char buffer[32];
	int target_len = readlink(path, buffer, sizeof buffer);
	free(path);
	if(target_len < 7 \|\| memcmp(buffer, "../../", 6)) continue;
	target_len -= 6;
	char *orig_name = xMalloc(target_len + 1);
	memcpy(orig_name, buffer + 6, target_len);
	orig_name[target_len] = 0;
	if(!r && (size_t)target_len == len && memcmp(orig_name, name, len) == 0) {
	r = xStrdup(e->d_name);
	}
	char *alt_name = xStrdup(e->d_name);
	AltDiskName *n = xMalloc(sizeof(AltDiskName));
	Object_setClass(n, Class(AltDiskName));
	n->orig_name = orig_name;
	n->alt_name = alt_name;
	Vector_add(*cache, n);
	}
	closedir(dir);
	return r;
	}

	static char get_phys_path(LinuxDiskList disk_list, const char *name, size_t len) {
	return get_alternative_name(name, len, "/dev/disk/by-path/", &disk_list->disk_path_cache);
	}

	static char get_devid(LinuxDiskList disk_list, const char *name, size_t len) {
	return get_alternative_name(name, len, "/dev/disk/by-id/", &disk_list->disk_id_cache);
	}

	static void fill_from_device_node(Disk disk, const char name, size_t len, int flags) {
	char path[5 + len + 1];
	memcpy(path, "/dev/", 5);
	memcpy(path + 5, disk->name, len);
	path[5 + len] = 0;
	int fd = open(path, O_RDONLY);
	if(fd == -1) return;
	#ifdef BLKSSZGET
	if(!disk->block_size) {
	int size;
	if(ioctl(fd, BLKSSZGET, &size) == 0 && size) disk->block_size = size;
	}
	#endif
	if(flags & HTOP_DISK_CAPACITY_FLAG) {
	#ifdef BLKGETSIZE64
	uint64_t size;
	if(ioctl(fd, BLKGETSIZE64, &size) == 0) {
	disk->block_count = size / (disk->block_size ? : 512);
	} else
	#endif
	{
	#ifdef BLKGETSIZE
	unsigned long int sector_count;
	if(ioctl(fd, BLKGETSIZE, &sector_count) == 0) {
	disk->block_count = sector_count;
	// Fixup broken sector size in Linux
	if(disk->block_size && disk->block_size != 512) {
	disk->block_count =
	FIXUP_SECTOR_COUNT(disk->block_count, disk->block_size);
	}
	}
	#endif
	}
	}
	close(fd);
	}

	void DiskList_internalScan(DiskList *super, double interval) {
	LinuxDiskList this = (LinuxDiskList )super;
	if(interval < 0) interval = 0.000001;
	char last_name[32];
	*last_name = 0;
	size_t last_name_len = 0;
	char *line;
	rewind(this->diskstats_file);
	while((line = String_readLine(this->diskstats_file))) {
	int major, minor;
	char name[32];
	unsigned long int read_op_count, read_merge_count, read_512byte_count;
	unsigned int read_time;
	unsigned long int write_op_count, write_merge_count, write_512byte_count;
	unsigned int write_time;
	unsigned int pending_op_count, operation_time, queue_time;
	int n = sscanf(line, "%d %d %31s %lu %lu %lu %u %lu %lu %lu %u %u %u %u",
	&major, &minor, name,
	&read_op_count, &read_merge_count, &read_512byte_count, &read_time,
	&write_op_count, &write_merge_count, &write_512byte_count, &write_time,
	&pending_op_count, &operation_time, &queue_time);
	free(line);
	if(n < 11) continue;
	size_t name_len = strlen(name);
	if(*last_name && name_len > 2) {
	if(last_name_len > 2 && name_len > 3 && name_len > last_name_len && islower(name[0]) && name[1] == 'd' && islower(name[2]) && strncmp(name, last_name, last_name_len) == 0) {
	unsigned int i = 3;
	while(islower(name[i])) i++;
	if(i == last_name_len && i < name_len) {
	while(isdigit(name[i])) i++;
	if(i >= name_len) continue;
	}
	} else if(isdigit(name[name_len - 1])) {
	unsigned int i = name_len - 2;
	while(isdigit(name[i]) && i) i--;
	if(i && name[i] == 'p' && i == last_name_len && strncmp(name, last_name, last_name_len) == 0) {
	continue;
	}
	}
	}
	memcpy(last_name, name, name_len + 1);
	last_name_len = name_len;

	bool is_existing;
	Disk *disk = DiskList_getOrCreate(super, name, &is_existing, (DiskConstructor)LinuxDisk_new);
	LinuxDisk linux_disk = (LinuxDisk )disk;
	if(!is_existing) {
	disk->block_size = get_block_size(name, name_len);
	disk->creation_time = get_creation_time(name, name_len);
	if(super->settings->disk_flags & HTOP_DISK_PHYS_PATH_FLAG) {
	disk->phys_path = get_phys_path(this, name, name_len);
	}
	if(super->settings->disk_flags & HTOP_DISK_DEVID_FLAG) {
	disk->devid = get_devid(this, name, name_len);
	}
	if(!disk->block_size \|\| (super->settings->disk_flags & HTOP_DISK_CAPACITY_FLAG)) {
	fill_from_device_node(disk, name, name_len, super->settings->disk_flags);
	if(!disk->block_size) disk->block_size = 512;
	}
	DiskList_add(super, disk);
	}
	uint64_t read_block_count = FIXUP_SECTOR_COUNT(read_512byte_count, disk->block_size);
	uint64_t write_block_count = FIXUP_SECTOR_COUNT(write_512byte_count, disk->block_size);
	disk->queue_length = pending_op_count;
	uint64_t operation_count = read_op_count + write_op_count;
	disk->operation_rate = (operation_count - disk->operation_count) / interval;
	disk->read_operation_rate = (read_op_count - disk->read_operation_count) / interval;
	disk->write_operation_rate = (write_op_count - disk->write_operation_count) / interval;
	disk->read_block_rate = (read_block_count - disk->read_block_count) / interval;
	disk->write_block_rate = (write_block_count - disk->write_block_count) / interval;
	disk->operation_count = operation_count;
	disk->read_operation_count = read_op_count;
	disk->write_operation_count = write_op_count;
	disk->read_block_count = read_block_count;
	disk->write_block_count = write_block_count;
	if(super->settings->disk_flags & HTOP_DISK_PERCENT_UTIL_FLAG) {
	disk->percent_util =
	(operation_time - linux_disk->oper_time_msec) / interval / 10;
	}
	linux_disk->oper_time_msec = operation_time;
	disk->oper_time = operation_time / 10;
	disk->updated = true;
	}
	}