/* calculate file length, etc */
static URET _BuildTreeStepThree(uffs_Device *dev)
{
int i;
u16 x;
TreeNode *work;
TreeNode *node;
struct uffs_TreeSt *tree;
uffs_Pool *pool;
u16 blockSave;
TreeNode *cache = NULL;
u16 cacheSerial = INVALID_UFFS_SERIAL;
tree = &(dev->tree);
pool = TPOOL(dev);
uffs_Perror(UFFS_MSG_NOISY, "build tree step three");
for (i = 0; i < DATA_NODE_ENTRY_LEN; i++) {
x = tree->data_entry[i];
while (x != EMPTY_NODE) {
work = FROM_IDX(x, pool);
if (work->u.data.parent == cacheSerial) {
node = cache;
}
else {
node = uffs_TreeFindFileNode(dev, work->u.data.parent);
cache = node;
cacheSerial = work->u.data.parent;
}
if (node == NULL) {
x = work->hash_next;
//this data block does not belong to any file ?
//should be erased.
uffs_Perror(UFFS_MSG_NORMAL,
"find a orphan data block:%d, "
"parent:%d, serial:%d, will be erased!",
work->u.data.block,
work->u.data.parent, work->u.data.serial);
uffs_BreakFromEntry(dev, UFFS_TYPE_DATA, work);
blockSave = work->u.data.block;
work->u.list.block = blockSave;
uffs_FlashEraseBlock(dev, blockSave);
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, work);
else
uffs_TreeInsertToErasedListTail(dev, work);
}
else {
node->u.file.len += work->u.data.len;
x = work->hash_next;
}
}
}
return U_SUCC;
}
/**
* \brief delete uffs object
*
* \param[in] name full name of object
* \param[out] err return error code
*
* \return U_SUCC if object is deleted successfully.
* return U_FAIL if error happen, error code is set to *err.
*/
URET uffs_DeleteObject(const char * name, int *err)
{
uffs_Object *obj, *work;
TreeNode *node, *d_node;
uffs_Device *dev = NULL;
u16 block;
u16 serial, parent, last_serial;
UBOOL bad = U_FALSE;
URET ret = U_FAIL;
obj = uffs_GetObject();
if (obj == NULL) {
if (err)
*err = UEMFILE;
goto ext_unlock;
}
if (uffs_OpenObject(obj, name, UO_RDWR|UO_DIR) == U_FAIL) {
if (uffs_OpenObject(obj, name, UO_RDWR) == U_FAIL) {
if (err)
*err = UENOENT;
goto ext_unlock;
}
}
dev = obj->dev;
// working throught object pool see if the object is opened ...
uffs_ObjectDevLock(obj);
work = NULL;
while ((work = (uffs_Object *)uffs_PoolFindNextAllocated(&_object_pool, work)) != NULL) {
if (work != obj &&
work->dev &&
work->dev == obj->dev &&
work->node &&
work->node == obj->node) {
// this object is opened, can't delete it.
if (err)
*err = UEACCES;
goto ext_lock;
}
}
if (obj->type == UFFS_TYPE_DIR) {
// if the dir is not empty, can't delete it.
node = uffs_TreeFindDirNodeWithParent(dev, obj->serial);
if (node != NULL) {
if (err)
*err = UEACCES;
goto ext_lock; //have sub dirs ?
}
node = uffs_TreeFindFileNodeWithParent(dev, obj->serial);
if (node != NULL) {
if (err)
*err = UEACCES;
goto ext_lock; //have sub files ?
}
}
// before erase the block, we need to take care of the buffer ...
uffs_BufFlushAll(dev);
if (_CheckObjBufRef(obj) > 0) {
if (err)
*err = UEACCES;
goto ext_lock;
}
node = obj->node;
// ok, now we are safe to erase DIR/FILE block :-)
block = GET_BLOCK_FROM_NODE(obj);
parent = obj->serial;
last_serial = (obj->type == UFFS_TYPE_FILE && node->u.file.len > 0 ? GetFdnByOfs(obj, node->u.file.len - 1) : 0);
uffs_BreakFromEntry(dev, obj->type, node);
uffs_FlashEraseBlock(dev, block);
node->u.list.block = block;
node->u.list.u.serial = obj->serial;
// From now on, the object is gone physically,
// but we need to 'suspend' this node so that no one will re-use
// the serial number during deleting the reset part of object.
if (HAVE_BADBLOCK(dev)) {
uffs_BadBlockProcessSuspend(dev, node);
bad = U_TRUE; // will be put into 'bad' list later
}
else {
uffs_TreeSuspendAdd(dev, node);
bad = U_FALSE; // will be put into erased list later
}
// now erase DATA blocks
if (obj->type == UFFS_TYPE_FILE && last_serial > 0) {
for (serial = 1; serial <= last_serial; serial++) {
uffs_ObjectDevUnLock(obj);
; // yield CPU to improve responsive when deleting large file.
uffs_ObjectDevLock(obj);
d_node = uffs_TreeFindDataNode(dev, parent, serial);
if (uffs_Assert(d_node != NULL, "Can't find DATA node parent = %d, serial = %d\n", parent, serial)) {
uffs_BreakFromEntry(dev, UFFS_TYPE_DATA, d_node);
block = d_node->u.data.block;
uffs_FlashEraseBlock(dev, block);
d_node->u.list.block = block;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, d_node);
else
uffs_TreeInsertToErasedListTail(dev, d_node);
}
}
}
// now process the suspend node
uffs_TreeRemoveSuspendNode(dev, node);
if (bad)
uffs_TreeInsertToBadBlockList(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
ret = U_SUCC;
ext_lock:
uffs_ObjectDevUnLock(obj);
ext_unlock:
do_ReleaseObjectResource(obj);
uffs_PutObject(obj);
return ret;
}
/** truncate obj without lock device */
static URET do_TruncateObject(uffs_Object *obj, u32 remain, RunOptionE run_opt)
{
uffs_Device *dev = obj->dev;
TreeNode *fnode = obj->node;
u16 fdn;
u32 flen;
u32 block_start;
TreeNode *node;
uffs_BlockInfo *bc;
uffs_Buf *buf;
u16 page;
int pos;
pos = obj->pos; // save current file position
if (obj->dev == NULL || obj->open_succ == U_FALSE || fnode == NULL) {
obj->err = UEBADF;
goto ext;
}
/* can't truncate a dir */
/* TODO: delete files under dir ? */
if (obj->type == UFFS_TYPE_DIR) {
obj->err = UEEXIST;
goto ext;
}
if (remain >= fnode->u.file.len) {
goto ext; //!< nothing to do ...
}
flen = fnode->u.file.len;
if (flen < remain) {
// file is shorter than 'reamin', fill the gap with '\0'
if (run_opt == eREAL_RUN) {
obj->pos = flen; // move file pointer to the end
if (do_WriteObject(obj, NULL, remain - flen) > 0) { // fill '\0' ...
uffs_Perror(UFFS_MSG_SERIOUS, "Write object not finished. expect %d but only %d wrote.",
remain - flen, fnode->u.file.len - flen);
obj->err = UEIOERR; // likely be an I/O error.
}
flen = obj->node->u.file.len;
}
}
else {
while (flen > remain) {
fdn = GetFdnByOfs(obj, flen - 1);
//uffs_BufFlushGroup(dev, obj->serial, fdn); //!< flush the buffer
block_start = GetStartOfDataBlock(obj, fdn);
if (remain <= block_start && fdn > 0) {
node = uffs_TreeFindDataNode(dev, obj->serial, fdn);
if (node == NULL) {
uffs_Perror(UFFS_MSG_SERIOUS,
"can't find data node when trancate obj.");
obj->err = UEIOERR;
goto ext;
}
bc = uffs_BlockInfoGet(dev, node->u.data.block);
if (bc == NULL) {
uffs_Perror(UFFS_MSG_SERIOUS,
"can't get block info when trancate obj.");
obj->err = UEIOERR;
goto ext;
}
for (page = 0; page < dev->attr->pages_per_block; page++) {
buf = uffs_BufFind(dev, fnode->u.file.serial, fdn, page);
if (buf) {
//!< ok, the buffer was loaded before ...
if (uffs_BufIsFree(buf) == U_FALSE) {
uffs_BlockInfoPut(dev, bc);
goto ext; //!< and someone is still holding the buffer,
// can't truncate it !!!
}
else if (run_opt == eREAL_RUN)
uffs_BufMarkEmpty(dev, buf); //!< discard the buffer
}
}
if (run_opt == eREAL_RUN) {
uffs_BreakFromEntry(dev, UFFS_TYPE_DATA, node);
uffs_FlashEraseBlock(dev, bc->block);
node->u.list.block = bc->block;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
fnode->u.file.len = block_start;
}
flen = block_start;
uffs_BlockInfoPut(dev, bc);
}
else {
if (do_TruncateInternalWithBlockRecover(obj, fdn,
remain, run_opt) == U_SUCC) {
if (run_opt == eREAL_RUN)
fnode->u.file.len = remain;
flen = remain;
}
}
}
}
if (HAVE_BADBLOCK(dev))
uffs_BadBlockRecover(dev);
ext:
obj->pos = pos; // keep file pointer offset not changed.
uffs_Assert(fnode == obj->node, "obj->node change!\n");
return (obj->err == UENOERR ? U_SUCC : U_FAIL);
}
/**
* \brief delete uffs object
*
* \param[in] name full name of object
* \param[out] err return error code
*
* \return U_SUCC if object is deleted successfully.
* return U_FAIL if error happen, error code is set to *err.
*/
URET uffs_DeleteObject(const char * name, int *err)
{
uffs_Object *obj;
TreeNode *node;
uffs_Device *dev;
u16 block;
uffs_Buf *buf;
URET ret = U_FAIL;
obj = uffs_GetObject();
if (obj == NULL) {
if (err)
*err = UEMFILE;
goto err1;
}
if (uffs_OpenObject(obj, name, UO_RDWR|UO_DIR) == U_FAIL) {
if (uffs_OpenObject(obj, name, UO_RDWR) == U_FAIL) {
if (err)
*err = UENOENT;
goto err1;
}
}
uffs_TruncateObject(obj, 0);
uffs_ObjectDevLock(obj);
dev = obj->dev;
if (obj->type == UFFS_TYPE_DIR)
{
// if the dir is not empty, can't delete it.
node = uffs_TreeFindDirNodeWithParent(dev, obj->serial);
if (node != NULL)
{
if (err)
*err = UEACCES;
goto err; //have sub dirs ?
}
node = uffs_TreeFindFileNodeWithParent(dev, obj->serial);
if (node != NULL)
{
if (err)
*err = UEACCES;
goto err; //have sub files ?
}
}
block = GET_BLOCK_FROM_NODE(obj);
node = obj->node;
// before erase the block, we need to take care of the buffer ...
uffs_BufFlushAll(dev);
if (HAVE_BADBLOCK(dev))
uffs_BadBlockRecover(dev);
buf = uffs_BufFind(dev, obj->parent, obj->serial, 0);
if (buf) {
//need to expire this buffer ...
if (buf->ref_count != 0) {
//there is other obj for this file still in use ?
uffs_Perror(UFFS_ERR_NORMAL, "Try to delete object but still have buf referenced.");
if (err)
*err = UEACCES;
goto err;
}
buf->mark = UFFS_BUF_EMPTY; //!< make this buffer expired.
}
//TODO: need to take care of other obj->node ?
uffs_BreakFromEntry(dev, obj->type, node);
uffs_FlashEraseBlock(dev, block);
node->u.list.block = block;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
ret = U_SUCC;
err:
uffs_ObjectDevUnLock(obj);
err1:
do_ReleaseObjectResource(obj);
uffs_PutObject(obj);
return ret;
}
/** truncate obj without lock device */
static URET do_TruncateObject(uffs_Object *obj, u32 remain, UBOOL dry_run)
{
uffs_Device *dev = obj->dev;
TreeNode *fnode = obj->node;
u16 fdn;
u32 flen;
u32 block_start;
TreeNode *node;
uffs_BlockInfo *bc;
uffs_Buf *buf;
u16 page;
if (obj->dev == NULL || obj->open_succ == U_FALSE || fnode == NULL) {
obj->err = UEBADF;
goto ext;
}
/* can't truncate a dir */
/* TODO: delete files under dir ? */
if (obj->type == UFFS_TYPE_DIR) {
obj->err = UEEXIST;
goto ext;
}
if (remain >= fnode->u.file.len) {
goto ext; //!< nothing to do ...
}
flen = fnode->u.file.len;
while (flen > remain) {
fdn = GetFdnByOfs(obj, flen - 1);
//uffs_BufFlushGroup(dev, obj->serial, fdn); //!< flush the buffer
block_start = GetStartOfDataBlock(obj, fdn);
if (remain <= block_start && fdn > 0) {
node = uffs_TreeFindDataNode(dev, obj->serial, fdn);
if (node == NULL) {
uffs_Perror(UFFS_ERR_SERIOUS, "can't find data node when trancate obj.");
obj->err = UEIOERR;
goto ext;
}
bc = uffs_BlockInfoGet(dev, node->u.data.block);
if (bc == NULL) {
uffs_Perror(UFFS_ERR_SERIOUS, "can't get block info when trancate obj.");
obj->err = UEIOERR;
goto ext;
}
for (page = 0; page < dev->attr->pages_per_block; page++) {
buf = uffs_BufFind(dev, fnode->u.file.serial, fdn, page);
if (buf) { //!< ok, the buffer was loaded before ...
if (uffs_BufIsFree(buf) == U_FALSE) {
uffs_BlockInfoPut(dev, bc);
goto ext; //!< and someone is still holding the buffer, can't truncate it !!!
}
else if (dry_run == U_FALSE)
uffs_BufMarkEmpty(dev, buf); //!< discard the buffer
}
}
if (dry_run == U_FALSE) {
uffs_BlockInfoExpire(dev, bc, UFFS_ALL_PAGES);
uffs_BreakFromEntry(dev, UFFS_TYPE_DATA, node);
uffs_FlashEraseBlock(dev, bc->block);
node->u.list.block = bc->block;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
uffs_BlockInfoPut(dev, bc);
fnode->u.file.len = block_start;
}
else {
uffs_BlockInfoPut(dev, bc);
}
flen = block_start;
}
else {
if (do_TruncateInternalWithBlockRecover(obj, fdn, remain, dry_run) == U_SUCC) {
if (dry_run == U_FALSE)
fnode->u.file.len = remain;
flen = remain;
}
}
}
if (HAVE_BADBLOCK(dev))
uffs_BadBlockRecover(dev);
ext:
return (obj->err == UENOERR ? U_SUCC : U_FAIL);
}
/* usage: t_pgrw
*
* This test case test page read/write
*/
static int cmd_TestPageReadWrite(int argc, char *argv[])
{
TreeNode *node = NULL;
uffs_Device *dev;
uffs_Tags local_tag;
uffs_Tags *tag = &local_tag;
int ret;
u16 block;
u16 page;
uffs_Buf *buf = NULL;
u32 i;
int rc = -1;
dev = uffs_GetDeviceFromMountPoint("/");
if (!dev)
goto ext;
buf = uffs_BufClone(dev, NULL);
if (!buf)
goto ext;
node = uffs_TreeGetErasedNode(dev);
if (!node) {
MSGLN("no free block ?");
goto ext;
}
for (i = 0; i < dev->com.pg_data_size; i++) {
buf->data[i] = i & 0xFF;
}
block = node->u.list.block;
page = 1;
TAG_DIRTY_BIT(tag) = TAG_DIRTY;
TAG_VALID_BIT(tag) = TAG_VALID;
TAG_DATA_LEN(tag) = dev->com.pg_data_size;
TAG_TYPE(tag) = UFFS_TYPE_DATA;
TAG_PAGE_ID(tag) = 3;
TAG_PARENT(tag) = 100;
TAG_SERIAL(tag) = 10;
TAG_BLOCK_TS(tag) = 1;
SEAL_TAG(tag);
ret = uffs_FlashWritePageCombine(dev, block, page, buf, tag);
if (UFFS_FLASH_HAVE_ERR(ret)) {
MSGLN("Write page error: %d", ret);
goto ext;
}
ret = uffs_FlashReadPage(dev, block, page, buf, U_FALSE);
if (UFFS_FLASH_HAVE_ERR(ret)) {
MSGLN("Read page error: %d", ret);
goto ext;
}
for (i = 0; i < dev->com.pg_data_size; i++) {
if (buf->data[i] != (i & 0xFF)) {
MSGLN("Data verify fail at: %d", i);
goto ext;
}
}
ret = uffs_FlashReadPageTag(dev, block, page, tag);
if (UFFS_FLASH_HAVE_ERR(ret)) {
MSGLN("Read tag (page spare) error: %d", ret);
goto ext;
}
// verify tag:
if (!TAG_IS_SEALED(tag)) {
MSGLN("not sealed ? Tag verify fail!");
goto ext;
}
if (!TAG_IS_DIRTY(tag)) {
MSGLN("not dirty ? Tag verify fail!");
goto ext;
}
if (!TAG_IS_VALID(tag)) {
MSGLN("not valid ? Tag verify fail!");
goto ext;
}
if (TAG_DATA_LEN(tag) != dev->com.pg_data_size ||
TAG_TYPE(tag) != UFFS_TYPE_DATA ||
TAG_PAGE_ID(tag) != 3 ||
TAG_PARENT(tag) != 100 ||
TAG_SERIAL(tag) != 10 ||
TAG_BLOCK_TS(tag) != 1) {
MSGLN("Tag verify fail!");
goto ext;
}
MSGLN("Page read/write test succ.");
rc = 0;
ext:
if (node) {
uffs_TreeEraseNode(dev, node);
uffs_TreeInsertToErasedListTail(dev, node);
}
if (dev)
uffs_PutDevice(dev);
if (buf)
uffs_BufFreeClone(dev, buf);
return rc;
}
static URET _BuildValidTreeNode(uffs_Device *dev,
TreeNode *node, //!< empty node
uffs_BlockInfo *bc,
struct BlockTypeStatSt *st)
{
uffs_Tags *tag;
TreeNode *node_alt;
u16 block, parent, serial, block_alt, block_save;
uffs_BlockInfo *bc_alt;
u8 type;
int page;
UBOOL needToInsertToTree = U_FALSE;
uffs_Buf *buf = NULL;
uffs_FileInfo *info;
u16 data_sum = 0;
// check the first page on the block ...
uffs_BlockInfoLoad(dev, bc, 0);
tag = GET_TAG(bc, 0); //get first page's tag
if (!TAG_IS_DIRTY(tag)) {
// should never go here ... unless mark dirty page failed ?
uffs_Perror(UFFS_MSG_NORMAL,
"First page is clean in a non-erased block ?");
return U_FAIL;
}
if (!TAG_IS_VALID(tag)) {
//first page is invalid ? should be erased now!
uffs_Perror(UFFS_MSG_NORMAL,
"first page in block %d is invalid, will be erased now!",
bc->block);
goto process_invalid_block;
}
block = bc->block;
parent = TAG_PARENT(tag);
serial = TAG_SERIAL(tag);
type = TAG_TYPE(tag);
// check if there is an 'alternative block'
// (node which has the same serial number) in tree ?
node_alt = uffs_FindFromTree(dev, type, parent, serial);
if (node_alt != NULL) {
//find a alternate node ! need to check the timestamp !
block_alt = _GetBlockFromNode(type, node_alt);
uffs_Perror(UFFS_MSG_NORMAL,
"Process unclean block (%d vs %d)", block, block_alt);
if (block_alt == INVALID_UFFS_SERIAL) {
uffs_Perror(UFFS_MSG_SERIOUS, "invalid block ?");
return U_FAIL;
}
bc_alt = uffs_BlockInfoGet(dev, block_alt);
if (bc_alt == NULL) {
uffs_Perror(UFFS_MSG_SERIOUS, "can't get block info ");
return U_FAIL;
}
uffs_BlockInfoLoad(dev, bc_alt, 0);
if (uffs_IsSrcNewerThanObj (
TAG_BLOCK_TS(tag),
TAG_BLOCK_TS(GET_TAG(bc_alt, 0))) == U_TRUE) {
//the node is newer than node_alt, so keep node_alt, and erase node
uffs_FlashEraseBlock(dev, block);
node->u.list.block = block;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
uffs_BlockInfoPut(dev, bc_alt); //put back bc_alt before we return.
return U_SUCC;
}
else {
//the node is older than node_alt, so keep node, and erase node_alt
//we use node as erased node to insert to erased list
block_save = _GetBlockFromNode(type, node_alt);
uffs_FlashEraseBlock(dev, block_save);
node->u.list.block = block_save;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
//put back bc_alt because we don't need it anymore.
uffs_BlockInfoPut(dev, bc_alt);
//use node_alt to store new informations in following
node = node_alt;
needToInsertToTree = U_FALSE;
}
}
else {
needToInsertToTree = U_TRUE;
}
if (type == UFFS_TYPE_DIR || type == UFFS_TYPE_FILE) {
buf = uffs_BufClone(dev, NULL);
if (buf == NULL)
return U_FAIL;
uffs_BlockInfoLoad(dev, bc, UFFS_ALL_PAGES);
page = uffs_FindPageInBlockWithPageId(dev, bc, 0);
if (page == UFFS_INVALID_PAGE) {
uffs_BufFreeClone(dev, buf);
uffs_Perror(UFFS_MSG_SERIOUS,
"Can't find any valid page for page_id=0 ? invalid block !"
"this might be caused by the tag layout change.\n");
goto process_invalid_block;
}
page = uffs_FindBestPageInBlock(dev, bc, page);
uffs_FlashReadPage(dev, block, page, buf, U_FALSE);
info = (uffs_FileInfo *) (buf->data);
data_sum = uffs_MakeSum16(info->name, info->name_len);
uffs_BufFreeClone(dev, buf);
}
switch (type) {
case UFFS_TYPE_DIR:
node->u.dir.block = bc->block;
node->u.dir.checksum = data_sum;
node->u.dir.parent = TAG_PARENT(tag);
node->u.dir.serial = TAG_SERIAL(tag);
st->dir++;
break;
case UFFS_TYPE_FILE:
node->u.file.block = bc->block;
node->u.file.checksum = data_sum;
node->u.file.parent = TAG_PARENT(tag);
node->u.file.serial = TAG_SERIAL(tag);
node->u.file.len = uffs_GetBlockFileDataLength(dev, bc, UFFS_TYPE_FILE);
st->file++;
break;
case UFFS_TYPE_DATA:
node->u.data.block = bc->block;
node->u.data.parent = TAG_PARENT(tag);
node->u.data.serial = TAG_SERIAL(tag);
node->u.data.len = uffs_GetBlockFileDataLength(dev, bc, UFFS_TYPE_DATA);
st->data++;
break;
}
if (needToInsertToTree == U_TRUE) {
uffs_InsertNodeToTree(dev, type, node);
}
return U_SUCC;
process_invalid_block:
/* erase the invalid block */
uffs_FlashEraseBlock(dev, bc->block);
node->u.list.block = bc->block;
if (HAVE_BADBLOCK(dev))
uffs_BadBlockProcess(dev, node);
else
uffs_TreeInsertToErasedListTail(dev, node);
return U_SUCC;
}
/**
* \brief recover bad block
* \param[in] dev uffs device
*/
void uffs_BadBlockRecover(uffs_Device *dev)
{
TreeNode *good, *bad;
uffs_Buf *buf;
u16 i;
u16 page;
uffs_BlockInfo *bc = NULL;
uffs_Tags *tag;
uffs_Tags newTag;
UBOOL succRecov;
UBOOL goodBlockIsDirty = U_FALSE;
int ret;
int region;
u8 type;
if (dev->bad.block == UFFS_INVALID_BLOCK)
return;
// pick up an erased good block
good = uffs_TreeGetErasedNode(dev);
if (good == NULL) {
uffs_Perror(UFFS_ERR_SERIOUS, "no free block to replace bad block!");
return;
}
//recover block
bc = uffs_BlockInfoGet(dev, dev->bad.block);
if (bc == NULL) {
uffs_Perror(UFFS_ERR_SERIOUS, "can't get bad block info");
return;
}
succRecov = U_TRUE;
for (i = 0; i < dev->attr->pages_per_block; i++) {
page = uffs_FindPageInBlockWithPageId(dev, bc, i);
if(page == UFFS_INVALID_PAGE) {
break; //end of last valid page, normal break
}
page = uffs_FindBestPageInBlock(dev, bc, page);
tag = GET_TAG(bc, page);
buf = uffs_BufClone(dev, NULL);
if (buf == NULL) {
uffs_Perror(UFFS_ERR_SERIOUS, "Can't clone a new buf!");
succRecov = U_FALSE;
break;
}
//NOTE: since this is a bad block, we can't guarantee the data is ECC ok, so just load data even ECC is not OK.
ret = uffs_LoadPhyDataToBufEccUnCare(dev, buf, bc->block, page);
if (ret == U_FAIL) {
uffs_Perror(UFFS_ERR_SERIOUS, "I/O error ?");
uffs_BufFreeClone(dev, buf);
succRecov = U_FALSE;
break;
}
buf->data_len = TAG_DATA_LEN(tag);
if (buf->data_len > dev->com.pg_data_size) {
uffs_Perror(UFFS_ERR_NOISY, "data length over flow!!!");
buf->data_len = dev->com.pg_data_size;
}
buf->parent = TAG_PARENT(tag);
buf->serial = TAG_SERIAL(tag);
buf->type = TAG_TYPE(tag);
buf->page_id = TAG_PAGE_ID(tag);
newTag = *tag;
TAG_BLOCK_TS(&newTag) = uffs_GetNextBlockTimeStamp(TAG_BLOCK_TS(tag));
ret = uffs_FlashWritePageCombine(dev, good->u.list.block, i, buf, &newTag);
goodBlockIsDirty = U_TRUE;
uffs_BufFreeClone(dev, buf);
if (ret == UFFS_FLASH_IO_ERR) {
uffs_Perror(UFFS_ERR_NORMAL, "I/O error ?");
succRecov = U_FALSE;
break;
}
}
if (succRecov == U_TRUE) {
//successful recover bad block, so need to mark bad block, and replace with good one
region = SEARCH_REGION_DIR|SEARCH_REGION_FILE|SEARCH_REGION_DATA;
bad = uffs_TreeFindNodeByBlock(dev, dev->bad.block, ®ion);
if (bad != NULL) {
switch (region) {
case SEARCH_REGION_DIR:
bad->u.dir.block = good->u.list.block;
type = UFFS_TYPE_DIR;
break;
case SEARCH_REGION_FILE:
bad->u.file.block = good->u.list.block;
type = UFFS_TYPE_FILE;
break;
case SEARCH_REGION_DATA:
bad->u.data.block = good->u.list.block;
type = UFFS_TYPE_DATA;
}
//from now, the 'bad' is actually good block :)))
uffs_Perror(UFFS_ERR_NOISY, "new bad block %d found, and replaced by %d!", dev->bad.block, good->u.list.block);
uffs_BlockInfoExpire(dev, bc, UFFS_ALL_PAGES);
//we reuse the 'good' node as bad block node, and process the bad block.
good->u.list.block = dev->bad.block;
uffs_BadBlockProcess(dev, good);
}
else {
uffs_Perror(UFFS_ERR_SERIOUS, "can't find the reported bad block(%d) in the tree???", dev->bad.block);
if (goodBlockIsDirty == U_TRUE)
dev->ops->EraseBlock(dev, good->u.list.block);
uffs_TreeInsertToErasedListTail(dev, good);
}
}
else {
if (goodBlockIsDirty == U_TRUE)
dev->ops->EraseBlock(dev, good->u.list.block);
uffs_TreeInsertToErasedListTail(dev, good); //put back to erased list
}
uffs_BlockInfoPut(dev, bc);
}