src/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_types.h>
  39 #include <ext4_misc.h>
  40 #include <ext4_errno.h>
  41 #include <ext4_debug.h>
  42
  43 #include <ext4_blockdev.h>
  44 #include <ext4_fs.h>
  45 #include <ext4_journal.h>
  46
  47 #include <string.h>
  48 #include <stdlib.h>
  49
  50 static void ext4_bdif_lock(struct ext4_blockdev *bdev)
  51 {
  52         if (!bdev->bdif->lock)
  53                 return;
  54
  55         int r = bdev->bdif->lock(bdev);
  56         ext4_assert(r == EOK);
  57 }
  58
  59 static void ext4_bdif_unlock(struct ext4_blockdev *bdev)
  60 {
  61         if (!bdev->bdif->unlock)
  62                 return;
  63
  64         int r = bdev->bdif->unlock(bdev);
  65         ext4_assert(r == EOK);
  66 }
  67
  68 static int ext4_bdif_bread(struct ext4_blockdev *bdev, void *buf,
  69                            uint64_t blk_id, uint32_t blk_cnt)
  70 {
  71         ext4_bdif_lock(bdev);
  72         int r = bdev->bdif->bread(bdev, buf, blk_id, blk_cnt);
  73         bdev->bdif->bread_ctr++;
  74         ext4_bdif_unlock(bdev);
  75         return r;
  76 }
  77
  78 static int ext4_bdif_bwrite(struct ext4_blockdev *bdev, const void *buf,
  79                             uint64_t blk_id, uint32_t blk_cnt)
  80 {
  81         ext4_dbg(DEBUG_BLOCKDEV, DBG_NONE "Writing blk_id=%lu cnt=%d", blk_id, blk_cnt);
  82         ext4_bdif_lock(bdev);
  83         int r = bdev->bdif->bwrite(bdev, buf, blk_id, blk_cnt);
  84         bdev->bdif->bwrite_ctr++;
  85         ext4_bdif_unlock(bdev);
  86         ext4_dbg(DEBUG_BLOCKDEV, DBG_NONE "Result was %d", r);
  87         return r;
  88 }
  89
  90 int ext4_block_init(struct ext4_blockdev *bdev)
  91 {
  92         int rc;
  93         ext4_assert(bdev);
  94         ext4_assert(bdev->bdif);
  95         ext4_assert(bdev->bdif->open &&
  96                    bdev->bdif->close &&
  97                    bdev->bdif->bread &&
  98                    bdev->bdif->bwrite);
  99
 100         if (bdev->bdif->ph_refctr) {
 101                 bdev->bdif->ph_refctr++;
 102                 return EOK;
 103         }
 104
 105         /*Low level block init*/
 106         rc = bdev->bdif->open(bdev);
 107         if (rc != EOK)
 108                 return rc;
 109
 110         bdev->bdif->ph_refctr = 1;
 111         return EOK;
 112 }
 113
 114 int ext4_block_bind_bcache(struct ext4_blockdev *bdev, struct ext4_bcache *bc)
 115 {
 116         ext4_assert(bdev && bc);
 117         bdev->bc = bc;
 118         bc->bdev = bdev;
 119         return EOK;
 120 }
 121
 122 void ext4_block_set_lb_size(struct ext4_blockdev *bdev, uint32_t lb_bsize)
 123 {
 124         /*Logical block size has to be multiply of physical */
 125         ext4_assert(!(lb_bsize % bdev->bdif->ph_bsize));
 126
 127         bdev->lg_bsize = lb_bsize;
 128         bdev->lg_bcnt = bdev->part_size / lb_bsize;
 129 }
 130
 131 int ext4_block_fini(struct ext4_blockdev *bdev)
 132 {
 133         ext4_assert(bdev);
 134
 135         if (!bdev->bdif->ph_refctr)
 136                 return EOK;
 137
 138         bdev->bdif->ph_refctr--;
 139         if (bdev->bdif->ph_refctr)
 140                 return EOK;
 141
 142         /*Low level block fini*/
 143         return bdev->bdif->close(bdev);
 144 }
 145
 146 int ext4_block_flush_buf(struct ext4_blockdev *bdev, struct ext4_buf *buf)
 147 {
 148         int r;
 149         struct ext4_bcache *bc = bdev->bc;
 150
 151         if (ext4_bcache_test_flag(buf, BC_DIRTY) &&
 152             ext4_bcache_test_flag(buf, BC_UPTODATE)) {
 153                 r = ext4_blocks_set_direct(bdev, buf->data, buf->lba, 1);
 154                 if (r) {
 155                         if (buf->end_write) {
 156                                 bc->dont_shake = true;
 157                                 buf->end_write(bc, buf, r, buf->end_write_arg);
 158                                 bc->dont_shake = false;
 159                         }
 160
 161                         return r;
 162                 }
 163
 164                 ext4_bcache_remove_dirty_node(bc, buf);
 165                 ext4_bcache_clear_flag(buf, BC_DIRTY);
 166                 if (buf->end_write) {
 167                         bc->dont_shake = true;
 168                         buf->end_write(bc, buf, r, buf->end_write_arg);
 169                         bc->dont_shake = false;
 170                 }
 171         }
 172         return EOK;
 173 }
 174
 175 int ext4_block_flush_lba(struct ext4_blockdev *bdev, uint64_t lba)
 176 {
 177         int r = EOK;
 178         struct ext4_buf *buf;
 179         struct ext4_block b;
 180         buf = ext4_bcache_find_get(bdev->bc, &b, lba);
 181         if (buf) {
 182                 r = ext4_block_flush_buf(bdev, buf);
 183                 ext4_bcache_free(bdev->bc, &b);
 184         }
 185         return r;
 186 }
 187
 188 int ext4_block_cache_shake(struct ext4_blockdev *bdev)
 189 {
 190         int r = EOK;
 191         struct ext4_buf *buf;
 192         if (bdev->bc->dont_shake)
 193                 return EOK;
 194
 195         bdev->bc->dont_shake = true;
 196
 197         while (!RB_EMPTY(&bdev->bc->lru_root) &&
 198                 ext4_bcache_is_full(bdev->bc)) {
 199
 200                 buf = ext4_buf_lowest_lru(bdev->bc);
 201                 ext4_assert(buf);
 202                 if (ext4_bcache_test_flag(buf, BC_DIRTY)) {
 203                         r = ext4_block_flush_buf(bdev, buf);
 204                         if (r != EOK)
 205                                 break;
 206
 207                 }
 208
 209                 ext4_bcache_drop_buf(bdev->bc, buf);
 210         }
 211         bdev->bc->dont_shake = false;
 212         return r;
 213 }
 214
 215 int ext4_block_get_noread(struct ext4_blockdev *bdev, struct ext4_block *b,
 216                           uint64_t lba)
 217 {
 218         bool is_new;
 219         int r;
 220
 221         ext4_assert(bdev && b);
 222
 223         if (!bdev->bdif->ph_refctr)
 224                 return EIO;
 225
 226         if (!(lba < bdev->lg_bcnt))
 227                 return ENXIO;
 228
 229         b->lb_id = lba;
 230
 231         /*If cache is full we have to (flush and) drop it anyway :(*/
 232         r = ext4_block_cache_shake(bdev);
 233         if (r != EOK)
 234                 return r;
 235
 236         r = ext4_bcache_alloc(bdev->bc, b, &is_new);
 237         if (r != EOK)
 238                 return r;
 239
 240         if (!b->data)
 241                 return ENOMEM;
 242
 243         return EOK;
 244 }
 245
 246 int ext4_block_get(struct ext4_blockdev *bdev, struct ext4_block *b,
 247                    uint64_t lba)
 248 {
 249         int r = ext4_block_get_noread(bdev, b, lba);
 250         if (r != EOK)
 251                 return r;
 252
 253         if (ext4_bcache_test_flag(b->buf, BC_UPTODATE)) {
 254                 /* Data in the cache is up-to-date.
 255                  * Reading from physical device is not required */
 256                 return EOK;
 257         }
 258
 259         r = ext4_blocks_get_direct(bdev, b->data, lba, 1);
 260         if (r != EOK) {
 261                 ext4_bcache_free(bdev->bc, b);
 262                 b->lb_id = 0;
 263                 return r;
 264         }
 265
 266         /* Mark buffer up-to-date, since
 267          * fresh data is read from physical device just now. */
 268         ext4_bcache_set_flag(b->buf, BC_UPTODATE);
 269         return EOK;
 270 }
 271
 272 int ext4_block_set(struct ext4_blockdev *bdev, struct ext4_block *b)
 273 {
 274         ext4_assert(bdev && b);
 275         ext4_assert(b->buf);
 276
 277         if (!bdev->bdif->ph_refctr)
 278                 return EIO;
 279
 280         return ext4_bcache_free(bdev->bc, b);
 281 }
 282
 283 int ext4_blocks_get_direct(struct ext4_blockdev *bdev, void *buf, uint64_t lba,
 284                            uint32_t cnt)
 285 {
 286         uint64_t pba;
 287         uint32_t pb_cnt;
 288
 289         ext4_assert(bdev && buf);
 290
 291         pba = (lba * bdev->lg_bsize + bdev->part_offset) / bdev->bdif->ph_bsize;
 292         pb_cnt = bdev->lg_bsize / bdev->bdif->ph_bsize;
 293
 294         return ext4_bdif_bread(bdev, buf, pba, pb_cnt * cnt);
 295 }
 296
 297 int ext4_blocks_set_direct(struct ext4_blockdev *bdev, const void *buf,
 298                            uint64_t lba, uint32_t cnt)
 299 {
 300         uint64_t pba;
 301         uint32_t pb_cnt;
 302
 303         ext4_assert(bdev && buf);
 304
 305         pba = (lba * bdev->lg_bsize + bdev->part_offset) / bdev->bdif->ph_bsize;
 306         pb_cnt = bdev->lg_bsize / bdev->bdif->ph_bsize;
 307
 308         return ext4_bdif_bwrite(bdev, buf, pba, pb_cnt * cnt);
 309 }
 310
 311 int ext4_block_writebytes(struct ext4_blockdev *bdev, uint64_t off,
 312                           const void *buf, uint32_t len)
 313 {
 314         uint64_t block_idx;
 315         uint32_t blen;
 316         uint32_t unalg;
 317         int r = EOK;
 318
 319         const uint8_t *p = (void *)buf;
 320
 321         ext4_assert(bdev && buf);
 322
 323         if (!bdev->bdif->ph_refctr)
 324                 return EIO;
 325
 326         if (off + len > bdev->part_size)
 327                 return EINVAL; /*Ups. Out of range operation*/
 328
 329         block_idx = ((off + bdev->part_offset) / bdev->bdif->ph_bsize);
 330
 331         /*OK lets deal with the first possible unaligned block*/
 332         unalg = (off & (bdev->bdif->ph_bsize - 1));
 333         if (unalg) {
 334
 335                 uint32_t wlen = (bdev->bdif->ph_bsize - unalg) > len
 336                                     ? len
 337                                     : (bdev->bdif->ph_bsize - unalg);
 338
 339                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 340                 if (r != EOK)
 341                         return r;
 342
 343                 memcpy(bdev->bdif->ph_bbuf + unalg, p, wlen);
 344                 r = ext4_bdif_bwrite(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 345                 if (r != EOK)
 346                         return r;
 347
 348                 p += wlen;
 349                 len -= wlen;
 350                 block_idx++;
 351         }
 352
 353         /*Aligned data*/
 354         blen = len / bdev->bdif->ph_bsize;
 355         if (blen != 0) {
 356                 r = ext4_bdif_bwrite(bdev, p, block_idx, blen);
 357                 if (r != EOK)
 358                         return r;
 359
 360                 p += bdev->bdif->ph_bsize * blen;
 361                 len -= bdev->bdif->ph_bsize * blen;
 362
 363                 block_idx += blen;
 364         }
 365
 366         /*Rest of the data*/
 367         if (len) {
 368                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 369                 if (r != EOK)
 370                         return r;
 371
 372                 memcpy(bdev->bdif->ph_bbuf, p, len);
 373                 r = ext4_bdif_bwrite(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 374                 if (r != EOK)
 375                         return r;
 376         }
 377
 378         return r;
 379 }
 380
 381 int ext4_block_readbytes(struct ext4_blockdev *bdev, uint64_t off, void *buf,
 382                          uint32_t len)
 383 {
 384         uint64_t block_idx;
 385         uint32_t blen;
 386         uint32_t unalg;
 387         int r = EOK;
 388
 389         uint8_t *p = (void *)buf;
 390
 391         ext4_assert(bdev && buf);
 392
 393         if (!bdev->bdif->ph_refctr)
 394                 return EIO;
 395
 396         if (off + len > bdev->part_size)
 397                 return EINVAL; /*Ups. Out of range operation*/
 398
 399         block_idx = ((off + bdev->part_offset) / bdev->bdif->ph_bsize);
 400
 401         /*OK lets deal with the first possible unaligned block*/
 402         unalg = (off & (bdev->bdif->ph_bsize - 1));
 403         if (unalg) {
 404
 405                 uint32_t rlen = (bdev->bdif->ph_bsize - unalg) > len
 406                                     ? len
 407                                     : (bdev->bdif->ph_bsize - unalg);
 408
 409                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 410                 if (r != EOK)
 411                         return r;
 412
 413                 memcpy(p, bdev->bdif->ph_bbuf + unalg, rlen);
 414
 415                 p += rlen;
 416                 len -= rlen;
 417                 block_idx++;
 418         }
 419
 420         /*Aligned data*/
 421         blen = len / bdev->bdif->ph_bsize;
 422
 423         if (blen != 0) {
 424                 r = ext4_bdif_bread(bdev, p, block_idx, blen);
 425                 if (r != EOK)
 426                         return r;
 427
 428                 p += bdev->bdif->ph_bsize * blen;
 429                 len -= bdev->bdif->ph_bsize * blen;
 430
 431                 block_idx += blen;
 432         }
 433
 434         /*Rest of the data*/
 435         if (len) {
 436                 r = ext4_bdif_bread(bdev, bdev->bdif->ph_bbuf, block_idx, 1);
 437                 if (r != EOK)
 438                         return r;
 439
 440                 memcpy(p, bdev->bdif->ph_bbuf, len);
 441         }
 442
 443         return r;
 444 }
 445
 446 int ext4_block_cache_flush(struct ext4_blockdev *bdev)
 447 {
 448         while (!SLIST_EMPTY(&bdev->bc->dirty_list)) {
 449                 int r;
 450                 struct ext4_buf *buf = SLIST_FIRST(&bdev->bc->dirty_list);
 451                 ext4_assert(buf);
 452                 r = ext4_block_flush_buf(bdev, buf);
 453                 if (r != EOK)
 454                         return r;
 455
 456         }
 457         return EOK;
 458 }
 459
 460 int ext4_block_cache_write_back(struct ext4_blockdev *bdev, uint8_t on_off)
 461 {
 462         if (on_off)
 463                 bdev->cache_write_back++;
 464
 465         if (!on_off && bdev->cache_write_back)
 466                 bdev->cache_write_back--;
 467
 468         if (bdev->cache_write_back)
 469                 return EOK;
 470
 471         /*Flush data in all delayed cache blocks*/
 472         return ext4_block_cache_flush(bdev);
 473 }
 474
 475 /**
 476  * @}
 477  */