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