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