add TRIM support

Author: braindigitalis

include/ahci.h

@@ -261,6 +261,27 @@ typedef struct ahci_hba_cmd_tbl_t {
 	ahci_hba_prdt_entry_t prdt_entry[1];	/**< PRDT entries (0–65535, flexible array) */
 } __attribute__((packed)) ahci_hba_cmd_tbl_t;
 
+#define ATA_CMD_DATA_SET_MANAGEMENT 0x06
+
+struct ahci_trim_range {
+	uint64_t lba;      /* 48-bit used */
+	uint32_t sectors;  /* 512-byte sectors */
+};
+
+/* IDENTIFY DEVICE words of interest:
+ *  - w169 bit0: DATA SET MANAGEMENT / TRIM supported
+ *  - w69  bit14: Deterministic read after TRIM (DRAT)
+ *  - w69  bit5 : Read zeroes after TRIM (RZAT)
+ *  - w105     : Max 512B DSM parameter blocks per command (0 => 1)
+ */
+
+typedef struct {
+	bool has_trim;
+	bool drat;
+	bool rzat;
+	uint16_t max_dsm_blocks; /* 512-byte blocks; 0 => 1 */
+} ahci_trim_caps;
+
 /* ----------------------------- ATA identify offsets ----------------------------- */
 
 /** @brief ATA IDENTIFY: device type offset (bytes). */
@@ -670,6 +691,12 @@ void scsi_extract_fixed_sense(const uint8_t* buf, scsi_sense_key_t* sense_key, s
  */
 bool atapi_handle_check_condition(ahci_hba_port_t* port, ahci_hba_mem_t* abar, const char* function);
 
+bool ahci_trim_one_range(ahci_hba_port_t *port, ahci_hba_mem_t *abar, const ahci_trim_caps *caps, uint64_t lba, uint32_t sectors);
+
+ahci_trim_caps ahci_probe_trim_caps(const uint16_t *id_words);
+
+bool storage_device_ahci_block_clear(void *dev, uint64_t lba, uint32_t sectors);
+
 /* ----------------------------- Layout sanity checks ----------------------------- */
 
 /** @brief Compile-time size check: command header must be 0x20 bytes. */

include/filesystem.h

@@ -44,6 +44,7 @@ typedef uint64_t (*get_free_space)(void*);
 /* Prototypes for block storage device drivers (see storage_device_t) */
 typedef int (*block_read)(void*, uint64_t, uint32_t, unsigned char*);
 typedef int (*block_write)(void*, uint64_t, uint32_t, const unsigned char*);
+typedef bool (*block_clear)(void*, uint64_t, uint32_t);
 
 typedef enum fs_error_t {
 	FS_ERR_NO_ERROR = 0,
@@ -298,6 +299,11 @@ typedef struct storage_device_t {
 	 */
 	block_write blockwrite;
 
+	/**
+	 * @brief Mark blocks as freed on the device
+	 */
+	block_clear blockclear;
+
 	/**
 	 * @brief The block size read and write operations.
 	 * This is usually a sector size on disk drives.
@@ -317,6 +323,12 @@ typedef struct storage_device_t {
 	 */
 	void* opaque2;
 
+	/**
+	 * @brief An opaque pointer value which can be given meaning by
+	 * the storage device driver.
+	 */
+	void* opaque3;
+
 	/**
 	 * @brief User interface strings, model name, capacity, type
 	 * as human-readable text.
@@ -557,8 +569,24 @@ int fs_truncate_file(fs_directory_entry_t* file, uint32_t length);
  */
 int fs_read_file(fs_directory_entry_t* file, uint32_t start, uint32_t length, unsigned char* buffer);
 
+/**
+ * @brief Returns the free space in bytes for a path depending on the filesystem attached
+ * @param path path to return space for
+ * @return free space in bytes
+ */
 uint64_t fs_get_free_space(const char* path);
 
+/**
+ * @brief Mark blocks on a block storage as freed, as a hint to the storage device.
+ * May be sent as TRIM or other similar command.
+ * @param dev Storage device
+ * @param start Start sector
+ * @param bytes Number of bytes, must be a multiple of block size
+ * @return nonzero on success, zero on failure or not supported. Lack of support
+ * is not considered fatal.
+ */
+int storage_device_clear_blocks(void* dev, uint64_t start, uint32_t bytes);
+
 /**
  * @brief POSIX style _open function
  * 

include/retrofs.h

@@ -259,6 +259,16 @@ bool rfs_read_device(rfs_t *rfs, uint64_t start_sectors, uint64_t size_bytes, vo
  */
 bool rfs_write_device(rfs_t *rfs, uint64_t start_sectors, uint64_t size_bytes, const void *buffer);
 
+/**
+ * @brief Hint to the storage driver that we can clear blocks on the device, e.g.
+ * TRIM or similar.
+ * @param rfs 		Filesystem context
+ * @param start_sectors Sector index (relative to the filesystem start)
+ * @param size_bytes	Number of bytes to write (must be a multiple of sector size).
+ * @return true on success, false on error or not supported
+ */
+bool rfs_clear_device(rfs_t *rfs, uint64_t start_sectors, uint64_t size_bytes);
+
 /**
  * @brief Find a contiguous extent of free sectors.
  *

src/block/ahci/main.c

@@ -217,19 +217,28 @@ void probe_port(ahci_hba_mem_t *abar)
 				}
 				sd->opaque1 = i;
 				sd->opaque2 = (void*)abar;
+				sd->opaque3 = NULL;
 				sd->cache = NULL;
 				sd->blockread = storage_device_ahci_block_read;
 				sd->blockwrite = storage_device_ahci_block_write;
+				sd->blockclear = storage_device_ahci_block_clear;
 				sd->size = dt == AHCI_DEV_SATA ? ahci_read_size(&abar->ports[i], abar) : SIZE_MAX;
 				make_unique_device_name(dt == AHCI_DEV_SATA ? "hd" : "cd", sd->name, sizeof(sd->name));
 				sd->block_size = dt == AHCI_DEV_SATA ? HDD_SECTOR_SIZE : ATAPI_SECTOR_SIZE;
 				/* Build end-user label */
 				sd->ui.label[0] = 0;
 				sd->ui.is_optical = false;
+				bool has_trim = false;
 				if (dt == AHCI_DEV_SATA) {
 					uint8_t id_page[512] = {0};
 					if (ahci_identify_page(&abar->ports[i], abar, id_page)) {
 						build_sata_label(sd, id_page);
+						ahci_trim_caps* caps = kmalloc(sizeof(ahci_trim_caps));
+						if (caps) {
+							*caps = ahci_probe_trim_caps((uint16_t *) id_page);
+							sd->opaque3 = caps;
+							has_trim = caps->has_trim;
+						}
 					} else {
 						char size_str[24] = {0};
 						humanise_capacity(size_str, sizeof(size_str), sd->size * sd->block_size);
@@ -244,7 +253,7 @@ void probe_port(ahci_hba_mem_t *abar)
 						sd->ui.is_optical = true;
 					}
 				}
-				kprintf("%s storage, Port #%d: %s (%d bit)\n", dt == AHCI_DEV_SATA ? "SATA" : "ATAPI", i, sd->ui.label, ahci_hba_supports_64b(abar) ? 64 : 32);
+				kprintf("%s storage, Port #%d: %s (%d bit%s)\n", dt == AHCI_DEV_SATA ? "SATA" : "ATAPI", i, sd->ui.label, ahci_hba_supports_64b(abar) ? 64 : 32, has_trim ? ", TRIM" : "");
 				register_storage_device(sd);
 				storage_enable_cache(sd);
 			}

src/block/ahci/storage_device.c

@@ -9,7 +9,7 @@ int storage_device_ahci_block_read(void* dev, uint64_t start, uint32_t bytes, un
 	uint32_t sectors = (bytes + sd->block_size - 1) / sd->block_size;
 	unsigned char* end = buffer + bytes;
 
-	ahci_hba_mem_t* abar = (ahci_hba_mem_t*)sd->opaque2;
+	ahci_hba_mem_t* abar = sd->opaque2;
 	ahci_hba_port_t* port = &abar->ports[sd->opaque1];
 
 	const uint32_t max_per_cmd = 16;
@@ -51,6 +51,26 @@ int storage_device_ahci_block_read(void* dev, uint64_t start, uint32_t bytes, un
 	}
 }
 
+bool storage_device_ahci_block_clear(void *dev, uint64_t lba, uint32_t bytes) {
+	storage_device_t* sd = (storage_device_t*)dev;
+	if (!sd) {
+		return 0;
+	}
+
+	uint32_t sectors = (bytes + sd->block_size - 1) / sd->block_size;
+	if (sectors < 1) {
+		sectors = 1;
+	}
+
+	ahci_hba_mem_t* abar = sd->opaque2;
+	ahci_hba_port_t* port = &abar->ports[sd->opaque1];
+	ahci_trim_caps* caps = sd->opaque3;
+	if (caps && caps->has_trim) {
+		return ahci_trim_one_range(port, abar, caps, lba, sectors) > 0;
+	}
+	return false;
+}
+
 int storage_device_ahci_block_write(void* dev, uint64_t start, uint32_t bytes, const unsigned char* buffer) {
 	storage_device_t* sd = (storage_device_t*)dev;
 	if (!sd) {
@@ -62,7 +82,7 @@ int storage_device_ahci_block_write(void* dev, uint64_t start, uint32_t bytes, c
 		sectors = 1;
 	}
 
-	ahci_hba_mem_t* abar = (ahci_hba_mem_t*)sd->opaque2;
+	ahci_hba_mem_t* abar = sd->opaque2;
 	ahci_hba_port_t* port = &abar->ports[sd->opaque1];
 
 	const uint32_t max_per_cmd = 16;

src/block/ahci/trim.c

@@ -0,0 +1,78 @@
+#include <kernel.h>
+
+extern uint8_t* aligned_read_buf;
+
+/// @brief Extract TRIM/DSM capability flags from IDENTIFY DEVICE.
+ahci_trim_caps ahci_probe_trim_caps(const uint16_t *id_words) {
+	ahci_trim_caps caps = {0};
+
+	if (!id_words) {
+		return caps;
+	}
+
+	uint16_t w69  = id_words[69];
+	uint16_t w105 = id_words[105];
+	uint16_t w169 = id_words[169];
+
+	caps.has_trim = (w169 & 0x0001) != 0;
+	caps.drat = (w69 & 0x4000) != 0;
+	caps.rzat = (w69 & 0x0020) != 0;
+	caps.max_dsm_blocks = w105 != 0 ? w105 : 1;
+
+	return caps;
+}
+
+/// @brief Trim a single contiguous LBA range. No batching/merging of disjoint ranges.
+/// @return true on success, or if TRIM unsupported (no-op); false on submission error.
+bool ahci_trim_one_range(ahci_hba_port_t *port, ahci_hba_mem_t *abar, const ahci_trim_caps *caps, uint64_t lba, uint32_t sectors) {
+	if (sectors == 0) {
+		return true;
+	}
+	if (!caps || !caps->has_trim) {
+		/* No-op on devices without TRIM so callers need no special cases. */
+		return true;
+	}
+
+	/* One DSM block is 512 bytes, containing 64 entries of 8 bytes.
+	 * We only use a single entry per command here. Sector-count field is 16-bit.
+	 */
+	const uint32_t dsm_block_bytes = 512;
+	const uint16_t max_entry_sectors = 65535;
+
+	while (sectors != 0) {
+		uint16_t chunk = (sectors > max_entry_sectors) ? max_entry_sectors : (uint16_t)sectors;
+
+		memset(aligned_read_buf, 0, dsm_block_bytes);
+		/* 48-bit LBA, little-endian, bytes 0..5 */
+		aligned_read_buf[0] = (uint8_t)(lba >> 0);
+		aligned_read_buf[1] = (uint8_t)(lba >> 8);
+		aligned_read_buf[2] = (uint8_t)(lba >> 16);
+		aligned_read_buf[3] = (uint8_t)(lba >> 24);
+		aligned_read_buf[4] = (uint8_t)(lba >> 32);
+		aligned_read_buf[5] = (uint8_t)(lba >> 40);
+		/* 16-bit sector count, little-endian, bytes 6..7 */
+		aligned_read_buf[6] = (uint8_t)(chunk & 0xff);
+		aligned_read_buf[7] = (uint8_t)(chunk >> 8);
+
+		GET_SLOT(port, abar);
+
+		ahci_hba_cmd_header_t *command_header = get_cmdheader_for_slot(port, slot, true, false, 1);
+		ahci_hba_cmd_tbl_t    *cmdtbl  = get_and_clear_cmdtbl(command_header);
+
+		fill_prdt(cmdtbl, 0, aligned_read_buf, dsm_block_bytes, false);
+
+		ahci_fis_reg_h2d_t *cfis = setup_reg_h2d(cmdtbl, FIS_TYPE_REG_H2D, ATA_CMD_DATA_SET_MANAGEMENT, 0x01 /* TRIM */);
+		cfis->count_low = 1;
+		cfis->count_high = 0;
+
+		if (!issue_and_wait(port, abar, slot)) {
+			return atapi_handle_check_condition(port, abar, "trim");
+		}
+
+		lba += (uint64_t)chunk;
+		sectors -= (uint32_t)chunk;
+	}
+
+	return true;
+}
+

src/fs/filesystem.c

@@ -355,6 +355,20 @@ uint64_t fs_get_free_space(const char* path)
 	return dir && dir->responsible_driver && dir->responsible_driver->freespace ? dir->responsible_driver->freespace(dir) : 0;
 }
 
+
+int storage_device_clear_blocks(void* dev, uint64_t start, uint32_t bytes) {
+	storage_device_t* sd = (storage_device_t*)dev;
+	if (!sd) {
+		return 0;
+	}
+
+	if (sd->blockclear) {
+		return sd->blockclear(sd, start, bytes);
+	}
+	return 0;
+}
+
+
 int read_storage_device(const char* name, uint64_t start_block, uint32_t bytes, unsigned char* data)
 {
 	storage_device_t* cur = find_storage_device(name);

src/fs/retrofs/helpers.c

@@ -39,6 +39,26 @@ bool rfs_write_device(rfs_t *rfs, uint64_t start_sectors, uint64_t size_bytes, c
 	return write_storage_device(rfs->dev->name, volume_start + start_sectors, size_bytes, buffer);
 }
 
+bool rfs_clear_device(rfs_t *rfs, uint64_t start_sectors, uint64_t size_bytes) {
+	const uint64_t total_sectors = rfs->total_sectors;
+	const uint64_t nsectors = size_bytes / RFS_SECTOR_SIZE;
+
+	if ((size_bytes % RFS_SECTOR_SIZE) != 0) {
+		dprintf("rfs_clear_device: size not sector-aligned\n");
+		fs_set_error(FS_ERR_OUTSIDE_VOLUME);
+		return 0;
+	}
+	if (start_sectors + nsectors > total_sectors) {
+		dprintf("rfs_clear_device: would write past end of device\n");
+		fs_set_error(FS_ERR_OUTSIDE_VOLUME);
+		return 0;
+	}
+
+	uint64_t volume_start = rfs->start;
+	return storage_device_clear_blocks(rfs->dev, volume_start + start_sectors, size_bytes);
+}
+
+
 bool rfs_locate_entry(rfs_t *info, fs_tree_t *tree, const char *name, uint64_t *out_sector, size_t *out_index, rfs_directory_entry_inner_t *out_entry_copy) {
 	if (info == NULL || tree == NULL || name == NULL || name[0] == '\0') {
 		fs_set_error(FS_ERR_INVALID_ARG);

src/fs/retrofs/unlink.c

@@ -73,11 +73,11 @@ bool rfs_delete_directory_entry(fs_directory_entry_t *file) {
 		}
 
 		if (found_idx != (size_t) - 1) {
+
 			/* Compact: shift following entries left by one within this block, then clear the tail slot. */
 			if (found_idx < last_used) {
 				size_t move_count = last_used - found_idx;
-				memmove(&ents[found_idx], &ents[found_idx + 1],
-					move_count * sizeof(rfs_directory_entry_t));
+				memmove(&ents[found_idx], &ents[found_idx + 1], move_count * sizeof(rfs_directory_entry_t));
 			}
 
 			/* Clear the last_used slot (now duplicated or original tail). */
@@ -142,6 +142,8 @@ bool rfs_unlink_file(void *dir, const char *name) {
 		if (!rfs_mark_extent(info, on_disk.sector_start, on_disk.sector_length, false)) {
 			return false;
 		}
+		rfs_clear_device(info, on_disk.sector_start, on_disk.sector_length * RFS_SECTOR_SIZE);
+
 	}
 	return done;
 }

src/fs/retrofs/unlinkdirectory.c

@@ -102,6 +102,7 @@ bool rfs_unlink_dir(void *dir, const char *name) {
 			uint64_t span = start_entry->sectors;
 
 			rfs_mark_extent(info, cur, span, false);
+			rfs_clear_device(info, cur, span * RFS_SECTOR_SIZE);
 
 			cur = next;
 		}