From 37f799d8a2e36cf8eaab88a3f1f588c7f85e9297 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 17 Mar 2018 10:28:14 -0500 Subject: [PATCH] WIP added hacky taped on inline files --- lfs.c | 155 ++++++++++++++++++++++++++++++++++++++++------------------ lfs.h | 28 ++++++----- 2 files changed, 124 insertions(+), 59 deletions(-) diff --git a/lfs.c b/lfs.c index e4e2917..852fb65 100644 --- a/lfs.c +++ b/lfs.c @@ -24,7 +24,7 @@ static int lfs_cache_read(lfs_t *lfs, lfs_cache_t *rcache, const lfs_cache_t *pcache, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size) { uint8_t *data = buffer; - LFS_ASSERT(block < lfs->cfg->block_count); + //LFS_ASSERT(block < lfs->cfg->block_count); TODO reintroduce :/ while (size > 0) { if (pcache && block == pcache->block && off >= pcache->off && @@ -149,7 +149,7 @@ static int lfs_cache_prog(lfs_t *lfs, lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size) { const uint8_t *data = buffer; - LFS_ASSERT(block < lfs->cfg->block_count); + //LFS_ASSERT(block < lfs->cfg->block_count); TODO reintroduce :/ while (size > 0) { if (block == pcache->block && off >= pcache->off && @@ -841,7 +841,7 @@ static int lfs_dir_update(lfs_t *lfs, lfs_dir_t *dir, } static int lfs_dir_next(lfs_t *lfs, lfs_dir_t *dir, lfs_entry_t *entry) { - while (dir->off + sizeof(entry->d) > (0x7fffffff & dir->d.size)-4) { + while (dir->off >= (0x7fffffff & dir->d.size)-4) { if (!(0x80000000 & dir->d.size)) { entry->off = dir->off; return LFS_ERR_NOENT; @@ -932,8 +932,8 @@ static int lfs_dir_find(lfs_t *lfs, lfs_dir_t *dir, return err; } - if (((0x7f & entry->d.type) != (LFS_STRUCT_CTZ | LFS_TYPE_REG) && - (0x7f & entry->d.type) != (LFS_STRUCT_DIR | LFS_TYPE_DIR)) || + if (((0xf & entry->d.type) != LFS_TYPE_REG && + (0xf & entry->d.type) != LFS_TYPE_DIR) || entry->d.nlen != pathlen) { continue; } @@ -1116,8 +1116,8 @@ int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) { return (err == LFS_ERR_NOENT) ? 0 : err; } - if ((0x7f & entry.d.type) != (LFS_STRUCT_CTZ | LFS_TYPE_REG) && - (0x7f & entry.d.type) != (LFS_STRUCT_DIR | LFS_TYPE_DIR)) { + if ((0xf & entry.d.type) != LFS_TYPE_REG && + (0xf & entry.d.type) != LFS_TYPE_DIR) { continue; } @@ -1139,8 +1139,10 @@ int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) { } info->type = 0xf & entry.d.type; - if (info->type == LFS_TYPE_REG) { + if (entry.d.type == (LFS_STRUCT_CTZ | LFS_TYPE_REG)) { info->size = entry.d.u.file.size; + } else if (entry.d.type == (LFS_STRUCT_INLINE | LFS_TYPE_REG)) { + info->size = entry.d.elen; } int err = lfs_bd_read(lfs, dir->pair[0], @@ -1414,18 +1416,16 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file, } // create entry to remember name - entry.d.type = LFS_STRUCT_CTZ | LFS_TYPE_REG; - entry.d.elen = sizeof(entry.d) - 4; + entry.d.type = LFS_STRUCT_INLINE | LFS_TYPE_REG; + entry.d.elen = 0; entry.d.alen = 0; entry.d.nlen = strlen(path); - entry.d.u.file.head = 0xffffffff; - entry.d.u.file.size = 0; entry.size = 4 + entry.d.elen + entry.d.alen + entry.d.nlen; err = lfs_dir_append(lfs, &cwd, &entry, &(struct lfs_region){ - 0, +sizeof(entry.d), - lfs_commit_mem, &entry.d, sizeof(entry.d), + 0, +4, + lfs_commit_mem, &entry.d, 4, &(struct lfs_region){ 0, +entry.d.nlen, lfs_commit_mem, path, entry.d.nlen}}); @@ -1471,6 +1471,20 @@ int lfs_file_open(lfs_t *lfs, lfs_file_t *file, } } + // load inline files + if ((0x70 & entry.d.type) == LFS_STRUCT_INLINE) { + file->head = 0xffffffff; + file->size = entry.d.elen; + file->flags |= LFS_F_INLINE; + err = lfs_bd_read(lfs, cwd.pair[0], + entry.off + 4, + file->cache.buffer, file->size); + if (err) { + lfs_free(file->cache.buffer); + return err; + } + } + // add to list of files file->next = lfs->files; lfs->files = file; @@ -1546,6 +1560,20 @@ relocate: } static int lfs_file_flush(lfs_t *lfs, lfs_file_t *file) { + if (file->flags & LFS_F_INLINE) { + // do nothing since we won't need the cache for anything else + if (file->flags & LFS_F_READING) { + file->flags &= ~LFS_F_READING; + } + + if (file->flags & LFS_F_WRITING) { + file->flags &= ~LFS_F_WRITING; + file->flags |= LFS_F_DIRTY; + } + + return 0; + } + if (file->flags & LFS_F_READING) { // just drop read cache file->cache.block = 0xffffffff; @@ -1639,19 +1667,34 @@ int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) { if (err) { return err; } + LFS_ASSERT((0xf & entry.d.type) == LFS_TYPE_REG); - LFS_ASSERT(entry.d.type == (LFS_STRUCT_CTZ | LFS_TYPE_REG)); - entry.d.u.file.head = file->head; - entry.d.u.file.size = file->size; + if (file->flags & LFS_F_INLINE) { + file->size = lfs_max(file->pos, file->size); + lfs_ssize_t diff = file->size - entry.d.elen; + entry.d.elen = file->size; - lfs_entry_tole32(&entry.d); - err = lfs_dir_update(lfs, &cwd, &entry, - &(struct lfs_region){ - 0, 0, - lfs_commit_mem, &entry.d, sizeof(entry.d)}); - lfs_entry_fromle32(&entry.d); - if (err) { - return err; + err = lfs_dir_update(lfs, &cwd, &entry, + &(struct lfs_region){ + 0, 0, + lfs_commit_mem, &entry.d, 4, + &(struct lfs_region){ + 4, diff, + lfs_commit_mem, file->cache.buffer, file->size}}); + if (err) { + return err; + } + } else { + entry.d.u.file.head = file->head; + entry.d.u.file.size = file->size; + + err = lfs_dir_update(lfs, &cwd, &entry, + &(struct lfs_region){ + 0, 0, + lfs_commit_mem, &entry.d, sizeof(entry.d)}); + if (err) { + return err; + } } file->flags &= ~LFS_F_DIRTY; @@ -1689,11 +1732,16 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, // check if we need a new block if (!(file->flags & LFS_F_READING) || file->off == lfs->cfg->block_size) { - int err = lfs_ctz_find(lfs, &file->cache, NULL, - file->head, file->size, - file->pos, &file->block, &file->off); - if (err) { - return err; + if (!(file->flags & LFS_F_INLINE)) { + int err = lfs_ctz_find(lfs, &file->cache, NULL, + file->head, file->size, + file->pos, &file->block, &file->off); + if (err) { + return err; + } + } else { + file->block = 0xffffffff; + file->off = 0; } file->flags |= LFS_F_READING; @@ -1751,31 +1799,42 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, } while (nsize > 0) { + //printf("pos %d\n", file->pos + nsize); + // TODO combine with block allocation? + if (file->pos + nsize >= LFS_INLINE_MAX) { + file->flags &= ~LFS_F_INLINE; + } + // check if we need a new block if (!(file->flags & LFS_F_WRITING) || file->off == lfs->cfg->block_size) { - 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, - file->head, file->size, - file->pos-1, &file->block, &file->off); + 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, + file->head, file->size, + file->pos-1, &file->block, &file->off); + if (err) { + file->flags |= LFS_F_ERRED; + return err; + } + + // mark cache as dirty since we may have read data into it + file->cache.block = 0xffffffff; + } + + // extend file with new blocks + lfs_alloc_ack(lfs); + int err = lfs_ctz_extend(lfs, &lfs->rcache, &file->cache, + file->block, file->pos, + &file->block, &file->off); if (err) { file->flags |= LFS_F_ERRED; return err; } - - // mark cache as dirty since we may have read data into it - file->cache.block = 0xffffffff; - } - - // extend file with new blocks - lfs_alloc_ack(lfs); - int err = lfs_ctz_extend(lfs, &lfs->rcache, &file->cache, - file->block, file->pos, - &file->block, &file->off); - if (err) { - file->flags |= LFS_F_ERRED; - return err; + } else { + file->block = 0xffffffff; + file->off = 0; } file->flags |= LFS_F_WRITING; diff --git a/lfs.h b/lfs.h index 91e7232..87b7704 100644 --- a/lfs.h +++ b/lfs.h @@ -55,6 +55,10 @@ typedef uint32_t lfs_block_t; #define LFS_NAME_MAX 255 #endif +#ifndef LFS_INLINE_MAX +#define LFS_INLINE_MAX 255 +#endif + // Possible error codes, these are negative to allow // valid positive return values enum lfs_error { @@ -82,25 +86,27 @@ enum lfs_type { // on disk structure LFS_STRUCT_CTZ = 0x10, LFS_STRUCT_DIR = 0x20, + LFS_STRUCT_INLINE = 0x30, LFS_STRUCT_MOVED = 0x80, }; // File open flags enum lfs_open_flags { // open flags - LFS_O_RDONLY = 1, // Open a file as read only - LFS_O_WRONLY = 2, // Open a file as write only - LFS_O_RDWR = 3, // Open a file as read and write - LFS_O_CREAT = 0x0100, // Create a file if it does not exist - LFS_O_EXCL = 0x0200, // Fail if a file already exists - LFS_O_TRUNC = 0x0400, // Truncate the existing file to zero size - LFS_O_APPEND = 0x0800, // Move to end of file on every write + LFS_O_RDONLY = 1, // Open a file as read only + LFS_O_WRONLY = 2, // Open a file as write only + LFS_O_RDWR = 3, // Open a file as read and write + LFS_O_CREAT = 0x0100, // Create a file if it does not exist + LFS_O_EXCL = 0x0200, // Fail if a file already exists + LFS_O_TRUNC = 0x0400, // Truncate the existing file to zero size + LFS_O_APPEND = 0x0800, // Move to end of file on every write // internally used flags - LFS_F_DIRTY = 0x10000, // File does not match storage - LFS_F_WRITING = 0x20000, // File has been written since last flush - LFS_F_READING = 0x40000, // File has been read since last flush - LFS_F_ERRED = 0x80000, // An error occured during write + LFS_F_DIRTY = 0x10000, // File does not match storage + LFS_F_WRITING = 0x20000, // File has been written since last flush + LFS_F_READING = 0x40000, // File has been read since last flush + LFS_F_ERRED = 0x80000, // An error occured during write + LFS_F_INLINE = 0x100000, // Currently inlined in directory entry }; // File seek flags