lunaix-os/kernel/block.c

   1 #include <hal/ahci/hba.h>
   2 #include <klibc/stdio.h>
   3 #include <klibc/string.h>
   4 #include <lib/crc.h>
   5 #include <lunaix/block.h>
   6 #include <lunaix/fs/twifs.h>
   7 #include <lunaix/mm/cake.h>
   8 #include <lunaix/mm/valloc.h>
   9 #include <lunaix/syslog.h>
  10
  11 #include <lunaix/spike.h>
  12
  13 #define BLOCK_EREAD 1
  14 #define BLOCK_ESIG 2
  15 #define BLOCK_ECRC 3
  16 #define BLOCK_EFULL 3
  17
  18 LOG_MODULE("BLOCK")
  19
  20 #define MAX_DEV 32
  21
  22 struct cake_pile* lbd_pile;
  23 struct block_dev** dev_registry;
  24
  25 int free_slot = 0;
  26
  27 int
  28 __block_mount_partitions(struct hba_device* hd_dev);
  29
  30 int
  31 __block_register(struct block_dev* dev);
  32
  33 void
  34 block_init()
  35 {
  36     lbd_pile = cake_new_pile("block_dev", sizeof(struct block_dev), 1, 0);
  37     dev_registry = vcalloc(sizeof(struct block_dev*), MAX_DEV);
  38     free_slot = 0;
  39 }
  40
  41 int
  42 __block_read(struct device* dev,
  43              void* buf,
  44              unsigned int offset,
  45              unsigned int len)
  46 {
  47     int errno;
  48     struct block_dev* bdev = (struct block_dev*)dev->underlay;
  49     size_t acc_size = 0, rd_size = 0, bsize = bdev->hd_dev->block_size,
  50            rd_block = offset / bsize, r = offset % bsize;
  51     void* block = vzalloc(bsize);
  52
  53     while (acc_size < len) {
  54         if (!bdev->hd_dev->ops.read_buffer(
  55               bdev->hd_dev, rd_block, block, bsize)) {
  56             errno = ENXIO;
  57             goto error;
  58         }
  59         rd_size = MIN(len - acc_size, bsize - r);
  60         memcpy(buf + acc_size, block + r, rd_size);
  61         acc_size += rd_size;
  62         r = 0;
  63         rd_block++;
  64     }
  65
  66     vfree(block);
  67     return rd_block;
  68
  69 error:
  70     vfree(block);
  71     return errno;
  72 }
  73
  74 int
  75 __block_write(struct device* dev,
  76               void* buf,
  77               unsigned int offset,
  78               unsigned int len)
  79 {
  80     int errno;
  81     struct block_dev* bdev = (struct block_dev*)dev->underlay;
  82     size_t acc_size = 0, wr_size = 0, bsize = bdev->hd_dev->block_size,
  83            wr_block = offset / bsize, r = offset % bsize;
  84     void* block = vzalloc(bsize);
  85
  86     while (acc_size < len) {
  87         wr_size = MIN(len - acc_size, bsize - r);
  88         memcpy(block + r, buf + acc_size, wr_size);
  89         if (!bdev->hd_dev->ops.write_buffer(
  90               bdev->hd_dev, wr_block, block, bsize)) {
  91             errno = ENXIO;
  92             break;
  93         }
  94         acc_size += wr_size;
  95         r = 0;
  96         wr_block++;
  97     }
  98
  99     vfree(block);
 100     return wr_block;
 101
 102 error:
 103     vfree(block);
 104     return errno;
 105 }
 106
 107 int
 108 block_mount_disk(struct hba_device* hd_dev)
 109 {
 110     int errno = 0;
 111     struct block_dev* bdev = cake_grab(lbd_pile);
 112     strncpy(bdev->name, hd_dev->model, PARTITION_NAME_SIZE);
 113     bdev->hd_dev = hd_dev;
 114     bdev->base_lba = 0;
 115     bdev->end_lba = hd_dev->max_lba;
 116     if (!__block_register(bdev)) {
 117         errno = BLOCK_EFULL;
 118         goto error;
 119     }
 120
 121     return errno;
 122
 123 error:
 124     kprintf(KERROR "Fail to mount hd: %s[%s] (%x)\n",
 125             hd_dev->model,
 126             hd_dev->serial_num,
 127             -errno);
 128 }
 129
 130 int
 131 __block_register(struct block_dev* bdev)
 132 {
 133     if (free_slot >= MAX_DEV) {
 134         return 0;
 135     }
 136
 137     struct device* dev = device_addvol(NULL, bdev, "sd%c", 'a' + free_slot);
 138     dev->write = __block_write;
 139     dev->read = __block_read;
 140
 141     bdev->dev = dev;
 142     dev_registry[free_slot++] = bdev;
 143     return 1;
 144 }