Google Git
Sign in
apache/nuttx/refs/heads/master/./fs/spiffs/src/spiffs_check.c
blob: cfebfa77335aac137edc6cfeb4e3b1a0c21c670b [file] [log] [blame]
/****************************************************************************
* fs/spiffs/src/spiffs_check.c
*
* SPDX-License-Identifier: BSD-3-Clause
* SPDX-FileCopyrightText: 2018 Gregory Nutt
*
* This is a port of version 0.3.7 of SPIFFS by Peter Andersion. That
* version was originally released under the MIT license but is here re-
* released under the NuttX BSD license.
*
* Copyright (c) 2013-2017 Peter Andersson (pelleplutt1976@gmail.com)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* Contains functionality for checking file system consistency
* and mending problems.
* Three levels of consistency checks are implemented:
*
* Look up consistency
* Checks if indices in lookup pages are coherent with page headers
* Object index consistency
* Checks if there are any orphaned object indices (missing object index
* headers).
* If an object index is found but not its header, the object index is
* deleted.
* This is critical for the following page consistency check.
* Page consistency
* Checks for pages that ought to be indexed, ought not to be indexed, are
* multiple indexed
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <string.h>
#include <debug.h>
#include "spiffs.h"
#include "spiffs_core.h"
#include "spiffs_cache.h"
#include "spiffs_check.h"
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: spiffs_check_get_data_pgndx
*
* Description:
* Searches in the object indices and returns the referenced page index
* given the object ID and the data span index destroys fs->lu_work
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - Object ID
* data_spndx - Data span index
* pgnx - Page index
* objndx_pgndx - Object index page index
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
static int spiffs_check_get_data_pgndx(FAR struct spiffs_s *fs,
int16_t objid, int16_t data_spndx,
FAR int16_t *pgndx,
FAR int16_t *objndx_pgndx)
{
uint32_t addr;
int16_t objndx_spndx;
int ret;
/* Calculate object index span index for given data page span index */
objndx_spndx = SPIFFS_OBJNDX_ENTRY_SPNDX(fs, data_spndx);
/* Find the object index for the object ID and span index */
ret = spiffs_objlu_find_id_and_span(fs, objid | SPIFFS_OBJID_NDXFLAG,
objndx_spndx, 0, objndx_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n", ret);
return ret;
}
/* Load the object index entry */
addr = SPIFFS_PAGE_TO_PADDR(fs, *objndx_pgndx);
if (objndx_spndx == 0)
{
/* Get the referenced page from object index header */
addr += sizeof(struct spiffs_pgobj_ndxheader_s) +
data_spndx * sizeof(int16_t);
}
else
{
/* Get the referenced page from object index */
addr += sizeof(struct spiffs_page_objndx_s) +
SPIFFS_OBJNDX_ENTRY(fs, data_spndx) *
sizeof(int16_t);
}
/* Read the page from FLASH (or the cache) */
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ, 0,
addr, sizeof(int16_t), (FAR uint8_t *)pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
}
return ret;
}
/****************************************************************************
* Name: spiffs_check_rewrite_page
*
* Description:
* Copies page contents to a new page
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* cur_pgndx - Current page index
* pghdr - Reference to page header
* new_pgndx - Location to return the new page index
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
static int spiffs_check_rewrite_page(FAR struct spiffs_s *fs,
int16_t cur_pgndx,
FAR struct spiffs_page_header_s *pghdr,
FAR int16_t *new_pgndx)
{
int ret;
ret = spiffs_page_allocate_data(fs, pghdr->objid, pghdr, 0, 0, 0, 0,
new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_allocate_data() failed: %d\n", ret);
return ret;
}
ret = spiffs_phys_cpy(fs, 0,
SPIFFS_PAGE_TO_PADDR(fs, *new_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_DATA_PAGE_SIZE(fs));
if (ret < 0)
{
ferr("ERROR: spiffs_phys_cpy() failed: %d\n", ret);
}
return ret;
}
/****************************************************************************
* Name: spiffs_check_rewrite_index
*
* Description:
* Rewrites the object index for given object ID and replaces the
* data page index to a new page index
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - Object ID
* data_spndx - Data span index
* pgnx - Page index
* objndx_pgndx - Object index page index
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
static int spiffs_check_rewrite_index(FAR struct spiffs_s *fs,
int16_t objid, int16_t data_spndx,
int16_t new_data_pgndx,
int16_t objndx_pgndx)
{
FAR struct spiffs_page_header_s *objndx_phdr;
int16_t blkndx;
int16_t free_pgndx;
int entry;
int ret;
objid |= SPIFFS_OBJID_NDXFLAG;
/* Find free entry */
ret = spiffs_objlu_find_free(fs, fs->free_blkndx,
fs->free_entry, &blkndx, &entry);
if (ret < 0)
{
fwarn("WARNING: spiffs_objlu_find_free() failed: %d\n", ret);
return ret;
}
free_pgndx = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PGNDX(fs, blkndx, entry);
/* Calculate object index span index for given data page span index */
int16_t objndx_spndx = SPIFFS_OBJNDX_ENTRY_SPNDX(fs, data_spndx);
if (objndx_spndx == 0)
{
/* Calculate index in index header */
entry = data_spndx;
}
else
{
/* Calculate entry in index */
entry = SPIFFS_OBJNDX_ENTRY(fs, data_spndx);
}
/* Load index */
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, objndx_pgndx),
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
objndx_phdr = (FAR struct spiffs_page_header_s *)fs->lu_work;
/* Be ultra safe, double check header against provided data. Return
* -EFAULT to indicate this condition.
*/
if (objndx_phdr->objid != objid)
{
spiffs_page_delete(fs, free_pgndx);
return -EFAULT;
}
if (objndx_phdr->spndx != objndx_spndx)
{
spiffs_page_delete(fs, free_pgndx);
return -EFAULT;
}
if ((objndx_phdr->flags & (SPIFFS_PH_FLAG_USED | SPIFFS_PH_FLAG_NDXDELE |
SPIFFS_PH_FLAG_INDEX | SPIFFS_PH_FLAG_FINAL |
SPIFFS_PH_FLAG_DELET)) !=
(SPIFFS_PH_FLAG_NDXDELE | SPIFFS_PH_FLAG_DELET))
{
spiffs_page_delete(fs, free_pgndx);
return -EFAULT;
}
/* Rewrite in memory */
if (objndx_spndx == 0)
{
((FAR int16_t *)((FAR uint8_t *)fs->lu_work +
sizeof(struct spiffs_pgobj_ndxheader_s)))[data_spndx] =
new_data_pgndx;
}
else
{
((FAR int16_t *)((FAR uint8_t *)fs->lu_work +
sizeof(struct spiffs_page_objndx_s)))
[SPIFFS_OBJNDX_ENTRY(fs, data_spndx)] = new_data_pgndx;
}
ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_UPDT, 0,
SPIFFS_PAGE_TO_PADDR(fs, free_pgndx),
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret);
return ret;
}
ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_UPDT, 0,
SPIFFS_BLOCK_TO_PADDR(fs, SPIFFS_BLOCK_FOR_PAGE(fs, free_pgndx)) +
SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, free_pgndx) * sizeof(int16_t),
sizeof(int16_t), (FAR uint8_t *)&objid);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret);
return ret;
}
ret = spiffs_page_delete(fs, objndx_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_delete() failed: %d\n", ret);
}
return ret;
}
/****************************************************************************
* Name: spiffs_check_delobj_lazy
*
* Description:
* Deletes an object just by marking object index header as deleted
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - Object ID to be deleted
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
static int spiffs_check_delobj_lazy(FAR struct spiffs_s *fs, int16_t objid)
{
int16_t objhdr_pgndx;
uint8_t flags = 0xff;
int ret;
ret = spiffs_objlu_find_id_and_span(fs, objid, 0, 0, &objhdr_pgndx);
if (ret == -ENOENT)
{
return OK;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n", ret);
return ret;
}
#ifdef CONFIG_SPIFFS_NO_BLIND_WRITES
/* Perform a read-modify-write */
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ, 0,
SPIFFS_PAGE_TO_PADDR(fs, objhdr_pgndx) +
offsetof(struct spiffs_page_header_s, flags),
sizeof(flags), &flags);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
#endif
/* Clear the deleted flag in FLASH to mark the page deleted */
flags &= ~SPIFFS_PH_FLAG_NDXDELE;
ret = spiffs_cache_write(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_UPDT, 0,
SPIFFS_PAGE_TO_PADDR(fs, objhdr_pgndx) +
offsetof(struct spiffs_page_header_s, flags),
sizeof(flags), &flags);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret);
}
return ret;
}
/****************************************************************************
* Name: spiffs_check_rewrite_index
*
* Description:
* Validates the given look up entry
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - Object ID
* pghdr - Page header
* cur_pgndx - Current page index
* cur_block - Current block
* cur_entry - Current entry
* reload_lu - Reload lookup entry (returned)
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
static int
spiffs_check_luentry_validate(FAR struct spiffs_s *fs,
int16_t lu_objid,
FAR struct spiffs_page_header_s *pghdr,
int16_t cur_pgndx,
int16_t cur_block,
int cur_entry,
FAR bool *reload_lu)
{
int16_t objndx_pgndx;
int16_t ref_pgndx;
bool delete_page = false;
int ret = OK;
/* Check validity, take actions */
if (((lu_objid == SPIFFS_OBJID_DELETED) &&
(pghdr->flags & SPIFFS_PH_FLAG_DELET)) ||
((lu_objid == SPIFFS_OBJID_FREE) &&
(pghdr->flags & SPIFFS_PH_FLAG_USED) == 0))
{
/* Look up entry deleted / free but used in page header */
spiffs_checkinfo("pgndx=%04x deleted/free in lu but not on page\n",
cur_pgndx);
*reload_lu = true;
delete_page = true;
if (pghdr->flags & SPIFFS_PH_FLAG_INDEX)
{
/* Header says data page data page can be removed if not
* referenced by some object index
*/
ret = spiffs_check_get_data_pgndx(fs, pghdr->objid,
pghdr->spndx,
&ref_pgndx, &objndx_pgndx);
if (ret == -ENOENT)
{
/* No object with this objid, so remove page safely */
ret = OK;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_check_get_data_pgndx() failed: %d\n", ret);
return ret;
}
else if (ref_pgndx == cur_pgndx)
{
int16_t new_pgndx;
/* Data page referenced by object index but deleted in lu copy
* page to new place and re-write the object index to new place
*/
ret = spiffs_check_rewrite_page(fs, cur_pgndx, pghdr,
&new_pgndx);
spiffs_checkinfo("Data page not found elsewhere, rewriting "
"%04x to new page %04x\n",
cur_pgndx, new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_page() failed: %d\n",
ret);
return ret;
}
*reload_lu = true;
spiffs_checkinfo("Page %04x rewritten to %04x, "
"affected objndx_pgndx %04x\n",
cur_pgndx, new_pgndx, objndx_pgndx);
ret = spiffs_check_rewrite_index(fs,
pghdr->objid, pghdr->spndx,
new_pgndx, objndx_pgndx);
if (ret == -EFAULT)
{
int ret2;
/* Index bad also, cannot mend this file */
spiffs_checkinfo("Index bad %d, cannot mend!\n", ret);
ret2 = spiffs_page_delete(fs, new_pgndx);
if (ret2 < 0)
{
ferr("ERROR: spiffs_page_delete() failed: %d\n", ret2);
return ret2;
}
ret2 = spiffs_check_delobj_lazy(fs, pghdr->objid);
if (ret2 < 0)
{
ferr("ERROR: spiffs_check_delobj_lazy() failed: %d\n",
ret2);
return ret2;
}
}
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_index() failed: %d\n",
ret);
return ret;
}
}
}
else
{
/* Header says index page index page can be removed if other index
* with same objid and span index is found
*/
ret = spiffs_objlu_find_id_and_span(fs,
pghdr->objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx, 0);
if (ret == -ENOENT)
{
/* No such index page found, check for a data page amongst page
* headers. lu cannot be trusted
*/
ret =
spiffs_objlu_find_id_and_span_byphdr(fs,
pghdr->objid |
SPIFFS_OBJID_NDXFLAG,
0, 0, 0);
if (ret >= 0)
{
int16_t new_pgndx;
/* Ignore other errors. Got a data page also, assume lu
* corruption only, rewrite to new page
*/
ret = spiffs_check_rewrite_page(fs, cur_pgndx, pghdr,
&new_pgndx);
spiffs_checkinfo("Index page with data not found, "
"rewriting %04x to new page %04x\n",
cur_pgndx, new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_page() failed: %d\n",
ret);
return ret;
}
*reload_lu = true;
}
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span_byphdr(): %d\n",
ret);
return ret;
}
}
}
if (lu_objid != SPIFFS_OBJID_FREE && lu_objid != SPIFFS_OBJID_DELETED)
{
/* look up entry used */
if ((pghdr->objid | SPIFFS_OBJID_NDXFLAG) !=
(lu_objid | SPIFFS_OBJID_NDXFLAG))
{
spiffs_checkinfo("pgndx %04x differ in objid lu="
"%04x ph:%04x\n", cur_pgndx, lu_objid,
pghdr->objid);
delete_page = true;
if ((pghdr->flags & SPIFFS_PH_FLAG_DELET) == 0 ||
(pghdr->flags & SPIFFS_PH_FLAG_FINAL) ||
(pghdr->flags & (SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_NDXDELE)) == 0)
{
/* Page deleted or not finalized, just remove it */
}
else if (pghdr->flags & SPIFFS_PH_FLAG_INDEX)
{
/* if data page, check for reference to this page */
ret = spiffs_check_get_data_pgndx(fs,
pghdr->objid,
pghdr->spndx,
&ref_pgndx,
&objndx_pgndx);
if (ret == -ENOENT)
{
/* no object with this objid, so remove page safely */
ret = OK;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_check_get_data_pgndx() failed: %d\n",
ret);
return ret;
}
/* if found, rewrite page with object ID, update index, and
* delete current
*/
else if (ref_pgndx == cur_pgndx)
{
int16_t new_pgndx;
ret = spiffs_check_rewrite_page(fs, cur_pgndx, pghdr,
&new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_page() failed: %d\n",
ret);
return ret;
}
ret = spiffs_check_rewrite_index(fs, pghdr->objid,
pghdr->spndx, new_pgndx,
objndx_pgndx);
if (ret == -EFAULT)
{
int ret2;
/* Index bad also, cannot mend this file */
spiffs_checkinfo("Index bad %d, cannot mend!\n", ret);
ret2 = spiffs_page_delete(fs, new_pgndx);
if (ret2 < 0)
{
ferr("ERROR: spiffs_page_delete() failed: %d\n",
ret2);
return ret2;
}
ret2 = spiffs_check_delobj_lazy(fs, pghdr->objid);
if (ret2 < 0)
{
ferr("ERROR: spiffs_check_delobj_lazy(): %d\n",
ret2);
return ret2;
}
*reload_lu = true;
}
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_index(): %d\n",
ret);
return ret;
}
}
}
else
{
int16_t objndx_pgndx_lu;
int16_t objndx_pgndx_ph;
/* Else if index, check for other pages with both ID's and
* span index
*
* See if other object index page exists for lookup objid
* and span index
*/
ret = spiffs_objlu_find_id_and_span(fs,
lu_objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, 0,
&objndx_pgndx_lu);
if (ret == -ENOENT)
{
ret = OK;
objndx_pgndx_lu = 0;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n",
ret);
return ret;
}
/* See if other object index exists for page header objid and
* span index
*/
ret = spiffs_objlu_find_id_and_span(fs,
pghdr->objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, 0, &objndx_pgndx_ph);
if (ret == -ENOENT)
{
ret = OK;
objndx_pgndx_ph = 0;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n",
ret);
return ret;
}
/* If both ID's found, just delete current */
if (objndx_pgndx_ph == 0 || objndx_pgndx_lu == 0)
{
struct spiffs_page_header_s new_ph;
int16_t data_pgndx_lu;
int16_t data_pgndx_ph;
int16_t new_pgndx;
/* Otherwise try finding first corresponding data pages.
*
* See if other data page exists for look up objid and
* span index
*/
ret =
spiffs_objlu_find_id_and_span(fs,
lu_objid & ~SPIFFS_OBJID_NDXFLAG,
0, 0, &data_pgndx_lu);
if (ret == -ENOENT)
{
ret = OK;
objndx_pgndx_lu = 0;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span(): %d\n",
ret);
return ret;
}
/* See if other data page exists for page header objid
* and span index
*/
ret =
spiffs_objlu_find_id_and_span(fs,
pghdr->objid &
~SPIFFS_OBJID_NDXFLAG,
0, 0, &data_pgndx_ph);
if (ret == -ENOENT)
{
ret = OK;
objndx_pgndx_ph = 0;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span(): %d\n",
ret);
return ret;
}
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED |
SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_FINAL);
new_ph.spndx = pghdr->spndx;
if ((objndx_pgndx_lu != 0 && data_pgndx_lu != 0 &&
data_pgndx_ph != 0 && objndx_pgndx_ph == 0) ||
(objndx_pgndx_lu == 0 && data_pgndx_ph &&
objndx_pgndx_ph == 0))
{
/* Got a data page for page header objid rewrite as
* objid_ph
*/
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",
cur_pgndx, new_ph.objid, new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_page(): %d\n",
ret);
return ret;
}
*reload_lu = true;
}
else if ((objndx_pgndx_ph != 0 && data_pgndx_ph != 0 &&
data_pgndx_lu != 0 && objndx_pgndx_lu == 0) ||
(objndx_pgndx_ph == 0 && data_pgndx_lu &&
objndx_pgndx_lu == 0))
{
/* Got a data page for look up objid rewrite as
* objid_lu
*/
new_ph.objid = lu_objid | SPIFFS_OBJID_NDXFLAG;
spiffs_checkinfo("Rewrite page %04x as %04x\n",
cur_pgndx, new_ph.objid);
ret = spiffs_check_rewrite_page(fs, cur_pgndx, &new_ph,
&new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_check_rewrite_page(): %d\n",
ret);
return ret;
}
*reload_lu = true;
}
else
{
/* Cannot safely do anything */
spiffs_checkinfo("Nothing to do, just delete\n");
}
}
}
}
else if (((lu_objid & SPIFFS_OBJID_NDXFLAG) != 0 &&
(pghdr->flags & SPIFFS_PH_FLAG_INDEX) != 0) ||
((lu_objid & SPIFFS_OBJID_NDXFLAG) == 0 &&
(pghdr->flags & SPIFFS_PH_FLAG_INDEX) == 0))
{
int16_t data_pgndx;
int16_t objndx_pgndx_d;
spiffs_checkinfo("%04x lu/page index marking differ\n", cur_pgndx);
/* see if other data page exists for given objid and span index */
ret = spiffs_objlu_find_id_and_span(fs,
lu_objid & ~SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx, &data_pgndx);
if (ret == -ENOENT)
{
ret = OK;
data_pgndx = 0;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n",
ret);
return ret;
}
/* See if other object index exists for given objid and span
* index
*/
ret = spiffs_objlu_find_id_and_span(fs,
lu_objid | SPIFFS_OBJID_NDXFLAG,
pghdr->spndx, cur_pgndx,
&objndx_pgndx_d);
if (ret == -ENOENT)
{
ret = OK;
objndx_pgndx_d = 0;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n",
ret);
return ret;
}
delete_page = true;
/* If other data page exists and object index exists, just delete
* page
*/
if (data_pgndx != 0 && objndx_pgndx_d != 0)
{
spiffs_checkinfo(
"Other index and data page exists, simply remove\n");
}
/* If only data page exists, make this page index */
else if (data_pgndx && objndx_pgndx_d == 0)
{
struct spiffs_page_header_s new_ph;
int16_t new_pgndx;
spiffs_checkinfo("Other data page exists, make this index\n");
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED |
SPIFFS_PH_FLAG_FINAL |
SPIFFS_PH_FLAG_INDEX);
new_ph.objid = lu_objid | SPIFFS_OBJID_NDXFLAG;
new_ph.spndx = pghdr->spndx;
ret = spiffs_page_allocate_data(fs, new_ph.objid, &new_ph,
0, 0, 0, 1, &new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_allocate_data() failed: %d\n",
ret);
return ret;
}
ret = spiffs_phys_cpy(fs, 0,
SPIFFS_PAGE_TO_PADDR(fs, new_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_page_header_s));
if (ret < 0)
{
ferr("ERROR: spiffs_phys_cpy() failed: %d\n", ret);
return ret;
}
}
/* If only index exists, make data page */
else if (data_pgndx == 0 && objndx_pgndx_d)
{
struct spiffs_page_header_s new_ph;
int16_t new_pgndx;
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_OBJID_NDXFLAG;
new_ph.spndx = pghdr->spndx;
ret = spiffs_page_allocate_data(fs, new_ph.objid, &new_ph,
0, 0, 0, 1, &new_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_allocate_data() failed: %d\n",
ret);
return ret;
}
ret = spiffs_phys_cpy(fs, 0,
SPIFFS_PAGE_TO_PADDR(fs, new_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
sizeof(struct spiffs_page_header_s),
SPIFFS_GEO_PAGE_SIZE(fs) -
sizeof(struct spiffs_page_header_s));
if (ret < 0)
{
ferr("ERROR: spiffs_phys_cpy() failed: %d\n", ret);
return ret;
}
}
else
{
/* If nothing exists, we cannot safely make a decision -
* delete
*/
}
}
else if ((pghdr->flags & SPIFFS_PH_FLAG_DELET) == 0)
{
spiffs_checkinfo("pgndx=%04x busy in lu but deleted on page\n",
cur_pgndx);
delete_page = 1;
}
else if ((pghdr->flags & SPIFFS_PH_FLAG_FINAL))
{
spiffs_checkinfo("pgndx=%04x busy but not final\n",
cur_pgndx);
/* Page can be removed if not referenced by object index */
*reload_lu = true;
ret = spiffs_check_get_data_pgndx(fs, lu_objid, pghdr->spndx,
&ref_pgndx, &objndx_pgndx);
if (ret == -ENOENT)
{
/* No object with this ID, so remove page safely */
ret = OK;
delete_page = true;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_phys_cpy() failed: %d\n", ret);
return ret;
}
else if (ref_pgndx != cur_pgndx)
{
spiffs_checkinfo(
"Other finalized page is referred, just delete\n");
delete_page = true;
}
else
{
uint8_t flags = 0xff;
/* page referenced by object index but not final
* just finalize
*/
spiffs_checkinfo("Unfinalized page is referred, finalizing\n");
#ifdef CONFIG_SPIFFS_NO_BLIND_WRITES
ret = spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
offsetof(struct spiffs_page_header_s, flags),
sizeof(flags), &flags);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
#endif
flags &= ~SPIFFS_PH_FLAG_FINAL;
ret = spiffs_cache_write(fs,
SPIFFS_OP_T_OBJ_DA | SPIFFS_OP_C_UPDT,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx) +
offsetof(struct spiffs_page_header_s, flags),
sizeof(flags), &flags);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_write() failed: %d\n", ret);
return ret;
}
}
}
}
if (delete_page)
{
spiffs_checkinfo("Deleting page %04x\n", cur_pgndx);
ret = spiffs_page_delete(fs, cur_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_delete() failed: %d\n", ret);
return ret;
}
}
return ret;
}
/****************************************************************************
* Name: spiffs_lucheck_callback
*
* Description:
* This is a callback from spiffs_foreach_objlu(). It is part of the
* logic of spiffs_check_luconsistency(). It checks the page page
* header for each entry for validity.
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - Object ID
* cur_block - Current block
* cur_entry - Current entry
* user_const - User provided constant data
* user_var - User provided variable data
*
* Returned Value:
* Returns SPIFFS_VIS_COUNTINUE_RELOAD, SPIFFS_VIS_COUNTINUE, or a
* negated errno value in the event of a failure.
*
****************************************************************************/
static int spiffs_lucheck_callback(FAR struct spiffs_s *fs, int16_t objid,
int16_t cur_block, int cur_entry,
FAR const void *user_const,
FAR void *user_var)
{
struct spiffs_page_header_s pghdr;
int16_t cur_pgndx;
int ret = OK;
bool reload_lu = false;
cur_pgndx = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PGNDX(fs, cur_block, cur_entry);
/* Load header */
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx),
sizeof(struct spiffs_page_header_s),
(FAR uint8_t *)&pghdr);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
ret = spiffs_check_luentry_validate(fs, objid, &pghdr, cur_pgndx,
cur_block, cur_entry, &reload_lu);
if (ret < 0)
{
ferr("ERROR: spiffs_check_luentry_validate() failed: %d\n", ret);
return ret;
}
return reload_lu ? SPIFFS_VIS_COUNTINUE_RELOAD : SPIFFS_VIS_COUNTINUE;
}
/****************************************************************************
* Name: spifss_check_objndx_search
*
* Description:
* Searches for given object ID in temporary object ID index.
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - The Object ID
*
* Returned Value:
* The index associated with the objid is returned on success. -ENOENT
* is resulted if the objid was not found.
*
****************************************************************************/
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_OBJID_NDXFLAG;
for (i = 0; i < SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t); i++)
{
if ((obj_table[i] & ~SPIFFS_OBJID_NDXFLAG) == objid)
{
return i;
}
}
return -ENOENT;
}
/****************************************************************************
* Name: spiffs_check_objidconsistency_callback
*
* Description:
* Check object index consistency. This is callback from
* spiffs_foreach_objlu() and logically a part of
* spiffs_check_objidconsistency()
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
* objid - Object ID
* cur_block - Current block
* cur_entry - Current entry
* user_const - User provided constant data
* user_var - User provided variable data
*
* Returned Value:
* Returns SPIFFS_VIS_COUNTINUE_RELOAD, SPIFFS_VIS_COUNTINUE, or a
* negated errno value in the event of a failure.
*
****************************************************************************/
static int spiffs_check_objidconsistency_callback(FAR struct spiffs_s *fs,
int16_t objid,
int16_t cur_block,
int cur_entry,
FAR const void *user_const,
FAR void *user_var)
{
FAR uint32_t *log_ndx = (FAR uint32_t *)user_var;
FAR int16_t *obj_table = (FAR int16_t *)fs->work;
int retc = SPIFFS_VIS_COUNTINUE;
int ret = OK;
if (objid != SPIFFS_OBJID_FREE && objid != SPIFFS_OBJID_DELETED &&
(objid & SPIFFS_OBJID_NDXFLAG) != 0)
{
struct spiffs_page_header_s pghdr;
int16_t cur_pgndx;
cur_pgndx = SPIFFS_OBJ_LOOKUP_ENTRY_TO_PGNDX(fs, cur_block, cur_entry);
/* Load header */
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx),
sizeof(struct spiffs_page_header_s), (uint8_t *)&pghdr);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
if (pghdr.spndx == 0 &&
(pghdr.flags & (SPIFFS_PH_FLAG_INDEX | SPIFFS_PH_FLAG_FINAL |
SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_NDXDELE)) ==
(SPIFFS_PH_FLAG_DELET))
{
spiffs_checkinfo("pgndx=%04x, objid=%04x spndx=%04x "
"header not fully deleted - deleting\n",
cur_pgndx, objid, pghdr.spndx);
ret = spiffs_page_delete(fs, cur_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_delete() failed: %d\n", ret);
return ret;
}
return retc;
}
if ((pghdr.flags & (SPIFFS_PH_FLAG_INDEX | SPIFFS_PH_FLAG_FINAL |
SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_NDXDELE)) ==
(SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_NDXDELE))
{
return retc;
}
if (pghdr.spndx == 0)
{
int ret2;
/* objndx header page, register objid as reachable */
ret2 = spifss_check_objndx_search(fs, objid);
if (ret2 < 0)
{
/* Not registered, do it */
obj_table[*log_ndx] = objid & ~SPIFFS_OBJID_NDXFLAG;
(*log_ndx)++;
if (*log_ndx >= SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t))
{
*log_ndx = 0;
}
}
}
else
{
bool delete = false;
int ret2;
/* Span index
* objndx page, see if header can be found
*/
ret2 = spifss_check_objndx_search(fs, objid);
if (ret2 < 0)
{
int16_t objhdr_pgndx;
/* Not in temporary index, try finding it */
ret = spiffs_objlu_find_id_and_span(fs,
objid | SPIFFS_OBJID_NDXFLAG,
0, 0, &objhdr_pgndx);
retc = SPIFFS_VIS_COUNTINUE_RELOAD;
if (ret >= 0)
{
/* Found, register as reachable */
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_OBJID_NDXFLAG;
}
else if (ret < 0)
{
ferr("ERROR: spiffs_objlu_find_id_and_span() failed: %d\n",
ret);
return ret;
}
(*log_ndx)++;
if (*log_ndx >= SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t))
{
*log_ndx = 0;
}
}
else
{
/* In temporary index, check reachable flag */
if ((obj_table[ret2] & SPIFFS_OBJID_NDXFLAG))
{
/* Registered as unreachable */
delete = true;
}
}
if (delete)
{
spiffs_checkinfo("pgndx=%04x objid=%04x spndx:%04x"
" is orphan index - deleting\n",
cur_pgndx, objid, pghdr.spndx);
ret = spiffs_page_delete(fs, cur_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_delete() failed: %d\n", ret);
return ret;
}
}
}
}
return retc;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: spiffs_check_luconsistency
*
* Description:
* Scans all object look up. For each entry, corresponding page header is
* checked for validity. If an object index header page is found, this is
* also checked
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
int spiffs_check_luconsistency(FAR struct spiffs_s *fs)
{
int ret = OK;
ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0, spiffs_lucheck_callback,
0, 0, 0, 0);
if (ret == SPIFFS_VIS_END)
{
ret = OK;
}
return ret;
}
/****************************************************************************
* Name: spiffs_check_pgconsistency
*
* Description:
* Checks consistency amongst all pages and fixes irregularities
* Scans all pages (except lu pages), reserves 4 bits in working memory
* for each page
*
* bit 0: 0 == FREE|DELETED, 1 == USED
* bit 1: 0 == UNREFERENCED, 1 == REFERENCED
* bit 2: 0 == NOT_INDEX, 1 == INDEX
* bit 3: unused
*
* A consistent file system will have only pages being
*
* - x000 free, unreferenced, not index
* - x011 used, referenced only once, not index
* - x101 used, unreferenced, index
*
* The working memory might not fit all pages so several scans might be
* needed
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
int spiffs_check_pgconsistency(FAR struct spiffs_s *fs)
{
const uint32_t bits = 4;
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_GEO_PAGES_PER_BLOCK(fs) *
SPIFFS_GEO_BLOCK_COUNT(fs))
{
int16_t cur_block = 0;
bool restart = false;
memset(fs->work, 0, SPIFFS_GEO_PAGE_SIZE(fs));
/* Build consistency bitmap for ID range traversing all blocks */
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_GEO_PAGES_PER_BLOCK(fs) * cur_block;
while (!restart && cur_pgndx <
SPIFFS_GEO_PAGES_PER_BLOCK(fs) * (cur_block + 1))
{
struct spiffs_page_header_s pghdr;
uint32_t pgndx_bytendx;
uint8_t pgndx_bitndx;
bool within_range;
/* read header */
ret =
spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx),
sizeof(struct spiffs_page_header_s),
(FAR uint8_t *)&pghdr);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
within_range = (cur_pgndx >= pgndx_offset &&
cur_pgndx < pgndx_offset + pages_per_scan);
pgndx_bytendx = (cur_pgndx - pgndx_offset) / (8 / bits);
pgndx_bitndx = (cur_pgndx & ((8 / bits) - 1)) * bits;
if (within_range &&
(pghdr.flags & SPIFFS_PH_FLAG_DELET) &&
(pghdr.flags & SPIFFS_PH_FLAG_USED) == 0)
{
/* Used */
fs->work[pgndx_bytendx] |= (1 << (pgndx_bitndx + 0));
}
if ((pghdr.flags & SPIFFS_PH_FLAG_DELET) &&
(pghdr.flags & SPIFFS_PH_FLAG_NDXDELE) &&
(pghdr.flags & (SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_USED)) == 0)
{
FAR struct spiffs_page_header_s *objndx_phdr;
FAR int16_t *object_page_index;
int16_t data_spndx_offset;
int entries;
int i;
/* Found non-deleted index */
if (within_range)
{
fs->work[pgndx_bytendx] |= (1 << (pgndx_bitndx + 2));
}
/* Load non-deleted index */
ret = spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx),
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n", ret);
return ret;
}
/* traverse index for referenced pages */
objndx_phdr =
(FAR struct spiffs_page_header_s *)fs->lu_work;
if (pghdr.spndx == 0)
{
/* object header page index */
entries = SPIFFS_OBJHDR_NDXLEN(fs);
data_spndx_offset = 0;
object_page_index =
(FAR int16_t *)((FAR uint8_t *)fs->lu_work +
sizeof(struct spiffs_pgobj_ndxheader_s));
}
else
{
/* Object page index */
entries = SPIFFS_OBJNDX_LEN(fs);
data_spndx_offset = SPIFFS_OBJHDR_NDXLEN(fs) +
SPIFFS_OBJNDX_LEN(fs) *
(pghdr.spndx - 1);
object_page_index =
(FAR int16_t *)((FAR uint8_t *) fs->lu_work +
sizeof(struct spiffs_page_objndx_s));
}
/* For all entries in index */
for (i = 0; !restart && i < entries; i++)
{
int16_t rpgndx = object_page_index[i];
bool rpgndx_within_range;
rpgndx_within_range = (rpgndx >= pgndx_offset &&
rpgndx < pgndx_offset +
pages_per_scan);
if ((rpgndx != (int16_t) - 1 &&
rpgndx > SPIFFS_GEO_PAGE_COUNT(fs)) ||
(rpgndx_within_range &&
SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx)))
{
int16_t data_pgndx;
/* Bad reference */
spiffs_checkinfo("pgndx=%04x bad pgndx / LU "
"referenced from page %04x\n",
rpgndx, cur_pgndx);
/* Check for data page elsewhere */
ret = spiffs_objlu_find_id_and_span(fs,
objndx_phdr->objid &
~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i,
0, &data_pgndx);
if (ret == -ENOENT)
{
ret = OK;
data_pgndx = 0;
}
else if (ret < 0)
{
ferr("ERR: spiffs_objlu_find_id_and_span %d\n",
ret);
return ret;
}
if (data_pgndx == 0)
{
struct spiffs_page_header_s new_ph;
/* If not, allocate free page */
new_ph.flags = 0xff & ~(SPIFFS_PH_FLAG_USED |
SPIFFS_PH_FLAG_FINAL);
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,
&new_ph, 0, 0, 0, 1,
&data_pgndx);
if (ret < 0)
{
ferr("ERR: spiffs_page_allocate_data %d\n",
ret);
return ret;
}
spiffs_checkinfo("Found no existing data page,"
" created new @ %04x\n",
data_pgndx);
}
/* Remap index */
spiffs_checkinfo("Rewriting index pgndx=%04x\n",
cur_pgndx);
ret =
spiffs_check_rewrite_index(fs,
objndx_phdr->objid |
SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i,
data_pgndx, cur_pgndx);
if (ret == -EFAULT)
{
/* Index bad also, cannot mend this file */
spiffs_checkinfo("Index bad %d, cannot mend - "
"delete object\n",
ret);
/* Delete file */
ret = spiffs_page_delete(fs, cur_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_delete(): %d\n",
ret);
return ret;
}
}
else if (ret < 0)
{
ferr("ERR: spiffs_check_rewrite_index(): %d\n",
ret);
return ret;
}
restart = true;
}
else if (rpgndx_within_range)
{
/* Valid reference. read referenced page header */
struct spiffs_page_header_s rphdr;
ret =
spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0, SPIFFS_PAGE_TO_PADDR(fs, rpgndx),
sizeof(struct spiffs_page_header_s),
(FAR uint8_t *)&rphdr);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n",
ret);
return ret;
}
/* Cross reference page header check */
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)) !=
(SPIFFS_PH_FLAG_DELET | SPIFFS_PH_FLAG_INDEX))
{
int16_t data_pgndx;
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_OBJID_NDXFLAG,
data_spndx_offset + i, rphdr.objid,
rphdr.spndx, rphdr.flags);
/* Try finding correct page */
ret =
spiffs_objlu_find_id_and_span(fs,
pghdr.objid &
~SPIFFS_OBJID_NDXFLAG,
data_spndx_offset + i,
rpgndx, &data_pgndx);
if (ret == -ENOENT)
{
ret = OK;
data_pgndx = 0;
}
else if (ret < 0)
{
ferr("spiffs_objlu_find_id_and_span: %d\n",
ret);
return ret;
}
if (data_pgndx == 0)
{
/* Not found, this index is badly borked */
spiffs_checkinfo(
"Index bad, delete object objid %04x\n",
pghdr.objid);
ret = spiffs_check_delobj_lazy(fs,
pghdr.objid);
if (ret < 0)
{
ferr("spiffs_check_delobj_lazy: %d\n",
ret);
return ret;
}
break;
}
else
{
/* Found it, so rewrite index */
spiffs_checkinfo(
"Found correct data pgndx=%04x, "
"rewrite index pgndx=%04x objid=%04x\n",
data_pgndx, cur_pgndx, pghdr.objid);
ret =
spiffs_check_rewrite_index(
fs, pghdr.objid, data_spndx_offset + i,
data_pgndx, cur_pgndx);
if (ret == -EFAULT)
{
/* Index bad, cannot mend this file */
spiffs_checkinfo(
"Index bad %d, cannot mend!\n", ret);
ret = spiffs_check_delobj_lazy(
fs, pghdr.objid);
}
else if (ret < 0)
{
ferr("spiffs_check_rewrite_index %d\n",
ret);
return ret;
}
restart = true;
}
}
else
{
/* Mark rpgndx as referenced */
const uint32_t rpgndx_byte_ix =
(rpgndx - pgndx_offset) / (8 / bits);
const uint8_t rpgndx_bit_ix =
(rpgndx & ((8 / bits) - 1)) * bits;
if ((fs->work[rpgndx_byte_ix] &
(1 << (rpgndx_bit_ix + 1))) != 0)
{
spiffs_checkinfo(
"pgndx=%04x multiple referenced "
"from page %04x\n",
rpgndx, cur_pgndx);
/* Here, we should have fixed all broken
* references - getting this means there
* must be multiple files with same object
* ID. Only solution is to delete
* the object which is referring to this
* page
*/
spiffs_checkinfo("Removing objid=%04x and"
"page=%04x\n",
pghdr.objid, cur_pgndx);
ret = spiffs_check_delobj_lazy(
fs, pghdr.objid);
if (ret < 0)
{
ferr("spiffs_check_delobj_lazy: %d\n",
ret);
return ret;
}
/* Precaution, delete this page also */
ret = spiffs_page_delete(fs, cur_pgndx);
if (ret < 0)
{
ferr("ERR: spiffs_page_delete(): %d\n",
ret);
return ret;
}
restart = true;
}
fs->work[rpgndx_byte_ix] |=
(1 << (rpgndx_bit_ix + 1));
}
}
}
}
/* Next page */
cur_pgndx++;
}
/* Next block */
cur_block++;
}
/* Check consistency bitmap */
if (!restart)
{
uint32_t byte_ndx;
int16_t objndx_pgndx;
int16_t rpgndx;
uint8_t bit_ndx;
for (byte_ndx = 0;
!restart && byte_ndx < SPIFFS_GEO_PAGE_SIZE(fs);
byte_ndx++)
{
for (bit_ndx = 0; !restart && bit_ndx < 8 / bits; bit_ndx++)
{
uint8_t bitmask;
int16_t cur_pgndx;
bitmask = (fs->work[byte_ndx] >> (bit_ndx * bits)) & 0x7;
cur_pgndx = pgndx_offset + byte_ndx * (8 / bits) + bit_ndx;
/* 000 ok - free, unreferenced, not index */
if (bitmask == 0x1)
{
struct spiffs_page_header_s pghdr;
bool rewrite_ndx_to_this = false;
bool delete_page = false;
/* 001 */
spiffs_checkinfo(
"pgndx=%04x USED, UNREFERENCED, not index\n",
cur_pgndx);
/* Check corresponding object index entry */
ret = spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_LU2 | SPIFFS_OP_C_READ,
0,
SPIFFS_PAGE_TO_PADDR(fs, cur_pgndx),
sizeof(struct spiffs_page_header_s),
(FAR uint8_t *)&pghdr);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read() failed: %d\n",
ret);
return ret;
}
ret = spiffs_check_get_data_pgndx(fs, pghdr.objid,
pghdr.spndx, &rpgndx,
&objndx_pgndx);
if (ret >= 0)
{
if (((rpgndx == (int16_t) - 1 ||
rpgndx > SPIFFS_GEO_PAGE_COUNT(fs)) ||
(SPIFFS_IS_LOOKUP_PAGE(fs, rpgndx))))
{
/* Pointing to a bad page altogether, rewrite
* index to this
*/
rewrite_ndx_to_this = true;
spiffs_checkinfo(
"Corresponding ref is bad: "
"%04x, rewrite to this %04x\n",
rpgndx, cur_pgndx);
}
else
{
struct spiffs_page_header_s rphdr;
/* Pointing to something else, check what */
ret =
spiffs_cache_read(fs,
SPIFFS_OP_T_OBJ_LU2 |
SPIFFS_OP_C_READ,
0,
SPIFFS_PAGE_TO_PADDR(fs, rpgndx),
sizeof(struct spiffs_page_header_s),
(FAR uint8_t *)&rphdr);
if (ret < 0)
{
ferr("ERROR: spiffs_cache_read(): %d\n",
ret);
return ret;
}
if (((pghdr.objid & ~SPIFFS_OBJID_NDXFLAG) ==
rphdr.objid) &&
((rphdr.flags & (SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_DELET |
SPIFFS_PH_FLAG_USED |
SPIFFS_PH_FLAG_FINAL)) ==
(SPIFFS_PH_FLAG_INDEX |
SPIFFS_PH_FLAG_DELET)))
{
/* Pointing to something else valid, just
* delete this page then
*/
spiffs_checkinfo(
"Corresponding ref is good but "
"different: %04x, delete this %04x\n",
rpgndx, cur_pgndx);
delete_page = true;
}
/* Pointing to something weird, update index
* to point to this page instead
*/
else if (rpgndx != cur_pgndx)
{
spiffs_checkinfo
("PA: corresponding ref is weird: "
"%04x %s%s%s%s, rewrite this "
"%04x\n", rpgndx,
(rphdr.flags & SPIFFS_PH_FLAG_INDEX) ?
"" : "INDEX ",
(rphdr.flags & SPIFFS_PH_FLAG_DELET) ?
"" : "DELETED ",
(rphdr.flags & SPIFFS_PH_FLAG_USED) ?
"NOTUSED " : "",
(rphdr.flags & SPIFFS_PH_FLAG_FINAL) ?
"NOTFINAL " : "", cur_pgndx);
rewrite_ndx_to_this = true;
}
else
{
/* Should not happen, destined for fubar */
}
}
}
else if (ret == -ENOENT)
{
spiffs_checkinfo("Corresponding ref not found, "
"delete %04x\n",
cur_pgndx);
delete_page = true;
ret = OK;
}
if (rewrite_ndx_to_this)
{
/* If pointing to invalid page, redirect index to
* this page
*/
spiffs_checkinfo(
"Rewrite index objid=%04x data spndx=%04x"
" to point to this pgndx: %04x\n",
pghdr.objid, pghdr.spndx, cur_pgndx);
ret = spiffs_check_rewrite_index(fs, pghdr.objid,
pghdr.spndx, cur_pgndx, objndx_pgndx);
if (ret == -EFAULT)
{
int ret2;
/* Index bad also, cannot mend this file */
spiffs_checkinfo("PA: FIXUP: index bad %d"
", cannot mend!\n", ret);
ret2 = spiffs_page_delete(fs, cur_pgndx);
if (ret2 < 0)
{
ferr("ERROR: spiffs_page_delete(): %d\n",
ret2);
return ret2;
}
ret2 = spiffs_check_delobj_lazy(fs,
pghdr.objid);
if (ret2 < 0)
{
ferr(
"ERR: spiffs_check_delobj_lazy(): %d\n",
ret2);
return ret2;
}
}
else if (ret < 0)
{
ferr("ERR: spiffs_check_rewrite_index(): %d\n",
ret);
return ret;
}
restart = true;
continue;
}
else if (delete_page)
{
spiffs_checkinfo("Deleting page %04x\n",
cur_pgndx);
ret = spiffs_page_delete(fs, cur_pgndx);
if (ret < 0)
{
ferr("ERROR: spiffs_page_delete(): %d\n", ret);
return ret;
}
}
}
if (bitmask == 0x2)
{
/* 010 */
spiffs_checkinfo(
"pgndx=%04x FREE, REFERENCED, not index\n",
cur_pgndx);
/* No op, this should be taken care of when checking
* valid references
*/
}
/* 011 OK - busy, referenced, not index */
if (bitmask == 0x4)
{
/* 100 */
spiffs_checkinfo(
"pgndx=%04x FREE, unreferenced, INDEX\n", cur_pgndx);
/* This should never happen, major fubar */
}
/* 101 OK - busy, unreferenced, index */
if (bitmask == 0x6)
{
/* 110 */
spiffs_checkinfo(
"pgndx=%04x FREE, REFERENCED, INDEX\n", cur_pgndx);
/* No op, this should be taken care of when checking
* valid references
*/
}
if (bitmask == 0x7)
{
/* 111 */
spiffs_checkinfo(
"pgndx=%04x USED, REFERENCED, INDEX\n", cur_pgndx);
/* No op, this should be taken care of when checking
* valid references
*/
}
}
}
}
spiffs_checkinfo("Processed %04x, restart %d\n",
pgndx_offset, restart);
/* next page range */
if (!restart)
{
pgndx_offset += pages_per_scan;
}
}
return ret;
}
/****************************************************************************
* Name: spiffs_check_pgconsistency
*
* Description:
* Removes orphaned and partially deleted index pages.
* Scans for index pages. When an index page is found, corresponding index
* header is searched for. If no such page exists, the index page cannot
* be reached as no index header exists and must be deleted.
*
* Input Parameters:
* fs - A reference to the SPIFFS volume object instance
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
int spiffs_check_objidconsistency(FAR struct spiffs_s *fs)
{
uint32_t objid_logndx = 0;
int ret = OK;
/* Implementation not:
* 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_OBJID_NDXFLAG bit is used to indicate a reachable/
* unreachable object ID.
*/
memset(fs->work, 0, SPIFFS_GEO_PAGE_SIZE(fs));
ret = spiffs_foreach_objlu(fs, 0, 0, 0, 0,
spiffs_check_objidconsistency_callback, 0,
&objid_logndx, 0, 0);
if (ret == SPIFFS_VIS_END)
{
ret = OK;
}
return ret;
}
/****************************************************************************
* Name: spiffs_dump
*
* Description:
* Dump logical flash content
*
* Input Parameters:
* fs - A reference to the volume structure
*
* Returned Value:
* Zero (OK) is returned on success; A negated errno value is returned on
* any failure.
*
****************************************************************************/
#ifdef CONFIG_SPIFFS_DUMP
int spiffs_dump(FAR struct spiffs_s *fs)
{
FAR int16_t *objlu_buf = (FAR int16_t *)fs->lu_work;
uint32_t pages_per_block;
uint32_t blocks;
uint32_t obj_lupages;
uint32_t data_pgsize;
uint32_t ndata_pages;
int16_t pgndx = 0;
int16_t erase_count;
char buffer[80];
int entries_per_page;
int len = 0;
int ret = OK;
entries_per_page = (SPIFFS_GEO_PAGE_SIZE(fs) / sizeof(int16_t));
while (pgndx < SPIFFS_GEO_PAGE_COUNT(fs))
{
/* Check each object lookup page */
int obj_lookup_page = 0;
int cur_entry = 0;
while (ret >= 0 && obj_lookup_page < (int)SPIFFS_OBJ_LOOKUP_PAGES(fs))
{
int entry_offset = obj_lookup_page * entries_per_page;
ret = spiffs_cache_read(fs, SPIFFS_OP_T_OBJ_LU | SPIFFS_OP_C_READ,
0, pgndx * SPIFFS_GEO_PAGE_SIZE(fs) +
SPIFFS_PAGE_TO_PADDR(fs, obj_lookup_page),
SPIFFS_GEO_PAGE_SIZE(fs), fs->lu_work);
/* Check each entry */
while (ret >= 0 &&
cur_entry - entry_offset < entries_per_page &&
cur_entry < (int)(SPIFFS_GEO_PAGES_PER_BLOCK(fs) -
SPIFFS_OBJ_LOOKUP_PAGES(fs)))
{
int16_t objid = objlu_buf[cur_entry - entry_offset];
if (cur_entry == 0)
{
len += snprintf(&buffer[len], 80 - len, "%04x ", pgndx);
}
else if ((cur_entry & 0x3f) == 0)
{
len += snprintf(&buffer[len], 80 - len, " ");
}
if ((objid == SPIFFS_OBJID_FREE) != 0)
{
len += snprintf(&buffer[len], 80 - len, ".");
}
else if ((objid == SPIFFS_OBJID_DELETED) != 0)
{
len += snprintf(&buffer[len], 80 - len, "x");
}
else if ((objid & SPIFFS_OBJID_NDXFLAG) != 0)
{
len += snprintf(&buffer[len], 80 - len, "I");
}
else
{
len += snprintf(&buffer[len], 80 - len, "D");
}
cur_entry++;
if ((cur_entry & 0x3f) == 0)
{
len += snprintf(&buffer[len], 80 - len, "\n");
spiffs_checkinfo("%s", buffer);
len = 0;
}
}
obj_lookup_page++;
}
ret = spiffs_cache_read(fs, SPIFFS_OP_C_READ | SPIFFS_OP_T_OBJ_LU2, 0,
SPIFFS_ERASE_COUNT_PADDR(fs, pgndx),
sizeof(int16_t), (FAR uint8_t *)&erase_count);
if (ret < 0)
{
ferr("ERROR: spiffs_mtd_read() failed: %d\n", ret);
return ret;
}
if (erase_count != (int16_t)-1)
{
len += snprintf(&buffer[len], 80 - len,
" era_cnt=%d\n", erase_count);
}
else
{
len += snprintf(&buffer[len], 80 - len, " era_cnt (N/A)\n");
}
spiffs_checkinfo("%s", buffer);
len = 0;
pgndx++;
}
spiffs_checkinfo("era_cnt_max: %d\n", fs->max_erase_count);
spiffs_checkinfo("blocks: %d\n", SPIFFS_GEO_PAGE_COUNT(fs));
spiffs_checkinfo("free_blocks: %d\n", fs->free_blocks);
spiffs_checkinfo("page_alloc: %d\n", fs->alloc_pages);
spiffs_checkinfo("page_delet: %d\n", fs->deleted_pages);
/* The following duplicates some logic from spiffs_statfs().
* -2 for spare blocks, +1 for emergency page.
*/
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);
ndata_pages = (blocks - 2) * (pages_per_block - obj_lupages) + 1;
spiffs_checkinfo("used: %ld of %ld\n",
(long)(fs->alloc_pages * data_pgsize),
(long)(ndata_pages * data_pgsize));
return OK;
}
#endif