lwext4/ext4_blockdev.c

   1 /*
   2  * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup lwext4
  30  * @{
  31  */
  32 /**
  33  * @file  ext4_blockdev.c
  34  * @brief Block device module.
  35  */
  36
  37 #include "ext4_config.h"
  38 #include "ext4_blockdev.h"
  39 #include "ext4_errno.h"
  40 #include "ext4_debug.h"
  41
  42 #include <string.h>
  43 #include <stdlib.h>
  44
  45 static void ext4_bdif_lock(struct ext4_blockdev *bdev)
  46 {
  47         if (!bdev->bdif->lock)
  48                 return;
  49
  50         int r = bdev->bdif->lock(bdev);
  51         ext4_assert(r == EOK);
  52 }
  53
  54 static void ext4_bdif_unlock(struct ext4_blockdev *bdev)
  55 {
  56         if (!bdev->bdif->unlock)
  57                 return;
  58
  59         int r = bdev->bdif->unlock(bdev);
  60         ext4_assert(r == EOK);
  61 }
  62
  63 static int ext4_bdif_bread(struct ext4_blockdev *bdev, void *buf,
  64                            uint64_t blk_id, uint32_t blk_cnt)
  65 {
  66         ext4_bdif_lock(bdev);
  67         int r = bdev->bdif->bread(bdev, buf, blk_id, blk_cnt);
  68         ext4_bdif_unlock(bdev);
  69         return r;
  70 }
  71
  72 static int ext4_bdif_bwrite(struct ext4_blockdev *bdev, const void *buf,
  73                             uint64_t blk_id, uint32_t blk_cnt)
  74 {
  75         ext4_bdif_lock(bdev);
  76         int r = bdev->bdif->bwrite(bdev, buf, blk_id, blk_cnt);
  77         ext4_bdif_unlock(bdev);
  78         return r;
  79 }
  80
  81 int ext4_block_init(struct ext4_blockdev *bdev)
  82 {
  83         int rc;
  84         ext4_assert(bdev);
  85         ext4_assert(bdev->bdif);
  86         ext4_assert(bdev->bdif->open &&
  87                    bdev->bdif->close &&
  88                    bdev->bdif->bread &&
  89                    bdev->bdif->bwrite);
  90
  91         if (bdev->bdif->ph_refctr) {
  92                 bdev->bdif->ph_refctr++;
  93                 return EOK;
  94         }
  95
  96         /*Low level block init*/
  97         rc = bdev->bdif->open(bdev);
  98         if (rc != EOK)
  99                 return rc;
 100
 101         bdev->bdif->ph_refctr = 1;
 102         return EOK;
 103 }
 104
 105 int ext4_block_bind_bcache(struct ext4_blockdev *bdev, struct ext4_bcache *bc)
 106 {
 107         ext4_assert(bdev && bc);
 108         bdev->bc = bc;
 109         bc->bdev = bdev;
 110         return EOK;
 111 }
 112
 113 void ext4_block_set_lb_size(struct ext4_blockdev *bdev, uint64_t lb_bsize)
 114 {
 115         /*Logical block size has to be multiply of physical */
 116         ext4_assert(!(lb_bsize % bdev->bdif->ph_bsize));
 117
 118         bdev->lg_bsize = lb_bsize;
 119         bdev->lg_bcnt = (bdev->bdif->ph_bcnt * bdev->bdif->ph_bsize) / lb_bsize;
 120 }
 121
 122 int ext4_block_fini(struct ext4_blockdev *bdev)
 123 {
 124         ext4_assert(bdev);
 125
 126         if (!bdev->bdif->ph_refctr)
 127                 return EOK;
 128
 129         bdev->bdif->ph_refctr--;
 130         if (bdev->bdif->ph_refctr)
 131                 return EOK;
 132
 133         /*Low level block fini*/
 134         return bdev->bdif->close(bdev);
 135 }
 136
 137 int ext4_block_flush_buf(struct ext4_blockdev *bdev, struct ext4_buf *buf)
 138 {
 139         int r;
 140         struct ext4_bcache *bc = bdev->bc;
 141         /*Only flushing unreferenced buffer is allowed.*/
 142         ext4_assert(!buf->refctr);
 143
 144         if (ext4_bcache_test_flag(buf, BC_DIRTY)) {
 145                 r = ext4_blocks_set_direct(bdev, buf->data, buf->lba, 1);
 146
 147                 if (r) {
 148                         if (buf->end_write)
 149                                 buf->end_write(bc, buf, r, buf->end_write_arg);
 150
 151                         return r;
 152                 }
 153
 154                 ext4_bcache_remove_dirty_node(bc, buf);
 155                 ext4_bcache_clear_flag(buf, BC_DIRTY);
 156                 if (buf->end_write)
 157                         buf->end_write(bc, buf, r, buf->end_write_arg);
 158
 159         }
 160         return EOK;
 161 }
 162
 163 int ext4_block_cache_shake(struct ext4_blockdev *bdev)
 164 {
 165         struct ext4_buf *buf;
 166         while (!RB_EMPTY(&bdev->bc->lru_root) &&
 167                 ext4_bcache_is_full(bdev->bc)) {
 168
 169                 buf = ext4_buf_lowest_lru(bdev->bc);
 170                 ext4_assert(buf);
 171                 if (ext4_bcache_test_flag(buf, BC_DIRTY)) {
 172                         int r = ext4_block_flush_buf(bdev, buf);
 173                         if (r != EOK)
 174                                 return r;
 175
 176                 }
 177
 178                 ext4_bcache_drop_buf(bdev->bc, buf);
 179         }
 180         return EOK;
 181 }
 182
 183 int ext4_block_get_noread(struct ext4_blockdev *bdev, struct ext4_block *b,
 184                           uint64_t lba)
 185 {
 186         bool is_new;
 187         int r;
 188
 189         ext4_assert(bdev && b);
 190
 191         if (!bdev->bdif->ph_refctr)
 192                 return EIO;
 193
 194         if (!(lba < bdev->lg_bcnt))
 195                 return ERANGE;
 196
 197         b->lb_id = lba;
 198
 199         /*If cache is full we have to (flush and) drop it anyway :(*/
 200         r = ext4_block_cache_shake(bdev);
 201         if (r != EOK)
 202                 return r;
 203
 204         r = ext4_bcache_alloc(bdev->bc, b, &is_new);
 205         if (r != EOK)
 206                 return r;
 207
 208         if (!b->data)
 209                 return ENOMEM;
 210
 211         return EOK;
 212 }
 213
 214 int ext4_block_get(struct ext4_blockdev *bdev, struct ext4_block *b,
 215                    uint64_t lba)
 216 {
 217         int r = ext4_block_get_noread(bdev, b, lba);
 218         if (r != EOK)
 219                 return r;
 220
 221         if (ext4_bcache_test_flag(b->buf, BC_UPTODATE)) {
 222                 /* Data in the cache is up-to-date.
 223                  * Reading from physical device is not required */
 224                 return EOK;
 225         }
 226
 227         r = ext4_blocks_get_direct(bdev, b->data, lba, 1);
 228         if (r != EOK) {
 229                 ext4_bcache_free(bdev->bc, b);
 230                 b->lb_id = 0;
 231                 return r;
 232         }
 233
 234         /* Mark buffer up-to-date, since
 235          * fresh data is read from physical device just now. */
 236         ext4_bcache_set_flag(b->buf, BC_UPTODATE);
 237         return EOK;
 238 }
 239
 240 int ext4_block_set(struct ext4_blockdev *bdev, struct ext4_block *b)
 241 {
 242         ext4_assert(bdev && b);
 243         ext4_assert(b->buf);
 244
 245         if (!bdev->bdif->ph_refctr)
 246                 return EIO;
 247
 248         return ext4_bcache_free(bdev->bc, b);
 249 }
 250
 251 int ext4_blocks_get_direct(struct ext4_blockdev *bdev, void *buf, uint64_t lba,
 252                            uint32_t cnt)
 253 {
 254         uint64_t pba;
 255         uint32_t pb_cnt;
 256
 257         ext4_assert(bdev && buf);
 258
 259         pba = (lba * bdev->lg_bsize) / bdev->bdif->ph_bsize;
 260         pba += bdev->ph_blk_offset;
 261         pb_cnt = bdev->lg_bsize / bdev->bdif->ph_bsize;
 262
 263         bdev->bread_ctr++;
 264         return ext4_bdif_bread(bdev, buf, pba, pb_cnt * cnt);
 265 }
 266
 267 int ext4_blocks_set_direct(struct ext4_blockdev *bdev, const void *buf,
 268                            uint64_t lba, uint32_t cnt)
 269 {
 270         uint64_t pba;
 271         uint32_t pb_cnt;
 272
 273         ext4_assert(bdev && buf);
 274
 275         pba = (lba * bdev->lg_bsize) / bdev->bdif->ph_bsize;
 276         pba += bdev->ph_blk_offset;
 277         pb_cnt = bdev->lg_bsize / bdev->bdif->ph_bsize;
 278
 279         bdev->bwrite_ctr++;
 280         return ext4_bdif_bwrite(bdev, buf, pba, pb_cnt * cnt);
 281 }
 282
 283 int ext4_block_writebytes(struct ext4_blockdev *bdev, uint64_t off,
 284                           const void *buf, uint32_t len)
 285 {
 286         uint64_t block_idx;
 287         uint64_t block_end;
 288         uint32_t blen;
 289         uint32_t unalg;
 290         int r = EOK;
 291
 292         const uint8_t *p = (void *)buf;
 293
 294         ext4_assert(bdev && buf);
 295
 296         if (!bdev->bdif->ph_refctr)
 297                 return EIO;
 298
 299         block_idx = (off / bdev->bdif->ph_bsize) + bdev->ph_blk_offset;
 300         block_end = block_idx + len / bdev->bdif->ph_bsize;
 301
 302         if (!(block_end < bdev->bdif->ph_bcnt))
 303                 return EINVAL; /*Ups. Out of range operation*/
 304
 305         /*OK lets deal with the first possible unaligned block*/
 306         unalg = (off & (bdev->bdif->ph_bsize - 1));
 307         if (unalg) {
 308
 309                 uint32_t wlen = (bdev->bdif->ph_bsize - unalg) > len
 310                                     ? len
 311                                     : (bdev->bdif->ph_bsize - unalg);
 312
 313                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 314                 if (r != EOK)
 315                         return r;
 316
 317                 memcpy(bdev->bdif->ph_bbuf + unalg, p, wlen);
 318                 r = ext4_bdif_bwrite(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 319                 if (r != EOK)
 320                         return r;
 321
 322                 p += wlen;
 323                 len -= wlen;
 324                 block_idx++;
 325         }
 326
 327         /*Aligned data*/
 328         blen = len / bdev->bdif->ph_bsize;
 329         r = ext4_bdif_bwrite(bdev, p, block_idx, blen);
 330         if (r != EOK)
 331                 return r;
 332
 333         p += bdev->bdif->ph_bsize * blen;
 334         len -= bdev->bdif->ph_bsize * blen;
 335
 336         block_idx += blen;
 337
 338         /*Rest of the data*/
 339         if (len) {
 340                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 341                 if (r != EOK)
 342                         return r;
 343
 344                 memcpy(bdev->bdif->ph_bbuf, p, len);
 345                 r = ext4_bdif_bwrite(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 346                 if (r != EOK)
 347                         return r;
 348         }
 349
 350         return r;
 351 }
 352
 353 int ext4_block_readbytes(struct ext4_blockdev *bdev, uint64_t off, void *buf,
 354                          uint32_t len)
 355 {
 356         uint64_t block_idx;
 357         uint64_t block_end;
 358         uint32_t blen;
 359         uint32_t unalg;
 360         int r = EOK;
 361
 362         uint8_t *p = (void *)buf;
 363
 364         ext4_assert(bdev && buf);
 365
 366         if (!bdev->bdif->ph_refctr)
 367                 return EIO;
 368
 369         block_idx = (off / bdev->bdif->ph_bsize) + bdev->ph_blk_offset;
 370         block_end = block_idx + len / bdev->bdif->ph_bsize;
 371
 372         if (!(block_end < bdev->bdif->ph_bcnt))
 373                 return EINVAL; /*Ups. Out of range operation*/
 374
 375         /*OK lets deal with the first possible unaligned block*/
 376         unalg = (off & (bdev->bdif->ph_bsize - 1));
 377         if (unalg) {
 378
 379                 uint32_t rlen = (bdev->bdif->ph_bsize - unalg) > len
 380                                     ? len
 381                                     : (bdev->bdif->ph_bsize - unalg);
 382
 383                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 384                 if (r != EOK)
 385                         return r;
 386
 387                 memcpy(p, bdev->bdif->ph_bbuf + unalg, rlen);
 388
 389                 p += rlen;
 390                 len -= rlen;
 391                 block_idx++;
 392         }
 393
 394         /*Aligned data*/
 395         blen = len / bdev->bdif->ph_bsize;
 396
 397         r = ext4_bdif_bread(bdev, p, block_idx, blen);
 398         if (r != EOK)
 399                 return r;
 400
 401         p += bdev->bdif->ph_bsize * blen;
 402         len -= bdev->bdif->ph_bsize * blen;
 403
 404         block_idx += blen;
 405
 406         /*Rest of the data*/
 407         if (len) {
 408                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 409                 if (r != EOK)
 410                         return r;
 411
 412                 memcpy(p, bdev->bdif->ph_bbuf, len);
 413         }
 414
 415         return r;
 416 }
 417
 418 int ext4_block_cache_write_back(struct ext4_blockdev *bdev, uint8_t on_off)
 419 {
 420         int r;
 421         struct ext4_buf *buf;
 422
 423         if (on_off)
 424                 bdev->cache_write_back++;
 425
 426         if (!on_off && bdev->cache_write_back)
 427                 bdev->cache_write_back--;
 428
 429         if (bdev->cache_write_back)
 430                 return EOK;
 431
 432         /*Flush all delayed cache blocks*/
 433         while (!SLIST_EMPTY(&bdev->bc->dirty_list)) {
 434
 435                 buf = SLIST_FIRST(&bdev->bc->dirty_list);
 436                 ext4_assert(buf);
 437                 r = ext4_block_flush_buf(bdev, buf);
 438                 if (r != EOK)
 439                         return r;
 440
 441         }
 442         return EOK;
 443 }
 444
 445 /**
 446  * @}
 447  */