X-Git-Url: https://scm.lunaixsky.com/lunaix-os.git/blobdiff_plain/ea77b9c3fc7fb9bf9d7f9604fc187c8049212a2a..97901724584e74554916b89dfb8e95dc6497e687:/lunaix-os/kernel/block/block.c

diff --git a/lunaix-os/kernel/block/block.c b/lunaix-os/kernel/block/block.c
index 936ce2a..216c0ef 100644
--- a/lunaix-os/kernel/block/block.c
+++ b/lunaix-os/kernel/block/block.c
@@ -8,6 +8,8 @@
 #include <lunaix/mm/valloc.h>
 #include <lunaix/syslog.h>
 
+#include <lunaix/blkpart_gpt.h>
+
 #include <lunaix/spike.h>
 
 #define BLOCK_EREAD 1
@@ -19,8 +21,9 @@ LOG_MODULE("BLOCK")
 
 #define MAX_DEV 32
 
-struct cake_pile* lbd_pile;
-struct block_dev** dev_registry;
+static struct cake_pile* lbd_pile;
+static struct block_dev** dev_registry;
+static struct twifs_node* blk_sysroot;
 
 int free_slot = 0;
 
@@ -33,11 +36,11 @@ __block_register(struct block_dev* dev);
 void
 block_init()
 {
+    blkio_init();
     lbd_pile = cake_new_pile("block_dev", sizeof(struct block_dev), 1, 0);
     dev_registry = vcalloc(sizeof(struct block_dev*), MAX_DEV);
     free_slot = 0;
-
-    blk_mapping_init();
+    blk_sysroot = twifs_dir_node(NULL, "block");
 }
 
 int
@@ -45,84 +48,143 @@ __block_read(struct device* dev, void* buf, size_t offset, size_t len)
 {
     int errno;
     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 = offset / bsize, r = offset % bsize,
-           max_blk = (size_t)bdev->hd_dev->max_lba;
-    void* block = vzalloc(bsize);
-
-    while (acc_size < len && rd_block < max_blk) {
-        if (!bdev->hd_dev->ops.read_buffer(
-              bdev->hd_dev, rd_block, block, bsize)) {
-            errno = EIO;
-            goto error;
+    size_t bsize = bdev->blk_size, rd_block = offset / bsize + bdev->start_lba,
+           r = offset % bsize, rd_size = 0;
+
+    if (!(len = MIN(len, ((size_t)bdev->end_lba - rd_block + 1) * bsize))) {
+        return 0;
+    }
+
+    struct vecbuf* vbuf = vbuf_alloc(NULL, buf, len);
+    struct blkio_req* req;
+    void* tmp_buf = NULL;
+
+    if (r) {
+        tmp_buf = vzalloc(bsize);
+        rd_size = MIN(len, bsize - r);
+        vbuf->buf.size = bsize;
+        vbuf->buf.buffer = tmp_buf;
+
+        if ((len - rd_size)) {
+            vbuf_alloc(vbuf, buf + rd_size, len - rd_size);
         }
-        rd_size = MIN(len - acc_size, bsize - r);
-        memcpy(buf + acc_size, block + r, rd_size);
-        acc_size += rd_size;
-        r = 0;
-        rd_block++;
     }
 
-    vfree(block);
-    return acc_size;
+    req = blkio_vrd(vbuf, rd_block, NULL, NULL, 0);
+    blkio_commit(bdev->blkio, req);
 
-error:
-    vfree(block);
+    pwait(&req->wait);
+
+    // XXX temporary work-around
+    //      in case pwait used in proc0. Need a dummy process!
+    wait_if((req->flags & BLKIO_PENDING));
+
+    if (!(errno = req->errcode)) {
+        memcpy(buf, tmp_buf + r, rd_size);
+        errno = len;
+    } else {
+        errno = -errno;
+    }
+
+    if (tmp_buf) {
+        vfree(tmp_buf);
+    }
+
+    blkio_free_req(req);
+    vbuf_free(vbuf);
     return errno;
 }
 
 int
 __block_write(struct device* dev, void* buf, size_t offset, size_t len)
 {
-    int errno;
     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 = offset / bsize, r = offset % bsize;
-    void* block = vzalloc(bsize);
-
-    while (acc_size < len) {
-        wr_size = MIN(len - acc_size, bsize - r);
-        memcpy(block + r, buf + acc_size, wr_size);
-        if (!bdev->hd_dev->ops.write_buffer(
-              bdev->hd_dev, wr_block, block, bsize)) {
-            errno = EIO;
-            break;
-        }
-        acc_size += wr_size;
-        r = 0;
-        wr_block++;
+    size_t bsize = bdev->blk_size, rd_block = offset / bsize + bdev->start_lba,
+           r = offset % bsize;
+
+    if (!(len = MIN(len, ((size_t)bdev->end_lba - rd_block + 1) * bsize))) {
+        return 0;
     }
 
-    vfree(block);
-    return wr_block;
+    struct vecbuf* vbuf = vbuf_alloc(NULL, buf, len);
+    struct blkio_req* req;
+    void* tmp_buf = NULL;
 
-error:
-    vfree(block);
+    if (r) {
+        size_t rd_size = MIN(len, bsize - r);
+        tmp_buf = vzalloc(bsize);
+        vbuf->buf.size = bsize;
+        vbuf->buf.buffer = tmp_buf;
+
+        memcpy(tmp_buf + r, buf, rd_size);
+        vbuf_alloc(vbuf, buf + rd_size, len - rd_size);
+    }
+
+    req = blkio_vwr(vbuf, rd_block, NULL, NULL, 0);
+    blkio_commit(bdev->blkio, req);
+
+    pwait(&req->wait);
+
+    // XXX temporary work-around
+    //      in case pwait used in proc0. Need a dummy process!
+    wait_if((req->flags & BLKIO_PENDING));
+
+    int errno = req->errcode;
+    if (!errno) {
+        errno = len;
+    } else {
+        errno = -errno;
+    }
+
+    if (tmp_buf) {
+        vfree(tmp_buf);
+    }
+
+    blkio_free_req(req);
+    vbuf_free(vbuf);
     return errno;
 }
 
+struct block_dev*
+block_alloc_dev(const char* blk_id, void* driver, req_handler ioreq_handler)
+{
+    struct block_dev* bdev = cake_grab(lbd_pile);
+    memset(bdev, 0, sizeof(struct block_dev));
+    llist_init_head(&bdev->parts);
+    strncpy(bdev->name, blk_id, PARTITION_NAME_SIZE);
+
+    bdev->blkio = blkio_newctx(ioreq_handler);
+    bdev->driver = driver;
+    bdev->blkio->driver = driver;
+
+    return bdev;
+}
+
 int
-block_mount_disk(struct hba_device* hd_dev)
+block_mount(struct block_dev* bdev, devfs_exporter fs_export)
 {
     int errno = 0;
-    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;
     }
 
-    blk_set_blkmapping(bdev);
+    errno = blkpart_probegpt(bdev->dev);
+    if (errno < 0) {
+        kprintf(KERROR "Corrupted partition table. (%d)", errno);
+    } else if (!errno) {
+        // TODO try other PT parser...
+    }
+
+    struct twifs_node* dev_root = twifs_dir_node(blk_sysroot, bdev->bdev_id);
+    blk_set_blkmapping(bdev, dev_root);
+    fs_export(bdev, dev_root);
+
     return errno;
 
 error:
-    kprintf(KERROR "Fail to mount hd: %s[%s] (%x)\n",
-            hd_dev->model,
-            hd_dev->serial_num,
-            -errno);
+    kprintf(KERROR "Fail to mount block device: %s (%x)\n", bdev->name, -errno);
     return errno;
 }
 
@@ -141,4 +203,33 @@ __block_register(struct block_dev* bdev)
     strcpy(bdev->bdev_id, dev->name_val);
     dev_registry[free_slot++] = bdev;
     return 1;
+}
+
+struct block_dev*
+blk_mount_part(struct block_dev* bdev,
+               const char* name,
+               size_t index,
+               u64_t start_lba,
+               u64_t end_lba)
+{
+    struct block_dev* pbdev = cake_grab(lbd_pile);
+    memcpy(pbdev, bdev, sizeof(*bdev));
+
+    struct device* dev =
+      device_addvol(NULL, pbdev, "%sp%d", bdev->bdev_id, index + 1);
+    dev->write = __block_write;
+    dev->read = __block_read;
+
+    pbdev->start_lba = start_lba;
+    pbdev->end_lba = end_lba;
+    pbdev->dev = dev;
+
+    strcpy(pbdev->bdev_id, dev->name_val);
+    if (name) {
+        strncpy(pbdev->name, name, PARTITION_NAME_SIZE);
+    }
+
+    llist_append(&bdev->parts, &pbdev->parts);
+
+    return pbdev;
 }
\ No newline at end of file