X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fio%2Fkblock.c;h=117c3e9b48ef3b9b51b43f134778580c87ea2df6;hb=1997bcac9db9a289afa5ca6d4fea4b75aef329d6;hp=def111cb598bcfcbdfe1c6a2e1f7bc060e31c393;hpb=06598a5e283451d544f77b10f8eea4f912d5253a;p=bertos.git diff --git a/bertos/io/kblock.c b/bertos/io/kblock.c index def111cb..117c3e9b 100644 --- a/bertos/io/kblock.c +++ b/bertos/io/kblock.c @@ -26,7 +26,7 @@ * invalidate any other reasons why the executable file might be covered by * the GNU General Public License. * - * Copyright 2009 Develer S.r.l. (http://www.develer.com/) + * Copyright 2010 Develer S.r.l. (http://www.develer.com/) * * --> * @@ -38,8 +38,8 @@ #include "kblock.h" -#define LOG_LEVEL LOG_LVL_ERR -#define LOG_FORMAT LOG_FMT_VERBOSE +#define LOG_LEVEL LOG_LVL_ERR +#define LOG_FORMAT LOG_FMT_VERBOSE #include #include @@ -51,11 +51,11 @@ INLINE size_t kblock_readDirect(struct KBlock *b, block_idx_t index, void *buf, return b->priv.vt->readDirect(b, b->priv.blk_start + index, buf, offset, size); } -INLINE int kblock_writeBlock(struct KBlock *b, block_idx_t index, const void *buf) +INLINE size_t kblock_writeDirect(struct KBlock *b, block_idx_t index, const void *buf, size_t offset, size_t size) { - KB_ASSERT_METHOD(b, writeBlock); + KB_ASSERT_METHOD(b, writeDirect); ASSERT(index < b->blk_cnt); - return b->priv.vt->writeBlock(b, b->priv.blk_start + index, buf); + return b->priv.vt->writeDirect(b, b->priv.blk_start + index, buf, offset, size); } INLINE size_t kblock_readBuf(struct KBlock *b, void *buf, size_t offset, size_t size) @@ -78,7 +78,7 @@ INLINE int kblock_load(struct KBlock *b, block_idx_t index) KB_ASSERT_METHOD(b, load); ASSERT(index < b->blk_cnt); - LOG_INFO("index %d\n", index); + LOG_INFO("index %ld\n", index); return b->priv.vt->load(b, b->priv.blk_start + index); } @@ -87,7 +87,7 @@ INLINE int kblock_store(struct KBlock *b, block_idx_t index) KB_ASSERT_METHOD(b, store); ASSERT(index < b->blk_cnt); - LOG_INFO("index %d\n", index); + LOG_INFO("index %ld\n", index); return b->priv.vt->store(b, b->priv.blk_start + index); } @@ -100,13 +100,12 @@ INLINE void kblock_setDirty(struct KBlock *b, bool dirty) } - size_t kblock_read(struct KBlock *b, block_idx_t idx, void *buf, size_t offset, size_t size) { ASSERT(b); ASSERT(buf); ASSERT(offset + size <= b->blk_size); - LOG_INFO("blk_idx %d, offset %d, size %d\n", idx, offset, size); + LOG_INFO("blk_idx %ld, offset %u, size %u\n", idx, offset, size); if (kblock_buffered(b) && idx == b->priv.curr_blk) return kblock_readBuf(b, buf, offset, size); @@ -119,9 +118,12 @@ int kblock_flush(struct KBlock *b) { ASSERT(b); + if (!kblock_buffered(b)) + return 0; + if (kblock_cacheDirty(b)) { - LOG_INFO("flushing block %d\n", b->priv.curr_blk); + LOG_INFO("flushing block %ld\n", b->priv.curr_blk); if (kblock_store(b, b->priv.curr_blk) == 0) kblock_setDirty(b, false); else @@ -137,7 +139,7 @@ static bool kblock_loadPage(struct KBlock *b, block_idx_t idx) if (idx != b->priv.curr_blk) { - LOG_INFO("loading block %d\n", idx); + LOG_INFO("loading block %ld\n", idx); if (kblock_flush(b) != 0 || kblock_load(b, idx) != 0) return false; @@ -147,6 +149,23 @@ static bool kblock_loadPage(struct KBlock *b, block_idx_t idx) } +int kblock_trim(struct KBlock *b, block_idx_t start, block_idx_t count) +{ + ASSERT(start + count <= b->blk_cnt); + + if (kblock_buffered(b)) + { + if (!kblock_loadPage(b, start)) + return EOF; + } + + b->priv.blk_start += start; + b->priv.curr_blk = 0; // adjust logical address + b->blk_cnt = count; + return 0; +} + + size_t kblock_write(struct KBlock *b, block_idx_t idx, const void *buf, size_t offset, size_t size) { ASSERT(b); @@ -154,8 +173,8 @@ size_t kblock_write(struct KBlock *b, block_idx_t idx, const void *buf, size_t o ASSERT(idx < b->blk_cnt); ASSERT(offset + size <= b->blk_size); - LOG_INFO("blk_idx %d, offset %d, size %d\n", idx, offset, size); - + LOG_INFO("blk_idx %ld, offset %u, size %u\n", idx, offset, size); + if (kblock_buffered(b)) { if (!kblock_loadPage(b, idx)) @@ -166,42 +185,84 @@ size_t kblock_write(struct KBlock *b, block_idx_t idx, const void *buf, size_t o } else { - ASSERT(offset == 0); - ASSERT(size == b->blk_size); - return (kblock_writeBlock(b, idx, buf) == 0) ? size : 0; + #ifdef _DEBUG + if (offset != 0 || size != b->blk_size) + ASSERT(kblock_partialWrite(b)); + #endif + return kblock_writeDirect(b, idx, buf, offset, size); } } -int kblock_copy(struct KBlock *b, block_idx_t idx1, block_idx_t idx2) +int kblock_copy(struct KBlock *b, block_idx_t src, block_idx_t dest) { ASSERT(b); - ASSERT(idx1 < b->blk_cnt); - ASSERT(idx2 < b->blk_cnt); - ASSERT(kblock_buffered(b)); + ASSERT(src < b->blk_cnt); + ASSERT(dest < b->blk_cnt); - if (!kblock_loadPage(b, idx1)) - return EOF; + if (kblock_buffered(b)) + { + if (!kblock_loadPage(b, src)) + return EOF; - b->priv.curr_blk = idx2; - kblock_setDirty(b, true); - return 0; + b->priv.curr_blk = dest; + kblock_setDirty(b, true); + return 0; + } + else if (kblock_partialWrite(b)) + { + uint8_t buf[16]; + size_t blk_size = b->blk_size; + size_t offset = 0; + + while (blk_size) + { + size_t size = MIN(sizeof(buf), blk_size); + if (kblock_readDirect(b, src, buf, offset, size) != size) + return EOF; + if (kblock_writeDirect(b, dest, buf, offset, size) != size) + return EOF; + + blk_size -= size; + offset += size; + } + return 0; + } + else + { + ASSERT(0); + return EOF; + } } int kblock_swLoad(struct KBlock *b, block_idx_t index) { - return (kblock_readDirect(b, index, b->priv.buf, 0, b->blk_size) == b->blk_size) ? 0 : EOF; + /* + * Since this is a low level API, the index here is a fisical index. + * If we call another low level API, logical to fisical translation + * would be applied twice. + * In order to avoid this we subtract the start block index. + */ + ASSERT(index >= b->priv.blk_start); + return (kblock_readDirect(b, index - b->priv.blk_start, b->priv.buf, 0, b->blk_size) == b->blk_size) ? 0 : EOF; } int kblock_swStore(struct KBlock *b, block_idx_t index) { - return kblock_writeBlock(b, index, b->priv.buf); + /* + * Since this is a low level API, the index here is a fisical index. + * If we call another low level API, logical to fisical translation + * would be applied twice. + * In order to avoid this we subtract the start block index. + */ + ASSERT(index >= b->priv.blk_start); + return (kblock_writeDirect(b, index - b->priv.blk_start, b->priv.buf, 0, b->blk_size) == b->blk_size) ? 0 : EOF; } size_t kblock_swReadBuf(struct KBlock *b, void *buf, size_t offset, size_t size) { ASSERT(buf); ASSERT(offset + size <= b->blk_size); - + memcpy(buf, (uint8_t *)b->priv.buf + offset, size); return size; } @@ -213,3 +274,8 @@ size_t kblock_swWriteBuf(struct KBlock *b, const void *buf, size_t offset, size_ memcpy((uint8_t *)b->priv.buf + offset, buf, size); return size; } + +int kblock_swClose(UNUSED_ARG(struct KBlock, *b)) +{ + return 0; +}