Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2026-05-20 12:33:27 +08:00
Code Issues Actions 1 Packages Projects 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
Download Patch File Download Diff File Expand all files Collapse all files
configs/sim/spiffs/defconfig
+2
View File
@@ -2,6 +2,7 @@ CONFIG_ARCH="sim"
CONFIG_ARCH_BOARD="sim"
CONFIG_ARCH_BOARD_SIM=y
CONFIG_ARCH_SIM=y
CONFIG_BOARD_INITIALIZE=y
CONFIG_DEBUG_ASSERTIONS=y
CONFIG_DEBUG_FEATURES=y
CONFIG_DEBUG_SYMBOLS=y
@@ -11,6 +12,7 @@ CONFIG_DISABLE_POSIX_TIMERS=y
CONFIG_DISABLE_PTHREAD=y
CONFIG_DISABLE_SIGNALS=y
CONFIG_EXAMPLES_FSTEST=y
CONFIG_EXAMPLES_FSTEST_MOUNTPT="/mnt/spiffs"
CONFIG_EXPERIMENTAL=y
CONFIG_FS_SPIFFS=y
CONFIG_IDLETHREAD_STACKSIZE=4096
configs/sim/src/sim_bringup.c
+10
View File
@@ -181,6 +181,16 @@ int sim_bringup(void)
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)
/* Initialize to provide NXFFS on the MTD interface */
fs/spiffs/src/spiffs.h
+5 -4
View File
@@ -147,12 +147,13 @@ struct spiffs_s
FAR uint8_t *work; /* Secondary work buffer, size of a logical page */
FAR void *cache; /* Cache memory */
#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
off_t phys_size; /* Physical size of the SPI flash */
off_t media_size; /* Physical size of the SPI flash */
#endif
int free_entry; /* Cursor for free blocks, 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 stats_p_allocated; /* Current number of busy 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_misses; /* Number of cache misses */
#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 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 */
fs/spiffs/src/spiffs_cache.c
+2 -2
View File
@@ -144,7 +144,7 @@ static int spiffs_cache_page_free(FAR struct spiffs_s *fs, int cpndx,
cpndx, 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)
@@ -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 -
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));
mem = spiffs_get_cache_page(fs, cache, cp->cpndx);
fs/spiffs/src/spiffs_cache.h
+1 -1
View File
@@ -61,7 +61,7 @@ extern "C"
#define SPIFFS_CACHE_FLAG_TYPE_WR (1 << 7)
#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) \
((FAR struct spiffs_cache_s *)((fs)->cache))
fs/spiffs/src/spiffs_check.c
+56 -56
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 */
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);
if (ret < 0)
{
@@ -226,7 +226,7 @@ static int spiffs_check_rewrite_index(FAR struct spiffs_s *fs,
int entry;
int ret;
objid |= SPIFFS_OBJ_ID_IX_FLAG;
objid |= SPIFFS_OBJID_NDXFLAG;
/* 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,
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)
{
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,
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)
{
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 */
if (((lu_objid == SPIFFS_OBJ_ID_DELETED) &&
if (((lu_objid == SPIFFS_OBJID_DELETED) &&
(pghdr->flags & SPIFFS_PH_FLAG_DELET)) ||
((lu_objid == SPIFFS_OBJ_ID_FREE) &&
((lu_objid == SPIFFS_OBJID_FREE) &&
(pghdr->flags & SPIFFS_PH_FLAG_USED) == 0))
{
/* 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,
pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG,
pghdr->objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx, 0);
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,
pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG,
pghdr->objid | SPIFFS_OBJID_NDXFLAG,
0, 0, 0);
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 */
if ((pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG) !=
(lu_objid | SPIFFS_OBJ_ID_IX_FLAG))
if ((pghdr->objid | SPIFFS_OBJID_NDXFLAG) !=
(lu_objid | SPIFFS_OBJID_NDXFLAG))
{
spiffs_checkinfo("LU: pgndx %04x differ in objid lu="
"%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,
lu_objid | SPIFFS_OBJ_ID_IX_FLAG,
lu_objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, 0,
&objndx_pgndx_lu);
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,
pghdr->objid | SPIFFS_OBJ_ID_IX_FLAG,
pghdr->objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, 0,
&objndx_pgndx_ph);
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,
lu_objid & ~SPIFFS_OBJ_ID_IX_FLAG,
lu_objid & ~SPIFFS_OBJID_NDXFLAG,
0, 0, &data_pgndx_lu);
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,
pghdr->objid & ~SPIFFS_OBJ_ID_IX_FLAG,
pghdr->objid & ~SPIFFS_OBJID_NDXFLAG,
0, 0, &data_pgndx_ph);
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 */
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);
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 */
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",
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) ||
((lu_objid & SPIFFS_OBJ_ID_IX_FLAG) == 0 &&
((lu_objid & SPIFFS_OBJID_NDXFLAG) == 0 &&
(pghdr->flags & SPIFFS_PH_FLAG_INDEX) == 0))
{
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 */
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);
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 */
ret = spiffs_objlu_find_id_and_span(fs,
lu_objid | SPIFFS_OBJ_ID_IX_FLAG,
lu_objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx,
&objndx_pgndx_d);
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 |
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;
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),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_CFG_LOG_PAGE_SZ(fs) -
SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_page_header_s));
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");
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;
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),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_CFG_LOG_PAGE_SZ(fs) -
SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_page_header_s));
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;
int i;
objid &= ~SPIFFS_OBJ_ID_IX_FLAG;
for (i = 0; i < SPIFFS_CFG_LOG_PAGE_SZ(fs) / sizeof(int16_t); i++)
objid &= ~SPIFFS_OBJID_NDXFLAG;
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;
}
@@ -1145,8 +1145,8 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
int retc = SPIFFS_VIS_COUNTINUE;
int ret = OK;
if (objid != SPIFFS_OBJ_ID_FREE && objid != SPIFFS_OBJ_ID_DELETED &&
(objid & SPIFFS_OBJ_ID_IX_FLAG) != 0)
if (objid != SPIFFS_OBJID_FREE && objid != SPIFFS_OBJID_DELETED &&
(objid & SPIFFS_OBJID_NDXFLAG) != 0)
{
struct spiffs_page_header_s pghdr;
int16_t cur_pgndx;
@@ -1201,9 +1201,9 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
{
/* Not registered, do it */
obj_table[*log_ndx] = objid & ~SPIFFS_OBJ_ID_IX_FLAG;
obj_table[*log_ndx] = objid & ~SPIFFS_OBJID_NDXFLAG;
(*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;
}
@@ -1225,7 +1225,7 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
/* 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);
retc = SPIFFS_VIS_COUNTINUE_RELOAD;
@@ -1233,14 +1233,14 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
{
/* 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)
{
/* Not found, register as unreachable */
delete = true;
obj_table[*log_ndx] = objid | SPIFFS_OBJ_ID_IX_FLAG;
obj_table[*log_ndx] = objid | SPIFFS_OBJID_NDXFLAG;
}
else if (ret < 0)
{
@@ -1249,7 +1249,7 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
}
(*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;
}
@@ -1258,7 +1258,7 @@ static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
{
/* 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 */
@@ -1353,30 +1353,30 @@ int spiffs_check_luconsistency(FAR struct spiffs_s *fs)
int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
{
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;
int ret = OK;
/* 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;
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 */
while (!restart && cur_block < fs->geo.neraseblocks)
while (!restart && cur_block < SPIFFS_GEO_BLOCK_COUNT(fs))
{
/* Traverse each page except for lookup pages */
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 &&
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;
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,
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)
{
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);
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)))
{
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,
objndx_phdr->objid &
~SPIFFS_OBJ_ID_IX_FLAG,
~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i,
0, &data_pgndx);
if (ret == -ENOENT)
@@ -1510,7 +1510,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED |
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;
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);
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_pgndx, cur_pgndx);
if (ret == -EFAULT)
@@ -1576,7 +1576,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
/* 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.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_INDEX |
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:"
"%04x/%04x, ref objid/span:%04x/%04x flags=%02x\n",
rpgndx,
pghdr.objid & ~SPIFFS_OBJ_ID_IX_FLAG,
pghdr.objid & ~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i,
rphdr.objid, rphdr.spndx,
rphdr.flags);
@@ -1596,7 +1596,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
ret = spiffs_objlu_find_id_and_span(fs,
pghdr.objid &
~SPIFFS_OBJ_ID_IX_FLAG,
~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i, rpgndx,
&data_pgndx);
if (ret == -ENOENT)
@@ -1726,7 +1726,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
uint8_t bit_ndx;
for (byte_ndx = 0;
!restart && byte_ndx < SPIFFS_CFG_LOG_PAGE_SZ(fs);
!restart && byte_ndx < SPIFFS_GEO_PAGE_SIZE(fs);
byte_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 (((rpgndx == (int16_t) - 1 ||
rpgndx > SPIFFS_MAX_PAGES(fs)) ||
rpgndx > SPIFFS_GEO_PAGE_COUNT(fs)) ||
(SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx))))
{
/* Pointing to a bad page altogether, rewrite
@@ -1801,7 +1801,7 @@ int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
return ret;
}
if (((pghdr.objid & ~SPIFFS_OBJ_ID_IX_FLAG) ==
if (((pghdr.objid & ~SPIFFS_OBJID_NDXFLAG) ==
rphdr.objid) &&
((rphdr.flags & (SPIFFS_PH_FLAG_INDEX |
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
* 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
* 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.
*/
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,
spiffs_check_objidconsistency_callback, 0,
fs/spiffs/src/spiffs_core.c
+100 -99
View File
File diff suppressed because it is too large Load Diff
fs/spiffs/src/spiffs_core.h
+51 -73
View File
@@ -174,138 +174,116 @@
#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_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_OBJID_NDXFLAG ((int16_t)(1 << (8 * sizeof(int16_t) - 1)))
#define SPIFFS_UNDEFINED_LEN (uint32_t)(-1)
#define SPIFFS_OBJ_ID_DELETED ((int16_t)0)
#define SPIFFS_OBJ_ID_FREE ((int16_t)-1)
#define SPIFFS_OBJID_DELETED ((int16_t)0)
#define SPIFFS_OBJID_FREE ((int16_t)-1)
/* total number of pages */
/* Number of object lookup pages per block */
#define SPIFFS_MAX_PAGES(fs) \
(SPIFFS_CFG_PHYS_SZ(fs)/SPIFFS_CFG_LOG_PAGE_SZ(fs))
#define SPIFFS_OBJ_LOOKUP_PAGES(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 */
#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 */
/* Checks if page index belongs to object lookup */
#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) \
(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) \
((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) \
(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) \
((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) \
(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
*/
#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) \
((SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) % (SPIFFS_CFG_LOG_PAGE_SZ(fs)/sizeof(int16_t))) * sizeof(int16_t) \
<= (SPIFFS_CFG_LOG_PAGE_SZ(fs)-sizeof(int16_t)*2))
((SPIFFS_OBJ_LOOKUP_MAX_ENTRIES(fs) % (SPIFFS_GEO_PAGE_SIZE(fs)/sizeof(int16_t))) * sizeof(int16_t) \
<= (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) \
((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) \
((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) \
((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) \
((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) \
((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);
int spiffs_erase_block(FAR struct spiffs_s *fs, int16_t blkndx);
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);
int spiffs_objlu_find_free(FAR struct spiffs_s *fs,
int16_t starting_block, int starting_lu_entry,
fs/spiffs/src/spiffs_gc.c
+75 -67
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. */
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);
}
@@ -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;
uint32_t dele = 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 obj_lookup_page = 0;
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;
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_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each entry */
while (ret == OK &&
cur_entry - entry_offset < entries_per_page &&
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];
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++;
}
@@ -235,7 +235,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
FAR int32_t *cand_scores;
FAR int16_t *objlu_buf = (FAR int16_t *)fs->lu_work;
FAR int16_t *cand_blocks;
uint32_t blocks = fs->geo.neraseblocks;
uint32_t blocks = SPIFFS_GEO_BLOCK_COUNT(fs);
int16_t cur_block = 0;
uint32_t cur_block_addr = 0;
int entries_per_page;
@@ -248,11 +248,11 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
*/
max_candidates =
MIN(fs->geo.neraseblocks,
(SPIFFS_CFG_LOG_PAGE_SZ(fs) - 8) /
MIN(SPIFFS_GEO_BLOCK_COUNT(fs),
(SPIFFS_GEO_PAGE_SIZE(fs) - 8) /
(sizeof(int16_t) + sizeof(int32_t)));
*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 */
@@ -268,7 +268,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
*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 */
@@ -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,
cur_block_addr +
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 */
while (ret == OK &&
cur_entry - entry_offset < entries_per_page &&
cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) -
(int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{
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
* 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 */
break;
}
else if (id == SPIFFS_OBJ_ID_DELETED)
else if (id == SPIFFS_OBJID_DELETED)
{
deleted_pages_in_block++;
}
@@ -359,7 +359,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
else
{
erase_age =
SPIFFS_OBJ_ID_FREE - (erase_count - fs->max_erase_count);
SPIFFS_OBJID_FREE - (erase_count - fs->max_erase_count);
}
score =
@@ -406,7 +406,7 @@ static int spiffs_gc_find_candidate(FAR struct spiffs_s *fs,
cur_entry = 0;
cur_block++;
cur_block_addr += SPIFFS_CFG_LOG_BLOCK_SZ(fs);
cur_block_addr += SPIFFS_GEO_BLOCK_SIZE(fs);
}
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)
{
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;
/* 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
*/
fs->free_blkndx = (blkndx + 1) % fs->geo.neraseblocks;
fs->free_blkndx = (blkndx + 1) % SPIFFS_GEO_BLOCK_COUNT(fs);
fs->free_entry = 0;
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;
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_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each object lookup entry */
while (scan && ret == OK &&
cur_entry - entry_offset < entries_per_page &&
cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) -
(int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{
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:
/* Find a data page. */
if (id != SPIFFS_OBJ_ID_DELETED &&
id != SPIFFS_OBJ_ID_FREE &&
((id & SPIFFS_OBJ_ID_IX_FLAG) == 0))
if (id != SPIFFS_OBJID_DELETED &&
id != SPIFFS_OBJID_FREE &&
((id & SPIFFS_OBJID_NDXFLAG) == 0))
{
/* Found a data page, stop scanning and handle in switch
* case below
@@ -592,9 +592,9 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
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_CFG_LOG_PAGE_SZ(fs),
SPIFFS_GEO_PAGE_SIZE(fs),
fs->lu_work);
if (ret < 0)
{
@@ -619,7 +619,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
return ret;
}
new_data_pgndx = SPIFFS_OBJ_ID_FREE;
new_data_pgndx = SPIFFS_OBJID_FREE;
}
/* 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:
/* Find and evacuate object index pages */
if (id != SPIFFS_OBJ_ID_DELETED &&
id != SPIFFS_OBJ_ID_FREE &&
(id & SPIFFS_OBJ_ID_IX_FLAG) != 0)
if (id != SPIFFS_OBJID_DELETED &&
id != SPIFFS_OBJID_FREE &&
(id & SPIFFS_OBJID_NDXFLAG) != 0)
{
/* 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,
(FAR struct spiffs_page_objndx_s *)&phdr,
SPIFFS_EV_IX_MOV, id,
SPIFFS_EV_NDXMOV, id,
phdr.spndx, new_pgndx, 0);
/* 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,
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_CFG_LOG_PAGE_SZ(fs), fs->lu_work);
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0)
{
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_EV_IX_DEL, id,
SPIFFS_EV_NDXDEL, id,
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);
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,
&objndx_pgndx);
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,
0,
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)
{
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,
gc.cur_objid | SPIFFS_OBJ_ID_IX_FLAG,
gc.cur_objid | SPIFFS_OBJID_NDXFLAG,
gc.cur_objndx_spndx);
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 */
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,
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 */
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,
&new_objndx_pgndx);
@@ -917,7 +917,7 @@ static int spiffs_gc_clean(FAR struct spiffs_s *fs, int16_t blkndx)
spiffs_object_event(fs,
(FAR struct spiffs_page_objndx_s *)fs->work,
SPIFFS_EV_IX_UPD, gc.cur_objid,
SPIFFS_EV_NDXUPD, gc.cur_objid,
objndx->phdr.spndx,
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;
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;
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 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,
cur_block_addr +
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 */
while (ret == OK &&
cur_entry - entry_offset < entries_per_page &&
cur_entry <
(int)(SPIFFS_PAGES_PER_BLOCK(fs) -
(int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{
int16_t id = objlu_buf[cur_entry - entry_offset];
if (id == SPIFFS_OBJ_ID_DELETED)
if (id == SPIFFS_OBJID_DELETED)
{
deleted_pages_in_block++;
}
else if (id == SPIFFS_OBJ_ID_FREE)
else if (id == SPIFFS_OBJID_FREE)
{
/* 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 &&
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)
{
/* 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_block++;
cur_block_addr += SPIFFS_CFG_LOG_BLOCK_SZ(fs);
cur_block_addr += SPIFFS_GEO_BLOCK_SIZE(fs);
}
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)
{
int32_t free_pages =
(SPIFFS_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (fs->geo.neraseblocks - 2) -
fs->stats_p_allocated - fs->stats_p_deleted;
int32_t free_pages;
uint32_t needed_pages;
int tries = 0;
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 &&
(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;
}
uint32_t needed_pages =
(len + SPIFFS_DATA_PAGE_SIZE(fs) - 1) / SPIFFS_DATA_PAGE_SIZE(fs);
/* Get the number of pages needed */
needed_pages = (len + SPIFFS_DATA_PAGE_SIZE(fs) - 1) /
SPIFFS_DATA_PAGE_SIZE(fs);
#if 0
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
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",
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;
}
free_pages = (SPIFFS_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (fs->geo.neraseblocks - 2) -
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 (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 ||
(int32_t) len > free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs)));
free_pages =
(SPIFFS_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)) * (fs->geo.neraseblocks - 2) -
fs->stats_p_allocated - fs->stats_p_deleted;
/* Re-caculate 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 ((int32_t) len > free_pages * (int32_t) SPIFFS_DATA_PAGE_SIZE(fs))
{
ret = -ENOSPC;
}
spiffs_gcinfo("Finished, %d dirty, blocks, %d free, %d pages free, %d tries, ret=%d\n",
fs->stats_p_allocated + fs->stats_p_deleted, fs->free_blocks,
free_pages, tries, ret);
spiffs_gcinfo("Finished, %d dirty, blocks, %d free, %d pages free, "
"%d tries, ret=%d\n",
fs->stats_p_allocated + fs->stats_p_deleted,
fs->free_blocks, free_pages, tries, ret);
return ret;
}
fs/spiffs/src/spiffs_mtd.c
+17 -16
View File
@@ -64,13 +64,13 @@
* Write data to FLASH memory
*
* Input Parameters:
* fs - A reference to the volume structure
* fs - A reference to the volume structure
* offset - The physical offset to write to
* len - The number of bytes to write
* src - A reference to the bytes to be written
* len - The number of bytes to write
* src - A reference to the bytes to be written
*
* 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.
*
****************************************************************************/
@@ -81,28 +81,30 @@ ssize_t spiffs_mtd_write(FAR struct spiffs_s *fs, off_t offset, size_t len,
int16_t blksize;
off_t blkstart;
off_t blkend;
ssize_t ret;
DEBUGASSERT(fs != NULL && fs->mtd != NULL && src != NULL);
#warning REVISIT: What are units of offset and len?
#ifdef CONFIG_MTD_BYTE_WRITE
ret = MTD_WRITE(fs->mtd, offset, len, src);
if (ret < 0)
#endif
{
/* We will have to do a block read */
blksize = fs->geo.blocksize;
DEBUGASSERT(offset = offset % blksize);
DEBUGASSERT(len = len % blksize);
DEBUGASSERT(offset == offset % blksize);
DEBUGASSERT(len == len % blksize);
blkstart = offset / blksize; /* Truncates to floor */
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);
}
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.
*
* 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.
*
****************************************************************************/
@@ -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);
#warning REVISIT: What are units of offset and len?
ret = MTD_READ(fs->mtd, offset, len, dest);
if (ret < 0)
{
blksize = fs->geo.blocksize;
DEBUGASSERT(offset = offset % blksize);
DEBUGASSERT(len = len % blksize);
DEBUGASSERT(offset == offset % blksize);
DEBUGASSERT(len == len % blksize);
blkstart = offset / blksize; /* Truncates to floor */
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);
}
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
*
* 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.
*
****************************************************************************/
fs/spiffs/src/spiffs_mtd.h
+15 -8
View File
@@ -53,11 +53,18 @@ extern "C"
* Pre-processor Definitions
****************************************************************************/
#define SPIFFS_CFG_EBLOCK_COUNT(fs) ((fs)->geo.neraseblocks)
#define SPIFFS_CFG_LOG_PAGE_SZ(fs) ((fs)->geo.blocksize)
#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)
/* The MTD interface does not deal with pages explicitly. With most
* hardware a logical block is the same as an SPIFFS page.
*/
#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
@@ -76,7 +83,7 @@ extern "C"
* src - A reference to the bytes to be written
*
* 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.
*
****************************************************************************/
@@ -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.
*
* 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.
*
****************************************************************************/
@@ -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
*
* 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.
*
****************************************************************************/
fs/spiffs/src/spiffs_vfs.c
+20 -17
View File
@@ -297,8 +297,8 @@ static int spiffs_readdir_callback(FAR struct spiffs_s *fs,
int16_t pgndx;
int ret;
if (objid == SPIFFS_OBJ_ID_FREE || objid == SPIFFS_OBJ_ID_DELETED ||
(objid & SPIFFS_OBJ_ID_IX_FLAG) == 0)
if (objid == SPIFFS_OBJID_FREE || objid == SPIFFS_OBJID_DELETED ||
(objid & SPIFFS_OBJID_NDXFLAG) == 0)
{
return SPIFFS_VIS_COUNTINUE;
}
@@ -314,7 +314,7 @@ static int spiffs_readdir_callback(FAR struct spiffs_s *fs,
return ret;
}
if ((objid & SPIFFS_OBJ_ID_IX_FLAG) &&
if ((objid & SPIFFS_OBJID_NDXFLAG) &&
objhdr.phdr.spndx == 0 &&
(objhdr.phdr.flags & (SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_FINAL |
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. */
ret = spiffs_objlu_find_free_obj_id(fs, &objid, 0);
ret = spiffs_objlu_find_free_objid(fs, &objid, 0);
if (ret < 0)
{
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 (buflen < (size_t)SPIFFS_CFG_LOG_PAGE_SZ(fs))
if (buflen < (size_t)SPIFFS_GEO_PAGE_SIZE(fs))
{
/* 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 ||
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
* new
@@ -881,7 +881,7 @@ static off_t spiffs_seek(FAR struct file *filep, off_t offset, int whence)
{
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);
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 */
int16_t blkndx = 0;
while (blkndx < fs->geo.neraseblocks)
while (blkndx < SPIFFS_GEO_BLOCK_COUNT(fs))
{
fs->max_erase_count = 0;
ret = spiffs_erase_block(fs, blkndx);
@@ -1289,7 +1289,7 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
int ret;
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 */
@@ -1316,7 +1316,9 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
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 */
@@ -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 */
cache_max = SPIFFS_CFG_LOG_PAGE_SZ(fs) << 5;
cache_max = SPIFFS_GEO_PAGE_SIZE(fs) << 5;
if (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.
*/
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);
if (work == NULL)
@@ -1363,7 +1365,8 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
fs->work = &work[0];
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 */
@@ -1375,11 +1378,11 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
}
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",
(unsigned int)SPIFFS_OBJ_LOOKUP_PAGES(fs));
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",
(unsigned int)sizeof(struct spiffs_page_header_s));
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 */
pages_per_block = SPIFFS_PAGES_PER_BLOCK(fs);
blocks = fs->geo.neraseblocks;
pages_per_block = SPIFFS_GEO_PAGES_PER_BLOCK(fs);
blocks = SPIFFS_GEO_BLOCK_COUNT(fs);
obj_lupages = SPIFFS_OBJ_LOOKUP_PAGES(fs);
data_pgsize = SPIFFS_DATA_PAGE_SIZE(fs);
fs/spiffs/src/spiffs_volume.c
+1 -1
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_size = objhdr.size == SPIFFS_UNDEFINED_LEN ? 0 : objhdr.size;
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;
}