feat: simple device abstraction layer

[lunaix-os.git] / lunaix-os / kernel / block.c

diff --git a/lunaix-os/kernel/block.c b/lunaix-os/kernel/block.c
index 23b937488a9b1cd197c942e0f1dcb60d8c4404a7..a4c1942b7756e2632900efb83e69c5a2295590b4 100644 (file)
--- a/lunaix-os/kernel/block.c
+++ b/lunaix-os/kernel/block.c
@@ -39,59 +39,25 @@ block_init()
 }
 
 int
-__block_read(struct v_file* file, void* buffer, size_t len);
-
-int
-__block_write(struct v_file* file, void* buffer, size_t len);
-
-void
-block_twifs_create()
+__block_read(struct device* dev,
+             void* buf,
+             unsigned int offset,
+             unsigned int len)
 {
-    struct twifs_node* dev = twifs_toplevel_node("dev", 3);
-    struct twifs_node* dev_block = twifs_dir_node(dev, "block", 5);
-
-    if (!dev_block) {
-        kprintf(KERROR "fail to create twifs node");
-        return;
-    }
-
-    struct block_dev* bdev;
-    struct twifs_node* bdev_node;
-    for (size_t i = 0; i < MAX_DEV; i++) {
-        if (!(bdev = dev_registry[i])) {
-            continue;
-        }
-
-        bdev_node =
-          twifs_dir_node(dev_block, bdev->bdev_id, strlen(bdev->bdev_id));
-        bdev_node->fops.read = __block_read;
-        bdev_node->fops.write = __block_write;
-        bdev_node->data = i;
-        bdev_node->inode->fsize = bdev->hd_dev->max_lba;
-    }
-}
-
-int
-__block_read(struct v_file* file, void* buffer, size_t len)
-{
-    int index = (int)((struct twifs_node*)file->inode->data)->data;
     int errno;
-    struct block_dev* bdev;
-    if (index < 0 || index >= MAX_DEV || !(bdev = dev_registry[index])) {
-        return ENXIO;
-    }
+    struct block_dev* bdev = (struct block_dev*)dev->underlay;
     size_t acc_size = 0, rd_size = 0, bsize = bdev->hd_dev->block_size,
            rd_block = 0;
     void* block = valloc(bsize);
 
     while (acc_size < len) {
         if (!bdev->hd_dev->ops.read_buffer(
-              bdev->hd_dev, file->f_pos + rd_block, block, bsize)) {
+              bdev->hd_dev, offset + rd_block, block, bsize)) {
             errno = ENXIO;
             goto error;
         }
         rd_size = MIN(len - acc_size, bsize);
-        memcpy(buffer + acc_size, block, rd_size);
+        memcpy(buf + acc_size, block, rd_size);
         acc_size += rd_size;
         rd_block++;
     }
@@ -105,23 +71,22 @@ error:
 }
 
 int
-__block_write(struct v_file* file, void* buffer, size_t len)
+__block_write(struct device* dev,
+              void* buf,
+              unsigned int offset,
+              unsigned int len)
 {
-    int index = (int)((struct twifs_node*)file->inode->data)->data;
     int errno;
-    struct block_dev* bdev;
-    if (index < 0 || index >= MAX_DEV || !(bdev = dev_registry[index])) {
-        return ENXIO;
-    }
+    struct block_dev* bdev = (struct block_dev*)dev->underlay;
     size_t acc_size = 0, wr_size = 0, bsize = bdev->hd_dev->block_size,
            wr_block = 0;
     void* block = valloc(bsize);
 
     while (acc_size < len) {
         wr_size = MIN(len - acc_size, bsize);
-        memcpy(block, buffer + acc_size, wr_size);
+        memcpy(block, buf + acc_size, wr_size);
         if (!bdev->hd_dev->ops.write_buffer(
-              bdev->hd_dev, file->f_pos + wr_block, block, bsize)) {
+              bdev->hd_dev, offset + wr_block, block, bsize)) {
             errno = ENXIO;
             break;
         }
@@ -141,12 +106,12 @@ int
 block_mount_disk(struct hba_device* hd_dev)
 {
     int errno = 0;
-    struct block_dev* dev = cake_grab(lbd_pile);
-    strncpy(dev->name, hd_dev->model, PARTITION_NAME_SIZE);
-    dev->hd_dev = hd_dev;
-    dev->base_lba = 0;
-    dev->end_lba = hd_dev->max_lba;
-    if (!__block_register(dev)) {
+    struct block_dev* bdev = cake_grab(lbd_pile);
+    strncpy(bdev->name, hd_dev->model, PARTITION_NAME_SIZE);
+    bdev->hd_dev = hd_dev;
+    bdev->base_lba = 0;
+    bdev->end_lba = hd_dev->max_lba;
+    if (!__block_register(bdev)) {
         errno = BLOCK_EFULL;
         goto error;
     }
@@ -160,63 +125,18 @@ error:
             -errno);
 }
 
-// FIXME make it more general, manipulate the device through vfs mapping
 int
-__block_mount_partitions(struct hba_device* hd_dev)
-{
-    int errno = 0;
-    void* buffer = valloc_dma(hd_dev->block_size);
-    if (!hd_dev->ops.read_buffer(hd_dev, 1, buffer, hd_dev->block_size)) {
-        errno = BLOCK_EREAD;
-        goto done;
-    }
-
-    struct lpt_header* header = (struct lpt_header*)buffer;
-    if (header->signature != LPT_SIG) {
-        errno = BLOCK_ESIG;
-        goto done;
-    }
-
-    if (header->crc != crc32b(buffer, sizeof(*header))) {
-        errno = BLOCK_ECRC;
-        goto done;
-    }
-
-    uint64_t lba = header->pt_start_lba;
-    int j = 0;
-    int count_per_sector = hd_dev->block_size / sizeof(struct lpt_entry);
-    while (lba < header->pt_end_lba) {
-        if (!hd_dev->ops.read_buffer(hd_dev, lba, buffer, hd_dev->block_size)) {
-            errno = BLOCK_EREAD;
-            goto done;
-        }
-        struct lpt_entry* entry = (struct lpt_entry*)buffer;
-        for (int i = 0; i < count_per_sector; i++, j++) {
-            struct block_dev* dev = cake_grab(lbd_pile);
-            strncpy(dev->name, entry->part_name, PARTITION_NAME_SIZE);
-            dev->hd_dev = hd_dev;
-            dev->base_lba = entry->base_lba;
-            dev->end_lba = entry->end_lba;
-            __block_register(dev);
-
-            if (j >= header->table_len) {
-                goto done;
-            }
-        }
-    }
-
-done:
-    vfree_dma(buffer);
-    return -errno;
-}
-
-int
-__block_register(struct block_dev* dev)
+__block_register(struct block_dev* bdev)
 {
     if (free_slot >= MAX_DEV) {
         return 0;
     }
-    snprintf(dev->bdev_id, DEV_ID_SIZE, "bd%x", free_slot);
-    dev_registry[free_slot++] = dev;
+
+    struct device* dev = device_add(NULL, bdev, "sd%c", 'a' + free_slot);
+    dev->write = __block_write;
+    dev->read = __block_read;
+
+    bdev->dev = dev;
+    dev_registry[free_slot++] = bdev;
     return 1;
 }
\ No newline at end of file