From 37cf030445b9ab0ff3d685f99ac5be06c3d0b809 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Fri, 13 Jul 2018 15:04:31 -0500 Subject: [PATCH] WIP cleaned up commit logic --- lfs.c | 910 ++++++++++++++++++++++++++++------------------------------ lfs.h | 2 +- 2 files changed, 438 insertions(+), 474 deletions(-) diff --git a/lfs.c b/lfs.c index 01faa004..20c03fc3 100644 --- a/lfs.c +++ b/lfs.c @@ -475,16 +475,11 @@ static bool lfs_globals_iszero(const lfs_globals_t *a) { struct lfs_commit { lfs_block_t block; lfs_off_t off; - lfs_off_t begin; - lfs_off_t end; - uint32_t ptag; uint32_t crc; - struct { - uint16_t begin; - uint16_t end; - } filter; + lfs_off_t begin; + lfs_off_t end; }; struct lfs_diskoff { @@ -492,42 +487,76 @@ struct lfs_diskoff { lfs_off_t off; }; -// TODO predelcare -static int lfs_commit_move(lfs_t *lfs, struct lfs_commit *commit, +static int32_t lfs_commitget(lfs_t *lfs, lfs_block_t block, lfs_off_t off, + uint32_t tag, uint32_t getmask, uint32_t gettag, void *buffer, + bool stopatcommit) { + uint16_t id = lfs_tagid(gettag); + lfs_size_t size = lfs_tagsize(gettag); + + // synthetic moves + if ((block == lfs->globals.move.pair[0] || + block == lfs->globals.move.pair[1]) + && lfs_tagid(gettag) <= lfs->globals.move.id) { + gettag += LFS_MKTAG(0, 1, 0); + } + + // iterate over dir block backwards (for faster lookups) + while (off > sizeof(tag)) { + LFS_ASSERT(off > sizeof(tag)+lfs_tagsize(tag)); + off -= sizeof(tag)+lfs_tagsize(tag); + + if (lfs_tagtype(tag) == LFS_TYPE_CRC && stopatcommit) { + break; + } else if (lfs_tagtype(tag) == LFS_TYPE_DELETE) { + if (lfs_tagid(tag) <= lfs_tagid(gettag)) { + gettag += LFS_MKTAG(0, 1, 0); + } + } else if ((tag & getmask) == (gettag & getmask)) { + if (buffer) { + lfs_size_t diff = lfs_min(size, lfs_tagsize(tag)); + int err = lfs_bd_read(lfs, block, + off+sizeof(tag), buffer, diff); + if (err) { + return err; + } + + memset((uint8_t*)buffer + diff, 0, size - diff); + } + + return (tag & 0xffc00fff) | LFS_MKTAG(0, id, 0); + } + + uint32_t ntag; + int err = lfs_bd_read(lfs, block, off, &ntag, sizeof(ntag)); + if (err) { + return err; + } + tag ^= lfs_fromle32(ntag); + } + + return LFS_ERR_NOENT; +} + +static int lfs_commitmove(lfs_t *lfs, struct lfs_commit *commit, uint16_t fromid, uint16_t toid, const lfs_mdir_t *dir, const lfs_mattr_t *attrs); -static int lfs_commit_attr(lfs_t *lfs, struct lfs_commit *commit, +static int lfs_commitattr(lfs_t *lfs, struct lfs_commit *commit, uint32_t tag, const void *buffer) { - // filter out ids - if (lfs_tagid(tag) < 0x3ff && ( - lfs_tagid(tag) < commit->filter.begin || - lfs_tagid(tag) >= commit->filter.end)) { - return 0; - } - - // special cases if (lfs_tagtype(tag) == LFS_FROM_MOVE) { - return lfs_commit_move(lfs, commit, + // special case for moves + return lfs_commitmove(lfs, commit, lfs_tagsize(tag), lfs_tagid(tag), buffer, NULL); } - if (lfs_tagid(tag) != 0x3ff) { - // TODO eh? - uint16_t id = lfs_tagid(tag) - commit->filter.begin; - tag = LFS_MKTAG(0, id, 0) | (tag & 0xffc00fff); - } - // check if we fit lfs_size_t size = lfs_tagsize(tag); - if (commit->off + sizeof(uint32_t)+size > commit->end) { + if (commit->off + sizeof(tag)+size > commit->end) { return LFS_ERR_NOSPC; } // write out tag - // TODO rm me - //printf("tag w %#010x (%x:%x %03x %03x %03x)\n", tag, commit->block, commit->off+sizeof(lfs_tag_t), lfs_tagtype(tag), lfs_tagid(tag), lfs_tagsize(tag)); uint32_t ntag = lfs_tole32((tag & 0x7fffffff) ^ commit->ptag); lfs_crc(&commit->crc, &ntag, sizeof(ntag)); int err = lfs_bd_prog(lfs, commit->block, commit->off, @@ -548,6 +577,7 @@ static int lfs_commit_attr(lfs_t *lfs, struct lfs_commit *commit, // from disk const struct lfs_diskoff *disk = buffer; for (lfs_off_t i = 0; i < size; i++) { + // rely on caching to make this efficient uint8_t dat; int err = lfs_bd_read(lfs, disk->block, disk->off+i, &dat, 1); if (err) { @@ -561,129 +591,19 @@ static int lfs_commit_attr(lfs_t *lfs, struct lfs_commit *commit, } } } + commit->off += size; - commit->ptag = tag & 0x7fffffff; // TODO do this once - + commit->ptag = tag & 0x7fffffff; return 0; } -static int lfs_commit_crc(lfs_t *lfs, struct lfs_commit *commit) { - // align to program units - lfs_off_t noff = lfs_alignup( - commit->off + 2*sizeof(uint32_t), lfs->cfg->prog_size); - - // read erased state from next program unit - uint32_t tag; - int err = lfs_bd_read(lfs, commit->block, noff, &tag, sizeof(tag)); - if (err) { - return err; - } - - // build crc tag - tag = (0x80000000 & ~lfs_fromle32(tag)) | - LFS_MKTAG(LFS_TYPE_CRC, 0x3ff, - noff - (commit->off+sizeof(uint32_t))); - - // write out crc - //printf("tag w %#010x (%x:%x %03x %03x %03x)\n", tag, commit->block, commit->off+sizeof(tag), lfs_tagtype(tag), lfs_tagid(tag), lfs_tagsize(tag)); - uint32_t footer[2]; - footer[0] = lfs_tole32(tag ^ commit->ptag); - lfs_crc(&commit->crc, &footer[0], sizeof(footer[0])); - footer[1] = lfs_tole32(commit->crc); - err = lfs_bd_prog(lfs, commit->block, commit->off, - footer, sizeof(footer)); - if (err) { - return err; - } - commit->off += sizeof(tag)+lfs_tagsize(tag); - commit->ptag = tag; - - // flush buffers - err = lfs_bd_sync(lfs); - if (err) { - return err; - } - - // successful commit, check checksum to make sure - uint32_t crc = 0xffffffff; - err = lfs_bd_crc(lfs, commit->block, commit->begin, - commit->off-lfs_tagsize(tag) - commit->begin, &crc); - if (err) { - return err; - } - - if (crc != commit->crc) { - return LFS_ERR_CORRUPT; - } - - return 0; -} - -// TODO predeclare -static int32_t lfs_commit_get(lfs_t *lfs, lfs_block_t block, lfs_off_t off, - uint32_t etag, uint32_t getmask, uint32_t gettag, void *buffer, - bool stopatcommit) { - uint16_t id = lfs_tagid(gettag); - lfs_size_t size = lfs_tagsize(gettag); - - // synthetic moves - if ((block == lfs->globals.move.pair[0] || - block == lfs->globals.move.pair[1]) - && lfs_tagid(gettag) <= lfs->globals.move.id) { - gettag += LFS_MKTAG(0, 1, 0); - } - - // iterate over dir block backwards (for faster lookups) - off += sizeof(uint32_t); // TODO nah - uint32_t tag = etag; - - while (off > 2*sizeof(tag)) { - LFS_ASSERT(off > 2*sizeof(tag)+lfs_tagsize(tag)); - off -= sizeof(tag)+lfs_tagsize(tag); - - if (lfs_tagtype(tag) == LFS_TYPE_CRC && stopatcommit) { - break; - } else if (lfs_tagtype(tag) == LFS_TYPE_DELETE) { - if (lfs_tagid(tag) <= lfs_tagid(gettag)) { - gettag += LFS_MKTAG(0, 1, 0); - } - } else if ((tag & getmask) == (gettag & getmask)) { - if (buffer) { - lfs_size_t diff = lfs_min(size, lfs_tagsize(tag)); - int err = lfs_bd_read(lfs, block, off, buffer, diff); - if (err) { - return err; - } - - memset((uint8_t*)buffer + diff, 0, size - diff); - } - - return LFS_MKTAG(0, id, 0) | (tag & 0xffc00fff); - } - - uint32_t ntag; - int err = lfs_bd_read(lfs, block, - off-sizeof(ntag), &ntag, sizeof(ntag)); - if (err) { - return err; - } - tag ^= lfs_fromle32(ntag); - } - - return LFS_ERR_NOENT; -} - -static int32_t lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir, - uint32_t getmask, uint32_t gettag, void *buffer); - -static int lfs_commit_move(lfs_t *lfs, struct lfs_commit *commit, +static int lfs_commitmove(lfs_t *lfs, struct lfs_commit *commit, uint16_t fromid, uint16_t toid, const lfs_mdir_t *dir, const lfs_mattr_t *attrs) { - // Iterate through list and commits, only committing unique entries - lfs_off_t off = dir->off + sizeof(uint32_t); + // iterate through list and commits, only committing unique entries + lfs_off_t off = dir->off; uint32_t ntag = dir->etag; - - while (attrs || off > 2*sizeof(uint32_t)) { + while (attrs || off > sizeof(uint32_t)) { struct lfs_diskoff disk; uint32_t tag; const void *buffer; @@ -692,16 +612,15 @@ static int lfs_commit_move(lfs_t *lfs, struct lfs_commit *commit, buffer = attrs->buffer; attrs = attrs->next; } else { - LFS_ASSERT(off > 2*sizeof(ntag)+lfs_tagsize(ntag)); + LFS_ASSERT(off > sizeof(ntag)+lfs_tagsize(ntag)); off -= sizeof(ntag)+lfs_tagsize(ntag); tag = ntag; - disk.block = dir->pair[0]; - disk.off = off; buffer = &disk; + disk.block = dir->pair[0]; + disk.off = off + sizeof(tag); - int err = lfs_bd_read(lfs, dir->pair[0], - off-sizeof(ntag), &ntag, sizeof(ntag)); + int err = lfs_bd_read(lfs, dir->pair[0], off, &ntag, sizeof(ntag)); if (err) { return err; } @@ -718,20 +637,18 @@ static int lfs_commit_move(lfs_t *lfs, struct lfs_commit *commit, // ignore non-matching ids } else { // check if type has already been committed - int32_t res = lfs_commit_get(lfs, commit->block, + int32_t res = lfs_commitget(lfs, commit->block, commit->off, commit->ptag, lfs_tagisuser(tag) ? 0x7ffff000 : 0x7c3ff000, - LFS_MKTAG(lfs_tagtype(tag), toid-commit->filter.begin, 0), - // TODO can all these filter adjustments be consolidated? - NULL, true); + LFS_MKTAG(lfs_tagtype(tag), toid, 0), NULL, true); if (res < 0 && res != LFS_ERR_NOENT) { return res; } if (res == LFS_ERR_NOENT) { // update id and commit, as we are currently unique - int err = lfs_commit_attr(lfs, commit, - LFS_MKTAG(0, toid, 0) | (tag & 0xffc00fff), + int err = lfs_commitattr(lfs, commit, + (tag & 0xffc00fff) | LFS_MKTAG(0, toid, 0), buffer); if (err) { return err; @@ -743,7 +660,7 @@ static int lfs_commit_move(lfs_t *lfs, struct lfs_commit *commit, return 0; } -static int lfs_commit_globals(lfs_t *lfs, struct lfs_commit *commit, +static int lfs_commitglobals(lfs_t *lfs, struct lfs_commit *commit, const lfs_globals_t *source, const lfs_globals_t *diff) { if (lfs_globals_iszero(diff)) { return 0; @@ -751,7 +668,7 @@ static int lfs_commit_globals(lfs_t *lfs, struct lfs_commit *commit, // TODO check performance/complexity of different strategies here lfs_globals_t res = lfs_globals_xor(source, diff); - int err = lfs_commit_attr(lfs, commit, + int err = lfs_commitattr(lfs, commit, LFS_MKTAG(LFS_TYPE_GLOBALS, 0x3ff, sizeof(res)), &res); if (err) { return err; @@ -760,6 +677,57 @@ static int lfs_commit_globals(lfs_t *lfs, struct lfs_commit *commit, return 0; } +static int lfs_commitcrc(lfs_t *lfs, struct lfs_commit *commit) { + // align to program units + lfs_off_t off = lfs_alignup(commit->off + 2*sizeof(uint32_t), + lfs->cfg->prog_size); + + // read erased state from next program unit + uint32_t tag; + int err = lfs_bd_read(lfs, commit->block, off, &tag, sizeof(tag)); + if (err) { + return err; + } + + // build crc tag + tag = (0x80000000 & ~lfs_fromle32(tag)) | + LFS_MKTAG(LFS_TYPE_CRC, 0x3ff, + off - (commit->off+sizeof(uint32_t))); + + // write out crc + uint32_t footer[2]; + footer[0] = lfs_tole32(tag ^ commit->ptag); + lfs_crc(&commit->crc, &footer[0], sizeof(footer[0])); + footer[1] = lfs_tole32(commit->crc); + err = lfs_bd_prog(lfs, commit->block, commit->off, footer, sizeof(footer)); + if (err) { + return err; + } + commit->off += sizeof(tag)+lfs_tagsize(tag); + commit->ptag = tag; + + // flush buffers + err = lfs_bd_sync(lfs); + if (err) { + return err; + } + + // successful commit, check checksum to make sure + uint32_t crc = 0xffffffff; + err = lfs_bd_crc(lfs, commit->block, commit->begin, + commit->off-lfs_tagsize(tag)-commit->begin, &crc); + if (err) { + return err; + } + + if (crc != commit->crc) { + return LFS_ERR_CORRUPT; + } + + return 0; +} + +// internal dir operations static int lfs_dir_alloc(lfs_t *lfs, lfs_mdir_t *dir, bool split, const lfs_block_t tail[2]) { // allocate pair of dir blocks (backwards, so we write to block 1 first) @@ -792,6 +760,267 @@ static int lfs_dir_alloc(lfs_t *lfs, lfs_mdir_t *dir, return 0; } +static int lfs_dir_compact(lfs_t *lfs, + lfs_mdir_t *dir, const lfs_mattr_t *attrs, + lfs_mdir_t *source, uint16_t begin, uint16_t end) { + // save some state in case block is bad + const lfs_block_t oldpair[2] = {dir->pair[1], dir->pair[0]}; + bool relocated = false; + + // There's nothing special about our global delta, so feed it back + // into the global global delta + // TODO IMMENSE HMM globals get bleed into from above, need to be fixed after commits due to potential moves + lfs_globals_t gtemp = dir->globals; // TODO hmm, why did we have different variables then? + + lfs->diff = lfs_globals_xor(&lfs->diff, &dir->globals); + dir->globals = (lfs_globals_t){0}; + + // increment revision count + dir->rev += 1; + + while (true) { + // last complete id + int16_t ack = -1; + dir->count = end - begin; + + if (true) { + // erase block to write to + int err = lfs_bd_erase(lfs, dir->pair[1]); + if (err) { + if (err == LFS_ERR_CORRUPT) { + goto relocate; + } + return err; + } + + // write out header + uint32_t crc = 0xffffffff; + uint32_t rev = lfs_tole32(dir->rev); + lfs_crc(&crc, &rev, sizeof(rev)); + err = lfs_bd_prog(lfs, dir->pair[1], 0, &rev, sizeof(rev)); + if (err) { + if (err == LFS_ERR_CORRUPT) { + goto relocate; + } + return err; + } + + // setup compaction + struct lfs_commit commit = { + .block = dir->pair[1], + .off = sizeof(dir->rev), + .crc = crc, + .ptag = 0, + + // space is complicated, we need room for tail, crc, and we + // keep cap at around half a block + .begin = 0, + .end = lfs_min( + lfs_alignup(lfs->cfg->block_size/2, lfs->cfg->prog_size), + lfs->cfg->block_size - 5*sizeof(uint32_t)), + }; + + if (!relocated) { + err = lfs_commitglobals(lfs, &commit, + &dir->globals, &lfs->diff); + if (err) { + if (err == LFS_ERR_NOSPC) { + goto split; + } else if (err == LFS_ERR_CORRUPT) { + goto relocate; + } + return err; + } + } + + // commit with a move + for (uint16_t id = begin; id < end; id++) { + err = lfs_commitmove(lfs, &commit, + id, id - begin, source, attrs); + if (err) { + if (err == LFS_ERR_NOSPC) { + goto split; + } else if (err == LFS_ERR_CORRUPT) { + goto relocate; + } + return err; + } + + ack = id; + } + + // reopen reserved space at the end + commit.end = lfs->cfg->block_size - 2*sizeof(uint32_t); + + if (!lfs_pairisnull(dir->tail)) { + // commit tail, which may be new after last size check + // TODO le32 + err = lfs_commitattr(lfs, &commit, + LFS_MKTAG(LFS_TYPE_TAIL + dir->split, + 0x3ff, sizeof(dir->tail)), dir->tail); + if (err) { + if (err == LFS_ERR_CORRUPT) { + goto relocate; + } + return err; + } + } + + err = lfs_commitcrc(lfs, &commit); + if (err) { + if (err == LFS_ERR_CORRUPT) { + goto relocate; + } + return err; + } + + // successful compaction, swap dir pair to indicate most recent + lfs_pairswap(dir->pair); + dir->off = commit.off; + dir->etag = commit.ptag; + dir->erased = true; + } + break; + +split: + // TODO update dirs that get split here? + + // commit no longer fits, need to split dir, + // drop caches and create tail + lfs->pcache.block = 0xffffffff; + + lfs_mdir_t tail; + int err = lfs_dir_alloc(lfs, &tail, dir->split, dir->tail); + if (err) { + return err; + } + + err = lfs_dir_compact(lfs, &tail, attrs, dir, ack+1, end); + if (err) { + return err; + } + + end = ack+1; + dir->tail[0] = tail.pair[0]; + dir->tail[1] = tail.pair[1]; + dir->split = true; + continue; + +relocate: + //commit was corrupted + LFS_DEBUG("Bad block at %d", dir->pair[1]); + + // drop caches and prepare to relocate block + relocated = true; + lfs->pcache.block = 0xffffffff; + + // can't relocate superblock, filesystem is now frozen + if (lfs_paircmp(oldpair, (const lfs_block_t[2]){0, 1}) == 0) { + LFS_WARN("Superblock %d has become unwritable", oldpair[1]); + return LFS_ERR_CORRUPT; + } + + // relocate half of pair + err = lfs_alloc(lfs, &dir->pair[1]); + if (err) { + return err; + } + + continue; + } + + if (relocated) { + // update references if we relocated + LFS_DEBUG("Relocating %d %d to %d %d", + oldpair[0], oldpair[1], dir->pair[0], dir->pair[1]); + int err = lfs_relocate(lfs, oldpair, dir->pair); + if (err) { + return err; + } + } else { + lfs->globals = lfs_globals_xor(&lfs->globals, &lfs->diff); + lfs->diff = (lfs_globals_t){0}; + } + + lfs->globals = lfs_globals_xor(&lfs->globals, >emp); // TODO hmm, why did we have different variables then? + + return 0; +} + +static int lfs_dir_commit(lfs_t *lfs, + lfs_mdir_t *dir, const lfs_mattr_t *attrs) { + while (true) { + if (!dir->erased) { + // not erased, must compact + goto compact; + } + + struct lfs_commit commit = { + .block = dir->pair[0], + .off = dir->off, + .crc = 0xffffffff, + .ptag = dir->etag, + + .begin = dir->off, + .end = lfs->cfg->block_size - 2*sizeof(uint32_t), + }; + + for (const lfs_mattr_t *a = attrs; a; a = a->next) { + int err = lfs_commitattr(lfs, &commit, a->tag, a->buffer); + if (err) { + if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { + goto compact; + } + return err; + } + } + + int err = lfs_commitglobals(lfs, &commit, &dir->globals, &lfs->diff); + if (err) { + if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { + goto compact; + } + return err; + } + + err = lfs_commitcrc(lfs, &commit); + if (err) { + if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { + goto compact; + } + return err; + } + + // successful commit, lets update dir + dir->off = commit.off; + dir->etag = commit.ptag; +// // TODO hm +// dir->globals = lfs_globals_xor(&dir->globals, &lfs->diff); + lfs->globals = lfs_globals_xor(&lfs->globals, &lfs->diff); + lfs->diff = (lfs_globals_t){0}; + break; + +compact: + lfs->pcache.block = 0xffffffff; + err = lfs_dir_compact(lfs, dir, attrs, dir, 0, dir->count); + if (err) { + return err; + } + break; + } + + // update any directories that are affected + // TODO what about pairs? what if we're splitting?? + for (lfs_dir_t *d = lfs->dirs; d; d = d->next) { + if (lfs_paircmp(d->m.pair, dir->pair) == 0) { + d->m = *dir; + } + } + + // TODO what if we relocated the block containing the move? + return 0; +} + static int32_t lfs_dir_find(lfs_t *lfs, lfs_mdir_t *dir, const lfs_block_t pair[2], uint32_t findmask, uint32_t findtag, @@ -965,268 +1194,10 @@ static int lfs_dir_fetch(lfs_t *lfs, return 0; } -static int lfs_dir_compact(lfs_t *lfs, lfs_mdir_t *dir, lfs_mattr_t *attrs, - lfs_mdir_t *source, uint16_t begin, uint16_t end) { - // save some state in case block is bad - const lfs_block_t oldpair[2] = {dir->pair[1], dir->pair[0]}; - bool relocated = false; - - // There's nothing special about our global delta, so feed it back - // into the global global delta - // TODO IMMENSE HMM globals get bleed into from above, need to be fixed after commits due to potential moves - lfs_globals_t gtemp = dir->globals; // TODO hmm, why did we have different variables then? - - lfs->diff = lfs_globals_xor(&lfs->diff, &dir->globals); - dir->globals = (lfs_globals_t){0}; - - // increment revision count - dir->rev += 1; - - while (true) { - // last complete id - int16_t ack = -1; - dir->count = end - begin; - - if (true) { - // erase block to write to - int err = lfs_bd_erase(lfs, dir->pair[1]); - if (err) { - if (err == LFS_ERR_CORRUPT) { - goto relocate; - } - return err; - } - - // write out header - uint32_t crc = 0xffffffff; - uint32_t rev = lfs_tole32(dir->rev); - lfs_crc(&crc, &rev, sizeof(rev)); - err = lfs_bd_prog(lfs, dir->pair[1], 0, &rev, sizeof(rev)); - if (err) { - if (err == LFS_ERR_CORRUPT) { - goto relocate; - } - return err; - } - - // setup compaction - struct lfs_commit commit = { - .block = dir->pair[1], - .off = sizeof(dir->rev), - - // space is complicated, we need room for tail, crc, idelete, - // and we keep cap at around half a block - .begin = 0, - .end = lfs_min( - lfs_alignup(lfs->cfg->block_size / 2, - lfs->cfg->prog_size), - lfs->cfg->block_size - 5*sizeof(uint32_t)), - .crc = crc, - .ptag = 0, - - // filter out ids - .filter.begin = begin, - .filter.end = end, - }; - - if (!relocated) { - err = lfs_commit_globals(lfs, &commit, - &dir->globals, &lfs->diff); - if (err) { - if (err == LFS_ERR_NOSPC) { - goto split; - } else if (err == LFS_ERR_CORRUPT) { - goto relocate; - } - return err; - } - } - - // commit with a move - for (uint16_t id = begin; id < end; id++) { - err = lfs_commit_move(lfs, &commit, id, id, source, attrs); - if (err) { - if (err == LFS_ERR_NOSPC) { - goto split; - } else if (err == LFS_ERR_CORRUPT) { - goto relocate; - } - return err; - } - - ack = id; - } - - // reopen reserved space at the end - commit.end = lfs->cfg->block_size - 2*sizeof(uint32_t); - - if (!lfs_pairisnull(dir->tail)) { - // commit tail, which may be new after last size check - // TODO le32 - err = lfs_commit_attr(lfs, &commit, - LFS_MKTAG(LFS_TYPE_TAIL + dir->split, - 0x3ff, sizeof(dir->tail)), dir->tail); - if (err) { - if (err == LFS_ERR_CORRUPT) { - goto relocate; - } - return err; - } - } - - err = lfs_commit_crc(lfs, &commit); - if (err) { - if (err == LFS_ERR_CORRUPT) { - goto relocate; - } - return err; - } - - // successful compaction, swap dir pair to indicate most recent - lfs_pairswap(dir->pair); - dir->off = commit.off; - dir->etag = commit.ptag; - dir->erased = true; - } - break; - -split: - // TODO update dirs that get split here? - - // commit no longer fits, need to split dir, - // drop caches and create tail - lfs->pcache.block = 0xffffffff; - - lfs_mdir_t tail; - int err = lfs_dir_alloc(lfs, &tail, dir->split, dir->tail); - if (err) { - return err; - } - - err = lfs_dir_compact(lfs, &tail, attrs, dir, ack+1, end); - if (err) { - return err; - } - - end = ack+1; - dir->tail[0] = tail.pair[0]; - dir->tail[1] = tail.pair[1]; - dir->split = true; - continue; - -relocate: - //commit was corrupted - LFS_DEBUG("Bad block at %d", dir->pair[1]); - - // drop caches and prepare to relocate block - relocated = true; - lfs->pcache.block = 0xffffffff; - - // can't relocate superblock, filesystem is now frozen - if (lfs_paircmp(oldpair, (const lfs_block_t[2]){0, 1}) == 0) { - LFS_WARN("Superblock %d has become unwritable", oldpair[1]); - return LFS_ERR_CORRUPT; - } - - // relocate half of pair - err = lfs_alloc(lfs, &dir->pair[1]); - if (err) { - return err; - } - - continue; - } - - if (relocated) { - // update references if we relocated - LFS_DEBUG("Relocating %d %d to %d %d", - oldpair[0], oldpair[1], dir->pair[0], dir->pair[1]); - int err = lfs_relocate(lfs, oldpair, dir->pair); - if (err) { - return err; - } - } else { - lfs->globals = lfs_globals_xor(&lfs->globals, &lfs->diff); - lfs->diff = (lfs_globals_t){0}; - } - - lfs->globals = lfs_globals_xor(&lfs->globals, >emp); // TODO hmm, why did we have different variables then? - - return 0; -} - -static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir, lfs_mattr_t *attrs) { - while (true) { - if (!dir->erased) { - // not erased, must compact - goto compact; - } - - struct lfs_commit commit = { - .block = dir->pair[0], - .begin = dir->off, - .off = dir->off, - .end = lfs->cfg->block_size - 2*sizeof(uint32_t), - .crc = 0xffffffff, - .ptag = dir->etag, - .filter.begin = 0, - .filter.end = 0x3ff, - }; - - for (lfs_mattr_t *a = attrs; a; a = a->next) { - int err = lfs_commit_attr(lfs, &commit, a->tag, a->buffer); - if (err) { - if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { - goto compact; - } - return err; - } - } - - int err = lfs_commit_globals(lfs, &commit, &dir->globals, &lfs->diff); - if (err) { - if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { - goto compact; - } - return err; - } - - err = lfs_commit_crc(lfs, &commit); - if (err) { - if (err == LFS_ERR_NOSPC || err == LFS_ERR_CORRUPT) { - goto compact; - } - return err; - } - - // successful commit, lets update dir - dir->off = commit.off; - dir->etag = commit.ptag; -// // TODO hm -// dir->globals = lfs_globals_xor(&dir->globals, &lfs->diff); - lfs->globals = lfs_globals_xor(&lfs->globals, &lfs->diff); - lfs->diff = (lfs_globals_t){0}; - break; - -compact: - lfs->pcache.block = 0xffffffff; - err = lfs_dir_compact(lfs, dir, attrs, dir, 0, dir->count); - if (err) { - return err; - } - break; - } - - // update any directories that are affected - // TODO what about pairs? what if we're splitting?? - for (lfs_dir_t *d = lfs->dirs; d; d = d->next) { - if (lfs_paircmp(d->m.pair, dir->pair) == 0) { - d->m = *dir; - } - } - - // TODO what if we relocated the block containing the move? - return 0; +static int32_t lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir, + uint32_t getmask, uint32_t gettag, void *buffer) { + return lfs_commitget(lfs, dir->pair[0], dir->off, dir->etag, + getmask, gettag, buffer, false); } static int lfs_dir_append(lfs_t *lfs, lfs_mdir_t *dir, uint16_t *id) { @@ -1292,42 +1263,6 @@ static int lfs_dir_delete(lfs_t *lfs, lfs_mdir_t *dir, uint16_t id) { return 0; } -static int32_t lfs_dir_get(lfs_t *lfs, lfs_mdir_t *dir, - uint32_t getmask, uint32_t gettag, void *buffer) { - return lfs_commit_get(lfs, dir->pair[0], dir->off, dir->etag, - getmask, gettag, buffer, false); -} - -static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir, - int16_t id, struct lfs_info *info) { - int32_t tag = lfs_dir_get(lfs, dir, 0x7c3ff000, - LFS_MKTAG(LFS_TYPE_NAME, id, lfs->name_size+1), info->name); - if (tag < 0) { - return tag; - } - - info->type = lfs_tagtype(tag); - if (lfs_tagsize(tag) > lfs->name_size) { - return LFS_ERR_RANGE; - } - - struct lfs_ctz ctz; - tag = lfs_dir_get(lfs, dir, 0x7c3ff000, - LFS_MKTAG(LFS_TYPE_STRUCT, id, sizeof(ctz)), &ctz); - if (tag < 0) { - return tag; - } - - if (lfs_tagtype(tag) == LFS_TYPE_CTZSTRUCT) { - info->size = ctz.size; - } else if (lfs_tagtype(tag) == LFS_TYPE_INLINESTRUCT) { - info->size = lfs_tagsize(tag); - } - - return 0; -} - - static int32_t lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir, const char **path) { lfs_block_t pair[2] = {lfs->root[0], lfs->root[1]}; const char *name = *path; @@ -1423,6 +1358,35 @@ static int32_t lfs_dir_lookup(lfs_t *lfs, lfs_mdir_t *dir, const char **path) { } } +static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir, + int16_t id, struct lfs_info *info) { + int32_t tag = lfs_dir_get(lfs, dir, 0x7c3ff000, + LFS_MKTAG(LFS_TYPE_NAME, id, lfs->name_size+1), info->name); + if (tag < 0) { + return tag; + } + + info->type = lfs_tagtype(tag); + if (lfs_tagsize(tag) > lfs->name_size) { + return LFS_ERR_RANGE; + } + + struct lfs_ctz ctz; + tag = lfs_dir_get(lfs, dir, 0x7c3ff000, + LFS_MKTAG(LFS_TYPE_STRUCT, id, sizeof(ctz)), &ctz); + if (tag < 0) { + return tag; + } + + if (lfs_tagtype(tag) == LFS_TYPE_CTZSTRUCT) { + info->size = ctz.size; + } else if (lfs_tagtype(tag) == LFS_TYPE_INLINESTRUCT) { + info->size = lfs_tagsize(tag); + } + + return 0; +} + /// Top level directory operations /// int lfs_mkdir(lfs_t *lfs, const char *path) { // deorphan if we haven't yet, needed at most once after poweron @@ -1638,7 +1602,7 @@ int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir) { /// File index list operations /// -static int lfs_ctz_index(lfs_t *lfs, lfs_off_t *off) { +static int lfs_ctzindex(lfs_t *lfs, lfs_off_t *off) { lfs_off_t size = *off; lfs_off_t b = lfs->cfg->block_size - 2*4; lfs_off_t i = size / b; @@ -1651,7 +1615,7 @@ static int lfs_ctz_index(lfs_t *lfs, lfs_off_t *off) { return i; } -static int lfs_ctz_find(lfs_t *lfs, +static int lfs_ctzfind(lfs_t *lfs, lfs_cache_t *rcache, const lfs_cache_t *pcache, lfs_block_t head, lfs_size_t size, lfs_size_t pos, lfs_block_t *block, lfs_off_t *off) { @@ -1661,8 +1625,8 @@ static int lfs_ctz_find(lfs_t *lfs, return 0; } - lfs_off_t current = lfs_ctz_index(lfs, &(lfs_off_t){size-1}); - lfs_off_t target = lfs_ctz_index(lfs, &pos); + lfs_off_t current = lfs_ctzindex(lfs, &(lfs_off_t){size-1}); + lfs_off_t target = lfs_ctzindex(lfs, &pos); while (current > target) { lfs_size_t skip = lfs_min( @@ -1684,7 +1648,7 @@ static int lfs_ctz_find(lfs_t *lfs, return 0; } -static int lfs_ctz_extend(lfs_t *lfs, +static int lfs_ctzextend(lfs_t *lfs, lfs_cache_t *rcache, lfs_cache_t *pcache, lfs_block_t head, lfs_size_t size, lfs_block_t *block, lfs_off_t *off) { @@ -1713,7 +1677,7 @@ static int lfs_ctz_extend(lfs_t *lfs, } size -= 1; - lfs_off_t index = lfs_ctz_index(lfs, &size); + lfs_off_t index = lfs_ctzindex(lfs, &size); size += 1; // just copy out the last block if it is incomplete @@ -1782,7 +1746,7 @@ relocate: } } -static int lfs_ctz_traverse(lfs_t *lfs, +static int lfs_ctztraverse(lfs_t *lfs, lfs_cache_t *rcache, const lfs_cache_t *pcache, lfs_block_t head, lfs_size_t size, int (*cb)(lfs_t*, void*, lfs_block_t), void *data) { @@ -1790,7 +1754,7 @@ static int lfs_ctz_traverse(lfs_t *lfs, return 0; } - lfs_off_t index = lfs_ctz_index(lfs, &(lfs_off_t){size-1}); + lfs_off_t index = lfs_ctzindex(lfs, &(lfs_off_t){size-1}); while (true) { int err = cb(lfs, data, head); @@ -2159,7 +2123,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, if (!(file->flags & LFS_F_READING) || file->off == lfs->cfg->block_size) { if (!(file->flags & LFS_F_INLINE)) { - int err = lfs_ctz_find(lfs, &file->cache, NULL, + int err = lfs_ctzfind(lfs, &file->cache, NULL, file->ctz.head, file->ctz.size, file->pos, &file->block, &file->off); if (err) { @@ -2248,7 +2212,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, if (!(file->flags & LFS_F_INLINE)) { if (!(file->flags & LFS_F_WRITING) && file->pos > 0) { // find out which block we're extending from - int err = lfs_ctz_find(lfs, &file->cache, NULL, + int err = lfs_ctzfind(lfs, &file->cache, NULL, file->ctz.head, file->ctz.size, file->pos-1, &file->block, &file->off); if (err) { @@ -2262,7 +2226,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, // extend file with new blocks lfs_alloc_ack(lfs); - int err = lfs_ctz_extend(lfs, &lfs->rcache, &file->cache, + int err = lfs_ctzextend(lfs, &lfs->rcache, &file->cache, file->block, file->pos, &file->block, &file->off); if (err) { @@ -2353,7 +2317,7 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { } // lookup new head in ctz skip list - err = lfs_ctz_find(lfs, &file->cache, NULL, + err = lfs_ctzfind(lfs, &file->cache, NULL, file->ctz.head, file->ctz.size, size, &file->ctz.head, &(lfs_off_t){0}); if (err) { @@ -3055,7 +3019,7 @@ int lfs_fs_traverse(lfs_t *lfs, } if (lfs_tagtype(tag) == LFS_TYPE_CTZSTRUCT) { - int err = lfs_ctz_traverse(lfs, &lfs->rcache, NULL, + int err = lfs_ctztraverse(lfs, &lfs->rcache, NULL, ctz.head, ctz.size, cb, data); if (err) { return err; @@ -3067,7 +3031,7 @@ int lfs_fs_traverse(lfs_t *lfs, // iterate over any open files for (lfs_file_t *f = lfs->files; f; f = f->next) { if ((f->flags & LFS_F_DIRTY) && !(f->flags & LFS_F_INLINE)) { - int err = lfs_ctz_traverse(lfs, &lfs->rcache, &f->cache, + int err = lfs_ctztraverse(lfs, &lfs->rcache, &f->cache, f->ctz.head, f->ctz.size, cb, data); if (err) { return err; @@ -3075,7 +3039,7 @@ int lfs_fs_traverse(lfs_t *lfs, } if ((f->flags & LFS_F_WRITING) && !(f->flags & LFS_F_INLINE)) { - int err = lfs_ctz_traverse(lfs, &lfs->rcache, &f->cache, + int err = lfs_ctztraverse(lfs, &lfs->rcache, &f->cache, f->block, f->pos, cb, data); if (err) { return err; @@ -3120,7 +3084,7 @@ int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) { dir.off += lfs_entry_size(&entry); if ((0x70 & entry.d.type) == LFS_TYPE_CTZSTRUCT) { - err = lfs_ctz_traverse(lfs, &lfs->rcache, NULL, + err = lfs_ctztraverse(lfs, &lfs->rcache, NULL, entry.d.u.file.head, entry.d.u.file.size, cb, data); if (err) { return err; @@ -3139,7 +3103,7 @@ int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) { // iterate over any open files for (lfs_file_t *f = lfs->files; f; f = f->next) { if ((f->flags & LFS_F_DIRTY) && !(f->flags & LFS_F_INLINE)) { - int err = lfs_ctz_traverse(lfs, &lfs->rcache, &f->cache, + int err = lfs_ctztraverse(lfs, &lfs->rcache, &f->cache, f->head, f->size, cb, data); if (err) { return err; @@ -3147,7 +3111,7 @@ int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void*, lfs_block_t), void *data) { } if ((f->flags & LFS_F_WRITING) && !(f->flags & LFS_F_INLINE)) { - int err = lfs_ctz_traverse(lfs, &lfs->rcache, &f->cache, + int err = lfs_ctztraverse(lfs, &lfs->rcache, &f->cache, f->block, f->pos, cb, data); if (err) { return err; diff --git a/lfs.h b/lfs.h index 9aecf89e..ccf3fbc5 100644 --- a/lfs.h +++ b/lfs.h @@ -263,7 +263,7 @@ struct lfs_attr { /// littlefs data structures /// typedef struct lfs_mattr { - struct lfs_mattr *next; + const struct lfs_mattr *next; int32_t tag; const void *buffer; } lfs_mattr_t;