sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fs/spiffs: Various fixes from initial testing. Still lots of issues. Also changes from further review to get better naming consistency and functional partitioning.

Browse Source
This commit is contained in:
Gregory Nutt 2018-09-25 16:18:37 -06:00
parent c21dfbb93c
commit 9984e209ab
13 changed files with 355 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configs/sim/spiffs/defconfig
View File

@ -2,6 +2,7 @@ CONFIG_ARCH="sim"
CONFIG_ARCH_BOARD="sim" CONFIG_ARCH_BOARD="sim"
CONFIG_ARCH_BOARD_SIM=y CONFIG_ARCH_BOARD_SIM=y
CONFIG_ARCH_SIM=y CONFIG_ARCH_SIM=y
CONFIG_BOARD_INITIALIZE=y
CONFIG_DEBUG_ASSERTIONS=y CONFIG_DEBUG_ASSERTIONS=y
CONFIG_DEBUG_FEATURES=y CONFIG_DEBUG_FEATURES=y
CONFIG_DEBUG_SYMBOLS=y CONFIG_DEBUG_SYMBOLS=y
@ -11,6 +12,7 @@ CONFIG_DISABLE_POSIX_TIMERS=y
CONFIG_DISABLE_PTHREAD=y CONFIG_DISABLE_PTHREAD=y
CONFIG_DISABLE_SIGNALS=y CONFIG_DISABLE_SIGNALS=y
CONFIG_EXAMPLES_FSTEST=y CONFIG_EXAMPLES_FSTEST=y
CONFIG_EXAMPLES_FSTEST_MOUNTPT="/mnt/spiffs"
CONFIG_EXPERIMENTAL=y CONFIG_EXPERIMENTAL=y
CONFIG_FS_SPIFFS=y CONFIG_FS_SPIFFS=y
CONFIG_IDLETHREAD_STACKSIZE=4096 CONFIG_IDLETHREAD_STACKSIZE=4096

10
configs/sim/src/sim_bringup.c
View File

@ -181,6 +181,16 @@ int sim_bringup(void)
ret); ret);
} }
/* Mount the SPIFFS file system */
ret = mount("/dev/rammtd", "/mnt/spiffs", "spiffs", 0, NULL);
if (ret < 0)
{
syslog(LOG_ERR,
"ERROR: Failed to mount SPIFFS at /mnt/spiffs: %d\n",
ret);
}
#elif defined(CONFIG_FS_NXFFS) #elif defined(CONFIG_FS_NXFFS)
/* Initialize to provide NXFFS on the MTD interface */ /* Initialize to provide NXFFS on the MTD interface */

9
fs/spiffs/src/spiffs.h
View File

@ -147,12 +147,13 @@ struct spiffs_s
FAR uint8_t *work; /* Secondary work buffer, size of a logical page */ FAR uint8_t *work; /* Secondary work buffer, size of a logical page */
FAR void *cache; /* Cache memory */ FAR void *cache; /* Cache memory */
#ifdef CONFIG_HAVE_LONG_LONG #ifdef CONFIG_HAVE_LONG_LONG
off64_t phys_size; /* Physical size of the SPI flash */ off64_t media_size; /* Physical size of the SPI flash */
#else #else
off_t phys_size; /* Physical size of the SPI flash */ off_t media_size; /* Physical size of the SPI flash */
#endif #endif
int free_entry; /* Cursor for free blocks, entry index */ int free_entry; /* Cursor for free blocks, entry index */
int lu_entry; /* Cursor when searching, entry index */ int lu_entry; /* Cursor when searching, entry index */
uint32_t total_pages; /* Total number of pages on the media */
uint32_t free_blocks; /* Current number of free blocks */ uint32_t free_blocks; /* Current number of free blocks */
uint32_t stats_p_allocated; /* Current number of busy pages */ uint32_t stats_p_allocated; /* Current number of busy pages */
uint32_t stats_p_deleted; /* Current number of deleted pages */ uint32_t stats_p_deleted; /* Current number of deleted pages */
@ -164,10 +165,10 @@ struct spiffs_s
uint32_t cache_hits; /* Number of cache hits */ uint32_t cache_hits; /* Number of cache hits */
uint32_t cache_misses; /* Number of cache misses */ uint32_t cache_misses; /* Number of cache misses */
#endif #endif
uint32_t config_magic; /* Config magic */ int16_t free_blkndx; /* Cursor for free blocks, block index */
int16_t free_blkndx; /* cursor for free blocks, block index */
int16_t lu_blkndx; /* Cursor when searching, block index */ int16_t lu_blkndx; /* Cursor when searching, block index */
int16_t max_erase_count; /* Max erase count amongst all blocks */ int16_t max_erase_count; /* Max erase count amongst all blocks */
uint8_t pages_per_block; /* Pages per block */
}; };
/* This structure represents the state of an open file */ /* This structure represents the state of an open file */

4
fs/spiffs/src/spiffs_cache.c
View File

@ -144,7 +144,7 @@ static int spiffs_cache_page_free(FAR struct spiffs_s *fs, int cpndx,
cpndx, cp->pgndx); cpndx, cp->pgndx);
ret = spiffs_mtd_write(fs, SPIFFS_PAGE_TO_PADDR(fs, cp->pgndx), ret = spiffs_mtd_write(fs, SPIFFS_PAGE_TO_PADDR(fs, cp->pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), mem); SPIFFS_GEO_PAGE_SIZE(fs), mem);
} }
if (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR) if (cp->flags & SPIFFS_CACHE_FLAG_TYPE_WR)
@ -460,7 +460,7 @@ ssize_t spiffs_cache_read(FAR struct spiffs_s *fs, uint8_t op, int16_t objid,
ret = spiffs_mtd_read(fs, addr - ret = spiffs_mtd_read(fs, addr -
SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr), SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr),
SPIFFS_CFG_LOG_PAGE_SZ(fs), SPIFFS_GEO_PAGE_SIZE(fs),
spiffs_get_cache_page(fs, cache, cp->cpndx)); spiffs_get_cache_page(fs, cache, cp->cpndx));
mem = spiffs_get_cache_page(fs, cache, cp->cpndx); mem = spiffs_get_cache_page(fs, cache, cp->cpndx);

2
fs/spiffs/src/spiffs_cache.h
View File

@ -61,7 +61,7 @@ extern "C"
#define SPIFFS_CACHE_FLAG_TYPE_WR (1 << 7) #define SPIFFS_CACHE_FLAG_TYPE_WR (1 << 7)
#define SPIFFS_CACHE_PAGE_SIZE(fs) \ #define SPIFFS_CACHE_PAGE_SIZE(fs) \
(sizeof(struct spiffs_cache_page_s) + SPIFFS_CFG_LOG_PAGE_SZ(fs)) (sizeof(struct spiffs_cache_page_s) + SPIFFS_GEO_PAGE_SIZE(fs))
#define spiffs_get_cache(fs) \ #define spiffs_get_cache(fs) \
((FAR struct spiffs_cache_s *)((fs)->cache)) ((FAR struct spiffs_cache_s *)((fs)->cache))

112
fs/spiffs/src/spiffs_check.c
View File

@ -109,7 +109,7 @@ static int spiffs_check_get_data_pgndx(FAR struct spiffs_s *fs,
/* Find the object index for the object ID and span index */ /* Find the object index for the object ID and span index */
ret = spiffs_objlu_find_id_and_span(fs, objid | SPIFFS_OBJ_ID_IX_FLAG, ret = spiffs_objlu_find_id_and_span(fs, objid | SPIFFS_OBJID_NDXFLAG,
objndx_spndx, 0, objndx_pgndx); objndx_spndx, 0, objndx_pgndx);
if (ret < 0) if (ret < 0)
{ {
@ -226,7 +226,7 @@ static int spiffs_check_rewrite_index(FAR struct spiffs_s *fs,
int entry; int entry;
int ret; int ret;
objid |= SPIFFS_OBJ_ID_IX_FLAG; objid |= SPIFFS_OBJID_NDXFLAG;
/* Find free entry */ /* Find free entry */
@ -260,7 +260,7 @@ static int spiffs_check_rewrite_index(FAR struct spiffs_s *fs,
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx), 0, SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -311,7 +311,7 @@ static int spiffs_check_rewrite_index(FAR struct spiffs_s *fs,
ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_UPDT, 0, ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_UPDT, 0,
SPIFFS_PAGE_TO_PADDR(fs, free_pgndx), SPIFFS_PAGE_TO_PADDR(fs, free_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret); ferr("ERROR: spiffs_cache_write() failed: %d\n", ret);
@ -436,9 +436,9 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
/* Check validity, take actions */ /* Check validity, take actions */
if (((lu_objid == SPIFFS_OBJ_ID_DELETED) && if (((lu_objid == SPIFFS_OBJID_DELETED) &&
(pghdr->flags & SPIFFS_PH_FLAG_DELET)) || (pghdr->flags & SPIFFS_PH_FLAG_DELET)) ||
((lu_objid == SPIFFS_OBJ_ID_FREE) && ((lu_objid == SPIFFS_OBJID_FREE) &&
(pghdr->flags & SPIFFS_PH_FLAG_USED) == 0)) (pghdr->flags & SPIFFS_PH_FLAG_USED) == 0))
{ {
/* Look up entry deleted / free but used in page header */ /* Look up entry deleted / free but used in page header */
@ -532,7 +532,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
*/ */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG, pghdr->objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx, 0); pghdr->spndx, cur_pgndx, 0);
if (ret == -ENOENT) if (ret == -ENOENT)
{ {
@ -541,7 +541,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
*/ */
ret = spiffs_objlu_find_id_and_span_byphdr(fs, ret = spiffs_objlu_find_id_and_span_byphdr(fs,
pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG, pghdr->objid | SPIFFS_OBJID_NDXFLAG,
0, 0, 0); 0, 0, 0);
if (ret == OK) if (ret == OK)
{ {
@ -574,12 +574,12 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
} }
} }
if (lu_objid != SPIFFS_OBJ_ID_FREE && lu_objid != SPIFFS_OBJ_ID_DELETED) if (lu_objid != SPIFFS_OBJID_FREE && lu_objid != SPIFFS_OBJID_DELETED)
{ {
/* look up entry used */ /* look up entry used */
if ((pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG) != if ((pghdr->objid | SPIFFS_OBJID_NDXFLAG) !=
(lu_objid | SPIFFS_OBJ_ID_IX_FLAG)) (lu_objid | SPIFFS_OBJID_NDXFLAG))
{ {
spiffs_checkinfo("LU: pgndx %04x differ in objid lu=" spiffs_checkinfo("LU: pgndx %04x differ in objid lu="
"%04x ph:%04x\n", cur_pgndx, lu_objid, "%04x ph:%04x\n", cur_pgndx, lu_objid,
@ -676,7 +676,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
*/ */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
lu_objid | SPIFFS_OBJ_ID_IX_FLAG, lu_objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, 0, pghdr->spndx, 0,
&objndx_pgndx_lu); &objndx_pgndx_lu);
if (ret == -ENOENT) if (ret == -ENOENT)
@ -695,7 +695,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
*/ */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG, pghdr->objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, 0, pghdr->spndx, 0,
&objndx_pgndx_ph); &objndx_pgndx_ph);
if (ret == -ENOENT) if (ret == -ENOENT)
@ -725,7 +725,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
*/ */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
lu_objid & ~SPIFFS_OBJ_ID_IX_FLAG, lu_objid & ~SPIFFS_OBJID_NDXFLAG,
0, 0, &data_pgndx_lu); 0, 0, &data_pgndx_lu);
if (ret == -ENOENT) if (ret == -ENOENT)
{ {
@ -743,7 +743,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
*/ */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
pghdr->objid & ~SPIFFS_OBJ_ID_IX_FLAG, pghdr->objid & ~SPIFFS_OBJID_NDXFLAG,
0, 0, &data_pgndx_ph); 0, 0, &data_pgndx_ph);
if (ret == -ENOENT) if (ret == -ENOENT)
{ {
@ -767,7 +767,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
{ {
/* Got a data page for page header objid rewrite as objid_ph */ /* Got a data page for page header objid rewrite as objid_ph */
new_ph.objid = pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG; new_ph.objid = pghdr->objid | SPIFFS_OBJID_NDXFLAG;
ret = spiffs_check_rewrite_page(fs, cur_pgndx, &new_ph, &new_pgndx); ret = spiffs_check_rewrite_page(fs, cur_pgndx, &new_ph, &new_pgndx);
spiffs_checkinfo("Rewrite page %04x as %04x to pgndx %04x\n", spiffs_checkinfo("Rewrite page %04x as %04x to pgndx %04x\n",
@ -788,7 +788,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
{ {
/* Got a data page for look up objid rewrite as objid_lu */ /* Got a data page for look up objid rewrite as objid_lu */
new_ph.objid = lu_objid | SPIFFS_OBJ_ID_IX_FLAG; new_ph.objid = lu_objid | SPIFFS_OBJID_NDXFLAG;
spiffs_checkinfo("Rewrite page %04x as %04x\n", spiffs_checkinfo("Rewrite page %04x as %04x\n",
cur_pgndx, new_ph.objid); cur_pgndx, new_ph.objid);
@ -811,9 +811,9 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
} }
} }
} }
else if (((lu_objid & SPIFFS_OBJ_ID_IX_FLAG) != 0 && else if (((lu_objid & SPIFFS_OBJID_NDXFLAG) != 0 &&
(pghdr->flags & SPIFFS_PH_FLAG_INDEX) != 0) || (pghdr->flags & SPIFFS_PH_FLAG_INDEX) != 0) ||
((lu_objid & SPIFFS_OBJ_ID_IX_FLAG) == 0 && ((lu_objid & SPIFFS_OBJID_NDXFLAG) == 0 &&
(pghdr->flags & SPIFFS_PH_FLAG_INDEX) == 0)) (pghdr->flags & SPIFFS_PH_FLAG_INDEX) == 0))
{ {
int16_t data_pgndx; int16_t data_pgndx;
@ -824,7 +824,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
/* see if other data page exists for given objid and span index */ /* see if other data page exists for given objid and span index */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
lu_objid & ~SPIFFS_OBJ_ID_IX_FLAG, lu_objid & ~SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx, &data_pgndx); pghdr->spndx, cur_pgndx, &data_pgndx);
if (ret == -ENOENT) if (ret == -ENOENT)
{ {
@ -840,7 +840,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
/* See if other object index exists for given objid and span index */ /* See if other object index exists for given objid and span index */
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
lu_objid | SPIFFS_OBJ_ID_IX_FLAG, lu_objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx, pghdr->spndx, cur_pgndx,
&objndx_pgndx_d); &objndx_pgndx_d);
if (ret == -ENOENT) if (ret == -ENOENT)
@ -876,7 +876,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED | SPIFFS_PH_FLAG_FINAL | new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED | SPIFFS_PH_FLAG_FINAL |
SPIFFS_PH_FLAG_INDEX); SPIFFS_PH_FLAG_INDEX);
new_ph.objid = lu_objid | SPIFFS_OBJ_ID_IX_FLAG; new_ph.objid = lu_objid | SPIFFS_OBJID_NDXFLAG;
new_ph.spndx = pghdr->spndx; new_ph.spndx = pghdr->spndx;
ret = spiffs_page_allocate_data(fs, new_ph.objid, &new_ph, ret = spiffs_page_allocate_data(fs, new_ph.objid, &new_ph,
@ -891,7 +891,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
sizeof(struct spiffs_page_header_s), sizeof(struct spiffs_page_header_s),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) + SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s), sizeof(struct spiffs_page_header_s),
SPIFFS_CFG_LOG_PAGE_SZ(fs) - SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_page_header_s)); sizeof(struct spiffs_page_header_s));
if (ret < 0) if (ret < 0)
{ {
@ -910,7 +910,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
spiffs_checkinfo("Other index page exists, make this data\n"); spiffs_checkinfo("Other index page exists, make this data\n");
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED | SPIFFS_PH_FLAG_FINAL); new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED | SPIFFS_PH_FLAG_FINAL);
new_ph.objid = lu_objid & ~SPIFFS_OBJ_ID_IX_FLAG; new_ph.objid = lu_objid & ~SPIFFS_OBJID_NDXFLAG;
new_ph.spndx = pghdr->spndx; new_ph.spndx = pghdr->spndx;
ret = spiffs_page_allocate_data(fs, new_ph.objid, &new_ph, ret = spiffs_page_allocate_data(fs, new_ph.objid, &new_ph,
@ -925,7 +925,7 @@ static int spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
sizeof(struct spiffs_page_header_s), sizeof(struct spiffs_page_header_s),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) + SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s), sizeof(struct spiffs_page_header_s),
SPIFFS_CFG_LOG_PAGE_SZ(fs) - SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_page_header_s)); sizeof(struct spiffs_page_header_s));
if (ret < 0) if (ret < 0)
{ {
@ -1099,10 +1099,10 @@ static int spifss_check_objndx_search(FAR struct spiffs_s *fs, int16_t objid)
FAR int16_t *obj_table = (FAR int16_t *)fs->work; FAR int16_t *obj_table = (FAR int16_t *)fs->work;
int i; int i;
objid &= ~SPIFFS_OBJ_ID_IX_FLAG; objid &= ~SPIFFS_OBJID_NDXFLAG;
for (i = 0; i < SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t); i++) for (i = 0; i < SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t); i++)
{ {
if ((obj_table[i] & ~SPIFFS_OBJ_ID_IX_FLAG) == objid) if ((obj_table[i] & ~SPIFFS_OBJID_NDXFLAG) == objid)
{ {
return i; return i;
} }
@ -1145,8 +1145,8 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
int retc = SPIFFS_VIS_COUNTINUE; int retc = SPIFFS_VIS_COUNTINUE;
int ret = OK; int ret = OK;
if (objid != SPIFFS_OBJ_ID_FREE && objid != SPIFFS_OBJ_ID_DELETED && if (objid != SPIFFS_OBJID_FREE && objid != SPIFFS_OBJID_DELETED &&
(objid & SPIFFS_OBJ_ID_IX_FLAG) != 0) (objid & SPIFFS_OBJID_NDXFLAG) != 0)
{ {
struct spiffs_page_header_s pghdr; struct spiffs_page_header_s pghdr;
int16_t cur_pgndx; int16_t cur_pgndx;
@ -1201,9 +1201,9 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
{ {
/* Not registered, do it */ /* Not registered, do it */
obj_table[*log_ndx] = objid & ~SPIFFS_OBJ_ID_IX_FLAG; obj_table[*log_ndx] = objid & ~SPIFFS_OBJID_NDXFLAG;
(*log_ndx)++; (*log_ndx)++;
if (*log_ndx >= SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)) if (*log_ndx >= SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t))
{ {
*log_ndx = 0; *log_ndx = 0;
} }
@ -1225,7 +1225,7 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
/* Not in temporary index, try finding it */ /* Not in temporary index, try finding it */
ret = spiffs_objlu_find_id_and_span(fs, objid | SPIFFS_OBJ_ID_IX_FLAG, ret = spiffs_objlu_find_id_and_span(fs, objid | SPIFFS_OBJID_NDXFLAG,
0, 0, &objhdr_pgndx); 0, 0, &objhdr_pgndx);
retc = SPIFFS_VIS_COUNTINUE_RELOAD; retc = SPIFFS_VIS_COUNTINUE_RELOAD;
@ -1233,14 +1233,14 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
{ {
/* Found, register as reachable */ /* Found, register as reachable */
obj_table[*log_ndx] = objid & ~SPIFFS_OBJ_ID_IX_FLAG; obj_table[*log_ndx] = objid & ~SPIFFS_OBJID_NDXFLAG;
} }
else if (ret == -ENOENT) else if (ret == -ENOENT)
{ {
/* Not found, register as unreachable */ /* Not found, register as unreachable */
delete = true; delete = true;
obj_table[*log_ndx] = objid | SPIFFS_OBJ_ID_IX_FLAG; obj_table[*log_ndx] = objid | SPIFFS_OBJID_NDXFLAG;
} }
else if (ret < 0) else if (ret < 0)
{ {
@ -1249,7 +1249,7 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
} }
(*log_ndx)++; (*log_ndx)++;
if (*log_ndx >= SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)) if (*log_ndx >= SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t))
{ {
*log_ndx = 0; *log_ndx = 0;
} }
@ -1258,7 +1258,7 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
{ {
/* In temporary index, check reachable flag */ /* In temporary index, check reachable flag */
if ((obj_table[ret2] & SPIFFS_OBJ_ID_IX_FLAG)) if ((obj_table[ret2] & SPIFFS_OBJID_NDXFLAG))
{ {
/* Registered as unreachable */ /* Registered as unreachable */
@ -1353,30 +1353,30 @@ int spiffs_check_luconsistency(FAR struct spiffs_s *fs)
int spiffs_check_pgconsistency(FAR struct spiffs_s *fs) int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
{ {
const uint32_t bits = 4; const uint32_t bits = 4;
const int16_t pages_per_scan = SPIFFS_CFG_LOG_PAGE_SZ(fs) * 8 / bits; const int16_t pages_per_scan = SPIFFS_GEO_PAGE_SIZE(fs) * 8 / bits;
int16_t pgndx_offset = 0; int16_t pgndx_offset = 0;
int ret = OK; int ret = OK;
/* For each range of pages fitting into work memory */ /* For each range of pages fitting into work memory */
while (pgndx_offset < SPIFFS_PAGES_PER_BLOCK(fs) * fs->geo.neraseblocks) while (pgndx_offset < SPIFFS_GEO_PAGES_PER_BLOCK(fs) * SPIFFS_GEO_BLOCK_COUNT(fs))
{ {
int16_t cur_block = 0; int16_t cur_block = 0;
bool restart = false; bool restart = false;
memset(fs->work, 0, SPIFFS_CFG_LOG_PAGE_SZ(fs)); memset(fs->work, 0, SPIFFS_GEO_PAGE_SIZE(fs));
/* Build consistency bitmap for ID range traversing all blocks */ /* Build consistency bitmap for ID range traversing all blocks */
while (!restart && cur_block < fs->geo.neraseblocks) while (!restart && cur_block < SPIFFS_GEO_BLOCK_COUNT(fs))
{ {
/* Traverse each page except for lookup pages */ /* Traverse each page except for lookup pages */
int16_t cur_pgndx = SPIFFS_OBJ_LOOKUP_PAGES(fs) + int16_t cur_pgndx = SPIFFS_OBJ_LOOKUP_PAGES(fs) +
SPIFFS_PAGES_PER_BLOCK(fs) * cur_block; SPIFFS_GEO_PAGES_PER_BLOCK(fs) * cur_block;
while (!restart && while (!restart &&
cur_pgndx < SPIFFS_PAGES_PER_BLOCK(fs) * (cur_block + 1)) cur_pgndx < SPIFFS_GEO_PAGES_PER_BLOCK(fs) * (cur_block + 1))
{ {
struct spiffs_page_header_s pghdr; struct spiffs_page_header_s pghdr;
uint32_t pgndx_bytendx; uint32_t pgndx_bytendx;
@ -1429,7 +1429,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx), 0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -1473,7 +1473,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
rpgndx < pgndx_offset + pages_per_scan); rpgndx < pgndx_offset + pages_per_scan);
if ((rpgndx != (int16_t) - 1 && if ((rpgndx != (int16_t) - 1 &&
rpgndx > SPIFFS_MAX_PAGES(fs)) || rpgndx > SPIFFS_GEO_PAGE_COUNT(fs)) ||
(rpgndx_within_range && SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx))) (rpgndx_within_range && SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx)))
{ {
int16_t data_pgndx; int16_t data_pgndx;
@ -1487,7 +1487,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
objndx_phdr->objid & objndx_phdr->objid &
~SPIFFS_OBJ_ID_IX_FLAG, ~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i, data_spndx_offset + i,
0, &data_pgndx); 0, &data_pgndx);
if (ret == -ENOENT) if (ret == -ENOENT)
@ -1510,7 +1510,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED | new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED |
SPIFFS_PH_FLAG_FINAL); SPIFFS_PH_FLAG_FINAL);
new_ph.objid = objndx_phdr->objid & ~SPIFFS_OBJ_ID_IX_FLAG; new_ph.objid = objndx_phdr->objid & ~SPIFFS_OBJID_NDXFLAG;
new_ph.spndx = data_spndx_offset + i; new_ph.spndx = data_spndx_offset + i;
ret = spiffs_page_allocate_data(fs, new_ph.objid, ret = spiffs_page_allocate_data(fs, new_ph.objid,
@ -1531,7 +1531,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
spiffs_checkinfo("Rewriting index pgndx=%04x\n", cur_pgndx); spiffs_checkinfo("Rewriting index pgndx=%04x\n", cur_pgndx);
ret = spiffs_check_rewrite_index(fs, ret = spiffs_check_rewrite_index(fs,
objndx_phdr->objid | SPIFFS_OBJ_ID_IX_FLAG, objndx_phdr->objid | SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i, data_spndx_offset + i,
data_pgndx, cur_pgndx); data_pgndx, cur_pgndx);
if (ret == -EFAULT) if (ret == -EFAULT)
@ -1576,7 +1576,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
/* Cross reference page header check */ /* Cross reference page header check */
if (rphdr.objid != (pghdr.objid & ~SPIFFS_OBJ_ID_IX_FLAG) || if (rphdr.objid != (pghdr.objid & ~SPIFFS_OBJID_NDXFLAG) ||
rphdr.spndx != data_spndx_offset + i || rphdr.spndx != data_spndx_offset + i ||
(rphdr.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_INDEX | (rphdr.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_USED)) != SPIFFS_PH_FLAG_USED)) !=
@ -1587,7 +1587,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
spiffs_checkinfo("pgndx=%04x has inconsistent page header index objid/span:" spiffs_checkinfo("pgndx=%04x has inconsistent page header index objid/span:"
"%04x/%04x, ref objid/span:%04x/%04x flags=%02x\n", "%04x/%04x, ref objid/span:%04x/%04x flags=%02x\n",
rpgndx, rpgndx,
pghdr.objid & ~SPIFFS_OBJ_ID_IX_FLAG, pghdr.objid & ~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i, data_spndx_offset + i,
rphdr.objid, rphdr.spndx, rphdr.objid, rphdr.spndx,
rphdr.flags); rphdr.flags);
@ -1596,7 +1596,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
pghdr.objid & pghdr.objid &
~SPIFFS_OBJ_ID_IX_FLAG, ~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i, rpgndx, data_spndx_offset + i, rpgndx,
&data_pgndx); &data_pgndx);
if (ret == -ENOENT) if (ret == -ENOENT)
@ -1726,7 +1726,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
uint8_t bit_ndx; uint8_t bit_ndx;
for (byte_ndx = 0; for (byte_ndx = 0;
!restart && byte_ndx < SPIFFS_CFG_LOG_PAGE_SZ(fs); !restart && byte_ndx < SPIFFS_GEO_PAGE_SIZE(fs);
byte_ndx++) byte_ndx++)
{ {
for (bit_ndx = 0; !restart && bit_ndx < 8 / bits; bit_ndx++) for (bit_ndx = 0; !restart && bit_ndx < 8 / bits; bit_ndx++)
@ -1770,7 +1770,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
if (ret == OK) if (ret == OK)
{ {
if (((rpgndx == (int16_t) - 1 || if (((rpgndx == (int16_t) - 1 ||
rpgndx > SPIFFS_MAX_PAGES(fs)) || rpgndx > SPIFFS_GEO_PAGE_COUNT(fs)) ||
(SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx)))) (SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx))))
{ {
/* Pointing to a bad page altogether, rewrite /* Pointing to a bad page altogether, rewrite
@ -1801,7 +1801,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
return ret; return ret;
} }
if (((pghdr.objid & ~SPIFFS_OBJ_ID_IX_FLAG) == if (((pghdr.objid & ~SPIFFS_OBJID_NDXFLAG) ==
rphdr.objid) && rphdr.objid) &&
((rphdr.flags & (SPIFFS_PH_FLAG_INDEX | ((rphdr.flags & (SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_DELET |
@ -2011,11 +2011,11 @@ int spiffs_check_objidconsistency(FAR struct spiffs_s *fs)
* fs->work is used for a temporary object index memory, listing found * fs->work is used for a temporary object index memory, listing found
* object ids and indicating whether they can be reached or not. Acting * object ids and indicating whether they can be reached or not. Acting
* as a FIFO if object ids cannot fit. In the temporary object index * as a FIFO if object ids cannot fit. In the temporary object index
* memory, SPIFFS_OBJ_ID_IX_FLAG bit is used to indicate a reachable/ * memory, SPIFFS_OBJID_NDXFLAG bit is used to indicate a reachable/
* unreachable object ID. * unreachable object ID.
*/ */
memset(fs->work, 0, SPIFFS_CFG_LOG_PAGE_SZ(fs)); memset(fs->work, 0, SPIFFS_GEO_PAGE_SIZE(fs));
ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0, ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0,
spiffs_check_objidconsistency_callback, 0, spiffs_check_objidconsistency_callback, 0,

199
fs/spiffs/src/spiffs_core.c
View File

@ -94,14 +94,14 @@ static int spiffs_page_data_check(FAR struct spiffs_s *fs,
return SPIFFS_ERR_INDEX_REF_FREE; return SPIFFS_ERR_INDEX_REF_FREE;
} }
if (pgndx % SPIFFS_PAGES_PER_BLOCK(fs) < SPIFFS_OBJ_LOOKUP_PAGES(fs)) if (pgndx % SPIFFS_GEO_PAGES_PER_BLOCK(fs) < SPIFFS_OBJ_LOOKUP_PAGES(fs))
{ {
/* Referring to an object lookup page, bad object index */ /* Referring to an object lookup page, bad object index */
return SPIFFS_ERR_INDEX_REF_LU; return SPIFFS_ERR_INDEX_REF_LU;
} }
if (pgndx > SPIFFS_MAX_PAGES(fs)) if (pgndx > SPIFFS_GEO_PAGE_COUNT(fs))
{ {
/* Referring to a bad page */ /* Referring to a bad page */
@ -165,14 +165,14 @@ static int spiffs_page_index_check(FAR struct spiffs_s *fs,
return SPIFFS_ERR_INDEX_FREE; return SPIFFS_ERR_INDEX_FREE;
} }
if (pgndx % SPIFFS_PAGES_PER_BLOCK(fs) < SPIFFS_OBJ_LOOKUP_PAGES(fs)) if (pgndx % SPIFFS_GEO_PAGES_PER_BLOCK(fs) < SPIFFS_OBJ_LOOKUP_PAGES(fs))
{ {
/* Referring to an object lookup page, bad object index */ /* Referring to an object lookup page, bad object index */
return SPIFFS_ERR_INDEX_LU; return SPIFFS_ERR_INDEX_LU;
} }
if (pgndx > SPIFFS_MAX_PAGES(fs)) if (pgndx > SPIFFS_GEO_PAGE_COUNT(fs))
{ {
/* Referring to a bad page */ /* Referring to a bad page */
@ -212,7 +212,7 @@ static int spiffs_objlu_scan_callback(FAR struct spiffs_s *fs, int16_t objid,
FAR const void *user_const, FAR const void *user_const,
FAR void *user_var) FAR void *user_var)
{ {
if (objid == SPIFFS_OBJ_ID_FREE) if (objid == SPIFFS_OBJID_FREE)
{ {
if (entry == 0) if (entry == 0)
{ {
@ -221,7 +221,7 @@ static int spiffs_objlu_scan_callback(FAR struct spiffs_s *fs, int16_t objid,
fs->free_blocks++; fs->free_blocks++;
} }
} }
else if (objid == SPIFFS_OBJ_ID_DELETED) else if (objid == SPIFFS_OBJID_DELETED)
{ {
fs->stats_p_deleted++; fs->stats_p_deleted++;
} }
@ -264,7 +264,7 @@ static int spiffs_objlu_find_id_and_span_callback(FAR struct spiffs_s *fs,
if (ph.objid == objid && ph.spndx == *((FAR int16_t *)user_var) && if (ph.objid == objid && ph.spndx == *((FAR int16_t *)user_var) &&
(ph.flags & (SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_DELET | (ph.flags & (SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_DELET |
SPIFFS_PH_FLAG_USED)) == SPIFFS_PH_FLAG_DELET && SPIFFS_PH_FLAG_USED)) == SPIFFS_PH_FLAG_DELET &&
!((objid & SPIFFS_OBJ_ID_IX_FLAG) != 0 && !((objid & SPIFFS_OBJID_NDXFLAG) != 0 &&
(ph.flags & SPIFFS_PH_FLAG_IXDELE) == 0 && ph.spndx == 0) && (ph.flags & SPIFFS_PH_FLAG_IXDELE) == 0 && ph.spndx == 0) &&
(user_const == NULL || *((FAR const int16_t *)user_const) != pgndx)) (user_const == NULL || *((FAR const int16_t *)user_const) != pgndx))
{ {
@ -292,8 +292,8 @@ static int spiffs_find_objhdr_pgndx_callback(FAR struct spiffs_s *fs, int16_t ob
int16_t pgndx; int16_t pgndx;
int ret; int ret;
if (objid == SPIFFS_OBJ_ID_FREE || objid == SPIFFS_OBJ_ID_DELETED || if (objid == SPIFFS_OBJID_FREE || objid == SPIFFS_OBJID_DELETED ||
(objid & SPIFFS_OBJ_ID_IX_FLAG) == 0) (objid & SPIFFS_OBJID_NDXFLAG) == 0)
{ {
return SPIFFS_VIS_COUNTINUE; return SPIFFS_VIS_COUNTINUE;
} }
@ -338,7 +338,7 @@ static int
FAR const void *user_const, FAR const void *user_const,
FAR void *user_var) FAR void *user_var)
{ {
if (objid != SPIFFS_OBJ_ID_FREE && objid != SPIFFS_OBJ_ID_DELETED) if (objid != SPIFFS_OBJID_FREE && objid != SPIFFS_OBJID_DELETED)
{ {
int16_t min_objid = *((FAR int16_t *)user_var); int16_t min_objid = *((FAR int16_t *)user_var);
FAR const uint8_t *conflicting_name = (FAR const uint8_t *)user_const; FAR const uint8_t *conflicting_name = (FAR const uint8_t *)user_const;
@ -349,7 +349,7 @@ static int
* found in object index headers * found in object index headers
*/ */
if (conflicting_name != NULL && (objid & SPIFFS_OBJ_ID_IX_FLAG) != 0) if (conflicting_name != NULL && (objid & SPIFFS_OBJID_NDXFLAG) != 0)
{ {
struct spiffs_pgobj_ndxheader_s objhdr; struct spiffs_pgobj_ndxheader_s objhdr;
int16_t pgndx = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, blkndx, entry); int16_t pgndx = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, blkndx, entry);
@ -379,11 +379,11 @@ static int
} }
} }
objid &= ~SPIFFS_OBJ_ID_IX_FLAG; objid &= ~SPIFFS_OBJID_NDXFLAG;
bitndx = (objid - min_objid) & 7; bitndx = (objid - min_objid) & 7;
bytendx = (objid - min_objid) >> 3; bytendx = (objid - min_objid) >> 3;
if (bytendx >= 0 && (uint32_t)bytendx < SPIFFS_CFG_LOG_PAGE_SZ(fs)) if (bytendx >= 0 && (uint32_t)bytendx < SPIFFS_GEO_PAGE_SIZE(fs))
{ {
fs->work[bytendx] |= (1 << bitndx); fs->work[bytendx] |= (1 << bitndx);
} }
@ -406,8 +406,8 @@ spiffs_objlu_find_free_objid_compact_callback(FAR struct spiffs_s *fs,
FAR const void *user_const, FAR const void *user_const,
FAR void *user_var) FAR void *user_var)
{ {
if (objid != SPIFFS_OBJ_ID_FREE && objid != SPIFFS_OBJ_ID_DELETED && if (objid != SPIFFS_OBJID_FREE && objid != SPIFFS_OBJID_DELETED &&
(objid & SPIFFS_OBJ_ID_IX_FLAG) != 0) (objid & SPIFFS_OBJID_NDXFLAG) != 0)
{ {
FAR const struct spiffs_free_objid_s *state = FAR const struct spiffs_free_objid_s *state =
(FAR const struct spiffs_free_objid_s *)user_const; (FAR const struct spiffs_free_objid_s *)user_const;
@ -433,7 +433,7 @@ spiffs_objlu_find_free_objid_compact_callback(FAR struct spiffs_s *fs,
return -EEXIST; return -EEXIST;
} }
objid &= ~SPIFFS_OBJ_ID_IX_FLAG; objid &= ~SPIFFS_OBJID_NDXFLAG;
if (objid >= state->min_objid && objid <= state->max_objid) if (objid >= state->min_objid && objid <= state->max_objid)
{ {
FAR uint8_t *map = (FAR uint8_t *)fs->work; FAR uint8_t *map = (FAR uint8_t *)fs->work;
@ -480,7 +480,7 @@ int spiffs_validate_objix(FAR struct spiffs_page_header_s *ph, int16_t objid,
{ {
ret = SPIFFS_ERR_NOT_INDEX; ret = SPIFFS_ERR_NOT_INDEX;
} }
else if ((objid & SPIFFS_OBJ_ID_IX_FLAG) == 0) else if ((objid & SPIFFS_OBJID_NDXFLAG) == 0)
{ {
ret = SPIFFS_ERR_NOT_INDEX; ret = SPIFFS_ERR_NOT_INDEX;
} }
@ -581,12 +581,12 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
int entries_per_page; int entries_per_page;
int ret; int ret;
entry_count = fs->geo.neraseblocks * SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs); entry_count = SPIFFS_GEO_BLOCK_COUNT(fs) * SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs);
cur_block = starting_block; cur_block = starting_block;
cur_block_addr = starting_block * SPIFFS_CFG_LOG_BLOCK_SZ(fs); cur_block_addr = starting_block * SPIFFS_GEO_BLOCK_SIZE(fs);
objlu_buf = (FAR int16_t *) fs->lu_work; objlu_buf = (FAR int16_t *) fs->lu_work;
cur_entry = starting_lu_entry; cur_entry = starting_lu_entry;
entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)); entries_per_page = (SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t));
ret = OK; ret = OK;
/* Wrap initial */ /* Wrap initial */
@ -595,9 +595,9 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
{ {
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_GEO_BLOCK_SIZE(fs);
if (cur_block >= fs->geo.neraseblocks) if (cur_block >= SPIFFS_GEO_BLOCK_COUNT(fs))
{ {
if (flags & SPIFFS_VIS_NO_WRAP) if (flags & SPIFFS_VIS_NO_WRAP)
{ {
@ -628,7 +628,7 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, cur_block_addr + 0, cur_block_addr +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each entry */ /* Check each entry */
@ -666,7 +666,7 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
SPIFFS_OP_C_READ, 0, SPIFFS_OP_C_READ, 0,
cur_block_addr + cur_block_addr +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), SPIFFS_GEO_PAGE_SIZE(fs),
fs->lu_work); fs->lu_work);
if (ret < 0) if (ret < 0)
{ {
@ -701,9 +701,9 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
cur_entry = 0; cur_entry = 0;
cur_block++; cur_block++;
cur_block_addr += SPIFFS_CFG_LOG_BLOCK_SZ(fs); cur_block_addr += SPIFFS_GEO_BLOCK_SIZE(fs);
if (cur_block >= fs->geo.neraseblocks) if (cur_block >= SPIFFS_GEO_BLOCK_COUNT(fs))
{ {
if (flags & SPIFFS_VIS_NO_WRAP) if (flags & SPIFFS_VIS_NO_WRAP)
{ {
@ -737,7 +737,7 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx) int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx)
{ {
uint32_t addr = SPIFFS_BLOCK_TO_PADDR(fs, blkndx); uint32_t addr = SPIFFS_BLOCK_TO_PADDR(fs, blkndx);
int32_t size = SPIFFS_CFG_LOG_BLOCK_SZ(fs); int32_t size = SPIFFS_GEO_BLOCK_SIZE(fs);
int ret; int ret;
/* Here we ignore the return value and just try erasing the block */ /* Here we ignore the return value and just try erasing the block */
@ -745,12 +745,12 @@ int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx)
while (size > 0) while (size > 0)
{ {
finfo("erase %08lx:%d\n", finfo("erase %08lx:%d\n",
(unsigned long)addr, SPIFFS_CFG_PHYS_ERASE_SZ(fs)); (unsigned long)addr, SPIFFS_GEO_EBLOCK_SIZE(fs));
(void)spiffs_mtd_erase(fs, addr, SPIFFS_CFG_PHYS_ERASE_SZ(fs)); (void)spiffs_mtd_erase(fs, addr, SPIFFS_GEO_EBLOCK_SIZE(fs));
addr += SPIFFS_CFG_PHYS_ERASE_SZ(fs); addr += SPIFFS_GEO_EBLOCK_SIZE(fs);
size -= SPIFFS_CFG_PHYS_ERASE_SZ(fs); size -= SPIFFS_GEO_EBLOCK_SIZE(fs);
} }
fs->free_blocks++; fs->free_blocks++;
@ -768,7 +768,7 @@ int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx)
} }
fs->max_erase_count++; fs->max_erase_count++;
if (fs->max_erase_count == SPIFFS_OBJ_ID_IX_FLAG) if (fs->max_erase_count == SPIFFS_OBJID_NDXFLAG)
{ {
fs->max_erase_count = 0; fs->max_erase_count = 0;
} }
@ -797,12 +797,13 @@ int spiffs_objlu_scan(FAR struct spiffs_s *fs)
/* Find out erase count. */ /* Find out erase count. */
blkndx = 0; blkndx = 0;
erase_count_min = SPIFFS_OBJ_ID_FREE; erase_count_min = SPIFFS_OBJID_FREE;
erase_count_max = 0; erase_count_max = 0;
while (blkndx < fs->geo.neraseblocks) while (blkndx < SPIFFS_GEO_BLOCK_COUNT(fs))
{ {
int16_t erase_count; int16_t erase_count;
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_ERASE_COUNT_PADDR(fs, blkndx), 0, SPIFFS_ERASE_COUNT_PADDR(fs, blkndx),
sizeof(int16_t), (FAR uint8_t *)&erase_count); sizeof(int16_t), (FAR uint8_t *)&erase_count);
@ -812,7 +813,7 @@ int spiffs_objlu_scan(FAR struct spiffs_s *fs)
return ret; return ret;
} }
if (erase_count != SPIFFS_OBJ_ID_FREE) if (erase_count != SPIFFS_OBJID_FREE)
{ {
erase_count_min = MIN(erase_count_min, erase_count); erase_count_min = MIN(erase_count_min, erase_count);
erase_count_max = MAX(erase_count_max, erase_count); erase_count_max = MAX(erase_count_max, erase_count);
@ -821,13 +822,13 @@ int spiffs_objlu_scan(FAR struct spiffs_s *fs)
blkndx++; blkndx++;
} }
if (erase_count_min == 0 && erase_count_max == SPIFFS_OBJ_ID_FREE) if (erase_count_min == 0 && erase_count_max == SPIFFS_OBJID_FREE)
{ {
/* Clean system, set counter to zero */ /* Clean system, set counter to zero */
erase_count_final = 0; erase_count_final = 0;
} }
else if (erase_count_max - erase_count_min > (SPIFFS_OBJ_ID_FREE) / 2) else if (erase_count_max - erase_count_min > (SPIFFS_OBJID_FREE / 2))
{ {
/* Wrap, take min */ /* Wrap, take min */
@ -898,7 +899,7 @@ int spiffs_objlu_find_free(FAR struct spiffs_s *fs, int16_t starting_block,
} }
ret = spiffs_objlu_find_id(fs, starting_block, starting_lu_entry, ret = spiffs_objlu_find_id(fs, starting_block, starting_lu_entry,
SPIFFS_OBJ_ID_FREE, blkndx, lu_entry); SPIFFS_OBJID_FREE, blkndx, lu_entry);
if (ret == OK) if (ret == OK)
{ {
fs->free_blkndx = *blkndx; fs->free_blkndx = *blkndx;
@ -1183,7 +1184,7 @@ int spiffs_page_move(FAR struct spiffs_s *fs,
phdr->flags &= ~SPIFFS_PH_FLAG_USED; phdr->flags &= ~SPIFFS_PH_FLAG_USED;
ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_UPDT, 0, ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_UPDT, 0,
SPIFFS_PAGE_TO_PADDR(fs, free_pgndx), SPIFFS_PAGE_TO_PADDR(fs, free_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), page_data); SPIFFS_GEO_PAGE_SIZE(fs), page_data);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret); ferr("ERROR: spiffs_cache_write() failed: %d\n", ret);
@ -1196,7 +1197,7 @@ int spiffs_page_move(FAR struct spiffs_s *fs,
ret = spiffs_phys_cpy(fs, objid, SPIFFS_PAGE_TO_PADDR(fs, free_pgndx), ret = spiffs_phys_cpy(fs, objid, SPIFFS_PAGE_TO_PADDR(fs, free_pgndx),
SPIFFS_PAGE_TO_PADDR(fs, src_pgndx), SPIFFS_PAGE_TO_PADDR(fs, src_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs)); SPIFFS_GEO_PAGE_SIZE(fs));
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_phys_cpy() failed: %d\n", ret); ferr("ERROR: spiffs_phys_cpy() failed: %d\n", ret);
@ -1256,7 +1257,7 @@ int spiffs_page_delete(FAR struct spiffs_s *fs, int16_t pgndx)
/* Mark deleted entry in source object lookup */ /* Mark deleted entry in source object lookup */
int16_t d_objid = SPIFFS_OBJ_ID_DELETED; int16_t d_objid = SPIFFS_OBJID_DELETED;
ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_DELE, 0, ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_DELE, 0,
SPIFFS_BLOCK_TO_PADDR(fs, SPIFFS_BLOCK_FOR_PAGE(fs, pgndx)) + SPIFFS_BLOCK_TO_PADDR(fs, SPIFFS_BLOCK_FOR_PAGE(fs, pgndx)) +
SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, pgndx) * SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, pgndx) *
@ -1327,7 +1328,7 @@ int spiffs_object_create(FAR struct spiffs_s *fs,
return ret; return ret;
} }
objid |= SPIFFS_OBJ_ID_IX_FLAG; objid |= SPIFFS_OBJID_NDXFLAG;
/* Find free entry */ /* Find free entry */
@ -1382,7 +1383,7 @@ int spiffs_object_create(FAR struct spiffs_s *fs,
} }
spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)&objndx_hdr, spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)&objndx_hdr,
SPIFFS_EV_IX_NEW, objid, 0, SPIFFS_EV_NDXNEW, objid, 0,
SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, blkndx, entry), SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, blkndx, entry),
SPIFFS_UNDEFINED_LEN); SPIFFS_UNDEFINED_LEN);
@ -1416,7 +1417,7 @@ int spiffs_object_update_index_hdr(FAR struct spiffs_s *fs,
int16_t new_objhdr_pgndx; int16_t new_objhdr_pgndx;
int ret = OK; int ret = OK;
objid |= SPIFFS_OBJ_ID_IX_FLAG; objid |= SPIFFS_OBJID_NDXFLAG;
if (new_objhdr_data) if (new_objhdr_data)
{ {
@ -1431,7 +1432,7 @@ int spiffs_object_update_index_hdr(FAR struct spiffs_s *fs,
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, objhdr_pgndx), SPIFFS_PAGE_TO_PADDR(fs, objhdr_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -1477,8 +1478,8 @@ int spiffs_object_update_index_hdr(FAR struct spiffs_s *fs,
/* callback on object index update */ /* callback on object index update */
spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)objhdr, spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)objhdr,
new_objhdr_data ? SPIFFS_EV_IX_UPD : new_objhdr_data ? SPIFFS_EV_NDXUPD :
SPIFFS_EV_IX_UPD_HDR, objid, SPIFFS_EV_NDXUPD_HDR, objid,
objhdr->phdr.spndx, new_objhdr_pgndx, objhdr->phdr.spndx, new_objhdr_pgndx,
objhdr->size); objhdr->size);
if (fobj != NULL) if (fobj != NULL)
@ -1512,7 +1513,7 @@ void spiffs_object_event(FAR struct spiffs_s *fs,
FAR struct spiffs_file_s *fobj; FAR struct spiffs_file_s *fobj;
FAR struct spiffs_file_s *next; FAR struct spiffs_file_s *next;
int16_t objid = objid_raw & ~SPIFFS_OBJ_ID_IX_FLAG; int16_t objid = objid_raw & ~SPIFFS_OBJID_NDXFLAG;
finfo("Event=%s objid=%04x spndx=%04x npgndx=%04x nsz=%d\n", finfo("Event=%s objid=%04x spndx=%04x npgndx=%04x nsz=%d\n",
evname[MIN(ev, 5)], objid_raw, spndx, new_pgndx, new_size); evname[MIN(ev, 5)], objid_raw, spndx, new_pgndx, new_size);
@ -1529,7 +1530,7 @@ void spiffs_object_event(FAR struct spiffs_s *fs,
/* Is this the object we are looking for? */ /* Is this the object we are looking for? */
if ((fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG) != objid) if ((fobj->objid & ~SPIFFS_OBJID_NDXFLAG) != objid)
{ {
continue; /* Object not related to updated file */ continue; /* Object not related to updated file */
} }
@ -1538,7 +1539,7 @@ void spiffs_object_event(FAR struct spiffs_s *fs,
{ {
/* Object index header update */ /* Object index header update */
if (ev != SPIFFS_EV_IX_DEL) if (ev != SPIFFS_EV_NDXDEL)
{ {
finfo("Setting objid=%d (offset=%d) objhdr_pgndx to %04x size=%d\n", finfo("Setting objid=%d (offset=%d) objhdr_pgndx to %04x size=%d\n",
fobj->objid, fobj->offset, new_pgndx, new_size); fobj->objid, fobj->offset, new_pgndx, new_size);
@ -1602,7 +1603,7 @@ void spiffs_object_event(FAR struct spiffs_s *fs,
if (fobj->objndx_spndx == spndx) if (fobj->objndx_spndx == spndx)
{ {
if (ev != SPIFFS_EV_IX_DEL) if (ev != SPIFFS_EV_NDXDEL)
{ {
finfo("callback: setting objid=%d span=%04x objndx_pgndx to %04x\n", finfo("callback: setting objid=%d span=%04x objndx_pgndx to %04x\n",
fobj->objid, spndx, new_pgndx); fobj->objid, spndx, new_pgndx);
@ -1773,7 +1774,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), SPIFFS_GEO_PAGE_SIZE(fs),
fs->work); fs->work);
if (ret < 0) if (ret < 0)
{ {
@ -1818,7 +1819,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), SPIFFS_GEO_PAGE_SIZE(fs),
fs->work); fs->work);
if (ret < 0) if (ret < 0)
{ {
@ -1827,7 +1828,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
} }
spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)fs->work, spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)fs->work,
SPIFFS_EV_IX_UPD, fobj->objid, SPIFFS_EV_NDXUPD, fobj->objid,
objndx->phdr.spndx, cur_objndx_pgndx, objndx->phdr.spndx, cur_objndx_pgndx,
0); 0);
@ -1867,7 +1868,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -1894,13 +1895,13 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
if (written > 0 || cur_objndx_spndx > len_objndx_spndx) if (written > 0 || cur_objndx_spndx > len_objndx_spndx)
{ {
phdr.objid = fobj->objid | SPIFFS_OBJ_ID_IX_FLAG; phdr.objid = fobj->objid | SPIFFS_OBJID_NDXFLAG;
phdr.spndx = cur_objndx_spndx; phdr.spndx = cur_objndx_spndx;
phdr.flags = phdr.flags =
0xff & ~(SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_INDEX); 0xff & ~(SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_INDEX);
ret = spiffs_page_allocate_data(fs, ret = spiffs_page_allocate_data(fs,
fobj->objid | SPIFFS_OBJ_ID_IX_FLAG, fobj->objid | SPIFFS_OBJID_NDXFLAG,
&phdr, 0, 0, 0, 1, &phdr, 0, 0, 0, 1,
&cur_objndx_pgndx); &cur_objndx_pgndx);
if (ret < 0) if (ret < 0)
@ -1912,12 +1913,12 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
/* Quick "load" of new object index page */ /* Quick "load" of new object index page */
memset(fs->work, 0xff, SPIFFS_CFG_LOG_PAGE_SZ(fs)); memset(fs->work, 0xff, SPIFFS_GEO_PAGE_SIZE(fs));
memcpy(fs->work, &phdr, sizeof(struct spiffs_page_header_s)); memcpy(fs->work, &phdr, sizeof(struct spiffs_page_header_s));
spiffs_object_event(fs, spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)fs->work, (FAR struct spiffs_page_objndx_s *)fs->work,
SPIFFS_EV_IX_NEW, fobj->objid, SPIFFS_EV_NDXNEW, fobj->objid,
cur_objndx_spndx, cur_objndx_pgndx, 0); cur_objndx_spndx, cur_objndx_pgndx, 0);
finfo("objid=%04x create objndx page, %04x:%04x, written=%d\n", finfo("objid=%04x create objndx page, %04x:%04x, written=%d\n",
@ -1940,7 +1941,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
else else
{ {
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
fobj->objid | SPIFFS_OBJ_ID_IX_FLAG, fobj->objid | SPIFFS_OBJID_NDXFLAG,
cur_objndx_spndx, 0, cur_objndx_spndx, 0,
&pgndx); &pgndx);
if (ret < 0) if (ret < 0)
@ -1958,7 +1959,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, pgndx), SPIFFS_PAGE_TO_PADDR(fs, pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), SPIFFS_GEO_PAGE_SIZE(fs),
fs->work); fs->work);
if (ret < 0) if (ret < 0)
{ {
@ -1995,12 +1996,12 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
{ {
/* ATt beginning of a page, allocate and write a new page of data */ /* ATt beginning of a page, allocate and write a new page of data */
phdr.objid = fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG; phdr.objid = fobj->objid & ~SPIFFS_OBJID_NDXFLAG;
phdr.spndx = data_spndx; phdr.spndx = data_spndx;
phdr.flags = 0xff & ~(SPIFFS_PH_FLAG_FINAL); /* Finalize immediately */ phdr.flags = 0xff & ~(SPIFFS_PH_FLAG_FINAL); /* Finalize immediately */
ret = spiffs_page_allocate_data(fs, ret = spiffs_page_allocate_data(fs,
fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG, fobj->objid & ~SPIFFS_OBJID_NDXFLAG,
&phdr, &data[written], to_write, &phdr, &data[written], to_write,
page_offs, 1, &data_page); page_offs, 1, &data_page);
@ -2117,7 +2118,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
ret2 = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT, ret2 = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret2 < 0) if (ret2 < 0)
{ {
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret2); ferr("ERROR: spiffs_cache_write() failed: %d\n", ret2);
@ -2126,7 +2127,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
spiffs_object_event(fs, spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)fs->work, (FAR struct spiffs_page_objndx_s *)fs->work,
SPIFFS_EV_IX_UPD, fobj->objid, SPIFFS_EV_NDXUPD, fobj->objid,
objndx->phdr.spndx, cur_objndx_pgndx, 0); objndx->phdr.spndx, cur_objndx_pgndx, 0);
/* Update size in object header index page */ /* Update size in object header index page */
@ -2173,7 +2174,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_UPDT,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret2 < 0) if (ret2 < 0)
{ {
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret2); ferr("ERROR: spiffs_cache_write() failed: %d\n", ret2);
@ -2182,7 +2183,7 @@ int spiffs_object_append(FAR struct spiffs_s *fs,
spiffs_object_event(fs, spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)fs->work, (FAR struct spiffs_page_objndx_s *)fs->work,
SPIFFS_EV_IX_UPD_HDR, fobj->objid, SPIFFS_EV_NDXUPD_HDR, fobj->objid,
objhdr->phdr.spndx, cur_objndx_pgndx, objhdr->phdr.spndx, cur_objndx_pgndx,
objhdr->size); objhdr->size);
} }
@ -2331,7 +2332,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
spiffs_object_event(fs, spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)objndx, (FAR struct spiffs_page_objndx_s *)objndx,
SPIFFS_EV_IX_UPD, fobj->objid, SPIFFS_EV_NDXUPD, fobj->objid,
objndx->phdr.spndx, new_objndx_pgndx, objndx->phdr.spndx, new_objndx_pgndx,
0); 0);
} }
@ -2350,7 +2351,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, cur_objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -2380,7 +2381,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
else else
{ {
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
fobj->objid | SPIFFS_OBJ_ID_IX_FLAG, fobj->objid | SPIFFS_OBJID_NDXFLAG,
cur_objndx_spndx, 0, cur_objndx_spndx, 0,
&pgndx); &pgndx);
if (ret < 0) if (ret < 0)
@ -2397,7 +2398,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, pgndx), SPIFFS_PAGE_TO_PADDR(fs, pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -2443,7 +2444,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
[SPIFFS_OBJ_IX_ENTRY(fs, data_spndx)]; [SPIFFS_OBJ_IX_ENTRY(fs, data_spndx)];
} }
phdr.objid = fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG; phdr.objid = fobj->objid & ~SPIFFS_OBJID_NDXFLAG;
phdr.spndx = data_spndx; phdr.spndx = data_spndx;
phdr.flags = 0xff; phdr.flags = 0xff;
@ -2452,7 +2453,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
/* A full page, allocate and write a new page of data */ /* A full page, allocate and write a new page of data */
ret = spiffs_page_allocate_data(fs, ret = spiffs_page_allocate_data(fs,
fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG, fobj->objid & ~SPIFFS_OBJID_NDXFLAG,
&phdr, &data[written], to_write, &phdr, &data[written], to_write,
page_offs, 1, &data_pgndx); page_offs, 1, &data_pgndx);
finfo("Store new data page, %04x:%04x offset=%d, len=%d, written=%d\n", finfo("Store new data page, %04x:%04x offset=%d, len=%d, written=%d\n",
@ -2470,7 +2471,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
} }
ret = spiffs_page_allocate_data(fs, ret = spiffs_page_allocate_data(fs,
fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG, fobj->objid & ~SPIFFS_OBJID_NDXFLAG,
&phdr, 0, 0, 0, 0, &data_pgndx); &phdr, 0, 0, 0, 0, &data_pgndx);
if (ret < 0) if (ret < 0)
{ {
@ -2624,7 +2625,7 @@ int spiffs_object_modify(FAR struct spiffs_s *fs,
} }
spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)objndx, spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)objndx,
SPIFFS_EV_IX_UPD, fobj->objid, objndx->phdr.spndx, SPIFFS_EV_NDXUPD, fobj->objid, objndx->phdr.spndx,
new_objndx_pgndx, 0); new_objndx_pgndx, 0);
} }
else else
@ -2809,7 +2810,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
return ret; return ret;
} }
spiffs_object_event(fs, NULL, SPIFFS_EV_IX_DEL, fobj->objid, spiffs_object_event(fs, NULL, SPIFFS_EV_NDXDEL, fobj->objid,
objndx->phdr.spndx, objndx_pgndx, 0); objndx->phdr.spndx, objndx_pgndx, 0);
if (prev_objndx_spndx > 0) if (prev_objndx_spndx > 0)
{ {
@ -2857,7 +2858,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
else else
{ {
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
fobj->objid | SPIFFS_OBJ_ID_IX_FLAG, fobj->objid | SPIFFS_OBJID_NDXFLAG,
cur_objndx_spndx, 0, cur_objndx_spndx, 0,
&objndx_pgndx); &objndx_pgndx);
if (ret < 0) if (ret < 0)
@ -2874,7 +2875,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -2906,7 +2907,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
((FAR int16_t *)((FAR uint8_t *)objhdr + ((FAR int16_t *)((FAR uint8_t *)objhdr +
sizeof(struct spiffs_pgobj_ndxheader_s)))[data_spndx] = sizeof(struct spiffs_pgobj_ndxheader_s)))[data_spndx] =
SPIFFS_OBJ_ID_FREE; SPIFFS_OBJID_FREE;
} }
else else
{ {
@ -2919,7 +2920,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
((FAR int16_t *)((FAR uint8_t *)objndx + ((FAR int16_t *)((FAR uint8_t *)objndx +
sizeof(struct spiffs_page_objndx_s))) sizeof(struct spiffs_page_objndx_s)))
[SPIFFS_OBJ_IX_ENTRY(fs, data_spndx)] = SPIFFS_OBJ_ID_FREE; [SPIFFS_OBJ_IX_ENTRY(fs, data_spndx)] = SPIFFS_OBJID_FREE;
} }
finfo("Got data pgndx %04x\n", data_pgndx); finfo("Got data pgndx %04x\n", data_pgndx);
@ -2990,14 +2991,14 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
break; break;
} }
phdr.objid = fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG; phdr.objid = fobj->objid & ~SPIFFS_OBJID_NDXFLAG;
phdr.spndx = data_spndx; phdr.spndx = data_spndx;
phdr.flags = 0xff; phdr.flags = 0xff;
/* Allocate new page and copy unmodified data */ /* Allocate new page and copy unmodified data */
ret = spiffs_page_allocate_data(fs, ret = spiffs_page_allocate_data(fs,
fobj->objid & ~SPIFFS_OBJ_ID_IX_FLAG, fobj->objid & ~SPIFFS_OBJID_NDXFLAG,
&phdr, 0, 0, 0, 0, &phdr, 0, 0, 0, 0,
&new_data_pgndx); &new_data_pgndx);
if (ret < 0) if (ret < 0)
@ -3106,7 +3107,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
return ret; return ret;
} }
spiffs_object_event(fs, NULL, SPIFFS_EV_IX_DEL, fobj->objid, spiffs_object_event(fs, NULL, SPIFFS_EV_NDXDEL, fobj->objid,
0, objndx_pgndx, 0); 0, objndx_pgndx, 0);
} }
else else
@ -3117,7 +3118,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
memset(fs->work + sizeof(struct spiffs_pgobj_ndxheader_s), memset(fs->work + sizeof(struct spiffs_pgobj_ndxheader_s),
0xff, 0xff,
SPIFFS_CFG_LOG_PAGE_SZ(fs) - SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_pgobj_ndxheader_s)); sizeof(struct spiffs_pgobj_ndxheader_s));
ret = spiffs_object_update_index_hdr(fs, fobj, fobj->objid, ret = spiffs_object_update_index_hdr(fs, fobj, fobj->objid,
@ -3175,7 +3176,7 @@ int spiffs_object_truncate(FAR struct spiffs_s *fs,
} }
spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)objhdr, spiffs_object_event(fs, (FAR struct spiffs_page_objndx_s *)objhdr,
SPIFFS_EV_IX_UPD, fobj->objid, objndx->phdr.spndx, SPIFFS_EV_NDXUPD, fobj->objid, objndx->phdr.spndx,
new_objndx_pgndx, 0); new_objndx_pgndx, 0);
finfo("Store modified objndx page, %04x:%04x\n", finfo("Store modified objndx page, %04x:%04x\n",
@ -3254,7 +3255,7 @@ ssize_t spiffs_object_read(FAR struct spiffs_s *fs,
else else
{ {
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
fobj->objid | SPIFFS_OBJ_ID_IX_FLAG, fobj->objid | SPIFFS_OBJID_NDXFLAG,
cur_objndx_spndx, 0, cur_objndx_spndx, 0,
&objndx_pgndx); &objndx_pgndx);
if (ret < 0) if (ret < 0)
@ -3272,7 +3273,7 @@ ssize_t spiffs_object_read(FAR struct spiffs_s *fs,
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_IX | SPIFFS_OP_C_READ,
fobj->objid, fobj->objid,
SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -3385,24 +3386,24 @@ int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs, int16_t *objid,
int16_t free_objid; int16_t free_objid;
int ret = OK; int ret = OK;
max_objects = (fs->geo.neraseblocks * SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs)) / 2; max_objects = (SPIFFS_GEO_BLOCK_COUNT(fs) * SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs)) / 2;
free_objid = SPIFFS_OBJ_ID_FREE; free_objid = SPIFFS_OBJID_FREE;
state.min_objid = 1; state.min_objid = 1;
state.max_objid = max_objects + 1; state.max_objid = max_objects + 1;
if ((state.max_objid & SPIFFS_OBJ_ID_IX_FLAG) != 0) if ((state.max_objid & SPIFFS_OBJID_NDXFLAG) != 0)
{ {
state.max_objid = ((int16_t) - 1) & ~SPIFFS_OBJ_ID_IX_FLAG; state.max_objid = ((int16_t) - 1) & ~SPIFFS_OBJID_NDXFLAG;
} }
state.compaction = 0; state.compaction = 0;
state.conflicting_name = conflicting_name; state.conflicting_name = conflicting_name;
while (ret >= 0 && free_objid == SPIFFS_OBJ_ID_FREE) while (ret >= 0 && free_objid == SPIFFS_OBJID_FREE)
{ {
if (state.max_objid - state.min_objid <= if (state.max_objid - state.min_objid <=
(int16_t)SPIFFS_CFG_LOG_PAGE_SZ(fs) * 8) (int16_t)SPIFFS_GEO_PAGE_SIZE(fs) * 8)
{ {
uint32_t i; uint32_t i;
uint32_t j; uint32_t j;
@ -3412,7 +3413,7 @@ int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs, int16_t *objid,
finfo("BITM min=%04x max=%04x\n", finfo("BITM min=%04x max=%04x\n",
state.min_objid, state.max_objid); state.min_objid, state.max_objid);
memset(fs->work, 0, SPIFFS_CFG_LOG_PAGE_SZ(fs)); memset(fs->work, 0, SPIFFS_GEO_PAGE_SIZE(fs));
ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0, ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0,
spiffs_objlu_find_free_objid_bitmap_callback, spiffs_objlu_find_free_objid_bitmap_callback,
conflicting_name, &state.min_objid, conflicting_name, &state.min_objid,
@ -3429,7 +3430,7 @@ int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs, int16_t *objid,
/* Traverse bitmask until found free objid */ /* Traverse bitmask until found free objid */
for (i = 0; i < SPIFFS_CFG_LOG_PAGE_SZ(fs); i++) for (i = 0; i < SPIFFS_GEO_PAGE_SIZE(fs); i++)
{ {
uint8_t mask = fs->work[i]; uint8_t mask = fs->work[i];
@ -3472,7 +3473,7 @@ int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs, int16_t *objid,
min_count = 0xff; min_count = 0xff;
for (i = 0; for (i = 0;
i < SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(uint8_t); i < SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(uint8_t);
i++) i++)
{ {
if (map[i] < min_count) if (map[i] < min_count)
@ -3518,7 +3519,7 @@ int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs, int16_t *objid,
} }
if ((state.max_objid - state.min_objid <= if ((state.max_objid - state.min_objid <=
(int16_t)SPIFFS_CFG_LOG_PAGE_SZ(fs) * 8)) (int16_t)SPIFFS_GEO_PAGE_SIZE(fs) * 8))
{ {
/* No need for compacting, use bitmap */ /* No need for compacting, use bitmap */
@ -3536,12 +3537,12 @@ int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs, int16_t *objid,
state.compaction = state.compaction =
(state.max_objid - (state.max_objid -
state.min_objid) / ((SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(uint8_t))); state.min_objid) / ((SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(uint8_t)));
finfo("COMP min=%04x max=%04x compact=%d\n", finfo("COMP min=%04x max=%04x compact=%d\n",
state.min_objid, state.max_objid, state.compaction); state.min_objid, state.max_objid, state.compaction);
memset(fs->work, 0, SPIFFS_CFG_LOG_PAGE_SZ(fs)); memset(fs->work, 0, SPIFFS_GEO_PAGE_SIZE(fs));
ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0, ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0,
spiffs_objlu_find_free_objid_compact_callback, spiffs_objlu_find_free_objid_compact_callback,
&state, 0, 0, 0); &state, 0, 0, 0);

124
fs/spiffs/src/spiffs_core.h
View File

@ -174,138 +174,116 @@
#define SPIFFS_VIS_END (SPIFFS_ERR_INTERNAL - 22) #define SPIFFS_VIS_END (SPIFFS_ERR_INTERNAL - 22)
/* updating an object index contents */ /* Events */
#define SPIFFS_EV_IX_UPD (0) #define SPIFFS_EV_NDXUPD (0) /* Updating object index contents */
#define SPIFFS_EV_NDXNEW (1) /* Creating new object index */
#define SPIFFS_EV_NDXDEL (2) /* Deleting object index */
#define SPIFFS_EV_NDXMOV (3) /* Moving abject index without
* updating contents */
#define SPIFFS_EV_NDXUPD_HDR (4) /* Updating object index header
* data only (not the table itself */
/* creating a new object index */ #define SPIFFS_OBJID_NDXFLAG ((int16_t)(1 << (8 * sizeof(int16_t) - 1)))
#define SPIFFS_EV_IX_NEW (1)
/* deleting an object index */
#define SPIFFS_EV_IX_DEL (2)
/* moving an object index without updating contents */
#define SPIFFS_EV_IX_MOV (3)
/* updating an object index header data only, not the table itself */
#define SPIFFS_EV_IX_UPD_HDR (4)
#define SPIFFS_OBJ_ID_IX_FLAG ((int16_t)(1<<(8*sizeof(int16_t)-1)))
#define SPIFFS_UNDEFINED_LEN (uint32_t)(-1) #define SPIFFS_UNDEFINED_LEN (uint32_t)(-1)
#define SPIFFS_OBJ_ID_DELETED ((int16_t)0) #define SPIFFS_OBJID_DELETED ((int16_t)0)
#define SPIFFS_OBJ_ID_FREE ((int16_t)-1) #define SPIFFS_OBJID_FREE ((int16_t)-1)
/* total number of pages */ /* Number of object lookup pages per block */
#define SPIFFS_MAX_PAGES(fs) \ #define SPIFFS_OBJ_LOOKUP_PAGES(fs) \
(SPIFFS_CFG_PHYS_SZ(fs)/SPIFFS_CFG_LOG_PAGE_SZ(fs)) (MAX(1, (SPIFFS_GEO_PAGES_PER_BLOCK(fs) * sizeof(int16_t)) / SPIFFS_GEO_PAGE_SIZE(fs)))
/* total number of pages per block, including object lookup pages */ /* Checks if page index belongs to object lookup */
#define SPIFFS_PAGES_PER_BLOCK(fs) \
(SPIFFS_CFG_LOG_BLOCK_SZ(fs)/SPIFFS_CFG_LOG_PAGE_SZ(fs))
/* number of object lookup pages per block */
#define SPIFFS_OBJ_LOOKUP_PAGES(fs) \
(MAX(1, (SPIFFS_PAGES_PER_BLOCK(fs) * sizeof(int16_t)) / SPIFFS_CFG_LOG_PAGE_SZ(fs)))
/* checks if page index belongs to object lookup */
#define SPIFFS_IS_LOOKUP_PAGE(fs,pgndx) \ #define SPIFFS_IS_LOOKUP_PAGE(fs,pgndx) \
(((pgndx) % SPIFFS_PAGES_PER_BLOCK(fs)) < SPIFFS_OBJ_LOOKUP_PAGES(fs)) (((pgndx) % SPIFFS_GEO_PAGES_PER_BLOCK(fs)) < SPIFFS_OBJ_LOOKUP_PAGES(fs))
/* number of object lookup entries in all object lookup pages */ /* Number of object lookup entries in all object lookup pages */
#define SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) \ #define SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) \
(SPIFFS_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs)) (SPIFFS_GEO_PAGES_PER_BLOCK(fs)-SPIFFS_OBJ_LOOKUP_PAGES(fs))
/* converts a block to physical address */ /* Converts a block to physical address */
#define SPIFFS_BLOCK_TO_PADDR(fs, block) ((block) * SPIFFS_CFG_LOG_BLOCK_SZ(fs)) #define SPIFFS_BLOCK_TO_PADDR(fs, block) ((block) * SPIFFS_GEO_BLOCK_SIZE(fs))
/* converts a object lookup entry to page index */ /* Converts a object lookup entry to page index */
#define SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, block, entry) \ #define SPIFFS_OBJ_LOOKUP_ENTRY_TO_PIX(fs, block, entry) \
((block)*SPIFFS_PAGES_PER_BLOCK(fs) + (SPIFFS_OBJ_LOOKUP_PAGES(fs) + entry)) ((block)*SPIFFS_GEO_PAGES_PER_BLOCK(fs) + (SPIFFS_OBJ_LOOKUP_PAGES(fs) + entry))
/* converts a object lookup entry to physical address of corresponding page */ /* Converts a object lookup entry to physical address of corresponding page */
#define SPIFFS_OBJ_LOOKUP_ENTRY_TO_PADDR(fs, block, entry) \ #define SPIFFS_OBJ_LOOKUP_ENTRY_TO_PADDR(fs, block, entry) \
(SPIFFS_BLOCK_TO_PADDR(fs, block) + (SPIFFS_OBJ_LOOKUP_PAGES(fs) + entry) * SPIFFS_CFG_LOG_PAGE_SZ(fs)) (SPIFFS_BLOCK_TO_PADDR(fs, block) + (SPIFFS_OBJ_LOOKUP_PAGES(fs) + entry) * SPIFFS_GEO_PAGE_SIZE(fs))
/* converts a page to physical address */ /* Converts a page to physical address */
#define SPIFFS_PAGE_TO_PADDR(fs, page) ((page) * SPIFFS_CFG_LOG_PAGE_SZ(fs)) #define SPIFFS_PAGE_TO_PADDR(fs, page) ((page) * SPIFFS_GEO_PAGE_SIZE(fs))
/* converts a physical address to page */ /* Converts a physical address to page */
#define SPIFFS_PADDR_TO_PAGE(fs, addr) ((addr) / SPIFFS_CFG_LOG_PAGE_SZ(fs)) #define SPIFFS_PADDR_TO_PAGE(fs, addr) ((addr) / SPIFFS_GEO_PAGE_SIZE(fs))
/* gives index in page for a physical address */ /* Gives index in page for a physical address */
#define SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr) ((addr) % SPIFFS_CFG_LOG_PAGE_SZ(fs)) #define SPIFFS_PADDR_TO_PAGE_OFFSET(fs, addr) ((addr) % SPIFFS_GEO_PAGE_SIZE(fs))
/* returns containing block for given page */ /* Returns containing block for given page */
#define SPIFFS_BLOCK_FOR_PAGE(fs, page) ((page) / SPIFFS_PAGES_PER_BLOCK(fs)) #define SPIFFS_BLOCK_FOR_PAGE(fs, page) ((page) / SPIFFS_GEO_PAGES_PER_BLOCK(fs))
/* returns starting page for block */ /* Returns starting page for block */
#define SPIFFS_PAGE_FOR_BLOCK(fs, block) ((block) * SPIFFS_PAGES_PER_BLOCK(fs)) #define SPIFFS_PAGE_FOR_BLOCK(fs, block) ((block) * SPIFFS_GEO_PAGES_PER_BLOCK(fs))
/* converts page to entry in object lookup page */ /* Converts page to entry in object lookup page */
#define SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, page) \ #define SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, page) \
((page) % SPIFFS_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs)) ((page) % SPIFFS_GEO_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs))
/* returns data size in a data page */ /* Returns data size in a data page */
#define SPIFFS_DATA_PAGE_SIZE(fs) \ #define SPIFFS_DATA_PAGE_SIZE(fs) \
(SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(struct spiffs_page_header_s)) (SPIFFS_GEO_PAGE_SIZE(fs) - sizeof(struct spiffs_page_header_s))
/* returns physical address for block's erase count, /* Returns physical address for block's erase count,
* always in the physical last entry of the last object lookup page * always in the physical last entry of the last object lookup page
*/ */
#define SPIFFS_ERASE_COUNT_PADDR(fs, blkndx) \ #define SPIFFS_ERASE_COUNT_PADDR(fs, blkndx) \
(SPIFFS_BLOCK_TO_PADDR(fs, blkndx) + SPIFFS_OBJ_LOOKUP_PAGES(fs) * SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(int16_t)) (SPIFFS_BLOCK_TO_PADDR(fs, blkndx) + SPIFFS_OBJ_LOOKUP_PAGES(fs) * SPIFFS_GEO_PAGE_SIZE(fs) - sizeof(int16_t))
/* checks if there is any room for magic in the object luts */ /* Checks if there is any room for magic in the object luts */
#define SPIFFS_CHECK_MAGIC_POSSIBLE(fs) \ #define SPIFFS_CHECK_MAGIC_POSSIBLE(fs) \
((SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) % (SPIFFS_CFG_LOG_PAGE_SZ(fs)/sizeof(int16_t))) * sizeof(int16_t) \ ((SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) % (SPIFFS_GEO_PAGE_SIZE(fs)/sizeof(int16_t))) * sizeof(int16_t) \
<= (SPIFFS_CFG_LOG_PAGE_SZ(fs)-sizeof(int16_t)*2)) <= (SPIFFS_GEO_PAGE_SIZE(fs)-sizeof(int16_t)*2))
/* define helpers object */ /* Entries in an object header page index */
/* entries in an object header page index */
#define SPIFFS_OBJ_HDR_IX_LEN(fs) \ #define SPIFFS_OBJ_HDR_IX_LEN(fs) \
((SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(struct spiffs_pgobj_ndxheader_s))/sizeof(int16_t)) ((SPIFFS_GEO_PAGE_SIZE(fs) - sizeof(struct spiffs_pgobj_ndxheader_s))/sizeof(int16_t))
/* entries in an object page index */ /* Entries in an object page index */
#define SPIFFS_OBJ_IX_LEN(fs) \ #define SPIFFS_OBJ_IX_LEN(fs) \
((SPIFFS_CFG_LOG_PAGE_SZ(fs) - sizeof(struct spiffs_page_objndx_s))/sizeof(int16_t)) ((SPIFFS_GEO_PAGE_SIZE(fs) - sizeof(struct spiffs_page_objndx_s))/sizeof(int16_t))
/* object index entry for given data span index */ /* Object index entry for given data span index */
#define SPIFFS_OBJ_IX_ENTRY(fs, spndx) \ #define SPIFFS_OBJ_IX_ENTRY(fs, spndx) \
((spndx) < SPIFFS_OBJ_HDR_IX_LEN(fs) ? (spndx) : (((spndx)-SPIFFS_OBJ_HDR_IX_LEN(fs))%SPIFFS_OBJ_IX_LEN(fs))) ((spndx) < SPIFFS_OBJ_HDR_IX_LEN(fs) ? (spndx) : (((spndx)-SPIFFS_OBJ_HDR_IX_LEN(fs))%SPIFFS_OBJ_IX_LEN(fs)))
/* object index span index number for given data span index or entry */ /* Object index span index number for given data span index or entry */
#define SPIFFS_OBJ_IX_ENTRY_SPAN_IX(fs, spndx) \ #define SPIFFS_OBJ_IX_ENTRY_SPAN_IX(fs, spndx) \
((spndx) < SPIFFS_OBJ_HDR_IX_LEN(fs) ? 0 : (1+((spndx)-SPIFFS_OBJ_HDR_IX_LEN(fs))/SPIFFS_OBJ_IX_LEN(fs))) ((spndx) < SPIFFS_OBJ_HDR_IX_LEN(fs) ? 0 : (1+((spndx)-SPIFFS_OBJ_HDR_IX_LEN(fs))/SPIFFS_OBJ_IX_LEN(fs)))
/* get data span index for object index span index */ /* Get data span index for object index span index */
#define SPIFFS_DATA_SPAN_IX_FOR_OBJ_IX_SPAN_IX(fs, spndx) \ #define SPIFFS_DATA_SPAN_IX_FOR_OBJ_IX_SPAN_IX(fs, spndx) \
((spndx) == 0 ? 0 : (SPIFFS_OBJ_HDR_IX_LEN(fs) + (((spndx)-1) * SPIFFS_OBJ_IX_LEN(fs)))) ((spndx) == 0 ? 0 : (SPIFFS_OBJ_HDR_IX_LEN(fs) + (((spndx)-1) * SPIFFS_OBJ_IX_LEN(fs))))
@ -422,7 +400,7 @@ int spiffs_foreach_objlu(FAR struct spiffs_s *fs, int16_t starting_block,
FAR void *user_var, FAR int16_t *blkndx, int *lu_entry); FAR void *user_var, FAR int16_t *blkndx, int *lu_entry);
int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx); int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx);
int spiffs_objlu_scan(FAR struct spiffs_s *fs); int spiffs_objlu_scan(FAR struct spiffs_s *fs);
int spiffs_objlu_find_free_obj_id(FAR struct spiffs_s *fs, int spiffs_objlu_find_free_objid(FAR struct spiffs_s *fs,
int16_t *objid, FAR const uint8_t *conflicting_name); int16_t *objid, FAR const uint8_t *conflicting_name);
int spiffs_objlu_find_free(FAR struct spiffs_s *fs, int spiffs_objlu_find_free(FAR struct spiffs_s *fs,
int16_t starting_block, int starting_lu_entry, int16_t starting_block, int starting_lu_entry,

142
fs/spiffs/src/spiffs_gc.c
View File

@ -117,7 +117,7 @@ static int spiffs_gc_erase_block(FAR struct spiffs_s *fs, int16_t blkndx)
/* Then remove the pages from the cache. */ /* Then remove the pages from the cache. */
for (i = 0; i < SPIFFS_PAGES_PER_BLOCK(fs); i++) for (i = 0; i < SPIFFS_GEO_PAGES_PER_BLOCK(fs); i++)
{ {
spiffs_cache_drop_page(fs, SPIFFS_PAGE_FOR_BLOCK(fs, blkndx) + i); spiffs_cache_drop_page(fs, SPIFFS_PAGE_FOR_BLOCK(fs, blkndx) + i);
} }
@ -161,7 +161,7 @@ static int spiffs_gc_epage_stats(FAR struct spiffs_s *fs, int16_t blkndx)
FAR int16_t *objlu_buf = (int16_t *) fs->lu_work; FAR int16_t *objlu_buf = (int16_t *) fs->lu_work;
uint32_t dele = 0; uint32_t dele = 0;
uint32_t allo = 0; uint32_t allo = 0;
int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)); int entries_per_page = (SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t));
int cur_entry = 0; int cur_entry = 0;
int obj_lookup_page = 0; int obj_lookup_page = 0;
int ret = OK; int ret = OK;
@ -172,23 +172,23 @@ static int spiffs_gc_epage_stats(FAR struct spiffs_s *fs, int16_t blkndx)
{ {
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0,
blkndx * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + blkndx * SPIFFS_GEO_BLOCK_SIZE(fs) +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each entry */ /* Check each entry */
while (ret == OK && while (ret == OK &&
cur_entry - entry_offset < entries_per_page && cur_entry - entry_offset < entries_per_page &&
cur_entry < cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs))) (int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{ {
int16_t id = objlu_buf[cur_entry - entry_offset]; int16_t id = objlu_buf[cur_entry - entry_offset];
if (id == SPIFFS_OBJ_ID_FREE) if (id == SPIFFS_OBJID_FREE)
{ {
} }
else if (id == SPIFFS_OBJ_ID_DELETED) else if (id == SPIFFS_OBJID_DELETED)
{ {
dele++; dele++;
} }
@ -235,7 +235,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
FAR int32_t *cand_scores; FAR int32_t *cand_scores;
FAR int16_t *objlu_buf = (FAR int16_t *)fs->lu_work; FAR int16_t *objlu_buf = (FAR int16_t *)fs->lu_work;
FAR int16_t *cand_blocks; FAR int16_t *cand_blocks;
uint32_t blocks = fs->geo.neraseblocks; uint32_t blocks = SPIFFS_GEO_BLOCK_COUNT(fs);
int16_t cur_block = 0; int16_t cur_block = 0;
uint32_t cur_block_addr = 0; uint32_t cur_block_addr = 0;
int entries_per_page; int entries_per_page;
@ -248,11 +248,11 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
*/ */
max_candidates = max_candidates =
MIN(fs->geo.neraseblocks, MIN(SPIFFS_GEO_BLOCK_COUNT(fs),
(SPIFFS_CFG_LOG_PAGE_SZ(fs) - 8) / (SPIFFS_GEO_PAGE_SIZE(fs) - 8) /
(sizeof(int16_t) + sizeof(int32_t))); (sizeof(int16_t) + sizeof(int32_t)));
*candidate_count = 0; *candidate_count = 0;
memset(fs->work, 0xff, SPIFFS_CFG_LOG_PAGE_SZ(fs)); memset(fs->work, 0xff, SPIFFS_GEO_PAGE_SIZE(fs));
/* Divide up work area into block indices and scores */ /* Divide up work area into block indices and scores */
@ -268,7 +268,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
*block_candidates = cand_blocks; *block_candidates = cand_blocks;
entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)); entries_per_page = (SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t));
/* Check each block */ /* Check each block */
@ -287,19 +287,19 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0,
cur_block_addr + cur_block_addr +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each entry */ /* Check each entry */
while (ret == OK && while (ret == OK &&
cur_entry - entry_offset < entries_per_page && cur_entry - entry_offset < entries_per_page &&
cur_entry < cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) - (int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs))) SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{ {
int16_t id = objlu_buf[cur_entry - entry_offset]; int16_t id = objlu_buf[cur_entry - entry_offset];
if (id == SPIFFS_OBJ_ID_FREE) if (id == SPIFFS_OBJID_FREE)
{ {
/* When a free entry is encountered, scan logic ensures that /* When a free entry is encountered, scan logic ensures that
* all following entries are free also * all following entries are free also
@ -308,7 +308,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
ret = 1; /* Kill object lu loop */ ret = 1; /* Kill object lu loop */
break; break;
} }
else if (id == SPIFFS_OBJ_ID_DELETED) else if (id == SPIFFS_OBJID_DELETED)
{ {
deleted_pages_in_block++; deleted_pages_in_block++;
} }
@ -359,7 +359,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
else else
{ {
erase_age = erase_age =
SPIFFS_OBJ_ID_FREE - (erase_count - fs->max_erase_count); SPIFFS_OBJID_FREE - (erase_count - fs->max_erase_count);
} }
score = score =
@ -406,7 +406,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
cur_entry = 0; cur_entry = 0;
cur_block++; cur_block++;
cur_block_addr += SPIFFS_CFG_LOG_BLOCK_SZ(fs); cur_block_addr += SPIFFS_GEO_BLOCK_SIZE(fs);
} }
return ret; return ret;
@ -444,7 +444,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx) static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
{ {
const int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)); const int entries_per_page = (SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t));
int ret = OK; int ret = OK;
/* This is the global localizer being pushed and popped */ /* This is the global localizer being pushed and popped */
@ -471,7 +471,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
* we want to clean * we want to clean
*/ */
fs->free_blkndx = (blkndx + 1) % fs->geo.neraseblocks; fs->free_blkndx = (blkndx + 1) % SPIFFS_GEO_BLOCK_COUNT(fs);
fs->free_entry = 0; fs->free_entry = 0;
spiffs_gcinfo("Move free cursor to block=%0rx\n", fs->free_blkndx); spiffs_gcinfo("Move free cursor to block=%0rx\n", fs->free_blkndx);
} }
@ -498,16 +498,16 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
int entry_offset = obj_lookup_page * entries_per_page; int entry_offset = obj_lookup_page * entries_per_page;
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0,
blkndx * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + blkndx * SPIFFS_GEO_BLOCK_SIZE(fs) +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each object lookup entry */ /* Check each object lookup entry */
while (scan && ret == OK && while (scan && ret == OK &&
cur_entry - entry_offset < entries_per_page && cur_entry - entry_offset < entries_per_page &&
cur_entry < cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) - (int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs))) SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{ {
int16_t id = objlu_buf[cur_entry - entry_offset]; int16_t id = objlu_buf[cur_entry - entry_offset];
@ -521,9 +521,9 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
case FIND_OBJ_DATA: case FIND_OBJ_DATA:
/* Find a data page. */ /* Find a data page. */
if (id != SPIFFS_OBJ_ID_DELETED && if (id != SPIFFS_OBJID_DELETED &&
id != SPIFFS_OBJ_ID_FREE && id != SPIFFS_OBJID_FREE &&
((id & SPIFFS_OBJ_ID_IX_FLAG) == 0)) ((id & SPIFFS_OBJID_NDXFLAG) == 0))
{ {
/* Found a data page, stop scanning and handle in switch /* Found a data page, stop scanning and handle in switch
* case below * case below
@ -592,9 +592,9 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
ret = spiffs_cache_read(fs, ret = spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, 0,
blkndx * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + blkndx * SPIFFS_GEO_BLOCK_SIZE(fs) +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), SPIFFS_GEO_PAGE_SIZE(fs),
fs->lu_work); fs->lu_work);
if (ret < 0) if (ret < 0)
{ {
@ -619,7 +619,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
return ret; return ret;
} }
new_data_pgndx = SPIFFS_OBJ_ID_FREE; new_data_pgndx = SPIFFS_OBJID_FREE;
} }
/* Update memory representation of object index page /* Update memory representation of object index page
@ -658,9 +658,9 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
case MOVE_OBJ_IX: case MOVE_OBJ_IX:
/* Find and evacuate object index pages */ /* Find and evacuate object index pages */
if (id != SPIFFS_OBJ_ID_DELETED && if (id != SPIFFS_OBJID_DELETED &&
id != SPIFFS_OBJ_ID_FREE && id != SPIFFS_OBJID_FREE &&
(id & SPIFFS_OBJ_ID_IX_FLAG) != 0) (id & SPIFFS_OBJID_NDXFLAG) != 0)
{ {
/* Found an index object id */ /* Found an index object id */
@ -700,7 +700,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
spiffs_object_event(fs, spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)&phdr, (FAR struct spiffs_page_objndx_s *)&phdr,
SPIFFS_EV_IX_MOV, id, SPIFFS_EV_NDXMOV, id,
phdr.spndx, new_pgndx, 0); phdr.spndx, new_pgndx, 0);
/* Move wipes obj_lu, reload it */ /* Move wipes obj_lu, reload it */
@ -708,9 +708,9 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
ret = spiffs_cache_read(fs, ret = spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, 0,
blkndx * SPIFFS_CFG_LOG_BLOCK_SZ(fs) + blkndx * SPIFFS_GEO_BLOCK_SIZE(fs) +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -735,7 +735,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
} }
spiffs_object_event(fs, NULL, spiffs_object_event(fs, NULL,
SPIFFS_EV_IX_DEL, id, SPIFFS_EV_NDXDEL, id,
phdr.spndx, cur_pgndx, 0); phdr.spndx, cur_pgndx, 0);
} }
} }
@ -794,7 +794,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
spiffs_gcinfo("Find objndx spndx=%04x\n", gc.cur_objndx_spndx); spiffs_gcinfo("Find objndx spndx=%04x\n", gc.cur_objndx_spndx);
ret = spiffs_objlu_find_id_and_span(fs, ret = spiffs_objlu_find_id_and_span(fs,
gc.cur_objid | SPIFFS_OBJ_ID_IX_FLAG, gc.cur_objid | SPIFFS_OBJID_NDXFLAG,
gc.cur_objndx_spndx, 0, gc.cur_objndx_spndx, 0,
&objndx_pgndx); &objndx_pgndx);
if (ret == -ENOENT) if (ret == -ENOENT)
@ -834,7 +834,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, 0,
SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx), SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->work); SPIFFS_GEO_PAGE_SIZE(fs), fs->work);
if (ret < 0) if (ret < 0)
{ {
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret); ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
@ -846,7 +846,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
*/ */
ret = spiffs_validate_objix(&objndx->phdr, ret = spiffs_validate_objix(&objndx->phdr,
gc.cur_objid | SPIFFS_OBJ_ID_IX_FLAG, gc.cur_objid | SPIFFS_OBJID_NDXFLAG,
gc.cur_objndx_spndx); gc.cur_objndx_spndx);
if (ret < 0) if (ret < 0)
{ {
@ -884,7 +884,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
/* Store object index header page */ /* Store object index header page */
ret = spiffs_object_update_index_hdr(fs, 0, ret = spiffs_object_update_index_hdr(fs, 0,
gc.cur_objid | SPIFFS_OBJ_ID_IX_FLAG, gc.cur_objid | SPIFFS_OBJID_NDXFLAG,
gc.cur_objndx_pgndx, fs->work, 0, gc.cur_objndx_pgndx, fs->work, 0,
0, &new_objndx_pgndx); 0, &new_objndx_pgndx);
@ -902,7 +902,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
/* Store object index page */ /* Store object index page */
ret = spiffs_page_move(fs, 0, fs->work, ret = spiffs_page_move(fs, 0, fs->work,
gc.cur_objid | SPIFFS_OBJ_ID_IX_FLAG, gc.cur_objid | SPIFFS_OBJID_NDXFLAG,
0, gc.cur_objndx_pgndx, 0, gc.cur_objndx_pgndx,
&new_objndx_pgndx); &new_objndx_pgndx);
@ -917,7 +917,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
spiffs_object_event(fs, spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)fs->work, (FAR struct spiffs_page_objndx_s *)fs->work,
SPIFFS_EV_IX_UPD, gc.cur_objid, SPIFFS_EV_NDXUPD, gc.cur_objid,
objndx->phdr.spndx, objndx->phdr.spndx,
new_objndx_pgndx, 0); new_objndx_pgndx, 0);
} }
@ -968,9 +968,9 @@ int spiffs_gc_quick(FAR struct spiffs_s *fs, uint16_t max_free_pages)
{ {
FAR int16_t *objlu_buf = (int16_t *) fs->lu_work; FAR int16_t *objlu_buf = (int16_t *) fs->lu_work;
uint32_t cur_block_addr = 0; uint32_t cur_block_addr = 0;
uint32_t blocks = fs->geo.neraseblocks; uint32_t blocks = SPIFFS_GEO_BLOCK_COUNT(fs);
int16_t cur_block = 0; int16_t cur_block = 0;
int entries_per_page = (SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t)); int entries_per_page = (SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t));
int cur_entry = 0; int cur_entry = 0;
int ret = OK; int ret = OK;
@ -997,23 +997,23 @@ int spiffs_gc_quick(FAR struct spiffs_s *fs, uint16_t max_free_pages)
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0, ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0,
cur_block_addr + cur_block_addr +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page), SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_CFG_LOG_PAGE_SZ(fs), fs->lu_work); SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each entry */ /* Check each entry */
while (ret == OK && while (ret == OK &&
cur_entry - entry_offset < entries_per_page && cur_entry - entry_offset < entries_per_page &&
cur_entry < cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) - (int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs))) SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{ {
int16_t id = objlu_buf[cur_entry - entry_offset]; int16_t id = objlu_buf[cur_entry - entry_offset];
if (id == SPIFFS_OBJ_ID_DELETED) if (id == SPIFFS_OBJID_DELETED)
{ {
deleted_pages_in_block++; deleted_pages_in_block++;
} }
else if (id == SPIFFS_OBJ_ID_FREE) else if (id == SPIFFS_OBJID_FREE)
{ {
/* Kill scan, go for next block */ /* Kill scan, go for next block */
@ -1047,7 +1047,7 @@ int spiffs_gc_quick(FAR struct spiffs_s *fs, uint16_t max_free_pages)
if (ret == OK && if (ret == OK &&
deleted_pages_in_block + free_pages_in_block == deleted_pages_in_block + free_pages_in_block ==
SPIFFS_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs) && SPIFFS_GEO_PAGES_PER_BLOCK(fs) - SPIFFS_OBJ_LOOKUP_PAGES(fs) &&
free_pages_in_block <= max_free_pages) free_pages_in_block <= max_free_pages)
{ {
/* Found a fully deleted block */ /* Found a fully deleted block */
@ -1059,7 +1059,7 @@ int spiffs_gc_quick(FAR struct spiffs_s *fs, uint16_t max_free_pages)
cur_entry = 0; cur_entry = 0;
cur_block++; cur_block++;
cur_block_addr += SPIFFS_CFG_LOG_BLOCK_SZ(fs); cur_block_addr += SPIFFS_GEO_BLOCK_SIZE(fs);
} }
if (ret == OK) if (ret == OK)
@ -1103,21 +1103,27 @@ int spiffs_gc_quick(FAR struct spiffs_s *fs, uint16_t max_free_pages)
int spiffs_gc_check(FAR struct spiffs_s *fs, off_t len) int spiffs_gc_check(FAR struct spiffs_s *fs, off_t len)
{ {
int32_t free_pages = int32_t free_pages;
(SPIFFS_PAGES_PER_BLOCK(fs) - uint32_t needed_pages;
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (fs->geo.neraseblocks - 2) -
fs->stats_p_allocated - fs->stats_p_deleted;
int tries = 0; int tries = 0;
int ret; int ret;
/* Get the number of free pages */
free_pages = (SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (SPIFFS_GEO_BLOCK_COUNT(fs) - 2) -
fs->stats_p_allocated - fs->stats_p_deleted;
if (fs->free_blocks > 3 && if (fs->free_blocks > 3 &&
(int32_t) len < free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs)) (int32_t)len < free_pages * (int32_t)SPIFFS_DATA_PAGE_SIZE(fs))
{ {
return OK; return OK;
} }
uint32_t needed_pages = /* Get the number of pages needed */
(len + SPIFFS_DATA_PAGE_SIZE(fs) - 1) / SPIFFS_DATA_PAGE_SIZE(fs);
needed_pages = (len + SPIFFS_DATA_PAGE_SIZE(fs) - 1) /
SPIFFS_DATA_PAGE_SIZE(fs);
#if 0 #if 0
if (fs->free_blocks <= 2 && (int32_t)needed_pages > free_pages) if (fs->free_blocks <= 2 && (int32_t)needed_pages > free_pages)
@ -1129,7 +1135,7 @@ int spiffs_gc_check(FAR struct spiffs_s *fs, off_t len)
} }
#endif #endif
if ((int32_t) needed_pages > (int32_t)(free_pages + fs->stats_p_deleted)) if ((int32_t)needed_pages > (int32_t)(free_pages + fs->stats_p_deleted))
{ {
spiffs_gcinfo("Full freeblk=%d needed=%d free=%d dele=%d\n", spiffs_gcinfo("Full freeblk=%d needed=%d free=%d dele=%d\n",
fs->free_blocks, needed_pages, free_pages, fs->free_blocks, needed_pages, free_pages,
@ -1196,8 +1202,8 @@ int spiffs_gc_check(FAR struct spiffs_s *fs, off_t len)
return ret; return ret;
} }
free_pages = (SPIFFS_PAGES_PER_BLOCK(fs) - free_pages = (SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (fs->geo.neraseblocks - 2) - SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (SPIFFS_GEO_BLOCK_COUNT(fs) - 2) -
fs->stats_p_allocated - fs->stats_p_deleted; fs->stats_p_allocated - fs->stats_p_deleted;
if (prev_free_pages <= 0 && prev_free_pages == free_pages) if (prev_free_pages <= 0 && prev_free_pages == free_pages)
@ -1213,19 +1219,21 @@ int spiffs_gc_check(FAR struct spiffs_s *fs, off_t len)
(fs->free_blocks <= 2 || (fs->free_blocks <= 2 ||
(int32_t) len > free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs))); (int32_t) len > free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs)));
free_pages = /* Re-caculate the number of free pages */
(SPIFFS_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (fs->geo.neraseblocks - 2) - free_pages = (SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
fs->stats_p_allocated - fs->stats_p_deleted; SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (SPIFFS_GEO_BLOCK_COUNT(fs) - 2) -
fs->stats_p_allocated - fs->stats_p_deleted;
if ((int32_t) len > free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs)) if ((int32_t) len > free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs))
{ {
ret = -ENOSPC; ret = -ENOSPC;
} }
spiffs_gcinfo("Finished, %d dirty, blocks, %d free, %d pages free, %d tries, ret=%d\n", spiffs_gcinfo("Finished, %d dirty, blocks, %d free, %d pages free, "
fs->stats_p_allocated + fs->stats_p_deleted, fs->free_blocks, "%d tries, ret=%d\n",
free_pages, tries, ret); fs->stats_p_allocated + fs->stats_p_deleted,
fs->free_blocks, free_pages, tries, ret);
return ret; return ret;
} }

33
fs/spiffs/src/spiffs_mtd.c
View File

@ -64,13 +64,13 @@
* Write data to FLASH memory * Write data to FLASH memory
* *
* Input Parameters: * Input Parameters:
* fs - A reference to the volume structure * fs - A reference to the volume structure
* offset - The physical offset to write to * offset - The physical offset to write to
* len - The number of bytes to write * len - The number of bytes to write
* src - A reference to the bytes to be written * src - A reference to the bytes to be written
* *
* Returned Value: * Returned Value:
* On success, the number of bytes written is returned. On failure, a * On success, the number of bytes written is returned. On failure, a
* negated errno value is returned. * negated errno value is returned.
* *
****************************************************************************/ ****************************************************************************/
@ -81,28 +81,30 @@ ssize_t spiffs_mtd_write(FAR struct spiffs_s *fs, off_t offset, size_t len,
int16_t blksize; int16_t blksize;
off_t blkstart; off_t blkstart;
off_t blkend; off_t blkend;
ssize_t ret; ssize_t ret;
DEBUGASSERT(fs != NULL && fs->mtd != NULL && src != NULL); DEBUGASSERT(fs != NULL && fs->mtd != NULL && src != NULL);
#warning REVISIT: What are units of offset and len?
#ifdef CONFIG_MTD_BYTE_WRITE #ifdef CONFIG_MTD_BYTE_WRITE
ret = MTD_WRITE(fs->mtd, offset, len, src); ret = MTD_WRITE(fs->mtd, offset, len, src);
if (ret < 0) if (ret < 0)
#endif #endif
{ {
/* We will have to do a block read */
blksize = fs->geo.blocksize; blksize = fs->geo.blocksize;
DEBUGASSERT(offset = offset % blksize); DEBUGASSERT(offset == offset % blksize);
DEBUGASSERT(len = len % blksize); DEBUGASSERT(len == len % blksize);
blkstart = offset / blksize; /* Truncates to floor */ blkstart = offset / blksize; /* Truncates to floor */
blkend = (offset + len + blksize - 1) / blksize; /* Rounds up to ceil */ blkend = (offset + len + blksize - 1) / blksize; /* Rounds up to ceil */
#warning WRONG: Needs to use page work buffer, not 'src'
ret = MTD_BWRITE(fs->mtd, blkstart, blkend - blkstart, src); ret = MTD_BWRITE(fs->mtd, blkstart, blkend - blkstart, src);
} }
return ret; return ret < 0 ret : len;
} }
/**************************************************************************** /****************************************************************************
@ -118,7 +120,7 @@ ssize_t spiffs_mtd_write(FAR struct spiffs_s *fs, off_t offset, size_t len,
* dest - The user provide location to store the bytes read from FLASH. * dest - The user provide location to store the bytes read from FLASH.
* *
* Returned Value: * Returned Value:
* On success, the number of bytes read is returned. On failure, a * On success, the number of bytes read is returned. On failure, a
* negated errno value is returned. * negated errno value is returned.
* *
****************************************************************************/ ****************************************************************************/
@ -133,22 +135,21 @@ ssize_t spiffs_mtd_read(FAR struct spiffs_s *fs, off_t offset, size_t len,
DEBUGASSERT(fs != NULL && fs->mtd != NULL && dest != NULL); DEBUGASSERT(fs != NULL && fs->mtd != NULL && dest != NULL);
#warning REVISIT: What are units of offset and len?
ret = MTD_READ(fs->mtd, offset, len, dest); ret = MTD_READ(fs->mtd, offset, len, dest);
if (ret < 0) if (ret < 0)
{ {
blksize = fs->geo.blocksize; blksize = fs->geo.blocksize;
DEBUGASSERT(offset = offset % blksize); DEBUGASSERT(offset == offset % blksize);
DEBUGASSERT(len = len % blksize); DEBUGASSERT(len == len % blksize);
blkstart = offset / blksize; /* Truncates to floor */ blkstart = offset / blksize; /* Truncates to floor */
blkend = (offset + len + blksize - 1) / blksize; /* Rounds up to ceil */ blkend = (offset + len + blksize - 1) / blksize; /* Rounds up to ceil */
#warning WRONG: Needs to use page work buffer, not 'dest'
ret = MTD_BREAD(fs->mtd, blkstart, blkend - blkstart, dest); ret = MTD_BREAD(fs->mtd, blkstart, blkend - blkstart, dest);
} }
return ret; return ret < 0 ret : len;
} }
/**************************************************************************** /****************************************************************************
@ -163,7 +164,7 @@ ssize_t spiffs_mtd_read(FAR struct spiffs_s *fs, off_t offset, size_t len,
* len - The number of bytes to erase * len - The number of bytes to erase
* *
* Returned Value: * Returned Value:
* On success, the number of bytes erased is returned. On failure, a * On success, the number of bytes erased is returned. On failure, a
* negated errno value is returned. * negated errno value is returned.
* *
****************************************************************************/ ****************************************************************************/

23
fs/spiffs/src/spiffs_mtd.h
View File

@ -53,11 +53,18 @@ extern "C"
* Pre-processor Definitions * Pre-processor Definitions
****************************************************************************/ ****************************************************************************/
#define SPIFFS_CFG_EBLOCK_COUNT(fs) ((fs)->geo.neraseblocks) /* The MTD interface does not deal with pages explicitly. With most
#define SPIFFS_CFG_LOG_PAGE_SZ(fs) ((fs)->geo.blocksize) * hardware a logical block is the same as an SPIFFS page.
#define SPIFFS_CFG_LOG_BLOCK_SZ(fs) ((fs)->geo.blocksize) */
#define SPIFFS_CFG_PHYS_SZ(fs) ((fs)->phys_size)
#define SPIFFS_CFG_PHYS_ERASE_SZ(fs) ((fs)->geo.erasesize) #define SPIFFS_GEO_MEDIA_SIZE(fs) ((fs)->media_size)
#define SPIFFS_GEO_EBLOCK_COUNT(fs) ((fs)->geo.neraseblocks)
#define SPIFFS_GEO_EBLOCK_SIZE(fs) ((fs)->geo.erasesize)
#define SPIFFS_GEO_BLOCK_COUNT(fs) ((fs)->geo.neraseblocks)
#define SPIFFS_GEO_BLOCK_SIZE(fs) ((fs)->geo.erasesize)
#define SPIFFS_GEO_PAGE_COUNT(fs) ((fs)->total_pages)
#define SPIFFS_GEO_PAGE_SIZE(fs) ((fs)->geo.blocksize)
#define SPIFFS_GEO_PAGES_PER_BLOCK(fs) ((fs)->pages_per_block)
/**************************************************************************** /****************************************************************************
* Public Function Prototypes * Public Function Prototypes
@ -76,7 +83,7 @@ extern "C"
* src - A reference to the bytes to be written * src - A reference to the bytes to be written
* *
* Returned Value: * Returned Value:
* On success, the number of bytes written is returned. On failure, a * On success, the number of bytes written is returned. On failure, a
* negated errno value is returned. * negated errno value is returned.
* *
****************************************************************************/ ****************************************************************************/
@ -97,7 +104,7 @@ ssize_t spiffs_mtd_write(FAR struct spiffs_s *fs, off_t offset, size_t len,
* dest - The user provide location to store the bytes read from FLASH. * dest - The user provide location to store the bytes read from FLASH.
* *
* Returned Value: * Returned Value:
* On success, the number of bytes read is returned. On failure, a * On success, the number of bytes read is returned. On failure, a
* negated errno value is returned. * negated errno value is returned.
* *
****************************************************************************/ ****************************************************************************/
@ -117,7 +124,7 @@ ssize_t spiffs_mtd_read(FAR struct spiffs_s *fs, off_t offset, size_t len,
* len - The number of bytes to erase * len - The number of bytes to erase
* *
* Returned Value: * Returned Value:
* On success, the number of bytes erased is returned. On failure, a * On success, the number of bytes erased is returned. On failure, a
* negated errno value is returned. * negated errno value is returned.
* *
****************************************************************************/ ****************************************************************************/

37
fs/spiffs/src/spiffs_vfs.c
View File

@ -297,8 +297,8 @@ static int spiffs_readdir_callback(FAR struct spiffs_s *fs,
int16_t pgndx; int16_t pgndx;
int ret; int ret;
if (objid == SPIFFS_OBJ_ID_FREE || objid == SPIFFS_OBJ_ID_DELETED || if (objid == SPIFFS_OBJID_FREE || objid == SPIFFS_OBJID_DELETED ||
(objid & SPIFFS_OBJ_ID_IX_FLAG) == 0) (objid & SPIFFS_OBJID_NDXFLAG) == 0)
{ {
return SPIFFS_VIS_COUNTINUE; return SPIFFS_VIS_COUNTINUE;
} }
@ -314,7 +314,7 @@ static int spiffs_readdir_callback(FAR struct spiffs_s *fs,
return ret; return ret;
} }
if ((objid & SPIFFS_OBJ_ID_IX_FLAG) && if ((objid & SPIFFS_OBJID_NDXFLAG) &&
objhdr.phdr.spndx == 0 && objhdr.phdr.spndx == 0 &&
(objhdr.phdr.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_FINAL | (objhdr.phdr.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_FINAL |
SPIFFS_PH_FLAG_IXDELE)) == SPIFFS_PH_FLAG_IXDELE)) ==
@ -411,7 +411,7 @@ static int spiffs_open(FAR struct file *filep, FAR const char *relpath,
/* The file does not exist. We need to create the it. */ /* The file does not exist. We need to create the it. */
ret = spiffs_objlu_find_free_obj_id(fs, &objid, 0); ret = spiffs_objlu_find_free_objid(fs, &objid, 0);
if (ret < 0) if (ret < 0)
{ {
goto errout_with_fileobject; goto errout_with_fileobject;
@ -644,7 +644,7 @@ static ssize_t spiffs_write(FAR struct file *filep, FAR const char *buffer,
if ((fobj->flags & O_DIRECT) == 0) if ((fobj->flags & O_DIRECT) == 0)
{ {
if (buflen < (size_t)SPIFFS_CFG_LOG_PAGE_SZ(fs)) if (buflen < (size_t)SPIFFS_GEO_PAGE_SIZE(fs))
{ {
/* Small write, try to cache it */ /* Small write, try to cache it */
@ -657,7 +657,7 @@ static ssize_t spiffs_write(FAR struct file *filep, FAR const char *buffer,
if (offset < fobj->cache_page->offset || if (offset < fobj->cache_page->offset ||
offset > fobj->cache_page->offset + fobj->cache_page->size || offset > fobj->cache_page->offset + fobj->cache_page->size ||
offset + buflen > fobj->cache_page->offset + SPIFFS_CFG_LOG_PAGE_SZ(fs)) offset + buflen > fobj->cache_page->offset + SPIFFS_GEO_PAGE_SIZE(fs))
{ {
/* Boundary violation, write back cache first and allocate /* Boundary violation, write back cache first and allocate
* new * new
@ -881,7 +881,7 @@ static off_t spiffs_seek(FAR struct file *filep, off_t offset, int whence)
{ {
int16_t pgndx; int16_t pgndx;
ret = spiffs_objlu_find_id_and_span(fs, fobj->objid | SPIFFS_OBJ_ID_IX_FLAG, ret = spiffs_objlu_find_id_and_span(fs, fobj->objid | SPIFFS_OBJID_NDXFLAG,
objndx_spndx, 0, &pgndx); objndx_spndx, 0, &pgndx);
if (ret < 0) if (ret < 0)
{ {
@ -956,7 +956,7 @@ static int spiffs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
/* No.. we will have to erase a block at a time */ /* No.. we will have to erase a block at a time */
int16_t blkndx = 0; int16_t blkndx = 0;
while (blkndx < fs->geo.neraseblocks) while (blkndx < SPIFFS_GEO_BLOCK_COUNT(fs))
{ {
fs->max_erase_count = 0; fs->max_erase_count = 0;
ret = spiffs_erase_block(fs, blkndx); ret = spiffs_erase_block(fs, blkndx);
@ -1289,7 +1289,7 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
int ret; int ret;
finfo("mtdinode: %p data: %p handle: %p\n", mtdinode, data, handle); finfo("mtdinode: %p data: %p handle: %p\n", mtdinode, data, handle);
DEBUGASSERT(mtdinode == NULL && handle != NULL); DEBUGASSERT(mtdinode != NULL && handle != NULL);
/* Extract the MTD interface reference */ /* Extract the MTD interface reference */
@ -1316,7 +1316,9 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
goto errout_with_volume; goto errout_with_volume;
} }
fs->phys_size = fs->geo.neraseblocks * fs->geo.erasesize; fs->media_size = SPIFFS_GEO_EBLOCK_COUNT(fs) * SPIFFS_GEO_EBLOCK_SIZE(fs);
fs->total_pages = fs->media_size / SPIFFS_GEO_PAGE_SIZE(fs);
fs->pages_per_block = SPIFFS_GEO_EBLOCK_SIZE(fs) / SPIFFS_GEO_PAGE_SIZE(fs);
/* Get the aligned cache size */ /* Get the aligned cache size */
@ -1325,7 +1327,7 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
/* Don't let the cache size exceed the maximum that is needed */ /* Don't let the cache size exceed the maximum that is needed */
cache_max = SPIFFS_CFG_LOG_PAGE_SZ(fs) << 5; cache_max = SPIFFS_GEO_PAGE_SIZE(fs) << 5;
if (cache_size > cache_max) if (cache_size > cache_max)
{ {
cache_size = cache_max; cache_size = cache_max;
@ -1351,7 +1353,7 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
* NOTE: Currently page size is equivalent to block size. * NOTE: Currently page size is equivalent to block size.
*/ */
work_size = SPIFFS_CFG_LOG_PAGE_SZ(fs) << 1; work_size = SPIFFS_GEO_PAGE_SIZE(fs) << 1;
work = (FAR uint8_t *)kmm_malloc(work_size); work = (FAR uint8_t *)kmm_malloc(work_size);
if (work == NULL) if (work == NULL)
@ -1363,7 +1365,8 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
fs->work = &work[0]; fs->work = &work[0];
fs->lu_work = &work[work_size >> 1]; fs->lu_work = &work[work_size >> 1];
fs->config_magic = SPIFFS_SUPER_MAGIC;
(void)nxsem_init(&fs->exclsem.sem, 0, 1);
/* Check the file system */ /* Check the file system */
@ -1375,11 +1378,11 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
} }
finfo("page index byte len: %u\n", finfo("page index byte len: %u\n",
(unsigned int)SPIFFS_CFG_LOG_PAGE_SZ(fs)); (unsigned int)SPIFFS_GEO_PAGE_SIZE(fs));
finfo("object lookup pages: %u\n", finfo("object lookup pages: %u\n",
(unsigned int)SPIFFS_OBJ_LOOKUP_PAGES(fs)); (unsigned int)SPIFFS_OBJ_LOOKUP_PAGES(fs));
finfo("page pages per block: %u\n", finfo("page pages per block: %u\n",
(unsigned int)SPIFFS_PAGES_PER_BLOCK(fs)); (unsigned int)SPIFFS_GEO_PAGES_PER_BLOCK(fs));
finfo("page header length: %u\n", finfo("page header length: %u\n",
(unsigned int)sizeof(struct spiffs_page_header_s)); (unsigned int)sizeof(struct spiffs_page_header_s));
finfo("object header index entries: %u\n", finfo("object header index entries: %u\n",
@ -1505,8 +1508,8 @@ static int spiffs_statfs(FAR struct inode *mountpt, FAR struct statfs *buf)
/* Collect some statistics */ /* Collect some statistics */
pages_per_block = SPIFFS_PAGES_PER_BLOCK(fs); pages_per_block = SPIFFS_GEO_PAGES_PER_BLOCK(fs);
blocks = fs->geo.neraseblocks; blocks = SPIFFS_GEO_BLOCK_COUNT(fs);
obj_lupages = SPIFFS_OBJ_LOOKUP_PAGES(fs); obj_lupages = SPIFFS_OBJ_LOOKUP_PAGES(fs);
data_pgsize = SPIFFS_DATA_PAGE_SIZE(fs); data_pgsize = SPIFFS_DATA_PAGE_SIZE(fs);

2
fs/spiffs/src/spiffs_volume.c
View File

@ -116,7 +116,7 @@ int spiffs_stat_pgndx(FAR struct spiffs_s *fs, int16_t pgndx, int16_t objid,
buf->st_mode = mode; buf->st_mode = mode;
buf->st_size = objhdr.size == SPIFFS_UNDEFINED_LEN ? 0 : objhdr.size; buf->st_size = objhdr.size == SPIFFS_UNDEFINED_LEN ? 0 : objhdr.size;
buf->st_blksize = fs->geo.blocksize; buf->st_blksize = fs->geo.blocksize;
buf->st_blocks = fs->phys_size / fs->geo.blocksize; buf->st_blocks = fs->media_size / fs->geo.blocksize;
return ret; return ret;
} }