MirrorSave
/
nodemcu-firmware
mirror of https://github.com/nodemcu/nodemcu-firmware.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' of https://github.com/nodemcu/nodemcu-firmware

This commit is contained in:
HuangRui 2015-02-11 22:51:33 +08:00
parent d2cdba255f a34e6e8e3d
commit db43b1e005
14 changed files with 314 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
app/modules/file.c
View File

@ -125,7 +125,7 @@ static int file_remove( lua_State* L )
if( len > FS_NAME_MAX_LENGTH ) if( len > FS_NAME_MAX_LENGTH )
return luaL_error(L, "filename too long"); return luaL_error(L, "filename too long");
file_close(L); file_close(L);
SPIFFS_remove(&fs, fname); SPIFFS_remove(&fs, (char *)fname);
return 0; return 0;
} }
@ -150,6 +150,31 @@ static int file_check( lua_State* L )
} }
#endif #endif
// Lua: rename("oldname", "newname")
static int file_rename( lua_State* L )
{
size_t len;
if((FS_OPEN_OK - 1)!=file_fd){
fs_close(file_fd);
file_fd = FS_OPEN_OK - 1;
}
const char *oldname = luaL_checklstring( L, 1, &len );
if( len > FS_NAME_MAX_LENGTH )
return luaL_error(L, "filename too long");
const char *newname = luaL_checklstring( L, 2, &len );
if( len > FS_NAME_MAX_LENGTH )
return luaL_error(L, "filename too long");
if(SPIFFS_OK==myspiffs_rename( oldname, newname )){
lua_pushboolean(L, 1);
} else {
lua_pushboolean(L, 0);
}
return 1;
}
#endif #endif
// g_read() // g_read()
@ -282,6 +307,7 @@ const LUA_REG_TYPE file_map[] =
{ LSTRKEY( "seek" ), LFUNCVAL( file_seek ) }, { LSTRKEY( "seek" ), LFUNCVAL( file_seek ) },
{ LSTRKEY( "flush" ), LFUNCVAL( file_flush ) }, { LSTRKEY( "flush" ), LFUNCVAL( file_flush ) },
// { LSTRKEY( "check" ), LFUNCVAL( file_check ) }, // { LSTRKEY( "check" ), LFUNCVAL( file_check ) },
{ LSTRKEY( "rename" ), LFUNCVAL( file_rename ) },
#endif #endif
#if LUA_OPTIMIZE_MEMORY > 0 #if LUA_OPTIMIZE_MEMORY > 0

1
app/platform/flash_fs.h
View File

@ -68,6 +68,7 @@
#define fs_format myspiffs_format #define fs_format myspiffs_format
#define fs_check myspiffs_check #define fs_check myspiffs_check
#define fs_rename myspiffs_rename
#define FS_NAME_MAX_LENGTH SPIFFS_OBJ_NAME_LEN #define FS_NAME_MAX_LENGTH SPIFFS_OBJ_NAME_LEN

20
app/spiffs/LICENSE Normal file
View File

@ -0,0 +1,20 @@
The MIT License (MIT)
Copyright (c) 2013-2015 Peter Andersson (pelleplutt1976<at>gmail.com)
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

31
app/spiffs/docs/INTEGRATION
View File

@ -40,7 +40,7 @@ Also, toss up some of the needed buffers:
static u8_t spiffs_work_buf[LOG_PAGE_SIZE*2]; static u8_t spiffs_work_buf[LOG_PAGE_SIZE*2];
static u8_t spiffs_fds[32*4]; static u8_t spiffs_fds[32*4];
static u8_t spiffs_cache[(LOG_PAGE_SIZE+32)*4]; static u8_t spiffs_cache_buf[(LOG_PAGE_SIZE+32)*4];
Now, write the my_spiffs_mount function: Now, write the my_spiffs_mount function:
@ -50,7 +50,7 @@ Now, write the my_spiffs_mount function:
cfg.phys_addr = 0; // start spiffs at start of spi flash cfg.phys_addr = 0; // start spiffs at start of spi flash
cfg.phys_erase_block = 65536; // according to datasheet cfg.phys_erase_block = 65536; // according to datasheet
cfg.log_block_size = 65536; // let us not complicate things cfg.log_block_size = 65536; // let us not complicate things
cfg.log_block_size = LOG_PAGE_SIZE; // as we said cfg.log_page_size = LOG_PAGE_SIZE; // as we said
cfg.hal_read_f = my_spi_read; cfg.hal_read_f = my_spi_read;
cfg.hal_write_f = my_spi_write; cfg.hal_write_f = my_spi_write;
@ -61,8 +61,8 @@ Now, write the my_spiffs_mount function:
spiffs_work_buf, spiffs_work_buf,
spiffs_fds, spiffs_fds,
sizeof(spiffs_fds), sizeof(spiffs_fds),
spiffs_cache, spiffs_cache_buf,
sizeof(spiffs_cache), sizeof(spiffs_cache_buf),
0); 0);
printf("mount res: %i\n", res); printf("mount res: %i\n", res);
} }
@ -127,6 +127,29 @@ Compile, run, cross fingers hard, and you'll get the output:
Got errors? Check spiffs.h for error definitions to get a clue what went voodoo. Got errors? Check spiffs.h for error definitions to get a clue what went voodoo.
* THINGS TO CHECK
When you alter the spiffs_config values, make sure you also check the typedefs
in spiffs_config.h:
- spiffs_block_ix
- spiffs_page_ix
- spiffs_obj_id
- spiffs_span_ix
The sizes of these typedefs must not underflow, else spiffs might end up in
eternal loops. Each typedef is commented what check for.
Also, if you alter the code or just want to verify your configuration, you can
run
> make test
in the spiffs folder. This will run all testcases using the configuration in
default/spiffs_config.h and test/params_test.h. The tests are written for linux
but should run under cygwin also.
* INTEGRATING SPIFFS * INTEGRATING SPIFFS
In order to integrate spiffs to your embedded target, you will basically need: In order to integrate spiffs to your embedded target, you will basically need:

36
app/spiffs/params_test.h
View File

@ -1,36 +0,0 @@
/*
* params_test.h
*
* Created on: May 26, 2013
* Author: petera
*/
#ifndef PARAMS_TEST_H_
#define PARAMS_TEST_H_
// // total emulated spi flash size
// #define PHYS_FLASH_SIZE (16*1024*1024)
// // spiffs file system size
// #define SPIFFS_FLASH_SIZE (2*1024*1024)
// // spiffs file system offset in emulated spi flash
// #define SPIFFS_PHYS_ADDR (4*1024*1024)
// #define SECTOR_SIZE 65536
// #define LOG_BLOCK (SECTOR_SIZE*2)
// #define LOG_PAGE (SECTOR_SIZE/256)
// #define FD_BUF_SIZE 64*6
// #define CACHE_BUF_SIZE (LOG_PAGE + 32)*8
// #define ASSERT(c, m) real_assert((c),(m), __FILE__, __LINE__);
typedef signed int s32_t;
typedef unsigned int u32_t;
typedef signed short s16_t;
typedef unsigned short u16_t;
typedef signed char s8_t;
typedef unsigned char u8_t;
void real_assert(int c, const char *n, const char *file, int l);
#endif /* PARAMS_TEST_H_ */

5
app/spiffs/spiffs.c
View File

@ -98,7 +98,7 @@ int myspiffs_check( void )
} }
int myspiffs_open(const char *name, int flags){ int myspiffs_open(const char *name, int flags){
return (int)SPIFFS_open(&fs, name, (spiffs_flags)flags, 0); return (int)SPIFFS_open(&fs, (char *)name, (spiffs_flags)flags, 0);
} }
int myspiffs_close( int fd ){ int myspiffs_close( int fd ){
@ -162,6 +162,9 @@ int myspiffs_error( int fd ){
void myspiffs_clearerr( int fd ){ void myspiffs_clearerr( int fd ){
fs.errno = SPIFFS_OK; fs.errno = SPIFFS_OK;
} }
int myspiffs_rename( const char *old, const char *newname ){
return SPIFFS_rename(&fs, (char *)old, (char *)newname);
}
#if 0 #if 0
void test_spiffs() { void test_spiffs() {
char buf[12]; char buf[12];

37
app/spiffs/spiffs.h
View File

@ -36,6 +36,7 @@
#define SPIFFS_ERR_INDEX_INVALID -10020 #define SPIFFS_ERR_INDEX_INVALID -10020
#define SPIFFS_ERR_NOT_WRITABLE -10021 #define SPIFFS_ERR_NOT_WRITABLE -10021
#define SPIFFS_ERR_NOT_READABLE -10022 #define SPIFFS_ERR_NOT_READABLE -10022
#define SPIFFS_ERR_CONFLICTING_NAME -10023
#define SPIFFS_ERR_INTERNAL -10050 #define SPIFFS_ERR_INTERNAL -10050
@ -225,6 +226,7 @@ struct spiffs_dirent {
u8_t name[SPIFFS_OBJ_NAME_LEN]; u8_t name[SPIFFS_OBJ_NAME_LEN];
spiffs_obj_type type; spiffs_obj_type type;
u32_t size; u32_t size;
spiffs_page_ix pix;
}; };
typedef struct { typedef struct {
@ -265,7 +267,7 @@ void SPIFFS_unmount(spiffs *fs);
* @param path the path of the new file * @param path the path of the new file
* @param mode ignored, for posix compliance * @param mode ignored, for posix compliance
*/ */
s32_t SPIFFS_creat(spiffs *fs, const char *path, spiffs_mode mode); s32_t SPIFFS_creat(spiffs *fs, char *path, spiffs_mode mode);
/** /**
* Opens/creates a file. * Opens/creates a file.
@ -276,7 +278,23 @@ s32_t SPIFFS_creat(spiffs *fs, const char *path, spiffs_mode mode);
* SPIFFS_WR_ONLY, SPIFFS_RDWR, SPIFFS_DIRECT * SPIFFS_WR_ONLY, SPIFFS_RDWR, SPIFFS_DIRECT
* @param mode ignored, for posix compliance * @param mode ignored, for posix compliance
*/ */
spiffs_file SPIFFS_open(spiffs *fs, const char *path, spiffs_flags flags, spiffs_mode mode); spiffs_file SPIFFS_open(spiffs *fs, char *path, spiffs_flags flags, spiffs_mode mode);
/**
* Opens a file by given dir entry.
* Optimization purposes, when traversing a file system with SPIFFS_readdir
* a normal SPIFFS_open would need to traverse the filesystem again to find
* the file, whilst SPIFFS_open_by_dirent already knows where the file resides.
* @param fs the file system struct
* @param path the dir entry to the file
* @param flags the flags for the open command, can be combinations of
* SPIFFS_APPEND, SPIFFS_TRUNC, SPIFFS_CREAT, SPIFFS_RD_ONLY,
* SPIFFS_WR_ONLY, SPIFFS_RDWR, SPIFFS_DIRECT.
* SPIFFS_CREAT will have no effect in this case.
* @param mode ignored, for posix compliance
*/
spiffs_file SPIFFS_open_by_dirent(spiffs *fs, struct spiffs_dirent *e, spiffs_flags flags, spiffs_mode mode);
/** /**
* Reads from given filehandle. * Reads from given filehandle.
@ -314,7 +332,7 @@ s32_t SPIFFS_lseek(spiffs *fs, spiffs_file fh, s32_t offs, int whence);
* @param fs the file system struct * @param fs the file system struct
* @param path the path of the file to remove * @param path the path of the file to remove
*/ */
s32_t SPIFFS_remove(spiffs *fs, const char *path); s32_t SPIFFS_remove(spiffs *fs, char *path);
/** /**
* Removes a file by filehandle * Removes a file by filehandle
@ -329,7 +347,7 @@ s32_t SPIFFS_fremove(spiffs *fs, spiffs_file fh);
* @param path the path of the file to stat * @param path the path of the file to stat
* @param s the stat struct to populate * @param s the stat struct to populate
*/ */
s32_t SPIFFS_stat(spiffs *fs, const char *path, spiffs_stat *s); s32_t SPIFFS_stat(spiffs *fs, char *path, spiffs_stat *s);
/** /**
* Gets file status by filehandle * Gets file status by filehandle
@ -353,6 +371,14 @@ s32_t SPIFFS_fflush(spiffs *fs, spiffs_file fh);
*/ */
void SPIFFS_close(spiffs *fs, spiffs_file fh); void SPIFFS_close(spiffs *fs, spiffs_file fh);
/**
* Renames a file
* @param fs the file system struct
* @param old path of file to rename
* @param new new path of file
*/
s32_t SPIFFS_rename(spiffs *fs, char *old, char *new);
/** /**
* Returns last error of last file operation. * Returns last error of last file operation.
* @param fs the file system struct * @param fs the file system struct
@ -368,7 +394,7 @@ s32_t SPIFFS_errno(spiffs *fs);
* @param name the name of the directory * @param name the name of the directory
* @param d pointer the directory stream to be populated * @param d pointer the directory stream to be populated
*/ */
spiffs_DIR *SPIFFS_opendir(spiffs *fs, const char *name, spiffs_DIR *d); spiffs_DIR *SPIFFS_opendir(spiffs *fs, char *name, spiffs_DIR *d);
/** /**
* Closes a directory stream * Closes a directory stream
@ -438,5 +464,6 @@ int myspiffs_flush( int fd );
int myspiffs_error( int fd ); int myspiffs_error( int fd );
void myspiffs_clearerr( int fd ); void myspiffs_clearerr( int fd );
int myspiffs_check( void ); int myspiffs_check( void );
int myspiffs_rename( const char *old, const char *newname );
#endif /* SPIFFS_H_ */ #endif /* SPIFFS_H_ */

6
app/spiffs/spiffs_cache.c
View File

@ -124,6 +124,7 @@ s32_t spiffs_phys_rd(
u32_t addr, u32_t addr,
u32_t len, u32_t len,
u8_t *dst) { u8_t *dst) {
(void)fh;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
spiffs_cache *cache = spiffs_get_cache(fs); spiffs_cache *cache = spiffs_get_cache(fs);
spiffs_cache_page *cp = spiffs_cache_page_get(fs, SPIFFS_PADDR_TO_PAGE(fs, addr)); spiffs_cache_page *cp = spiffs_cache_page_get(fs, SPIFFS_PADDR_TO_PAGE(fs, addr));
@ -172,6 +173,7 @@ s32_t spiffs_phys_wr(
u32_t addr, u32_t addr,
u32_t len, u32_t len,
u8_t *src) { u8_t *src) {
(void)fh;
spiffs_page_ix pix = SPIFFS_PADDR_TO_PAGE(fs, addr); spiffs_page_ix pix = SPIFFS_PADDR_TO_PAGE(fs, addr);
spiffs_cache *cache = spiffs_get_cache(fs); spiffs_cache *cache = spiffs_get_cache(fs);
spiffs_cache_page *cp = spiffs_cache_page_get(fs, pix); spiffs_cache_page *cp = spiffs_cache_page_get(fs, pix);
@ -249,7 +251,7 @@ spiffs_cache_page *spiffs_cache_page_allocate_by_fd(spiffs *fs, spiffs_fd *fd) {
// unrefers all fds that this cache page refers to and releases the cache page // unrefers all fds that this cache page refers to and releases the cache page
void spiffs_cache_fd_release(spiffs *fs, spiffs_cache_page *cp) { void spiffs_cache_fd_release(spiffs *fs, spiffs_cache_page *cp) {
if (cp == 0) return; if (cp == 0) return;
int i; u32_t i;
spiffs_fd *fds = (spiffs_fd *)fs->fd_space; spiffs_fd *fds = (spiffs_fd *)fs->fd_space;
for (i = 0; i < fs->fd_count; i++) { for (i = 0; i < fs->fd_count; i++) {
spiffs_fd *cur_fd = &fds[i]; spiffs_fd *cur_fd = &fds[i];
@ -282,7 +284,7 @@ void spiffs_cache_init(spiffs *fs) {
spiffs_cache cache; spiffs_cache cache;
c_memset(&cache, 0, sizeof(spiffs_cache)); c_memset(&cache, 0, sizeof(spiffs_cache));
cache.cpage_count = cache_entries; cache.cpage_count = cache_entries;
cache.cpages = (u8_t *)(fs->cache) + sizeof(spiffs_cache); cache.cpages = (u8_t *)((u8_t *)fs->cache + sizeof(spiffs_cache));
cache.cpage_use_map = 0xffffffff; cache.cpage_use_map = 0xffffffff;
cache.cpage_use_mask = cache_mask; cache.cpage_use_mask = cache_mask;

26
app/spiffs/spiffs_check.c
View File

@ -156,6 +156,8 @@ static s32_t spiffs_delete_obj_lazy(spiffs *fs, spiffs_obj_id obj_id) {
// validates the given look up entry // validates the given look up entry
static s32_t spiffs_lookup_check_validate(spiffs *fs, spiffs_obj_id lu_obj_id, spiffs_page_header *p_hdr, static s32_t spiffs_lookup_check_validate(spiffs *fs, spiffs_obj_id lu_obj_id, spiffs_page_header *p_hdr,
spiffs_page_ix cur_pix, spiffs_block_ix cur_block, int cur_entry, int *reload_lu) { spiffs_page_ix cur_pix, spiffs_block_ix cur_block, int cur_entry, int *reload_lu) {
(void)cur_block;
(void)cur_entry;
u8_t delete_page = 0; u8_t delete_page = 0;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
spiffs_page_ix objix_pix; spiffs_page_ix objix_pix;
@ -327,7 +329,7 @@ static s32_t spiffs_lookup_check_validate(spiffs *fs, spiffs_obj_id lu_obj_id, s
} else if (((lu_obj_id & SPIFFS_OBJ_ID_IX_FLAG) && (p_hdr->flags & SPIFFS_PH_FLAG_INDEX)) || } else if (((lu_obj_id & SPIFFS_OBJ_ID_IX_FLAG) && (p_hdr->flags & SPIFFS_PH_FLAG_INDEX)) ||
((lu_obj_id & SPIFFS_OBJ_ID_IX_FLAG) == 0 && (p_hdr->flags & SPIFFS_PH_FLAG_INDEX) == 0)) { ((lu_obj_id & SPIFFS_OBJ_ID_IX_FLAG) == 0 && (p_hdr->flags & SPIFFS_PH_FLAG_INDEX) == 0)) {
SPIFFS_CHECK_DBG("LU: %04x lu/page index marking differ\n", cur_pix); SPIFFS_CHECK_DBG("LU: %04x lu/page index marking differ\n", cur_pix);
spiffs_page_ix data_pix, objix_pix; spiffs_page_ix data_pix, objix_pix_d;
// see if other data page exists for given obj id and span index // see if other data page exists for given obj id and span index
res = spiffs_obj_lu_find_id_and_span(fs, lu_obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, p_hdr->span_ix, cur_pix, &data_pix); res = spiffs_obj_lu_find_id_and_span(fs, lu_obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, p_hdr->span_ix, cur_pix, &data_pix);
if (res == SPIFFS_ERR_NOT_FOUND) { if (res == SPIFFS_ERR_NOT_FOUND) {
@ -336,20 +338,20 @@ static s32_t spiffs_lookup_check_validate(spiffs *fs, spiffs_obj_id lu_obj_id, s
} }
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
// see if other object index exists for given obj id and span index // see if other object index exists for given obj id and span index
res = spiffs_obj_lu_find_id_and_span(fs, lu_obj_id | SPIFFS_OBJ_ID_IX_FLAG, p_hdr->span_ix, cur_pix, &objix_pix); res = spiffs_obj_lu_find_id_and_span(fs, lu_obj_id | SPIFFS_OBJ_ID_IX_FLAG, p_hdr->span_ix, cur_pix, &objix_pix_d);
if (res == SPIFFS_ERR_NOT_FOUND) { if (res == SPIFFS_ERR_NOT_FOUND) {
res = SPIFFS_OK; res = SPIFFS_OK;
objix_pix = 0; objix_pix_d = 0;
} }
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
delete_page = 1; delete_page = 1;
// if other data page exists and object index exists, just delete page // if other data page exists and object index exists, just delete page
if (data_pix && objix_pix) { if (data_pix && objix_pix_d) {
SPIFFS_CHECK_DBG("LU: FIXUP: other index and data page exists, simply remove\n"); SPIFFS_CHECK_DBG("LU: FIXUP: other index and data page exists, simply remove\n");
} else } else
// if only data page exists, make this page index // if only data page exists, make this page index
if (data_pix && objix_pix == 0) { if (data_pix && objix_pix_d == 0) {
SPIFFS_CHECK_DBG("LU: FIXUP: other data page exists, make this index\n"); SPIFFS_CHECK_DBG("LU: FIXUP: other data page exists, make this index\n");
if (fs->check_cb_f) fs->check_cb_f(SPIFFS_CHECK_LOOKUP, SPIFFS_CHECK_FIX_INDEX, lu_obj_id, p_hdr->span_ix); if (fs->check_cb_f) fs->check_cb_f(SPIFFS_CHECK_LOOKUP, SPIFFS_CHECK_FIX_INDEX, lu_obj_id, p_hdr->span_ix);
spiffs_page_header new_ph; spiffs_page_header new_ph;
@ -365,7 +367,7 @@ static s32_t spiffs_lookup_check_validate(spiffs *fs, spiffs_obj_id lu_obj_id, s
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
} else } else
// if only index exists, make data page // if only index exists, make data page
if (data_pix == 0 && objix_pix) { if (data_pix == 0 && objix_pix_d) {
SPIFFS_CHECK_DBG("LU: FIXUP: other index page exists, make this data\n"); SPIFFS_CHECK_DBG("LU: FIXUP: other index page exists, make this data\n");
if (fs->check_cb_f) fs->check_cb_f(SPIFFS_CHECK_LOOKUP, SPIFFS_CHECK_FIX_LOOKUP, lu_obj_id, p_hdr->span_ix); if (fs->check_cb_f) fs->check_cb_f(SPIFFS_CHECK_LOOKUP, SPIFFS_CHECK_FIX_LOOKUP, lu_obj_id, p_hdr->span_ix);
spiffs_page_header new_ph; spiffs_page_header new_ph;
@ -426,6 +428,8 @@ static s32_t spiffs_lookup_check_validate(spiffs *fs, spiffs_obj_id lu_obj_id, s
static s32_t spiffs_lookup_check_v(spiffs *fs, spiffs_obj_id obj_id, spiffs_block_ix cur_block, int cur_entry, static s32_t spiffs_lookup_check_v(spiffs *fs, spiffs_obj_id obj_id, spiffs_block_ix cur_block, int cur_entry,
u32_t user_data, void *user_p) { u32_t user_data, void *user_p) {
(void)user_data;
(void)user_p;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
spiffs_page_header p_hdr; spiffs_page_header p_hdr;
spiffs_page_ix cur_pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, cur_block, cur_entry); spiffs_page_ix cur_pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, cur_block, cur_entry);
@ -453,6 +457,7 @@ static s32_t spiffs_lookup_check_v(spiffs *fs, spiffs_obj_id obj_id, spiffs_bloc
// Scans all object look up. For each entry, corresponding page header is checked for validity. // Scans all object look up. For each entry, corresponding page header is checked for validity.
// If an object index header page is found, this is also checked // If an object index header page is found, this is also checked
s32_t spiffs_lookup_consistency_check(spiffs *fs, u8_t check_all_objects) { s32_t spiffs_lookup_consistency_check(spiffs *fs, u8_t check_all_objects) {
(void)check_all_objects;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
if (fs->check_cb_f) fs->check_cb_f(SPIFFS_CHECK_LOOKUP, SPIFFS_CHECK_PROGRESS, 0, 0); if (fs->check_cb_f) fs->check_cb_f(SPIFFS_CHECK_LOOKUP, SPIFFS_CHECK_PROGRESS, 0, 0);
@ -689,8 +694,8 @@ static s32_t spiffs_page_consistency_check_i(spiffs *fs) {
spiffs_page_ix objix_pix; spiffs_page_ix objix_pix;
spiffs_page_ix rpix; spiffs_page_ix rpix;
int byte_ix; u32_t byte_ix;
int bit_ix; u8_t bit_ix;
for (byte_ix = 0; !restart && byte_ix < SPIFFS_CFG_LOG_PAGE_SZ(fs); byte_ix++) { for (byte_ix = 0; !restart && byte_ix < SPIFFS_CFG_LOG_PAGE_SZ(fs); byte_ix++) {
for (bit_ix = 0; !restart && bit_ix < 8/bits; bit_ix ++) { for (bit_ix = 0; !restart && bit_ix < 8/bits; bit_ix ++) {
u8_t bitmask = (fs->work[byte_ix] >> (bit_ix * bits)) & 0x7; u8_t bitmask = (fs->work[byte_ix] >> (bit_ix * bits)) & 0x7;
@ -838,7 +843,7 @@ s32_t spiffs_page_consistency_check(spiffs *fs) {
// searches for given object id in temporary object id index, // searches for given object id in temporary object id index,
// returns the index or -1 // returns the index or -1
static int spiffs_object_index_search(spiffs *fs, spiffs_obj_id obj_id) { static int spiffs_object_index_search(spiffs *fs, spiffs_obj_id obj_id) {
int i; u32_t i;
spiffs_obj_id *obj_table = (spiffs_obj_id *)fs->work; spiffs_obj_id *obj_table = (spiffs_obj_id *)fs->work;
obj_id &= ~SPIFFS_OBJ_ID_IX_FLAG; obj_id &= ~SPIFFS_OBJ_ID_IX_FLAG;
for (i = 0; i < SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id); i++) { for (i = 0; i < SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id); i++) {
@ -849,8 +854,9 @@ static int spiffs_object_index_search(spiffs *fs, spiffs_obj_id obj_id) {
return -1; return -1;
} }
s32_t spiffs_object_index_consistency_check_v(spiffs *fs, spiffs_obj_id obj_id, spiffs_block_ix cur_block, static s32_t spiffs_object_index_consistency_check_v(spiffs *fs, spiffs_obj_id obj_id, spiffs_block_ix cur_block,
int cur_entry, u32_t user_data, void *user_p) { int cur_entry, u32_t user_data, void *user_p) {
(void)user_data;
s32_t res_c = SPIFFS_VIS_COUNTINUE; s32_t res_c = SPIFFS_VIS_COUNTINUE;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
u32_t *log_ix = (u32_t *)user_p; u32_t *log_ix = (u32_t *)user_p;

34
app/spiffs/spiffs_gc.c
View File

@ -35,7 +35,7 @@ static s32_t spiffs_gc_erase_block(
#if SPIFFS_CACHE #if SPIFFS_CACHE
{ {
int i; u32_t i;
for (i = 0; i < SPIFFS_PAGES_PER_BLOCK(fs); i++) { for (i = 0; i < SPIFFS_PAGES_PER_BLOCK(fs); i++) {
spiffs_cache_drop_page(fs, SPIFFS_PAGE_FOR_BLOCK(fs, bix) + i); spiffs_cache_drop_page(fs, SPIFFS_PAGE_FOR_BLOCK(fs, bix) + i);
} }
@ -61,7 +61,7 @@ s32_t spiffs_gc_quick(
fs->stats_gc_runs++; fs->stats_gc_runs++;
#endif #endif
u32_t entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id)); int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id));
// find fully deleted blocks // find fully deleted blocks
// check each block // check each block
@ -70,29 +70,33 @@ s32_t spiffs_gc_quick(
int obj_lookup_page = 0; int obj_lookup_page = 0;
// check each object lookup page // check each object lookup page
while (res == SPIFFS_OK && obj_lookup_page < SPIFFS_OBJ_LOOKUP_PAGES(fs)) { while (res == SPIFFS_OK && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, cur_block_addr + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); 0, cur_block_addr + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
// check each entry // check each entry
while (res == SPIFFS_OK && while (res == SPIFFS_OK &&
cur_entry - entry_offset < entries_per_page && cur_entry < SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) { cur_entry - entry_offset < entries_per_page &&
cur_entry < (int)(SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs))) {
spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset]; spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset];
if (obj_id == SPIFFS_OBJ_ID_DELETED) { if (obj_id == SPIFFS_OBJ_ID_DELETED) {
deleted_pages_in_block++; deleted_pages_in_block++;
} else if (obj_id == SPIFFS_OBJ_ID_FREE) { } else if (obj_id == SPIFFS_OBJ_ID_FREE) {
// kill scan, go for next block // kill scan, go for next block
obj_lookup_page = SPIFFS_OBJ_LOOKUP_PAGES(fs); obj_lookup_page = SPIFFS_OBJ_LOOKUP_PAGES(fs);
res = 1; // kill object lu loop
break; break;
} else { } else {
// kill scan, go for next block // kill scan, go for next block
obj_lookup_page = SPIFFS_OBJ_LOOKUP_PAGES(fs); obj_lookup_page = SPIFFS_OBJ_LOOKUP_PAGES(fs);
res = 1; // kill object lu loop
break; break;
} }
cur_entry++; cur_entry++;
} // per entry } // per entry
obj_lookup_page++; obj_lookup_page++;
} // per object lookup page } // per object lookup page
if (res == 1) res = SPIFFS_OK;
if (res == SPIFFS_OK && deleted_pages_in_block == SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) { if (res == SPIFFS_OK && deleted_pages_in_block == SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
// found a fully deleted block // found a fully deleted block
@ -184,20 +188,20 @@ s32_t spiffs_gc_erase_page_stats(
spiffs_block_ix bix) { spiffs_block_ix bix) {
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
int obj_lookup_page = 0; int obj_lookup_page = 0;
u32_t entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id)); int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id));
spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work; spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work;
int cur_entry = 0; int cur_entry = 0;
u32_t dele = 0; u32_t dele = 0;
u32_t allo = 0; u32_t allo = 0;
// check each object lookup page // check each object lookup page
while (res == SPIFFS_OK && obj_lookup_page < SPIFFS_OBJ_LOOKUP_PAGES(fs)) { while (res == SPIFFS_OK && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, bix * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); 0, bix * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
// check each entry // check each entry
while (res == SPIFFS_OK && while (res == SPIFFS_OK &&
cur_entry - entry_offset < entries_per_page && cur_entry < SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) { cur_entry - entry_offset < entries_per_page && cur_entry < (int)(SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs))) {
spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset]; spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset];
if (obj_id == SPIFFS_OBJ_ID_FREE) { if (obj_id == SPIFFS_OBJ_ID_FREE) {
} else if (obj_id == SPIFFS_OBJ_ID_DELETED) { } else if (obj_id == SPIFFS_OBJ_ID_DELETED) {
@ -239,7 +243,7 @@ s32_t spiffs_gc_find_candidate(
*block_candidates = cand_blocks; *block_candidates = cand_blocks;
u32_t entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id)); int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id));
// check each block // check each block
while (res == SPIFFS_OK && blocks--) { while (res == SPIFFS_OK && blocks--) {
@ -248,16 +252,18 @@ s32_t spiffs_gc_find_candidate(
int obj_lookup_page = 0; int obj_lookup_page = 0;
// check each object lookup page // check each object lookup page
while (res == SPIFFS_OK && obj_lookup_page < SPIFFS_OBJ_LOOKUP_PAGES(fs)) { while (res == SPIFFS_OK && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, cur_block_addr + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); 0, cur_block_addr + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
// check each entry // check each entry
while (res == SPIFFS_OK && while (res == SPIFFS_OK &&
cur_entry - entry_offset < entries_per_page && cur_entry < SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) { cur_entry - entry_offset < entries_per_page &&
cur_entry < (int)(SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs))) {
spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset]; spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset];
if (obj_id == SPIFFS_OBJ_ID_FREE) { if (obj_id == SPIFFS_OBJ_ID_FREE) {
// when a free entry is encountered, scan logic ensures that all following entries are free also // when a free entry is encountered, scan logic ensures that all following entries are free also
res = 1; // kill object lu loop
break; break;
} else if (obj_id == SPIFFS_OBJ_ID_DELETED) { } else if (obj_id == SPIFFS_OBJ_ID_DELETED) {
deleted_pages_in_block++; deleted_pages_in_block++;
@ -268,6 +274,7 @@ s32_t spiffs_gc_find_candidate(
} // per entry } // per entry
obj_lookup_page++; obj_lookup_page++;
} // per object lookup page } // per object lookup page
if (res == 1) res = SPIFFS_OK;
// calculate score and insert into candidate table // calculate score and insert into candidate table
// stoneage sort, but probably not so many blocks // stoneage sort, but probably not so many blocks
@ -352,7 +359,7 @@ typedef struct {
// //
s32_t spiffs_gc_clean(spiffs *fs, spiffs_block_ix bix) { s32_t spiffs_gc_clean(spiffs *fs, spiffs_block_ix bix) {
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
u32_t entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id)); int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id));
int cur_entry = 0; int cur_entry = 0;
spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work; spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work;
spiffs_gc gc; spiffs_gc gc;
@ -380,14 +387,14 @@ s32_t spiffs_gc_clean(spiffs *fs, spiffs_block_ix bix) {
int obj_lookup_page = cur_entry / entries_per_page; int obj_lookup_page = cur_entry / entries_per_page;
u8_t scan = 1; u8_t scan = 1;
// check each object lookup page // check each object lookup page
while (scan && res == SPIFFS_OK && obj_lookup_page < SPIFFS_OBJ_LOOKUP_PAGES(fs)) { while (scan && res == SPIFFS_OK && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, bix * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), 0, bix * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
// check each entry // check each entry
while (scan && res == SPIFFS_OK && while (scan && res == SPIFFS_OK &&
cur_entry - entry_offset < entries_per_page && cur_entry < SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) { cur_entry - entry_offset < entries_per_page && cur_entry < (int)(SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs))) {
spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset]; spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset];
cur_pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, bix, cur_entry); cur_pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, bix, cur_entry);
@ -526,7 +533,6 @@ s32_t spiffs_gc_clean(spiffs *fs, spiffs_block_ix bix) {
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
} else { } else {
// store object index page // store object index page
spiffs_page_ix new_objix_pix;
res = spiffs_page_move(fs, 0, fs->work, gc.cur_obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, gc.cur_objix_pix, &new_objix_pix); res = spiffs_page_move(fs, 0, fs->work, gc.cur_obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, gc.cur_objix_pix, &new_objix_pix);
SPIFFS_GC_DBG("gc_clean: MOVE_DATA store modified objix page, %04x:%04x\n", new_objix_pix, objix->p_hdr.span_ix); SPIFFS_GC_DBG("gc_clean: MOVE_DATA store modified objix page, %04x:%04x\n", new_objix_pix, objix->p_hdr.span_ix);
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);

127
app/spiffs/spiffs_hydrogen.c
View File

@ -51,7 +51,9 @@ s32_t SPIFFS_mount(spiffs *fs, spiffs_config *config, u8_t *work,
addr_lsb = (u8_t)(((u32_t)cache) & (ptr_size-1)); addr_lsb = (u8_t)(((u32_t)cache) & (ptr_size-1));
// #pragma GCC diagnostic pop // #pragma GCC diagnostic pop
if (addr_lsb) { if (addr_lsb) {
cache = (u8_t *)cache + (ptr_size-addr_lsb); u8_t *cache_8 = (u8_t *)cache;
cache_8 += (ptr_size-addr_lsb);
cache = cache_8;
cache_size -= (ptr_size-addr_lsb); cache_size -= (ptr_size-addr_lsb);
} }
if (cache_size & (ptr_size-1)) { if (cache_size & (ptr_size-1)) {
@ -85,7 +87,7 @@ s32_t SPIFFS_mount(spiffs *fs, spiffs_config *config, u8_t *work,
void SPIFFS_unmount(spiffs *fs) { void SPIFFS_unmount(spiffs *fs) {
if (!SPIFFS_CHECK_MOUNT(fs)) return; if (!SPIFFS_CHECK_MOUNT(fs)) return;
SPIFFS_LOCK(fs); SPIFFS_LOCK(fs);
int i; u32_t i;
spiffs_fd *fds = (spiffs_fd *)fs->fd_space; spiffs_fd *fds = (spiffs_fd *)fs->fd_space;
for (i = 0; i < fs->fd_count; i++) { for (i = 0; i < fs->fd_count; i++) {
spiffs_fd *cur_fd = &fds[i]; spiffs_fd *cur_fd = &fds[i];
@ -104,21 +106,23 @@ s32_t SPIFFS_errno(spiffs *fs) {
return fs->errno; return fs->errno;
} }
s32_t SPIFFS_creat(spiffs *fs, const char *path, spiffs_mode mode) { s32_t SPIFFS_creat(spiffs *fs, char *path, spiffs_mode mode) {
(void)mode;
SPIFFS_API_CHECK_MOUNT(fs); SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs); SPIFFS_LOCK(fs);
spiffs_obj_id obj_id; spiffs_obj_id obj_id;
s32_t res; s32_t res;
res = spiffs_obj_lu_find_free_obj_id(fs, &obj_id); res = spiffs_obj_lu_find_free_obj_id(fs, &obj_id, (u8_t *)path);
SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_object_create(fs, obj_id, (u8_t*)path, SPIFFS_TYPE_FILE, 0); res = spiffs_object_create(fs, obj_id, (u8_t *)path, SPIFFS_TYPE_FILE, 0);
SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
SPIFFS_UNLOCK(fs); SPIFFS_UNLOCK(fs);
return 0; return 0;
} }
spiffs_file SPIFFS_open(spiffs *fs, const char *path, spiffs_flags flags, spiffs_mode mode) { spiffs_file SPIFFS_open(spiffs *fs, char *path, spiffs_flags flags, spiffs_mode mode) {
(void)mode;
SPIFFS_API_CHECK_MOUNT(fs); SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs); SPIFFS_LOCK(fs);
@ -138,7 +142,8 @@ spiffs_file SPIFFS_open(spiffs *fs, const char *path, spiffs_flags flags, spiffs
if ((flags & SPIFFS_CREAT) && res == SPIFFS_ERR_NOT_FOUND) { if ((flags & SPIFFS_CREAT) && res == SPIFFS_ERR_NOT_FOUND) {
spiffs_obj_id obj_id; spiffs_obj_id obj_id;
res = spiffs_obj_lu_find_free_obj_id(fs, &obj_id); // no need to enter conflicting name here, already looked for it above
res = spiffs_obj_lu_find_free_obj_id(fs, &obj_id, 0);
if (res < SPIFFS_OK) { if (res < SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr); spiffs_fd_return(fs, fd->file_nbr);
} }
@ -155,7 +160,36 @@ spiffs_file SPIFFS_open(spiffs *fs, const char *path, spiffs_flags flags, spiffs
} }
SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
} }
res = spiffs_object_open_by_page(fs, pix, fd, flags, flags); res = spiffs_object_open_by_page(fs, pix, fd, flags, mode);
if (res < SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr);
}
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
if (flags & SPIFFS_TRUNC) {
res = spiffs_object_truncate(fd, 0, 0);
if (res < SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr);
}
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
}
fd->fdoffset = 0;
SPIFFS_UNLOCK(fs);
return fd->file_nbr;
}
spiffs_file SPIFFS_open_by_dirent(spiffs *fs, struct spiffs_dirent *e, spiffs_flags flags, spiffs_mode mode) {
SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs);
spiffs_fd *fd;
s32_t res = spiffs_fd_find_new(fs, &fd);
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_object_open_by_page(fs, e->pix, fd, flags, mode);
if (res < SPIFFS_OK) { if (res < SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr); spiffs_fd_return(fs, fd->file_nbr);
} }
@ -201,12 +235,13 @@ s32_t SPIFFS_read(spiffs *fs, spiffs_file fh, void *buf, u32_t len) {
SPIFFS_API_CHECK_RES_UNLOCK(fs, SPIFFS_ERR_END_OF_OBJECT); SPIFFS_API_CHECK_RES_UNLOCK(fs, SPIFFS_ERR_END_OF_OBJECT);
} }
res = spiffs_object_read(fd, fd->fdoffset, avail, (u8_t*)buf); res = spiffs_object_read(fd, fd->fdoffset, avail, (u8_t*)buf);
if (res == SPIFFS_OK) { if (res == SPIFFS_ERR_END_OF_OBJECT) {
fd->fdoffset += avail; fd->fdoffset += avail;
SPIFFS_UNLOCK(fs); SPIFFS_UNLOCK(fs);
return avail; return avail;
} else { } else {
SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
len = avail;
} }
} else { } else {
// reading within file size // reading within file size
@ -221,14 +256,17 @@ s32_t SPIFFS_read(spiffs *fs, spiffs_file fh, void *buf, u32_t len) {
} }
static s32_t spiffs_hydro_write(spiffs *fs, spiffs_fd *fd, void *buf, u32_t offset, s32_t len) { static s32_t spiffs_hydro_write(spiffs *fs, spiffs_fd *fd, void *buf, u32_t offset, s32_t len) {
(void)fs;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
s32_t remaining = len; s32_t remaining = len;
if (fd->size != SPIFFS_UNDEFINED_LEN && offset < fd->size) { if (fd->size != SPIFFS_UNDEFINED_LEN && offset < fd->size) {
s32_t m_len = MIN(fd->size - offset, len); s32_t m_len = MIN((s32_t)(fd->size - offset), len);
res = spiffs_object_modify(fd, offset, (u8_t *)buf, m_len); res = spiffs_object_modify(fd, offset, (u8_t *)buf, m_len);
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
remaining -= m_len; remaining -= m_len;
buf = (u8_t *)buf + m_len; u8_t *buf_8 = (u8_t *)buf;
buf_8 += m_len;
buf = buf_8;
offset += m_len; offset += m_len;
} }
if (remaining > 0) { if (remaining > 0) {
@ -280,7 +318,7 @@ s32_t SPIFFS_write(spiffs *fs, spiffs_file fh, void *buf, u32_t len) {
#if SPIFFS_CACHE_WR #if SPIFFS_CACHE_WR
if ((fd->flags & SPIFFS_DIRECT) == 0) { if ((fd->flags & SPIFFS_DIRECT) == 0) {
if (len < SPIFFS_CFG_LOG_PAGE_SZ(fs)) { if (len < (s32_t)SPIFFS_CFG_LOG_PAGE_SZ(fs)) {
// small write, try to cache it // small write, try to cache it
u8_t alloc_cpage = 1; u8_t alloc_cpage = 1;
if (fd->cache_page) { if (fd->cache_page) {
@ -379,7 +417,7 @@ s32_t SPIFFS_lseek(spiffs *fs, spiffs_file fh, s32_t offs, int whence) {
break; break;
} }
if (offs > fd->size) { if (offs > (s32_t)fd->size) {
res = SPIFFS_ERR_END_OF_OBJECT; res = SPIFFS_ERR_END_OF_OBJECT;
} }
SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
@ -401,7 +439,7 @@ s32_t SPIFFS_lseek(spiffs *fs, spiffs_file fh, s32_t offs, int whence) {
return 0; return 0;
} }
s32_t SPIFFS_remove(spiffs *fs, const char *path) { s32_t SPIFFS_remove(spiffs *fs, char *path) {
SPIFFS_API_CHECK_MOUNT(fs); SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs); SPIFFS_LOCK(fs);
@ -412,7 +450,7 @@ s32_t SPIFFS_remove(spiffs *fs, const char *path) {
res = spiffs_fd_find_new(fs, &fd); res = spiffs_fd_find_new(fs, &fd);
SPIFFS_API_CHECK_RES_UNLOCK(fs, res); SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_object_find_object_index_header_by_name(fs, (u8_t*)path, &pix); res = spiffs_object_find_object_index_header_by_name(fs, (u8_t *)path, &pix);
if (res != SPIFFS_OK) { if (res != SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr); spiffs_fd_return(fs, fd->file_nbr);
} }
@ -482,7 +520,7 @@ static s32_t spiffs_stat_pix(spiffs *fs, spiffs_page_ix pix, spiffs_file fh, spi
return res; return res;
} }
s32_t SPIFFS_stat(spiffs *fs, const char *path, spiffs_stat *s) { s32_t SPIFFS_stat(spiffs *fs, char *path, spiffs_stat *s) {
SPIFFS_API_CHECK_MOUNT(fs); SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs); SPIFFS_LOCK(fs);
@ -580,7 +618,48 @@ void SPIFFS_close(spiffs *fs, spiffs_file fh) {
SPIFFS_UNLOCK(fs); SPIFFS_UNLOCK(fs);
} }
spiffs_DIR *SPIFFS_opendir(spiffs *fs, const char *name, spiffs_DIR *d) { s32_t SPIFFS_rename(spiffs *fs, char *old, char *new) {
SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs);
spiffs_page_ix pix_old, pix_dummy;
spiffs_fd *fd;
s32_t res = spiffs_object_find_object_index_header_by_name(fs, (u8_t*)old, &pix_old);
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_object_find_object_index_header_by_name(fs, (u8_t*)new, &pix_dummy);
if (res == SPIFFS_ERR_NOT_FOUND) {
res = SPIFFS_OK;
} else if (res == SPIFFS_OK) {
res = SPIFFS_ERR_CONFLICTING_NAME;
}
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_fd_find_new(fs, &fd);
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_object_open_by_page(fs, pix_old, fd, 0, 0);
if (res != SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr);
}
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
res = spiffs_object_update_index_hdr(fs, fd, fd->obj_id, fd->objix_hdr_pix, 0, (u8_t*)new,
0, &pix_dummy);
if (res != SPIFFS_OK) {
spiffs_fd_return(fs, fd->file_nbr);
}
SPIFFS_API_CHECK_RES_UNLOCK(fs, res);
SPIFFS_UNLOCK(fs);
return res;
}
spiffs_DIR *SPIFFS_opendir(spiffs *fs, char *name, spiffs_DIR *d) {
(void)name;
if (!SPIFFS_CHECK_MOUNT(fs)) { if (!SPIFFS_CHECK_MOUNT(fs)) {
fs->errno = SPIFFS_ERR_NOT_MOUNTED; fs->errno = SPIFFS_ERR_NOT_MOUNTED;
return 0; return 0;
@ -598,6 +677,7 @@ static s32_t spiffs_read_dir_v(
int ix_entry, int ix_entry,
u32_t user_data, u32_t user_data,
void *user_p) { void *user_p) {
(void)user_data;
s32_t res; s32_t res;
spiffs_page_object_ix_header objix_hdr; spiffs_page_object_ix_header objix_hdr;
if (obj_id == SPIFFS_OBJ_ID_FREE || obj_id == SPIFFS_OBJ_ID_DELETED || if (obj_id == SPIFFS_OBJ_ID_FREE || obj_id == SPIFFS_OBJ_ID_DELETED ||
@ -618,6 +698,7 @@ static s32_t spiffs_read_dir_v(
strcpy((char *)e->name, (char *)objix_hdr.name); strcpy((char *)e->name, (char *)objix_hdr.name);
e->type = objix_hdr.type; e->type = objix_hdr.type;
e->size = objix_hdr.size == SPIFFS_UNDEFINED_LEN ? 0 : objix_hdr.size; e->size = objix_hdr.size == SPIFFS_UNDEFINED_LEN ? 0 : objix_hdr.size;
e->pix = pix;
return SPIFFS_OK; return SPIFFS_OK;
} }
@ -670,11 +751,11 @@ s32_t SPIFFS_check(spiffs *fs) {
res = spiffs_lookup_consistency_check(fs, 0); res = spiffs_lookup_consistency_check(fs, 0);
res = spiffs_object_index_consistency_check(fs); res = spiffs_object_index_consistency_check(fs);
// NODE_ERR("before spiffs_object_index_consistency_check\n");
res = spiffs_page_consistency_check(fs); res = spiffs_page_consistency_check(fs);
// NODE_ERR("spiffs_page_consistency_check\n");
res = spiffs_obj_lu_scan(fs); res = spiffs_obj_lu_scan(fs);
// NODE_ERR("spiffs_obj_lu_scan\n");
SPIFFS_UNLOCK(fs); SPIFFS_UNLOCK(fs);
return res; return res;
} }
@ -723,7 +804,7 @@ s32_t SPIFFS_vis(spiffs *fs) {
SPIFFS_API_CHECK_MOUNT(fs); SPIFFS_API_CHECK_MOUNT(fs);
SPIFFS_LOCK(fs); SPIFFS_LOCK(fs);
u32_t entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id)); int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id));
spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work; spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work;
spiffs_block_ix bix = 0; spiffs_block_ix bix = 0;
@ -732,13 +813,13 @@ s32_t SPIFFS_vis(spiffs *fs) {
int obj_lookup_page = 0; int obj_lookup_page = 0;
int cur_entry = 0; int cur_entry = 0;
while (res == SPIFFS_OK && obj_lookup_page < SPIFFS_OBJ_LOOKUP_PAGES(fs)) { while (res == SPIFFS_OK && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, bix * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); 0, bix * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
// check each entry // check each entry
while (res == SPIFFS_OK && while (res == SPIFFS_OK &&
cur_entry - entry_offset < entries_per_page && cur_entry < SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) { cur_entry - entry_offset < entries_per_page && cur_entry < (int)(SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs))) {
spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset]; spiffs_obj_id obj_id = obj_lu_buf[cur_entry-entry_offset];
if (cur_entry == 0) { if (cur_entry == 0) {
spiffs_printf("%4i ", bix); spiffs_printf("%4i ", bix);

76
app/spiffs/spiffs_nucleus.c
View File

@ -134,10 +134,10 @@ s32_t spiffs_obj_lu_find_entry_visitor(
spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work; spiffs_obj_id *obj_lu_buf = (spiffs_obj_id *)fs->lu_work;
int cur_entry = starting_lu_entry; int cur_entry = starting_lu_entry;
u32_t entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id)); int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(spiffs_obj_id));
// wrap initial // wrap initial
if (cur_entry >= SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) - 1) { if (cur_entry >= (int)SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) - 1) {
cur_entry = 0; cur_entry = 0;
cur_block++; cur_block++;
cur_block_addr = cur_block * SPIFFS_CFG_LOG_BLOCK_SZ(fs); cur_block_addr = cur_block * SPIFFS_CFG_LOG_BLOCK_SZ(fs);
@ -152,14 +152,14 @@ s32_t spiffs_obj_lu_find_entry_visitor(
while (res == SPIFFS_OK && entry_count > 0) { while (res == SPIFFS_OK && entry_count > 0) {
int obj_lookup_page = cur_entry / entries_per_page; int obj_lookup_page = cur_entry / entries_per_page;
// check each object lookup page // check each object lookup page
while (res == SPIFFS_OK && obj_lookup_page < SPIFFS_OBJ_LOOKUP_PAGES(fs)) { while (res == SPIFFS_OK && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs)) {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, cur_block_addr + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); 0, cur_block_addr + SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
// check each entry // check each entry
while (res == SPIFFS_OK && while (res == SPIFFS_OK &&
cur_entry - entry_offset < entries_per_page && // for non-last obj lookup pages cur_entry - entry_offset < entries_per_page && // for non-last obj lookup pages
cur_entry < SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs)) // for last obj lookup page cur_entry < (int)SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs)) // for last obj lookup page
{ {
if ((flags & SPIFFS_VIS_CHECK_ID) == 0 || obj_lu_buf[cur_entry-entry_offset] == obj_id) { if ((flags & SPIFFS_VIS_CHECK_ID) == 0 || obj_lu_buf[cur_entry-entry_offset] == obj_id) {
if (block_ix) *block_ix = cur_block; if (block_ix) *block_ix = cur_block;
@ -221,6 +221,9 @@ static s32_t spiffs_obj_lu_scan_v(
int ix_entry, int ix_entry,
u32_t user_data, u32_t user_data,
void *user_p) { void *user_p) {
(void)bix;
(void)user_data;
(void)user_p;
if (obj_id == SPIFFS_OBJ_ID_FREE) { if (obj_id == SPIFFS_OBJ_ID_FREE) {
if (ix_entry == 0) { if (ix_entry == 0) {
fs->free_blocks++; fs->free_blocks++;
@ -714,9 +717,10 @@ void spiffs_cb_object_event(
spiffs_span_ix spix, spiffs_span_ix spix,
spiffs_page_ix new_pix, spiffs_page_ix new_pix,
u32_t new_size) { u32_t new_size) {
(void)fd;
// update index caches in all file descriptors // update index caches in all file descriptors
obj_id &= ~SPIFFS_OBJ_ID_IX_FLAG; obj_id &= ~SPIFFS_OBJ_ID_IX_FLAG;
int i; u32_t i;
spiffs_fd *fds = (spiffs_fd *)fs->fd_space; spiffs_fd *fds = (spiffs_fd *)fs->fd_space;
for (i = 0; i < fs->fd_count; i++) { for (i = 0; i < fs->fd_count; i++) {
spiffs_fd *cur_fd = &fds[i]; spiffs_fd *cur_fd = &fds[i];
@ -769,6 +773,7 @@ s32_t spiffs_object_open_by_page(
spiffs_fd *fd, spiffs_fd *fd,
spiffs_flags flags, spiffs_flags flags,
spiffs_mode mode) { spiffs_mode mode) {
(void)mode;
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
spiffs_page_object_ix_header oix_hdr; spiffs_page_object_ix_header oix_hdr;
spiffs_obj_id obj_id; spiffs_obj_id obj_id;
@ -1238,6 +1243,7 @@ static s32_t spiffs_object_find_object_index_header_by_name_v(
int ix_entry, int ix_entry,
u32_t user_data, u32_t user_data,
void *user_p) { void *user_p) {
(void)user_data;
s32_t res; s32_t res;
spiffs_page_object_ix_header objix_hdr; spiffs_page_object_ix_header objix_hdr;
spiffs_page_ix pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, bix, ix_entry); spiffs_page_ix pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, bix, ix_entry);
@ -1307,7 +1313,7 @@ s32_t spiffs_object_truncate(
spiffs_page_ix objix_pix = fd->objix_hdr_pix; spiffs_page_ix objix_pix = fd->objix_hdr_pix;
spiffs_span_ix data_spix = (fd->size > 0 ? fd->size-1 : 0) / SPIFFS_DATA_PAGE_SIZE(fs); spiffs_span_ix data_spix = (fd->size > 0 ? fd->size-1 : 0) / SPIFFS_DATA_PAGE_SIZE(fs);
u32_t cur_size = fd->size == SPIFFS_UNDEFINED_LEN ? 0 : fd->size ; u32_t cur_size = fd->size == (u32_t)SPIFFS_UNDEFINED_LEN ? 0 : fd->size ;
spiffs_span_ix cur_objix_spix = 0; spiffs_span_ix cur_objix_spix = 0;
spiffs_span_ix prev_objix_spix = (spiffs_span_ix)-1; spiffs_span_ix prev_objix_spix = (spiffs_span_ix)-1;
spiffs_page_object_ix_header *objix_hdr = (spiffs_page_object_ix_header *)fs->work; spiffs_page_object_ix_header *objix_hdr = (spiffs_page_object_ix_header *)fs->work;
@ -1584,16 +1590,36 @@ typedef struct {
spiffs_obj_id min_obj_id; spiffs_obj_id min_obj_id;
spiffs_obj_id max_obj_id; spiffs_obj_id max_obj_id;
u32_t compaction; u32_t compaction;
const u8_t *conflicting_name;
} spiffs_free_obj_id_state; } spiffs_free_obj_id_state;
static s32_t spiffs_obj_lu_find_free_obj_id_bitmap_v(spiffs *fs, spiffs_obj_id id, spiffs_block_ix bix, int ix_entry, static s32_t spiffs_obj_lu_find_free_obj_id_bitmap_v(spiffs *fs, spiffs_obj_id id, spiffs_block_ix bix, int ix_entry,
u32_t user_data, void *user_p) { u32_t user_data, void *user_p) {
if (id != SPIFFS_OBJ_ID_FREE && id != SPIFFS_OBJ_ID_DELETED) { if (id != SPIFFS_OBJ_ID_FREE && id != SPIFFS_OBJ_ID_DELETED) {
spiffs_obj_id min_obj_id = user_data; spiffs_obj_id min_obj_id = user_data;
u8_t *conflicting_name = (u8_t *)user_p;
// if conflicting name parameter is given, also check if this name is found in object index hdrs
if (conflicting_name && (id & SPIFFS_OBJ_ID_IX_FLAG)) {
spiffs_page_ix pix = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, bix, ix_entry);
int res;
spiffs_page_object_ix_header objix_hdr;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, pix), sizeof(spiffs_page_object_ix_header), (u8_t *)&objix_hdr);
SPIFFS_CHECK_RES(res);
if (objix_hdr.p_hdr.span_ix == 0 &&
(objix_hdr.p_hdr.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_IXDELE)) ==
(SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_IXDELE)) {
if (strcmp((char *)user_p, (char *)objix_hdr.name) == 0) {
return SPIFFS_ERR_CONFLICTING_NAME;
}
}
}
id &= ~SPIFFS_OBJ_ID_IX_FLAG; id &= ~SPIFFS_OBJ_ID_IX_FLAG;
int bit_ix = (id-min_obj_id) & 7; u32_t bit_ix = (id-min_obj_id) & 7;
int byte_ix = (id-min_obj_id) >> 3; int byte_ix = (id-min_obj_id) >> 3;
if (byte_ix >= 0 && byte_ix < SPIFFS_CFG_LOG_PAGE_SZ(fs)) { if (byte_ix >= 0 && (u32_t)byte_ix < SPIFFS_CFG_LOG_PAGE_SZ(fs)) {
fs->work[byte_ix] |= (1<<bit_ix); fs->work[byte_ix] |= (1<<bit_ix);
} }
} }
@ -1602,17 +1628,22 @@ static s32_t spiffs_obj_lu_find_free_obj_id_bitmap_v(spiffs *fs, spiffs_obj_id i
static s32_t spiffs_obj_lu_find_free_obj_id_compact_v(spiffs *fs, spiffs_obj_id id, spiffs_block_ix bix, int ix_entry, static s32_t spiffs_obj_lu_find_free_obj_id_compact_v(spiffs *fs, spiffs_obj_id id, spiffs_block_ix bix, int ix_entry,
u32_t user_data, void *user_p) { u32_t user_data, void *user_p) {
(void)user_data;
if (id != SPIFFS_OBJ_ID_FREE && id != SPIFFS_OBJ_ID_DELETED && (id & SPIFFS_OBJ_ID_IX_FLAG)) { if (id != SPIFFS_OBJ_ID_FREE && id != SPIFFS_OBJ_ID_DELETED && (id & SPIFFS_OBJ_ID_IX_FLAG)) {
s32_t res; s32_t res;
spiffs_free_obj_id_state *state = (spiffs_free_obj_id_state *)user_p; spiffs_free_obj_id_state *state = (spiffs_free_obj_id_state *)user_p;
spiffs_page_header ph; spiffs_page_object_ix_header objix_hdr;
res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ, res = _spiffs_rd(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_OBJ_LOOKUP_ENTRY_TO_PADDR(fs, bix, ix_entry), sizeof(spiffs_page_header), (u8_t*)&ph); 0, SPIFFS_OBJ_LOOKUP_ENTRY_TO_PADDR(fs, bix, ix_entry), sizeof(spiffs_page_object_ix_header), (u8_t*)&objix_hdr);
if (res == SPIFFS_OK && ph.span_ix == 0 && if (res == SPIFFS_OK && objix_hdr.p_hdr.span_ix == 0 &&
((ph.flags & (SPIFFS_PH_FLAG_INDEX | SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_DELET)) == ((objix_hdr.p_hdr.flags & (SPIFFS_PH_FLAG_INDEX | SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_DELET)) ==
(SPIFFS_PH_FLAG_DELET))) { (SPIFFS_PH_FLAG_DELET))) {
// ok object look up entry // ok object look up entry
if (state->conflicting_name && strcmp((const char *)state->conflicting_name, (char *)objix_hdr.name) == 0) {
return SPIFFS_ERR_CONFLICTING_NAME;
}
id &= ~SPIFFS_OBJ_ID_IX_FLAG; id &= ~SPIFFS_OBJ_ID_IX_FLAG;
if (id >= state->min_obj_id && id <= state->max_obj_id) { if (id >= state->min_obj_id && id <= state->max_obj_id) {
u8_t *map = (u8_t *)fs->work; u8_t *map = (u8_t *)fs->work;
@ -1629,7 +1660,7 @@ static s32_t spiffs_obj_lu_find_free_obj_id_compact_v(spiffs *fs, spiffs_obj_id
// object ids cannot fit into a work buffer, these are grouped. When a group containing free // object ids cannot fit into a work buffer, these are grouped. When a group containing free
// object ids is found, the object lu is again scanned for object ids within group and bitmasked. // object ids is found, the object lu is again scanned for object ids within group and bitmasked.
// Finally, the bitmasked is searched for a free id // Finally, the bitmasked is searched for a free id
s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id) { s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id, u8_t *conflicting_name) {
s32_t res = SPIFFS_OK; s32_t res = SPIFFS_OK;
u32_t max_objects = (SPIFFS_CFG_PHYS_SZ(fs) / (u32_t)SPIFFS_CFG_LOG_PAGE_SZ(fs)) / 2; u32_t max_objects = (SPIFFS_CFG_PHYS_SZ(fs) / (u32_t)SPIFFS_CFG_LOG_PAGE_SZ(fs)) / 2;
spiffs_free_obj_id_state state; spiffs_free_obj_id_state state;
@ -1640,14 +1671,16 @@ s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id) {
state.max_obj_id = ((spiffs_obj_id)-1) & ~SPIFFS_OBJ_ID_IX_FLAG; state.max_obj_id = ((spiffs_obj_id)-1) & ~SPIFFS_OBJ_ID_IX_FLAG;
} }
state.compaction = 0; state.compaction = 0;
state.conflicting_name = conflicting_name;
while (res == SPIFFS_OK && free_obj_id == SPIFFS_OBJ_ID_FREE) { while (res == SPIFFS_OK && free_obj_id == SPIFFS_OBJ_ID_FREE) {
if (state.max_obj_id - state.min_obj_id <= SPIFFS_CFG_LOG_PAGE_SZ(fs)*8) { if (state.max_obj_id - state.min_obj_id <= (spiffs_obj_id)SPIFFS_CFG_LOG_PAGE_SZ(fs)*8) {
// possible to represent in bitmap // possible to represent in bitmap
int i, j; u32_t i, j;
SPIFFS_DBG("free_obj_id: BITM min:%04x max:%04x\n", state.min_obj_id, state.max_obj_id); SPIFFS_DBG("free_obj_id: BITM min:%04x max:%04x\n", state.min_obj_id, state.max_obj_id);
c_memset(fs->work, 0, SPIFFS_CFG_LOG_PAGE_SZ(fs)); c_memset(fs->work, 0, SPIFFS_CFG_LOG_PAGE_SZ(fs));
res = spiffs_obj_lu_find_entry_visitor(fs, 0, 0, 0, 0, spiffs_obj_lu_find_free_obj_id_bitmap_v, state.min_obj_id, 0, 0, 0); res = spiffs_obj_lu_find_entry_visitor(fs, 0, 0, 0, 0, spiffs_obj_lu_find_free_obj_id_bitmap_v, state.min_obj_id,
conflicting_name, 0, 0);
if (res == SPIFFS_VIS_END) res = SPIFFS_OK; if (res == SPIFFS_VIS_END) res = SPIFFS_OK;
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
// traverse bitmask until found free obj_id // traverse bitmask until found free obj_id
@ -1668,7 +1701,7 @@ s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id) {
// not possible to represent all ids in range in a bitmap, compact and count // not possible to represent all ids in range in a bitmap, compact and count
if (state.compaction != 0) { if (state.compaction != 0) {
// select element in compacted table, decrease range and recompact // select element in compacted table, decrease range and recompact
int i, min_i = 0; u32_t i, min_i = 0;
u8_t *map = (u8_t *)fs->work; u8_t *map = (u8_t *)fs->work;
u8_t min_count = 0xff; u8_t min_count = 0xff;
@ -1700,7 +1733,7 @@ s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id) {
state.max_obj_id = state.min_obj_id + state.compaction; state.max_obj_id = state.min_obj_id + state.compaction;
// decrease compaction // decrease compaction
} }
if ((state.max_obj_id - state.min_obj_id <= SPIFFS_CFG_LOG_PAGE_SZ(fs)*8)) { if ((state.max_obj_id - state.min_obj_id <= (spiffs_obj_id)SPIFFS_CFG_LOG_PAGE_SZ(fs)*8)) {
// no need for compacting, use bitmap // no need for compacting, use bitmap
continue; continue;
} }
@ -1714,6 +1747,7 @@ s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id) {
res = spiffs_obj_lu_find_entry_visitor(fs, 0, 0, 0, 0, spiffs_obj_lu_find_free_obj_id_compact_v, 0, &state, 0, 0); res = spiffs_obj_lu_find_entry_visitor(fs, 0, 0, 0, 0, spiffs_obj_lu_find_free_obj_id_compact_v, 0, &state, 0, 0);
if (res == SPIFFS_VIS_END) res = SPIFFS_OK; if (res == SPIFFS_VIS_END) res = SPIFFS_OK;
SPIFFS_CHECK_RES(res); SPIFFS_CHECK_RES(res);
state.conflicting_name = 0; // searched for conflicting name once, no need to do it again
} }
} }
@ -1721,7 +1755,7 @@ s32_t spiffs_obj_lu_find_free_obj_id(spiffs *fs, spiffs_obj_id *obj_id) {
} }
s32_t spiffs_fd_find_new(spiffs *fs, spiffs_fd **fd) { s32_t spiffs_fd_find_new(spiffs *fs, spiffs_fd **fd) {
int i; u32_t i;
spiffs_fd *fds = (spiffs_fd *)fs->fd_space; spiffs_fd *fds = (spiffs_fd *)fs->fd_space;
for (i = 0; i < fs->fd_count; i++) { for (i = 0; i < fs->fd_count; i++) {
spiffs_fd *cur_fd = &fds[i]; spiffs_fd *cur_fd = &fds[i];
@ -1735,7 +1769,7 @@ s32_t spiffs_fd_find_new(spiffs *fs, spiffs_fd **fd) {
} }
s32_t spiffs_fd_return(spiffs *fs, spiffs_file f) { s32_t spiffs_fd_return(spiffs *fs, spiffs_file f) {
if (f <= 0 || f > fs->fd_count) { if (f <= 0 || f > (s16_t)fs->fd_count) {
return SPIFFS_ERR_BAD_DESCRIPTOR; return SPIFFS_ERR_BAD_DESCRIPTOR;
} }
spiffs_fd *fds = (spiffs_fd *)fs->fd_space; spiffs_fd *fds = (spiffs_fd *)fs->fd_space;
@ -1748,7 +1782,7 @@ s32_t spiffs_fd_return(spiffs *fs, spiffs_file f) {
} }
s32_t spiffs_fd_get(spiffs *fs, spiffs_file f, spiffs_fd **fd) { s32_t spiffs_fd_get(spiffs *fs, spiffs_file f, spiffs_fd **fd) {
if (f <= 0 || f > fs->fd_count) { if (f <= 0 || f > (s16_t)fs->fd_count) {
return SPIFFS_ERR_BAD_DESCRIPTOR; return SPIFFS_ERR_BAD_DESCRIPTOR;
} }
spiffs_fd *fds = (spiffs_fd *)fs->fd_space; spiffs_fd *fds = (spiffs_fd *)fs->fd_space;

5
app/spiffs/spiffs_nucleus.h
View File

@ -126,7 +126,7 @@
#define SPIFFS_OBJ_ID_IX_FLAG (1<<(8*sizeof(spiffs_obj_id)-1)) #define SPIFFS_OBJ_ID_IX_FLAG (1<<(8*sizeof(spiffs_obj_id)-1))
#define SPIFFS_UNDEFINED_LEN (-1) #define SPIFFS_UNDEFINED_LEN (u32_t)(-1)
#define SPIFFS_OBJ_ID_DELETED ((spiffs_obj_id)0) #define SPIFFS_OBJ_ID_DELETED ((spiffs_obj_id)0)
#define SPIFFS_OBJ_ID_FREE ((spiffs_obj_id)-1) #define SPIFFS_OBJ_ID_FREE ((spiffs_obj_id)-1)
@ -487,7 +487,8 @@ s32_t spiffs_obj_lu_scan(
s32_t spiffs_obj_lu_find_free_obj_id( s32_t spiffs_obj_lu_find_free_obj_id(
spiffs *fs, spiffs *fs,
spiffs_obj_id *obj_id); spiffs_obj_id *obj_id,
u8_t *conflicting_name);
s32_t spiffs_obj_lu_find_free( s32_t spiffs_obj_lu_find_free(
spiffs *fs, spiffs *fs,

2
ld/eagle.app.v6.ld
View File

@ -5,7 +5,7 @@ MEMORY
dport0_0_seg : org = 0x3FF00000, len = 0x10 dport0_0_seg : org = 0x3FF00000, len = 0x10
dram0_0_seg : org = 0x3FFE8000, len = 0x14000 dram0_0_seg : org = 0x3FFE8000, len = 0x14000
iram1_0_seg : org = 0x40100000, len = 0x8000 iram1_0_seg : org = 0x40100000, len = 0x8000
irom0_0_seg : org = 0x40210000, len = 0x51000 irom0_0_seg : org = 0x40210000, len = 0x54000
} }
PHDRS PHDRS