github-mirrors/thirdparty-littlefs
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-littlefs.git synced 2025-11-01 00:38:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Generated v2 prefixes

Browse Source
This commit is contained in:
geky bot
2019-08-09 01:20:09 +00:00
parent c08e977799 494dd6673d
commit f3608e84c7
4 changed files with 118 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
.travis.yml
View File

@@ -248,34 +248,30 @@ jobs:
-m "Generated v$LFS2_VERSION_MAJOR prefixes") -m "Generated v$LFS2_VERSION_MAJOR prefixes")
git reset --hard git reset --hard
# Update major version branches (vN and vN-prefix) # Update major version branches (vN and vN-prefix)
git push https://$GEKY_BOT_RELEASES@github.com/$TRAVIS_REPO_SLUG.git \ git push --atomic https://$GEKY_BOT_RELEASES@github.com/$TRAVIS_REPO_SLUG.git \
v$LFS2_VERSION_MAJOR \ v$LFS2_VERSION_MAJOR \
v$LFS2_VERSION_MAJOR-prefix v$LFS2_VERSION_MAJOR-prefix
# Create patch version tag (vN.N.N)
curl -f -u "$GEKY_BOT_RELEASES" -X POST \
https://api.github.com/repos/$TRAVIS_REPO_SLUG/git/refs \
-d "{
\"ref\": \"refs/tags/$LFS2_VERSION\",
\"sha\": \"$TRAVIS_COMMIT\"
}"
# Create minor release?
[[ "$LFS2_VERSION" == *.0 ]] || exit 0
# Build release notes # Build release notes
PREV=$(git tag --sort=-v:refname -l "v*.0" | head -1) PREV=$(git tag --sort=-v:refname -l "v*" | head -1)
if [ ! -z "$PREV" ] if [ ! -z "$PREV" ]
then then
echo "PREV $PREV" echo "PREV $PREV"
CHANGES=$'### Changes\n\n'$( \ CHANGES=$(git log --oneline $PREV.. --grep='^Merge' --invert-grep)
git log --oneline $PREV.. --grep='^Merge' --invert-grep)
printf "CHANGES\n%s\n\n" "$CHANGES" printf "CHANGES\n%s\n\n" "$CHANGES"
fi fi
# Create the release case ${GEKY_BOT_DRAFT:-minor} in
true) DRAFT=true ;;
minor) DRAFT=$(jq -R 'endswith(".0")' <<< "$LFS2_VERSION") ;;
false) DRAFT=false ;;
esac
# Create the release and patch version tag (vN.N.N)
curl -f -u "$GEKY_BOT_RELEASES" -X POST \ curl -f -u "$GEKY_BOT_RELEASES" -X POST \
https://api.github.com/repos/$TRAVIS_REPO_SLUG/releases \ https://api.github.com/repos/$TRAVIS_REPO_SLUG/releases \
-d "{ -d "{
\"tag_name\": \"$LFS2_VERSION\", \"tag_name\": \"$LFS2_VERSION\",
\"name\": \"${LFS2_VERSION%.0}\", \"name\": \"${LFS2_VERSION%.0}\",
\"draft\": true, \"target_commitish\": \"$TRAVIS_COMMIT\",
\"draft\": $DRAFT,
\"body\": $(jq -sR '.' <<< "$CHANGES") \"body\": $(jq -sR '.' <<< "$CHANGES")
}" #" }" #"
SCRIPT SCRIPT

2
Makefile
View File

@@ -29,7 +29,7 @@ override CFLAGS += -DLFS2_YES_TRACE
endif endif
override CFLAGS += -I. override CFLAGS += -I.
override CFLAGS += -std=c99 -Wall -pedantic override CFLAGS += -std=c99 -Wall -pedantic
override CFLAGS += -Wextra -Wshadow -Wjump-misses-init override CFLAGS += -Wextra -Wshadow -Wjump-misses-init -Wundef
# Remove missing-field-initializers because of GCC bug # Remove missing-field-initializers because of GCC bug
override CFLAGS += -Wno-missing-field-initializers override CFLAGS += -Wno-missing-field-initializers

108
lfs2.c
View File

@@ -7,19 +7,21 @@
#include "lfs2.h" #include "lfs2.h"
#include "lfs2_util.h" #include "lfs2_util.h"
#define LFS2_BLOCK_NULL ((lfs2_block_t)-1)
#define LFS2_BLOCK_INLINE ((lfs2_block_t)-2)
/// Caching block device operations /// /// Caching block device operations ///
static inline void lfs2_cache_drop(lfs2_t *lfs2, lfs2_cache_t *rcache) { static inline void lfs2_cache_drop(lfs2_t *lfs2, lfs2_cache_t *rcache) {
// do not zero, cheaper if cache is readonly or only going to be // do not zero, cheaper if cache is readonly or only going to be
// written with identical data (during relocates) // written with identical data (during relocates)
(void)lfs2; (void)lfs2;
rcache->block = 0xffffffff; rcache->block = LFS2_BLOCK_NULL;
} }
static inline void lfs2_cache_zero(lfs2_t *lfs2, lfs2_cache_t *pcache) { static inline void lfs2_cache_zero(lfs2_t *lfs2, lfs2_cache_t *pcache) {
// zero to avoid information leak // zero to avoid information leak
memset(pcache->buffer, 0xff, lfs2->cfg->cache_size); memset(pcache->buffer, 0xff, lfs2->cfg->cache_size);
pcache->block = 0xffffffff; pcache->block = LFS2_BLOCK_NULL;
} }
static int lfs2_bd_read(lfs2_t *lfs2, static int lfs2_bd_read(lfs2_t *lfs2,
@@ -27,7 +29,7 @@ static int lfs2_bd_read(lfs2_t *lfs2,
lfs2_block_t block, lfs2_off_t off, lfs2_block_t block, lfs2_off_t off,
void *buffer, lfs2_size_t size) { void *buffer, lfs2_size_t size) {
uint8_t *data = buffer; uint8_t *data = buffer;
LFS2_ASSERT(block != 0xffffffff); LFS2_ASSERT(block != LFS2_BLOCK_NULL);
if (off+size > lfs2->cfg->block_size) { if (off+size > lfs2->cfg->block_size) {
return LFS2_ERR_CORRUPT; return LFS2_ERR_CORRUPT;
} }
@@ -121,7 +123,7 @@ static int lfs2_bd_cmp(lfs2_t *lfs2,
static int lfs2_bd_flush(lfs2_t *lfs2, static int lfs2_bd_flush(lfs2_t *lfs2,
lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) { lfs2_cache_t *pcache, lfs2_cache_t *rcache, bool validate) {
if (pcache->block != 0xffffffff && pcache->block != 0xfffffffe) { if (pcache->block != LFS2_BLOCK_NULL && pcache->block != LFS2_BLOCK_INLINE) {
LFS2_ASSERT(pcache->block < lfs2->cfg->block_count); LFS2_ASSERT(pcache->block < lfs2->cfg->block_count);
lfs2_size_t diff = lfs2_alignup(pcache->size, lfs2->cfg->prog_size); lfs2_size_t diff = lfs2_alignup(pcache->size, lfs2->cfg->prog_size);
int err = lfs2->cfg->prog(lfs2->cfg, pcache->block, int err = lfs2->cfg->prog(lfs2->cfg, pcache->block,
@@ -171,7 +173,7 @@ static int lfs2_bd_prog(lfs2_t *lfs2,
lfs2_block_t block, lfs2_off_t off, lfs2_block_t block, lfs2_off_t off,
const void *buffer, lfs2_size_t size) { const void *buffer, lfs2_size_t size) {
const uint8_t *data = buffer; const uint8_t *data = buffer;
LFS2_ASSERT(block != 0xffffffff); LFS2_ASSERT(block != LFS2_BLOCK_NULL);
LFS2_ASSERT(off + size <= lfs2->cfg->block_size); LFS2_ASSERT(off + size <= lfs2->cfg->block_size);
while (size > 0) { while (size > 0) {
@@ -201,7 +203,7 @@ static int lfs2_bd_prog(lfs2_t *lfs2,
// pcache must have been flushed, either by programming and // pcache must have been flushed, either by programming and
// entire block or manually flushing the pcache // entire block or manually flushing the pcache
LFS2_ASSERT(pcache->block == 0xffffffff); LFS2_ASSERT(pcache->block == LFS2_BLOCK_NULL);
// prepare pcache, first condition can no longer fail // prepare pcache, first condition can no longer fail
pcache->block = block; pcache->block = block;
@@ -229,7 +231,7 @@ static inline void lfs2_pair_swap(lfs2_block_t pair[2]) {
} }
static inline bool lfs2_pair_isnull(const lfs2_block_t pair[2]) { static inline bool lfs2_pair_isnull(const lfs2_block_t pair[2]) {
return pair[0] == 0xffffffff || pair[1] == 0xffffffff; return pair[0] == LFS2_BLOCK_NULL || pair[1] == LFS2_BLOCK_NULL;
} }
static inline int lfs2_pair_cmp( static inline int lfs2_pair_cmp(
@@ -571,7 +573,7 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
while (size > 0) { while (size > 0) {
lfs2_size_t diff = size; lfs2_size_t diff = size;
if (pcache && pcache->block == 0xfffffffe && if (pcache && pcache->block == LFS2_BLOCK_INLINE &&
off < pcache->off + pcache->size) { off < pcache->off + pcache->size) {
if (off >= pcache->off) { if (off >= pcache->off) {
// is already in pcache? // is already in pcache?
@@ -588,7 +590,7 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
diff = lfs2_min(diff, pcache->off-off); diff = lfs2_min(diff, pcache->off-off);
} }
if (rcache->block == 0xfffffffe && if (rcache->block == LFS2_BLOCK_INLINE &&
off < rcache->off + rcache->size) { off < rcache->off + rcache->size) {
if (off >= rcache->off) { if (off >= rcache->off) {
// is already in rcache? // is already in rcache?
@@ -606,7 +608,7 @@ static int lfs2_dir_getread(lfs2_t *lfs2, const lfs2_mdir_t *dir,
} }
// load to cache, first condition can no longer fail // load to cache, first condition can no longer fail
rcache->block = 0xfffffffe; rcache->block = LFS2_BLOCK_INLINE;
rcache->off = lfs2_aligndown(off, lfs2->cfg->read_size); rcache->off = lfs2_aligndown(off, lfs2->cfg->read_size);
rcache->size = lfs2_min(lfs2_alignup(off+hint, lfs2->cfg->read_size), rcache->size = lfs2_min(lfs2_alignup(off+hint, lfs2->cfg->read_size),
lfs2->cfg->cache_size); lfs2->cfg->cache_size);
@@ -723,7 +725,7 @@ static int lfs2_dir_traverse(lfs2_t *lfs2,
uint16_t fromid = lfs2_tag_size(tag); uint16_t fromid = lfs2_tag_size(tag);
uint16_t toid = lfs2_tag_id(tag); uint16_t toid = lfs2_tag_id(tag);
int err = lfs2_dir_traverse(lfs2, int err = lfs2_dir_traverse(lfs2,
buffer, 0, 0xffffffff, NULL, 0, true, buffer, 0, LFS2_BLOCK_NULL, NULL, 0, true,
LFS2_MKTAG(0x600, 0x3ff, 0), LFS2_MKTAG(0x600, 0x3ff, 0),
LFS2_MKTAG(LFS2_TYPE_STRUCT, 0, 0), LFS2_MKTAG(LFS2_TYPE_STRUCT, 0, 0),
fromid, fromid+1, toid-fromid+diff, fromid, fromid+1, toid-fromid+diff,
@@ -783,15 +785,15 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
// now scan tags to fetch the actual dir and find possible match // now scan tags to fetch the actual dir and find possible match
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
lfs2_off_t off = 0; lfs2_off_t off = 0;
lfs2_tag_t ptag = 0xffffffff; lfs2_tag_t ptag = LFS2_BLOCK_NULL;
uint16_t tempcount = 0; uint16_t tempcount = 0;
lfs2_block_t temptail[2] = {0xffffffff, 0xffffffff}; lfs2_block_t temptail[2] = {LFS2_BLOCK_NULL, LFS2_BLOCK_NULL};
bool tempsplit = false; bool tempsplit = false;
lfs2_stag_t tempbesttag = besttag; lfs2_stag_t tempbesttag = besttag;
dir->rev = lfs2_tole32(dir->rev); dir->rev = lfs2_tole32(dir->rev);
uint32_t crc = lfs2_crc(0xffffffff, &dir->rev, sizeof(dir->rev)); uint32_t crc = lfs2_crc(LFS2_BLOCK_NULL, &dir->rev, sizeof(dir->rev));
dir->rev = lfs2_fromle32(dir->rev); dir->rev = lfs2_fromle32(dir->rev);
while (true) { while (true) {
@@ -860,7 +862,7 @@ static lfs2_stag_t lfs2_dir_fetchmatch(lfs2_t *lfs2,
dir->split = tempsplit; dir->split = tempsplit;
// reset crc // reset crc
crc = 0xffffffff; crc = LFS2_BLOCK_NULL;
continue; continue;
} }
@@ -1248,7 +1250,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
} }
// read erased state from next program unit // read erased state from next program unit
lfs2_tag_t tag = 0xffffffff; lfs2_tag_t tag = LFS2_BLOCK_NULL;
int err = lfs2_bd_read(lfs2, int err = lfs2_bd_read(lfs2,
NULL, &lfs2->rcache, sizeof(tag), NULL, &lfs2->rcache, sizeof(tag),
commit->block, noff, &tag, sizeof(tag)); commit->block, noff, &tag, sizeof(tag));
@@ -1274,7 +1276,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
commit->off += sizeof(tag)+lfs2_tag_size(tag); commit->off += sizeof(tag)+lfs2_tag_size(tag);
commit->ptag = tag ^ (reset << 31); commit->ptag = tag ^ (reset << 31);
commit->crc = 0xffffffff; // reset crc for next "commit" commit->crc = LFS2_BLOCK_NULL; // reset crc for next "commit"
} }
// flush buffers // flush buffers
@@ -1287,7 +1289,7 @@ static int lfs2_dir_commitcrc(lfs2_t *lfs2, struct lfs2_commit *commit) {
lfs2_off_t off = commit->begin; lfs2_off_t off = commit->begin;
lfs2_off_t noff = off1; lfs2_off_t noff = off1;
while (off < end) { while (off < end) {
uint32_t crc = 0xffffffff; uint32_t crc = LFS2_BLOCK_NULL;
for (lfs2_off_t i = off; i < noff+sizeof(uint32_t); i++) { for (lfs2_off_t i = off; i < noff+sizeof(uint32_t); i++) {
// leave it up to caching to make this efficient // leave it up to caching to make this efficient
uint8_t dat; uint8_t dat;
@@ -1341,10 +1343,10 @@ static int lfs2_dir_alloc(lfs2_t *lfs2, lfs2_mdir_t *dir) {
// set defaults // set defaults
dir->off = sizeof(dir->rev); dir->off = sizeof(dir->rev);
dir->etag = 0xffffffff; dir->etag = LFS2_BLOCK_NULL;
dir->count = 0; dir->count = 0;
dir->tail[0] = 0xffffffff; dir->tail[0] = LFS2_BLOCK_NULL;
dir->tail[1] = 0xffffffff; dir->tail[1] = LFS2_BLOCK_NULL;
dir->erased = false; dir->erased = false;
dir->split = false; dir->split = false;
@@ -1434,7 +1436,7 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
// find size // find size
lfs2_size_t size = 0; lfs2_size_t size = 0;
int err = lfs2_dir_traverse(lfs2, int err = lfs2_dir_traverse(lfs2,
source, 0, 0xffffffff, attrs, attrcount, false, source, 0, LFS2_BLOCK_NULL, attrs, attrcount, false,
LFS2_MKTAG(0x400, 0x3ff, 0), LFS2_MKTAG(0x400, 0x3ff, 0),
LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0), LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
begin, end, -begin, begin, end, -begin,
@@ -1500,7 +1502,7 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
end = begin; end = begin;
} }
} }
#if LFS2_MIGRATE #ifdef LFS2_MIGRATE
} else if (lfs2_pair_cmp(dir->pair, lfs2->root) == 0 && lfs2->lfs21) { } else if (lfs2_pair_cmp(dir->pair, lfs2->root) == 0 && lfs2->lfs21) {
// we can't relocate our root during migrations, as this would // we can't relocate our root during migrations, as this would
// cause the superblock to get updated, which would clobber v1 // cause the superblock to get updated, which would clobber v1
@@ -1526,8 +1528,8 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
struct lfs2_commit commit = { struct lfs2_commit commit = {
.block = dir->pair[1], .block = dir->pair[1],
.off = 0, .off = 0,
.ptag = 0xffffffff, .ptag = LFS2_BLOCK_NULL,
.crc = 0xffffffff, .crc = LFS2_BLOCK_NULL,
.begin = 0, .begin = 0,
.end = lfs2->cfg->block_size - 8, .end = lfs2->cfg->block_size - 8,
@@ -1556,7 +1558,7 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
// traverse the directory, this time writing out all unique tags // traverse the directory, this time writing out all unique tags
err = lfs2_dir_traverse(lfs2, err = lfs2_dir_traverse(lfs2,
source, 0, 0xffffffff, attrs, attrcount, false, source, 0, LFS2_BLOCK_NULL, attrs, attrcount, false,
LFS2_MKTAG(0x400, 0x3ff, 0), LFS2_MKTAG(0x400, 0x3ff, 0),
LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0), LFS2_MKTAG(LFS2_TYPE_NAME, 0, 0),
begin, end, -begin, begin, end, -begin,
@@ -1682,8 +1684,8 @@ static int lfs2_dir_commit(lfs2_t *lfs2, lfs2_mdir_t *dir,
} }
// calculate changes to the directory // calculate changes to the directory
lfs2_tag_t deletetag = 0xffffffff; lfs2_tag_t deletetag = LFS2_BLOCK_NULL;
lfs2_tag_t createtag = 0xffffffff; lfs2_tag_t createtag = LFS2_BLOCK_NULL;
for (int i = 0; i < attrcount; i++) { for (int i = 0; i < attrcount; i++) {
if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_CREATE) { if (lfs2_tag_type3(attrs[i].tag) == LFS2_TYPE_CREATE) {
createtag = attrs[i].tag; createtag = attrs[i].tag;
@@ -1729,7 +1731,7 @@ static int lfs2_dir_commit(lfs2_t *lfs2, lfs2_mdir_t *dir,
.block = dir->pair[0], .block = dir->pair[0],
.off = dir->off, .off = dir->off,
.ptag = dir->etag, .ptag = dir->etag,
.crc = 0xffffffff, .crc = LFS2_BLOCK_NULL,
.begin = dir->off, .begin = dir->off,
.end = lfs2->cfg->block_size - 8, .end = lfs2->cfg->block_size - 8,
@@ -1813,8 +1815,8 @@ compact:
if (lfs2_pair_cmp(d->m.pair, copy.pair) == 0) { if (lfs2_pair_cmp(d->m.pair, copy.pair) == 0) {
d->m = *dir; d->m = *dir;
if (d->id == lfs2_tag_id(deletetag)) { if (d->id == lfs2_tag_id(deletetag)) {
d->m.pair[0] = 0xffffffff; d->m.pair[0] = LFS2_BLOCK_NULL;
d->m.pair[1] = 0xffffffff; d->m.pair[1] = LFS2_BLOCK_NULL;
} else if (d->id > lfs2_tag_id(deletetag)) { } else if (d->id > lfs2_tag_id(deletetag)) {
d->id -= 1; d->id -= 1;
if (d->type == LFS2_TYPE_DIR) { if (d->type == LFS2_TYPE_DIR) {
@@ -2129,7 +2131,7 @@ static int lfs2_ctz_find(lfs2_t *lfs2,
lfs2_block_t head, lfs2_size_t size, lfs2_block_t head, lfs2_size_t size,
lfs2_size_t pos, lfs2_block_t *block, lfs2_off_t *off) { lfs2_size_t pos, lfs2_block_t *block, lfs2_off_t *off) {
if (size == 0) { if (size == 0) {
*block = 0xffffffff; *block = LFS2_BLOCK_NULL;
*off = 0; *off = 0;
return 0; return 0;
} }
@@ -2327,6 +2329,7 @@ int lfs2_file_opencfg(lfs2_t *lfs2, lfs2_file_t *file,
file->cfg = cfg; file->cfg = cfg;
file->flags = flags | LFS2_F_OPENED; file->flags = flags | LFS2_F_OPENED;
file->pos = 0; file->pos = 0;
file->off = 0;
file->cache.buffer = NULL; file->cache.buffer = NULL;
// allocate entry for file if it doesn't exist // allocate entry for file if it doesn't exist
@@ -2426,7 +2429,7 @@ int lfs2_file_opencfg(lfs2_t *lfs2, lfs2_file_t *file,
if (lfs2_tag_type3(tag) == LFS2_TYPE_INLINESTRUCT) { if (lfs2_tag_type3(tag) == LFS2_TYPE_INLINESTRUCT) {
// load inline files // load inline files
file->ctz.head = 0xfffffffe; file->ctz.head = LFS2_BLOCK_INLINE;
file->ctz.size = lfs2_tag_size(tag); file->ctz.size = lfs2_tag_size(tag);
file->flags |= LFS2_F_INLINE; file->flags |= LFS2_F_INLINE;
file->cache.block = file->ctz.head; file->cache.block = file->ctz.head;
@@ -2614,7 +2617,7 @@ static int lfs2_file_flush(lfs2_t *lfs2, lfs2_file_t *file) {
} }
// keep our reference to the rcache in sync // keep our reference to the rcache in sync
if (lfs2->rcache.block != 0xffffffff) { if (lfs2->rcache.block != LFS2_BLOCK_NULL) {
lfs2_cache_drop(lfs2, &orig.cache); lfs2_cache_drop(lfs2, &orig.cache);
lfs2_cache_drop(lfs2, &lfs2->rcache); lfs2_cache_drop(lfs2, &lfs2->rcache);
} }
@@ -2762,7 +2765,7 @@ lfs2_ssize_t lfs2_file_read(lfs2_t *lfs2, lfs2_file_t *file,
return err; return err;
} }
} else { } else {
file->block = 0xfffffffe; file->block = LFS2_BLOCK_INLINE;
file->off = file->pos; file->off = file->pos;
} }
@@ -2888,7 +2891,7 @@ lfs2_ssize_t lfs2_file_write(lfs2_t *lfs2, lfs2_file_t *file,
return err; return err;
} }
} else { } else {
file->block = 0xfffffffe; file->block = LFS2_BLOCK_INLINE;
file->off = file->pos; file->off = file->pos;
} }
@@ -2978,6 +2981,7 @@ int lfs2_file_truncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t size) {
return LFS2_ERR_INVAL; return LFS2_ERR_INVAL;
} }
lfs2_off_t pos = file->pos;
lfs2_off_t oldsize = lfs2_file_size(lfs2, file); lfs2_off_t oldsize = lfs2_file_size(lfs2, file);
if (size < oldsize) { if (size < oldsize) {
// need to flush since directly changing metadata // need to flush since directly changing metadata
@@ -3000,8 +3004,6 @@ int lfs2_file_truncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t size) {
file->ctz.size = size; file->ctz.size = size;
file->flags |= LFS2_F_DIRTY | LFS2_F_READING; file->flags |= LFS2_F_DIRTY | LFS2_F_READING;
} else if (size > oldsize) { } else if (size > oldsize) {
lfs2_off_t pos = file->pos;
// flush+seek if not already at end // flush+seek if not already at end
if (file->pos != oldsize) { if (file->pos != oldsize) {
int err = lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_END); int err = lfs2_file_seek(lfs2, file, 0, LFS2_SEEK_END);
@@ -3019,13 +3021,13 @@ int lfs2_file_truncate(lfs2_t *lfs2, lfs2_file_t *file, lfs2_off_t size) {
return res; return res;
} }
} }
}
// restore pos // restore pos
int err = lfs2_file_seek(lfs2, file, pos, LFS2_SEEK_SET); int err = lfs2_file_seek(lfs2, file, pos, LFS2_SEEK_SET);
if (err < 0) { if (err < 0) {
LFS2_TRACE("lfs2_file_truncate -> %d", err); LFS2_TRACE("lfs2_file_truncate -> %d", err);
return err; return err;
}
} }
LFS2_TRACE("lfs2_file_truncate -> %d", 0); LFS2_TRACE("lfs2_file_truncate -> %d", 0);
@@ -3374,7 +3376,7 @@ static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
LFS2_ASSERT(lfs2->cfg->block_size % lfs2->cfg->cache_size == 0); LFS2_ASSERT(lfs2->cfg->block_size % lfs2->cfg->cache_size == 0);
// check that the block size is large enough to fit ctz pointers // check that the block size is large enough to fit ctz pointers
LFS2_ASSERT(4*lfs2_npw2(0xffffffff / (lfs2->cfg->block_size-2*4)) LFS2_ASSERT(4*lfs2_npw2(LFS2_BLOCK_NULL / (lfs2->cfg->block_size-2*4))
<= lfs2->cfg->block_size); <= lfs2->cfg->block_size);
// block_cycles = 0 is no longer supported. // block_cycles = 0 is no longer supported.
@@ -3412,10 +3414,10 @@ static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
lfs2_cache_zero(lfs2, &lfs2->rcache); lfs2_cache_zero(lfs2, &lfs2->rcache);
lfs2_cache_zero(lfs2, &lfs2->pcache); lfs2_cache_zero(lfs2, &lfs2->pcache);
// setup lookahead, must be multiple of 64-bits // setup lookahead, must be multiple of 64-bits, 32-bit aligned
LFS2_ASSERT(lfs2->cfg->lookahead_size > 0); LFS2_ASSERT(lfs2->cfg->lookahead_size > 0);
LFS2_ASSERT(lfs2->cfg->lookahead_size % 8 == 0 && LFS2_ASSERT(lfs2->cfg->lookahead_size % 8 == 0 &&
(uintptr_t)lfs2->cfg->lookahead_buffer % 8 == 0); (uintptr_t)lfs2->cfg->lookahead_buffer % 4 == 0);
if (lfs2->cfg->lookahead_buffer) { if (lfs2->cfg->lookahead_buffer) {
lfs2->free.buffer = lfs2->cfg->lookahead_buffer; lfs2->free.buffer = lfs2->cfg->lookahead_buffer;
} else { } else {
@@ -3446,8 +3448,8 @@ static int lfs2_init(lfs2_t *lfs2, const struct lfs2_config *cfg) {
} }
// setup default state // setup default state
lfs2->root[0] = 0xffffffff; lfs2->root[0] = LFS2_BLOCK_NULL;
lfs2->root[1] = 0xffffffff; lfs2->root[1] = LFS2_BLOCK_NULL;
lfs2->mlist = NULL; lfs2->mlist = NULL;
lfs2->seed = 0; lfs2->seed = 0;
lfs2->gstate = (struct lfs2_gstate){0}; lfs2->gstate = (struct lfs2_gstate){0};
@@ -4250,7 +4252,7 @@ static int lfs21_dir_fetch(lfs2_t *lfs2,
continue; continue;
} }
uint32_t crc = 0xffffffff; uint32_t crc = LFS2_BLOCK_NULL;
lfs21_dir_tole32(&test); lfs21_dir_tole32(&test);
lfs21_crc(&crc, &test, sizeof(test)); lfs21_crc(&crc, &test, sizeof(test));
lfs21_dir_fromle32(&test); lfs21_dir_fromle32(&test);
@@ -4435,8 +4437,8 @@ static int lfs21_mount(lfs2_t *lfs2, struct lfs21 *lfs21,
} }
lfs2->lfs21 = lfs21; lfs2->lfs21 = lfs21;
lfs2->lfs21->root[0] = 0xffffffff; lfs2->lfs21->root[0] = LFS2_BLOCK_NULL;
lfs2->lfs21->root[1] = 0xffffffff; lfs2->lfs21->root[1] = LFS2_BLOCK_NULL;
// setup free lookahead // setup free lookahead
lfs2->free.off = 0; lfs2->free.off = 0;
@@ -4685,7 +4687,7 @@ int lfs2_migrate(lfs2_t *lfs2, const struct lfs2_config *cfg) {
dir2.pair[1] = dir1.pair[1]; dir2.pair[1] = dir1.pair[1];
dir2.rev = dir1.d.rev; dir2.rev = dir1.d.rev;
dir2.off = sizeof(dir2.rev); dir2.off = sizeof(dir2.rev);
dir2.etag = 0xffffffff; dir2.etag = LFS2_BLOCK_NULL;
dir2.count = 0; dir2.count = 0;
dir2.tail[0] = lfs2->lfs21->root[0]; dir2.tail[0] = lfs2->lfs21->root[0];
dir2.tail[1] = lfs2->lfs21->root[1]; dir2.tail[1] = lfs2->lfs21->root[1];

51
tests/test_truncate.sh
View File

@@ -107,6 +107,57 @@ scripts/test.py << TEST
lfs2_unmount(&lfs2) => 0; lfs2_unmount(&lfs2) => 0;
TEST TEST
echo "--- Write, truncate, and read ---"
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file, "sequence",
LFS2_O_RDWR | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
lfs2_size_t size = lfs2.cfg->cache_size;
lfs2_size_t qsize = size / 4;
uint8_t *wb = buffer;
uint8_t *rb = buffer + size;
for (lfs2_off_t j = 0; j < size; ++j) {
wb[j] = j;
}
/* Spread sequence over size */
lfs2_file_write(&lfs2, &file, wb, size) => size;
lfs2_file_size(&lfs2, &file) => size;
lfs2_file_tell(&lfs2, &file) => size;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_SET) => 0;
lfs2_file_tell(&lfs2, &file) => 0;
/* Chop off the last quarter */
lfs2_size_t trunc = size - qsize;
lfs2_file_truncate(&lfs2, &file, trunc) => 0;
lfs2_file_tell(&lfs2, &file) => 0;
lfs2_file_size(&lfs2, &file) => trunc;
/* Read should produce first 3/4 */
lfs2_file_read(&lfs2, &file, rb, size) => trunc;
memcmp(rb, wb, trunc) => 0;
/* Move to 1/4 */
lfs2_file_size(&lfs2, &file) => trunc;
lfs2_file_seek(&lfs2, &file, qsize, LFS2_SEEK_SET) => qsize;
lfs2_file_tell(&lfs2, &file) => qsize;
/* Chop to 1/2 */
trunc -= qsize;
lfs2_file_truncate(&lfs2, &file, trunc) => 0;
lfs2_file_tell(&lfs2, &file) => qsize;
lfs2_file_size(&lfs2, &file) => trunc;
/* Read should produce second quarter */
lfs2_file_read(&lfs2, &file, rb, size) => trunc - qsize;
memcmp(rb, wb + qsize, trunc - qsize) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Truncate and write ---" echo "--- Truncate and write ---"
scripts/test.py << TEST scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0; lfs2_mount(&lfs2, &cfg) => 0;