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 <klibc/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/pagetable.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_cat* 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 static int
  51 __block_commit(struct blkio_context* blkio, struct blkio_req* req, int flags)
  52 {
  53     int errno;
  54     blkio_commit(blkio, req, flags);
  55
  56     if ((errno = req->errcode)) {
  57         errno = -errno;
  58     }
  59
  60     vbuf_free(req->vbuf);
  61     blkio_free_req(req);
  62     return errno;
  63 }
  64
  65 int
  66 __block_read(struct device* dev, void* buf, size_t offset, size_t len)
  67 {
  68     int errno;
  69     struct block_dev* bdev = (struct block_dev*)dev->underlay;
  70     size_t bsize = bdev->blk_size, rd_block = offset / bsize + bdev->start_lba,
  71            r = offset % bsize, rd_size = 0;
  72
  73     if (!(len = MIN(len, ((size_t)bdev->end_lba - rd_block + 1) * bsize))) {
  74         return 0;
  75     }
  76
  77     struct vecbuf* vbuf = NULL;
  78     struct blkio_req* req;
  79     void *head_buf = NULL, *tail_buf = NULL;
  80
  81     // align the boundary
  82     if (r || len < bsize) {
  83         head_buf = valloc(bsize);
  84         rd_size = MIN(len, bsize - r);
  85         vbuf_alloc(&vbuf, head_buf, bsize);
  86     }
  87
  88     // align the length
  89     if ((len - rd_size)) {
  90         size_t llen = len - rd_size;
  91         assert_msg(!(llen % bsize), "misalign block read");
  92         vbuf_alloc(&vbuf, buf + rd_size, llen);
  93     }
  94
  95     req = blkio_vrd(vbuf, rd_block, NULL, NULL, 0);
  96
  97     if (!(errno = __block_commit(bdev->blkio, req, BLKIO_WAIT))) {
  98         memcpy(buf, head_buf + r, rd_size);
  99         errno = len;
 100     }
 101
 102     if (head_buf) {
 103         vfree(head_buf);
 104     }
 105
 106     return errno;
 107 }
 108
 109 int
 110 __block_write(struct device* dev, void* buf, size_t offset, size_t len)
 111 {
 112     struct block_dev* bdev = (struct block_dev*)dev->underlay;
 113     size_t bsize = bdev->blk_size, wr_block = offset / bsize + bdev->start_lba,
 114            r = offset % bsize, wr_size = 0;
 115
 116     if (!(len = MIN(len, ((size_t)bdev->end_lba - wr_block + 1) * bsize))) {
 117         return 0;
 118     }
 119
 120     struct vecbuf* vbuf = NULL;
 121     struct blkio_req* req;
 122     void* tmp_buf = NULL;
 123
 124     if (r) {
 125         size_t wr_size = MIN(len, bsize - r);
 126         tmp_buf = vzalloc(bsize);
 127         vbuf_alloc(&vbuf, tmp_buf, bsize);
 128
 129         memcpy(tmp_buf + r, buf, wr_size);
 130     }
 131
 132     if ((len - wr_size)) {
 133         size_t llen = len - wr_size;
 134         assert_msg(!(llen % bsize), "misalign block write");
 135         vbuf_alloc(&vbuf, buf + wr_size, llen);
 136     }
 137
 138     req = blkio_vwr(vbuf, wr_block, NULL, NULL, 0);
 139
 140     int errno;
 141     if (!(errno = __block_commit(bdev->blkio, req, BLKIO_WAIT))) {
 142         errno = len;
 143     }
 144
 145     if (tmp_buf) {
 146         vfree(tmp_buf);
 147     }
 148
 149     return errno;
 150 }
 151
 152 int
 153 __block_read_page(struct device* dev, void* buf, size_t offset)
 154 {
 155     struct vecbuf* vbuf = NULL;
 156     struct block_dev* bdev = (struct block_dev*)dev->underlay;
 157
 158     u32_t lba = offset / bdev->blk_size + bdev->start_lba;
 159     u32_t rd_lba = MIN(lba + PAGE_SIZE / bdev->blk_size, bdev->end_lba);
 160
 161     if (rd_lba <= lba) {
 162         return 0;
 163     }
 164
 165     rd_lba -= lba;
 166
 167     vbuf_alloc(&vbuf, buf, rd_lba * bdev->blk_size);
 168
 169     struct blkio_req* req = blkio_vrd(vbuf, lba, NULL, NULL, 0);
 170
 171     int errno;
 172     if (!(errno = __block_commit(bdev->blkio, req, BLKIO_WAIT))) {
 173         errno = rd_lba * bdev->blk_size;
 174     }
 175
 176     return errno;
 177 }
 178
 179 int
 180 __block_write_page(struct device* dev, void* buf, size_t offset)
 181 {
 182     struct vecbuf* vbuf = NULL;
 183     struct block_dev* bdev = (struct block_dev*)dev->underlay;
 184
 185     u32_t lba = offset / bdev->blk_size + bdev->start_lba;
 186     u32_t wr_lba = MIN(lba + PAGE_SIZE / bdev->blk_size, bdev->end_lba);
 187
 188     if (wr_lba <= lba) {
 189         return 0;
 190     }
 191
 192     wr_lba -= lba;
 193
 194     vbuf_alloc(&vbuf, buf, wr_lba * bdev->blk_size);
 195
 196     struct blkio_req* req = blkio_vwr(vbuf, lba, NULL, NULL, 0);
 197
 198     int errno;
 199     if (!(errno = __block_commit(bdev->blkio, req, BLKIO_WAIT))) {
 200         errno = wr_lba * bdev->blk_size;
 201     }
 202
 203     return errno;
 204 }
 205
 206 int
 207 __block_rd_lb(struct block_dev* bdev, void* buf, u64_t start, size_t count)
 208 {
 209     struct vecbuf* vbuf = NULL;
 210     vbuf_alloc(&vbuf, buf, bdev->blk_size * count);
 211
 212     struct blkio_req* req = blkio_vrd(vbuf, start, NULL, NULL, 0);
 213
 214     int errno;
 215     if (!(errno = __block_commit(bdev->blkio, req, BLKIO_WAIT))) {
 216         errno = count;
 217     }
 218
 219     return errno;
 220 }
 221
 222 int
 223 __block_wr_lb(struct block_dev* bdev, void* buf, u64_t start, size_t count)
 224 {
 225     struct vecbuf* vbuf = NULL;
 226     vbuf_alloc(&vbuf, buf, bdev->blk_size * count);
 227
 228     struct blkio_req* req = blkio_vwr(vbuf, start, NULL, NULL, 0);
 229
 230     int errno;
 231     if (!(errno = __block_commit(bdev->blkio, req, BLKIO_WAIT))) {
 232         errno = count;
 233     }
 234
 235     return errno;
 236 }
 237
 238 void*
 239 block_alloc_buf(struct block_dev* bdev)
 240 {
 241     return valloc(bdev->blk_size);
 242 }
 243
 244 void
 245 block_free_buf(struct block_dev* bdev, void* buf)
 246 {
 247     return vfree(buf);
 248 }
 249
 250 struct block_dev*
 251 block_alloc_dev(const char* blk_id, void* driver, req_handler ioreq_handler)
 252 {
 253     struct block_dev* bdev = cake_grab(lbd_pile);
 254     memset(bdev, 0, sizeof(struct block_dev));
 255     llist_init_head(&bdev->parts);
 256     strncpy(bdev->name, blk_id, PARTITION_NAME_SIZE);
 257
 258     bdev->blkio = blkio_newctx(ioreq_handler);
 259     bdev->driver = driver;
 260     bdev->blkio->driver = driver;
 261     bdev->ops = (struct block_dev_ops){ .block_read = __block_rd_lb,
 262                                         .block_write = __block_wr_lb };
 263
 264     return bdev;
 265 }
 266
 267 int
 268 block_mount(struct block_dev* bdev, devfs_exporter fs_export)
 269 {
 270     int errno = 0;
 271
 272     if (!__block_register(bdev)) {
 273         errno = BLOCK_EFULL;
 274         goto error;
 275     }
 276
 277     errno = blkpart_probegpt(bdev->dev);
 278     if (errno < 0) {
 279         ERROR("Fail to parse partition table (%d)", errno);
 280     } else if (!errno) {
 281         // TODO try other PT parser...
 282     }
 283
 284     struct twifs_node* dev_root = twifs_dir_node(blk_sysroot, bdev->bdev_id);
 285     blk_set_blkmapping(bdev, dev_root);
 286     fs_export(bdev, dev_root);
 287
 288     return errno;
 289
 290 error:
 291     ERROR("Fail to mount block device: %s (%x)", bdev->name, -errno);
 292     return errno;
 293 }
 294
 295 int
 296 __block_register(struct block_dev* bdev)
 297 {
 298     if (free_slot >= MAX_DEV) {
 299         return 0;
 300     }
 301
 302     struct device* dev = device_allocvol(dev_meta(blk_parent_dev), bdev);
 303     dev->ops.write = __block_write;
 304     dev->ops.write_page = __block_write_page;
 305     dev->ops.read = __block_read;
 306     dev->ops.read_page = __block_read_page;
 307
 308     bdev->dev = dev;
 309
 310     register_device(dev, bdev->class, "sd%c", 'a' + free_slot);
 311     dev_registry[free_slot++] = bdev;
 312
 313     strcpy(bdev->bdev_id, dev->name_val);
 314
 315     return 1;
 316 }
 317
 318 struct block_dev*
 319 blk_mount_part(struct block_dev* bdev,
 320                const char* name,
 321                size_t index,
 322                u64_t start_lba,
 323                u64_t end_lba)
 324 {
 325     struct block_dev* pbdev = cake_grab(lbd_pile);
 326     memcpy(pbdev, bdev, sizeof(*bdev));
 327
 328     struct device* dev = device_allocvol(NULL, pbdev);
 329     dev->ops.write = __block_write;
 330     dev->ops.write_page = __block_write_page;
 331     dev->ops.read = __block_read;
 332     dev->ops.read_page = __block_read_page;
 333
 334     pbdev->start_lba = start_lba;
 335     pbdev->end_lba = end_lba;
 336     pbdev->dev = dev;
 337
 338     strcpy(pbdev->bdev_id, dev->name_val);
 339     if (name) {
 340         strncpy(pbdev->name, name, PARTITION_NAME_SIZE);
 341     }
 342
 343     llist_append(&bdev->parts, &pbdev->parts);
 344
 345     register_device(dev, pbdev->class, "%sp%d", bdev->bdev_id, index + 1);
 346
 347     return pbdev;
 348 }