XDRV_READ reading in sectors

kernel/device/device.c

@@ -2,6 +2,7 @@
 #include <device/ramdrv.h>
 #include <device/terminal.h>
 #include <kb_device.h>
+#include <libk/align.h>
 #include <libk/fieldlengthof.h>
 #include <libk/rbtree.h>
 #include <libk/std.h>

kernel/device/ramdrv.c

@@ -1,9 +1,11 @@
 #include <device/device.h>
 #include <device/ramdrv.h>
+#include <libk/align.h>
 #include <libk/std.h>
 #include <libk/string.h>
 #include <mm/liballoc.h>
 #include <status.h>
+#include <sys/debug.h>
 #include <xdrv_device.h>
 
 bool ramdrv_init (struct device* device, void* arg) {
@@ -14,22 +16,20 @@ bool ramdrv_init (struct device* device, void* arg) {
   if (ramdrv == NULL)
     return false;
 
-  ramdrv->total_size = init->total_size;
   ramdrv->sector_size = init->sector_size;
+  ramdrv->total_size = align_up (init->total_size, ramdrv->sector_size);
 
-  if (init->buffer == NULL) {
-    ramdrv->buffer = malloc (init->total_size);
+  ramdrv->buffer = malloc (ramdrv->total_size);
 
   if (ramdrv->buffer == NULL) {
     free (ramdrv);
     return false;
   }
 
-    ramdrv->managed = false;
-  } else {
-    ramdrv->buffer = init->buffer;
-    ramdrv->managed = true;
-  }
+  memset (ramdrv->buffer, 0, ramdrv->total_size);
+
+  if (init->buffer != NULL)
+    memcpy (ramdrv->buffer, init->buffer, init->total_size);
 
   device->udata = ramdrv;
 
@@ -39,7 +39,7 @@ bool ramdrv_init (struct device* device, void* arg) {
 void ramdrv_fini (struct device* device) {
   struct ramdrv* ramdrv = device->udata;
 
-  if (!ramdrv->managed)
+  free (ramdrv->buffer);
   free (ramdrv);
 }
 
@@ -91,19 +91,16 @@ int ramdrv_get_sector_size (struct device* device, struct proc* proc, struct res
 
 int ramdrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
                  void* a2, void* a3, void* a4) {
-  (void)a4;
-
-  if (a1 == NULL || a2 == NULL || a3 == NULL)
+  if (a1 == NULL || a2 == NULL || a3 == NULL || a4 == NULL)
     return -ST_BAD_ADDRESS_SPACE;
 
-  size_t pos = *(size_t*)a1;
-  size_t size = *(size_t*)a2;
-  uint8_t* buffer = a3;
+  size_t sector = *(size_t*)a1;
+  size_t off = *(size_t*)a2;
+  size_t size = *(size_t*)a3;
+  uint8_t* buffer = a4;
 
   struct ramdrv* ramdrv = device->udata;
-
-  if (pos + size > ramdrv->total_size)
-    return -ST_OOB_ERROR;
+  size_t pos = sector * ramdrv->sector_size + off;
 
   memcpy (buffer, (void*)(((uintptr_t)ramdrv->buffer) + pos), size);
 

kernel/device/ramdrv.h

@@ -19,7 +19,6 @@ struct ramdrv {
   size_t total_size;
   size_t sector_size;
   uint8_t* buffer;
-  bool managed;
 };
 
 bool ramdrv_init (struct device* device, void* arg);

kernel/fs/tarfs.c

@@ -66,7 +66,7 @@ int tarfs_mount (struct vfs_mountpoint* mountpoint, struct proc* proc,
   mountpoint->udata = tarfs;
 
   struct device* back_device = mountpoint->back_device;
-  size_t total_size;
+  size_t total_size, sector_size;
   int ret;
 
   spin_lock (&back_device->lock);
@@ -78,6 +78,14 @@ int tarfs_mount (struct vfs_mountpoint* mountpoint, struct proc* proc,
     return ret;
   }
 
+  ret = back_device->ops[XDRV_GET_SECTOR_SIZE](back_device, proc, rctx, &sector_size, NULL, NULL,
+                                               NULL);
+  if (ret < 0) {
+    spin_unlock (&back_device->lock);
+    free (mountpoint->udata);
+    return ret;
+  }
+
   uint8_t* buffer = malloc (total_size);
 
   if (buffer == NULL) {
@@ -86,8 +94,11 @@ int tarfs_mount (struct vfs_mountpoint* mountpoint, struct proc* proc,
     return ret;
   }
 
-  size_t pos = 0;
-  ret = back_device->ops[XDRV_READ](back_device, proc, rctx, &pos, &total_size, buffer, NULL);
+  size_t off = 0;
+  for (size_t sector = 0; sector < total_size / sector_size; sector++) {
+    uint8_t* dest = (uint8_t*)((uintptr_t)buffer + (sector * sector_size));
+    ret = back_device->ops[XDRV_READ](back_device, proc, rctx, &sector, &off, &sector_size, dest);
+  }
 
   spin_unlock (&back_device->lock);