lunaix-os/kernel/block/block.c

   1 #include <klibc/strfmt.h>
   2 #include <klibc/string.h>
   3
   4 #include <hal/ahci/hba.h>
   5
   6 #include <lib/crc.h>
   7
   8 #include <lunaix/blkpart_gpt.h>
   9 #include <lunaix/block.h>
  10 #include <lunaix/fs/twifs.h>
  11 #include <lunaix/mm/cake.h>
  12 #include <lunaix/mm/page.h>
  13 #include <lunaix/mm/valloc.h>
  14 #include <lunaix/spike.h>
  15 #include <lunaix/syslog.h>
  16
  17 #define BLOCK_EREAD 1
  18 #define BLOCK_ESIG 2
  19 #define BLOCK_ECRC 3
  20 #define BLOCK_EFULL 3
  21
  22 LOG_MODULE("BLOCK")
  23
  24 #define MAX_DEV 32
  25
  26 static struct cake_pile* lbd_pile;
  27 static struct block_dev** dev_registry;
  28 static struct twifs_node* blk_sysroot;
  29 static struct device* blk_parent_dev;
  30
  31 int free_slot = 0;
  32
  33 int
  34 __block_mount_partitions(struct hba_device* hd_dev);
  35
  36 int
  37 __block_register(struct block_dev* dev);
  38
  39 void
  40 block_init()
  41 {
  42     blkio_init();
  43     lbd_pile = cake_new_pile("block_dev", sizeof(struct block_dev), 1, 0);
  44     dev_registry = vcalloc(sizeof(struct block_dev*), MAX_DEV);
  45     free_slot = 0;
  46     blk_sysroot = twifs_dir_node(NULL, "block");
  47     blk_parent_dev = device_addcat(NULL, "block");
  48 }
  49
  50 int
  51 __block_read(struct device* dev, void* buf, size_t offset, size_t len)
  52 {
  53     int errno;
  54     struct block_dev* bdev = (struct block_dev*)dev->underlay;
  55     size_t bsize = bdev->blk_size, rd_block = offset / bsize + bdev->start_lba,
  56            r = offset % bsize, rd_size = 0;
  57
  58     if (!(len = MIN(len, ((size_t)bdev->end_lba - rd_block + 1) * bsize))) {
  59         return 0;
  60     }
  61
  62     struct vecbuf* vbuf = NULL;
  63     struct blkio_req* req;
  64     void *head_buf = NULL, *tail_buf = NULL;
  65
  66     // align the boundary
  67     if (r || len < bsize) {
  68         head_buf = valloc(bsize);
  69         rd_size = MIN(len, bsize - r);
  70         vbuf_alloc(&vbuf, head_buf, bsize);
  71     }
  72
  73     // align the length
  74     if ((len - rd_size)) {
  75         size_t llen = len - rd_size;
  76         assert_msg(!(llen % bsize), "misalign block read");
  77         vbuf_alloc(&vbuf, buf + rd_size, llen);
  78     }
  79
  80     req = blkio_vrd(vbuf, rd_block, NULL, NULL, 0);
  81     blkio_commit(bdev->blkio, req, BLKIO_WAIT);
  82
  83     if (!(errno = req->errcode)) {
  84         memcpy(buf, head_buf + r, rd_size);
  85         errno = len;
  86     } else {
  87         errno = -errno;
  88     }
  89
  90     if (head_buf) {
  91         vfree(head_buf);
  92     }
  93
  94     blkio_free_req(req);
  95     vbuf_free(vbuf);
  96     return errno;
  97 }
  98
  99 int
 100 __block_write(struct device* dev, void* buf, size_t offset, size_t len)
 101 {
 102     struct block_dev* bdev = (struct block_dev*)dev->underlay;
 103     size_t bsize = bdev->blk_size, wr_block = offset / bsize + bdev->start_lba,
 104            r = offset % bsize, wr_size = 0;
 105
 106     if (!(len = MIN(len, ((size_t)bdev->end_lba - wr_block + 1) * bsize))) {
 107         return 0;
 108     }
 109
 110     struct vecbuf* vbuf = NULL;
 111     struct blkio_req* req;
 112     void* tmp_buf = NULL;
 113
 114     if (r) {
 115         size_t wr_size = MIN(len, bsize - r);
 116         tmp_buf = vzalloc(bsize);
 117         vbuf_alloc(&vbuf, tmp_buf, bsize);
 118
 119         memcpy(tmp_buf + r, buf, wr_size);
 120     }
 121
 122     if ((len - wr_size)) {
 123         size_t llen = len - wr_size;
 124         assert_msg(!(llen % bsize), "misalign block write");
 125         vbuf_alloc(&vbuf, buf + wr_size, llen);
 126     }
 127
 128     req = blkio_vwr(vbuf, wr_block, NULL, NULL, 0);
 129     blkio_commit(bdev->blkio, req, BLKIO_WAIT);
 130
 131     int errno = req->errcode;
 132     if (!errno) {
 133         errno = len;
 134     } else {
 135         errno = -errno;
 136     }
 137
 138     if (tmp_buf) {
 139         vfree(tmp_buf);
 140     }
 141
 142     blkio_free_req(req);
 143     vbuf_free(vbuf);
 144     return errno;
 145 }
 146
 147 int
 148 __block_read_page(struct device* dev, void* buf, size_t offset)
 149 {
 150     struct vecbuf* vbuf = NULL;
 151     struct block_dev* bdev = (struct block_dev*)dev->underlay;
 152
 153     u32_t lba = offset / bdev->blk_size + bdev->start_lba;
 154     u32_t rd_lba = MIN(lba + PG_SIZE / bdev->blk_size, bdev->end_lba);
 155
 156     if (rd_lba <= lba) {
 157         return 0;
 158     }
 159
 160     rd_lba -= lba;
 161
 162     vbuf_alloc(&vbuf, buf, rd_lba * bdev->blk_size);
 163
 164     struct blkio_req* req = blkio_vrd(vbuf, lba, NULL, NULL, 0);
 165
 166     blkio_commit(bdev->blkio, req, BLKIO_WAIT);
 167
 168     int errno = req->errcode;
 169     if (!errno) {
 170         errno = rd_lba * bdev->blk_size;
 171     } else {
 172         errno = -errno;
 173     }
 174
 175     blkio_free_req(req);
 176     vbuf_free(vbuf);
 177     return errno;
 178 }
 179
 180 int
 181 __block_write_page(struct device* dev, void* buf, size_t offset)
 182 {
 183     struct vecbuf* vbuf = NULL;
 184     struct block_dev* bdev = (struct block_dev*)dev->underlay;
 185
 186     u32_t lba = offset / bdev->blk_size + bdev->start_lba;
 187     u32_t rd_lba = MIN(lba + PG_SIZE / bdev->blk_size, bdev->end_lba);
 188
 189     if (rd_lba <= lba) {
 190         return 0;
 191     }
 192
 193     rd_lba -= lba;
 194
 195     vbuf_alloc(&vbuf, buf, rd_lba * bdev->blk_size);
 196
 197     struct blkio_req* req = blkio_vwr(vbuf, lba, NULL, NULL, 0);
 198
 199     blkio_commit(bdev->blkio, req, BLKIO_WAIT);
 200
 201     int errno = req->errcode;
 202     if (!errno) {
 203         errno = rd_lba * bdev->blk_size;
 204     } else {
 205         errno = -errno;
 206     }
 207
 208     blkio_free_req(req);
 209     vbuf_free(vbuf);
 210     return errno;
 211 }
 212
 213 int
 214 __block_rd_lb(struct block_dev* bdev, void* buf, u64_t start, size_t count)
 215 {
 216     struct vecbuf* vbuf = NULL;
 217     vbuf_alloc(&vbuf, buf, bdev->blk_size * count);
 218
 219     struct blkio_req* req = blkio_vrd(vbuf, start, NULL, NULL, 0);
 220     blkio_commit(bdev->blkio, req, BLKIO_WAIT);
 221
 222     int errno = req->errcode;
 223     if (!errno) {
 224         errno = count;
 225     } else {
 226         errno = -errno;
 227     }
 228
 229     blkio_free_req(req);
 230     vbuf_free(vbuf);
 231
 232     return errno;
 233 }
 234
 235 int
 236 __block_wr_lb(struct block_dev* bdev, void* buf, u64_t start, size_t count)
 237 {
 238     struct vecbuf* vbuf = NULL;
 239     vbuf_alloc(&vbuf, buf, bdev->blk_size * count);
 240
 241     struct blkio_req* req = blkio_vwr(vbuf, start, NULL, NULL, 0);
 242     blkio_commit(bdev->blkio, req, BLKIO_WAIT);
 243
 244     int errno = req->errcode;
 245     if (!errno) {
 246         errno = count;
 247     } else {
 248         errno = -errno;
 249     }
 250
 251     blkio_free_req(req);
 252     vbuf_free(vbuf);
 253
 254     return errno;
 255 }
 256
 257 void*
 258 block_alloc_buf(struct block_dev* bdev)
 259 {
 260     return valloc(bdev->blk_size);
 261 }
 262
 263 void
 264 block_free_buf(struct block_dev* bdev, void* buf)
 265 {
 266     return vfree(buf);
 267 }
 268
 269 struct block_dev*
 270 block_alloc_dev(const char* blk_id, void* driver, req_handler ioreq_handler)
 271 {
 272     struct block_dev* bdev = cake_grab(lbd_pile);
 273     memset(bdev, 0, sizeof(struct block_dev));
 274     llist_init_head(&bdev->parts);
 275     strncpy(bdev->name, blk_id, PARTITION_NAME_SIZE);
 276
 277     bdev->blkio = blkio_newctx(ioreq_handler);
 278     bdev->driver = driver;
 279     bdev->blkio->driver = driver;
 280     bdev->ops = (struct block_dev_ops){ .block_read = __block_rd_lb,
 281                                         .block_write = __block_wr_lb };
 282
 283     return bdev;
 284 }
 285
 286 int
 287 block_mount(struct block_dev* bdev, devfs_exporter fs_export)
 288 {
 289     int errno = 0;
 290
 291     if (!__block_register(bdev)) {
 292         errno = BLOCK_EFULL;
 293         goto error;
 294     }
 295
 296     errno = blkpart_probegpt(bdev->dev);
 297     if (errno < 0) {
 298         kprintf(KERROR "Fail to parse partition table (%d)", errno);
 299     } else if (!errno) {
 300         // TODO try other PT parser...
 301     }
 302
 303     struct twifs_node* dev_root = twifs_dir_node(blk_sysroot, bdev->bdev_id);
 304     blk_set_blkmapping(bdev, dev_root);
 305     fs_export(bdev, dev_root);
 306
 307     return errno;
 308
 309 error:
 310     kprintf(KERROR "Fail to mount block device: %s (%x)", bdev->name, -errno);
 311     return errno;
 312 }
 313
 314 int
 315 __block_register(struct block_dev* bdev)
 316 {
 317     if (free_slot >= MAX_DEV) {
 318         return 0;
 319     }
 320
 321     struct device* dev = device_allocvol(blk_parent_dev, bdev);
 322     dev->ops.write = __block_write;
 323     dev->ops.write_page = __block_write_page;
 324     dev->ops.read = __block_read;
 325     dev->ops.read_page = __block_read_page;
 326
 327     bdev->dev = dev;
 328
 329     device_register(dev, bdev->class, "sd%c", 'a' + free_slot);
 330     dev_registry[free_slot++] = bdev;
 331
 332     strcpy(bdev->bdev_id, dev->name_val);
 333
 334     return 1;
 335 }
 336
 337 struct block_dev*
 338 blk_mount_part(struct block_dev* bdev,
 339                const char* name,
 340                size_t index,
 341                u64_t start_lba,
 342                u64_t end_lba)
 343 {
 344     struct block_dev* pbdev = cake_grab(lbd_pile);
 345     memcpy(pbdev, bdev, sizeof(*bdev));
 346
 347     struct device* dev = device_allocvol(NULL, pbdev);
 348     dev->ops.write = __block_write;
 349     dev->ops.write_page = __block_write_page;
 350     dev->ops.read = __block_read;
 351     dev->ops.read_page = __block_read_page;
 352
 353     pbdev->start_lba = start_lba;
 354     pbdev->end_lba = end_lba;
 355     pbdev->dev = dev;
 356
 357     strcpy(pbdev->bdev_id, dev->name_val);
 358     if (name) {
 359         strncpy(pbdev->name, name, PARTITION_NAME_SIZE);
 360     }
 361
 362     llist_append(&bdev->parts, &pbdev->parts);
 363
 364     device_register(dev, pbdev->class, "%sp%d", bdev->bdev_id, index + 1);
 365
 366     return pbdev;
 367 }