static URET do_FlushObject(uffs_Object *obj)
{
uffs_Device *dev;
URET ret = U_SUCC;
dev = obj->dev;
if (obj->node) {
if (obj->type == UFFS_TYPE_DIR)
ret = uffs_BufFlushGroup(dev, obj->node->u.dir.parent, obj->node->u.dir.serial);
else {
ret = (
uffs_BufFlushGroupMatchParent(dev, obj->node->u.file.serial) == U_SUCC &&
uffs_BufFlushGroup(dev, obj->node->u.file.parent, obj->node->u.file.serial) == U_SUCC
) ? U_SUCC : U_FAIL;
}
}
return ret;
}
static URET do_FlushObject(uffs_Object *obj)
{
uffs_Device *dev;
URET ret = U_SUCC;
TreeNode *node = NULL;
dev = obj->dev;
if (obj->node) {
node = obj->node;
if (obj->type == UFFS_TYPE_DIR)
ret = uffs_BufFlushGroup(dev, obj->node->u.dir.parent,
obj->node->u.dir.serial);
else {
ret = (
uffs_BufFlushGroupMatchParent(dev, obj->node->u.file.serial) == U_SUCC &&
uffs_BufFlushGroup(dev, obj->node->u.file.parent, obj->node->u.file.serial) == U_SUCC
) ? U_SUCC : U_FAIL;
}
uffs_Assert(node == obj->node, "obj->node change!\n");
}
return ret;
}
/**
* write data to obj, return remain data (0 if all data been written).
*/
static int do_WriteObject(uffs_Object *obj, const void *data, int len)
{
uffs_Device *dev = obj->dev;
TreeNode *fnode = obj->node;
int remain = len;
u16 fdn;
u32 write_start;
TreeNode *dnode;
u32 size;
while (remain > 0) {
write_start = obj->pos + len - remain;
if (write_start > fnode->u.file.len) {
uffs_Perror(UFFS_MSG_SERIOUS, "write point out of file ?");
break;
}
fdn = GetFdnByOfs(obj, write_start);
if (write_start == fnode->u.file.len && fdn > 0 &&
write_start == GetStartOfDataBlock(obj, fdn)) {
if (dev->tree.erased_count < dev->cfg.reserved_free_blocks) {
uffs_Perror(UFFS_MSG_NOISY, "insufficient block in write obj, new block");
break;
}
size = do_WriteNewBlock(obj, data ? (u8 *)data + len - remain : NULL,
remain, fnode->u.file.serial, fdn);
//
// Flush the new block buffers immediately, so that the new data node will be
// created and put in the tree.
//
// But before do that, we need to make sure the previous
// data block (if exist) been flushed first.
//
if (fdn > 1) {
uffs_BufFlushGroup(dev, fnode->u.file.serial, fdn - 1);
}
else {
uffs_BufFlushGroup(dev, fnode->u.file.parent, fnode->u.file.serial);
}
// Now flush the new block.
uffs_BufFlushGroup(dev, fnode->u.file.serial, fdn);
if (size == 0)
break;
remain -= size;
}
else {
if(fdn == 0)
dnode = obj->node;
else
dnode = uffs_TreeFindDataNode(dev, fnode->u.file.serial, fdn);
if(dnode == NULL) {
uffs_Perror(UFFS_MSG_SERIOUS, "can't find data node in tree ?");
obj->err = UEUNKNOWN_ERR;
break;
}
size = do_WriteInternalBlock(obj, dnode, fdn,
data ? (u8 *)data + len - remain : NULL, remain,
write_start - GetStartOfDataBlock(obj, fdn));
#ifdef CONFIG_FLUSH_BUF_AFTER_WRITE
if (fdn == 0)
uffs_BufFlushGroup(dev, fnode->u.file.parent, fnode->u.file.serial);
else
uffs_BufFlushGroup(dev, fnode->u.file.serial, fdn);
#endif
if (size == 0)
break;
remain -= size;
}
}
uffs_Assert(fnode == obj->node, "obj->node change!\n");
return remain;
}
/**
* Create an object under the given dir.
*
* \param[in|out] obj to be created, obj is returned from uffs_GetObject()
* \param[in] dev uffs device
* \param[in] dir object parent dir serial NO.
* \param[in] name point to the object name
* \param[in] name_len object name length
* \param[in] oflag open flag. UO_DIR should be passed for an dir object.
*
* \return U_SUCC or U_FAIL (error code in obj->err).
*/
URET uffs_CreateObjectEx(uffs_Object *obj, uffs_Device *dev,
int dir, const char *name, int name_len, int oflag)
{
uffs_Buf *buf = NULL;
uffs_FileInfo fi;
TreeNode *node;
obj->dev = dev;
obj->parent = dir;
obj->type = (oflag & UO_DIR ? UFFS_TYPE_DIR : UFFS_TYPE_FILE);
obj->name = name;
obj->name_len = name_len;
if (obj->type == UFFS_TYPE_DIR) {
if (name[obj->name_len - 1] == '/') // get rid of ending '/' for dir
obj->name_len--;
}
else {
if (name[obj->name_len - 1] == '/') { // file name can't end with '/'
obj->err = UENOENT;
goto ext;
}
}
if (obj->name_len == 0) { // empty name ?
obj->err = UENOENT;
goto ext;
}
obj->sum = uffs_MakeSum16(obj->name, obj->name_len);
uffs_ObjectDevLock(obj);
if (obj->type == UFFS_TYPE_DIR) {
//find out whether have file with the same name
node = uffs_TreeFindFileNodeByName(obj->dev, obj->name,
obj->name_len, obj->sum,
obj->parent);
if (node != NULL) {
obj->err = UEEXIST; // we can't create a dir has the
// same name with exist file.
goto ext_1;
}
obj->node = uffs_TreeFindDirNodeByName(obj->dev, obj->name,
obj->name_len, obj->sum,
obj->parent);
if (obj->node != NULL) {
obj->err = UEEXIST; // we can't create a dir already exist.
goto ext_1;
}
}
else {
//find out whether have dir with the same name
node = uffs_TreeFindDirNodeByName(obj->dev, obj->name,
obj->name_len, obj->sum,
obj->parent);
if (node != NULL) {
obj->err = UEEXIST;
goto ext_1;
}
obj->node = uffs_TreeFindFileNodeByName(obj->dev, obj->name,
obj->name_len, obj->sum,
obj->parent);
if (obj->node) {
/* file already exist, truncate it to zero length */
obj->serial = GET_OBJ_NODE_SERIAL(obj);
obj->open_succ = U_TRUE; // set open_succ to U_TRUE before
// call do_TruncateObject()
if (do_TruncateObject(obj, 0, eDRY_RUN) == U_SUCC)
do_TruncateObject(obj, 0, eREAL_RUN);
goto ext_1;
}
}
/* dir|file does not exist, create a new one */
obj->serial = uffs_FindFreeFsnSerial(obj->dev);
if (obj->serial == INVALID_UFFS_SERIAL) {
uffs_Perror(UFFS_MSG_SERIOUS, "No free serial num!");
obj->err = UENOMEM;
goto ext_1;
}
if (obj->dev->tree.erased_count < obj->dev->cfg.reserved_free_blocks) {
uffs_Perror(UFFS_MSG_NOISY,
"insufficient block in create obj");
obj->err = UENOMEM;
goto ext_1;
}
buf = uffs_BufNew(obj->dev, obj->type, obj->parent, obj->serial, 0);
if (buf == NULL) {
uffs_Perror(UFFS_MSG_SERIOUS,
"Can't create new buffer when create obj!");
goto ext_1;
}
memset(&fi, 0, sizeof(uffs_FileInfo));
fi.name_len = obj->name_len < sizeof(fi.name) ? obj->name_len : sizeof(fi.name) - 1;
memcpy(fi.name, obj->name, fi.name_len);
fi.name[fi.name_len] = '\0';
fi.access = 0;
fi.attr |= FILE_ATTR_WRITE;
if (obj->type == UFFS_TYPE_DIR)
fi.attr |= FILE_ATTR_DIR;
fi.create_time = fi.last_modify = uffs_GetCurDateTime();
uffs_BufWrite(obj->dev, buf, &fi, 0, sizeof(uffs_FileInfo));
uffs_BufPut(obj->dev, buf);
// flush buffer immediately,
// so that the new node will be inserted into the tree
uffs_BufFlushGroup(obj->dev, obj->parent, obj->serial);
// update obj->node: after buf flushed,
// the NEW node can be found in the tree
if (obj->type == UFFS_TYPE_DIR)
obj->node = uffs_TreeFindDirNode(obj->dev, obj->serial);
else
obj->node = uffs_TreeFindFileNode(obj->dev, obj->serial);
if (obj->node == NULL) {
uffs_Perror(UFFS_MSG_NOISY, "Can't find the node in the tree ?");
obj->err = UEIOERR;
goto ext_1;
}
if (obj->type == UFFS_TYPE_FILE)
obj->node->u.file.len = 0; //init the length to 0
if (HAVE_BADBLOCK(obj->dev))
uffs_BadBlockRecover(obj->dev);
obj->open_succ = U_TRUE;
ext_1:
uffs_ObjectDevUnLock(obj);
ext:
return (obj->err == UENOERR ? U_SUCC : U_FAIL);
}
//
// To trancate the file, this is the last block to be trancated.
// We need to discard one or more pages within this block, hence requires 'block recover'.
//
static URET do_TruncateInternalWithBlockRecover(uffs_Object *obj,
u16 fdn, u32 remain, RunOptionE run_opt)
{
uffs_Device *dev = obj->dev;
TreeNode *fnode = obj->node;
u16 page_id, max_page_id;
TreeNode *node;
uffs_Buf *buf = NULL;
u8 type;
u32 block_start, block_offset;
u16 parent, serial;
int slot;
uffs_BlockInfo *bc = NULL;
int block = -1;
if (fdn == 0) {
node = fnode;
type = UFFS_TYPE_FILE;
max_page_id = obj->head_pages;
block_start = 0;
parent = node->u.file.parent;
serial = node->u.file.serial;
block = node->u.file.block;
}
else {
node = uffs_TreeFindDataNode(dev, fnode->u.file.serial, fdn);
if (node == NULL) {
obj->err = UEIOERR;
uffs_Perror(UFFS_MSG_SERIOUS,
"can't find data node when truncate obj");
goto ext;
}
block = node->u.data.block;
type = UFFS_TYPE_DATA;
max_page_id = dev->attr->pages_per_block - 1;
block_start = obj->head_pages * dev->com.pg_data_size +
(fdn - 1) * dev->com.pg_data_size *
dev->attr->pages_per_block;
parent = node->u.data.parent;
serial = node->u.data.serial;
}
if (run_opt == eDRY_RUN) {
// checking the buffer. this is the main reason why we need the 'dry run' mode.
for (page_id = 0; page_id <= max_page_id; page_id++) {
buf = uffs_BufFind(dev, parent, serial, page_id);
if (buf) {
//!< ok, the buffer was loaded before ...
if (uffs_BufIsFree(buf) == U_FALSE) {
obj->err = UEEXIST;
break; //!< and someone is still holding the buffer,
// can't truncate it !!!
}
}
}
buf = NULL;
goto ext;
}
// find the last page *after* truncate
block_offset = remain - block_start;
page_id = block_offset / dev->com.pg_data_size;
if (fdn == 0)
page_id++;
if (!uffs_Assert(page_id <= max_page_id, "fdn = %d, block_start = %d, remain = %d\n", fdn, block_start, remain)) {
obj->err = UEUNKNOWN_ERR;
goto ext;
}
// flush buffer before performing block recovery
uffs_BufFlushGroup(dev, parent, serial);
// load the last page
buf = uffs_BufGetEx(dev, type, node, page_id, obj->oflag);
if (buf == NULL) {
obj->err = UENOMEM;
uffs_Perror(UFFS_MSG_SERIOUS, "Can't get buf");
goto ext;
}
uffs_BufWrite(dev, buf, NULL, 0, 0); // just make this buf dirty
// lock the group
slot = uffs_BufFindGroupSlot(dev, parent, serial);
uffs_BufLockGroup(dev, slot);
if (remain == 0) // remain == 0: means discard all data in this block.
buf->data_len = 0;
else {
remain = (remain % dev->com.pg_data_size);
// remain == 0: means that we need to keep all data in this page.
buf->data_len = (remain == 0 ? dev->com.pg_data_size : remain);
}
/* mark this buf as UFFS_BUF_EXT_MARK_TRUNC_TAIL, when flushing
dirty buffers, UFFS will not do page recover for pages after
this buf page id (because this file is ended at this page) */
buf->ext_mark |= UFFS_BUF_EXT_MARK_TRUNC_TAIL;
uffs_BufPut(dev, buf);
// invalidate the rest page buf
page_id++;
for (; page_id <= max_page_id; page_id++) {
buf = uffs_BufFind(dev, parent, serial, page_id);
if (buf)
uffs_BufMarkEmpty(dev, buf);
}
// flush dirty buffer immediately, forcing block recovery.
uffs_BufFlushGroupEx(dev, parent, serial, U_TRUE);
// unlock the group
uffs_BufUnLockGroup(dev, slot);
// Invalidate block info cache for the 'old' block
bc = uffs_BlockInfoGet(dev, block);
if (bc) {
uffs_BlockInfoExpire(dev, bc, UFFS_ALL_PAGES);
uffs_BlockInfoPut(dev, bc);
}
ext:
return (obj->err == UENOERR ? U_SUCC : U_FAIL);
}
/**
* write data to obj, from obj->pos
*
* \param[in] obj file obj
* \param[in] data data pointer
* \param[in] len length of data to be write
*
* \return bytes wrote to obj
*/
int uffs_WriteObject(uffs_Object *obj, const void *data, int len)
{
uffs_Device *dev = obj->dev;
TreeNode *fnode = obj->node;
int remain = len;
u16 fdn;
u32 write_start;
TreeNode *dnode;
u32 size;
if (obj == NULL)
return 0;
if (obj->dev == NULL || obj->open_succ != U_TRUE) {
obj->err = UEBADF;
return 0;
}
if (obj->type == UFFS_TYPE_DIR) {
uffs_Perror(UFFS_ERR_NOISY, "Can't write to an dir object!");
obj->err = UEACCES;
return 0;
}
if (obj->pos > fnode->u.file.len) {
return 0; //can't write file out of range
}
if (obj->oflag == UO_RDONLY) {
obj->err = UEACCES;
return 0;
}
uffs_ObjectDevLock(obj);
if (obj->oflag & UO_APPEND)
obj->pos = fnode->u.file.len;
while (remain > 0) {
write_start = obj->pos + len - remain;
if (write_start > fnode->u.file.len) {
uffs_Perror(UFFS_ERR_SERIOUS, "write point out of file ?");
break;
}
fdn = GetFdnByOfs(obj, write_start);
if (write_start == fnode->u.file.len && fdn > 0 &&
write_start == GetStartOfDataBlock(obj, fdn)) {
if (dev->tree.erased_count < MINIMUN_ERASED_BLOCK) {
uffs_Perror(UFFS_ERR_NOISY, "insufficient block in write obj, new block");
break;
}
size = do_WriteNewBlock(obj, (u8 *)data + len - remain, remain, fnode->u.file.serial, fdn);
//Flush immediately, so that the new data node will be created and put in the tree.
uffs_BufFlushGroup(dev, fnode->u.file.serial, fdn);
if (size == 0)
break;
remain -= size;
}
else {
if(fdn == 0)
dnode = obj->node;
else
dnode = uffs_TreeFindDataNode(dev, fnode->u.file.serial, fdn);
if(dnode == NULL) {
uffs_Perror(UFFS_ERR_SERIOUS, "can't find data node in tree ?");
obj->err = UEUNKNOWN;
break;
}
size = do_WriteInternalBlock(obj, dnode, fdn,
(u8 *)data + len - remain, remain,
write_start - GetStartOfDataBlock(obj, fdn));
#ifdef CONFIG_FLUSH_BUF_AFTER_WRITE
uffs_BufFlushGroup(dev, fnode->u.file.serial, fdn);
#endif
if (size == 0)
break;
remain -= size;
}
}
obj->pos += (len - remain);
if (HAVE_BADBLOCK(dev))
uffs_BadBlockRecover(dev);
uffs_ObjectDevUnLock(obj);
return len - remain;
}
static URET do_TruncateInternalWithBlockRecover(uffs_Object *obj, u16 fdn, u32 remain, UBOOL dry_run)
{
uffs_Device *dev = obj->dev;
TreeNode *fnode = obj->node;
u16 page_id, max_page_id;
TreeNode *node;
uffs_Buf *buf = NULL;
u8 type;
u32 block_start;
u16 parent, serial;
int slot;
if (fdn == 0) {
node = fnode;
type = UFFS_TYPE_FILE;
max_page_id = obj->head_pages;
block_start = 0;
parent = node->u.file.parent;
serial = node->u.file.serial;
}
else {
node = uffs_TreeFindDataNode(dev, fnode->u.file.serial, fdn);
if (node == NULL) {
obj->err = UEIOERR;
uffs_Perror(UFFS_ERR_SERIOUS, "can't find data node when truncate obj");
goto ext;
}
type = UFFS_TYPE_DATA;
max_page_id = dev->attr->pages_per_block - 1;
block_start = obj->head_pages * dev->com.pg_data_size + (fdn - 1) * dev->com.pg_data_size * dev->attr->pages_per_block;
parent = node->u.data.parent;
serial = node->u.data.serial;
}
if (dry_run == U_TRUE) {
// checking the buffer. this is the main reason why we need the 'dry run' mode.
for (page_id = 0; page_id <= max_page_id; page_id++) {
buf = uffs_BufFind(dev, parent, serial, page_id);
if (buf) { //!< ok, the buffer was loaded before ...
if (uffs_BufIsFree(buf) == U_FALSE) {
obj->err = UEEXIST;
break; //!< and someone is still holding the buffer, can't truncate it !!!
}
}
}
buf = NULL;
goto ext;
}
// find the last page after truncate
for (page_id = (fdn == 0 ? 1 : 0); page_id <= max_page_id; page_id++) {
if (block_start + (page_id + 1) * dev->com.pg_data_size >= remain)
break;
}
if (page_id > max_page_id) {
obj->err = UEUNKNOWN;
uffs_Perror(UFFS_ERR_SERIOUS, "Overflow");
goto ext;
}
// flush buffer before performing block recovery
uffs_BufFlushGroup(dev, parent, serial);
// load the last page
buf = uffs_BufGetEx(dev, type, node, page_id);
if (buf == NULL) {
obj->err = UENOMEM;
uffs_Perror(UFFS_ERR_SERIOUS, "Can't get buf");
goto ext;
}
uffs_BufWrite(dev, buf, NULL, 0, 0); // just make this buf dirty
// lock the group
slot = uffs_BufFindGroupSlot(dev, parent, serial);
uffs_BufLockGroup(dev, slot);
if (remain == 0)
buf->data_len = 0;
else {
remain = (remain % dev->com.pg_data_size);
buf->data_len = (remain == 0 ? dev->com.pg_data_size : 0);
}
buf->ext_mark |= UFFS_BUF_EXT_MARK_TRUNC_TAIL;
uffs_BufPut(dev, buf);
// invalidate the rest page buf
page_id++;
for (; page_id <= max_page_id; page_id++) {
buf = uffs_BufFind(dev, parent, serial, page_id);
if (buf)
uffs_BufMarkEmpty(dev, buf);
}
// flush dirty buffer immediately, forcing block recovery.
uffs_BufFlushGroupEx(dev, parent, serial, U_TRUE);
// unlock the group
uffs_BufUnLockGroup(dev, slot);
ext:
return (obj->err == UENOERR ? U_SUCC : U_FAIL);
}
