/** * 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; }
static int do_WriteInternalBlock(uffs_Object *obj, TreeNode *node, u16 fdn, const void *data, u32 len, u32 blockOfs) { uffs_Device *dev = obj->dev; u16 maxPageID; u16 page_id; u32 size; u32 pageOfs; u32 wroteSize = 0; URET ret; uffs_Buf *buf; u32 block_start; u8 type; u16 parent, serial; block_start = GetStartOfDataBlock(obj, fdn); if (fdn == 0) { type = UFFS_TYPE_FILE; parent = node->u.file.parent; serial = node->u.file.serial; } else { type = UFFS_TYPE_DATA; parent = node->u.data.parent; serial = fdn; } if (fdn == 0) maxPageID = obj->head_pages; else maxPageID = dev->attr->pages_per_block - 1; while (wroteSize < len) { page_id = blockOfs / dev->com.pg_data_size; if (fdn == 0) page_id++; //in file header, page_id start from 1, not 0. if (page_id > maxPageID) break; pageOfs = blockOfs % dev->com.pg_data_size; size = (len - wroteSize + pageOfs) > dev->com.pg_data_size ? (dev->com.pg_data_size - pageOfs) : (len - wroteSize); if ((obj->node->u.file.len % dev->com.pg_data_size) == 0 && (blockOfs + block_start) == obj->node->u.file.len) { buf = uffs_BufNew(dev, type, parent, serial, page_id); if(buf == NULL) { uffs_Perror(UFFS_MSG_SERIOUS, "can create a new buf!"); break; } } else { buf = uffs_BufGetEx(dev, type, node, page_id, obj->oflag); if (buf == NULL) { uffs_Perror(UFFS_MSG_SERIOUS, "can't get buffer ?"); break; } } // Note: if data == NULL, then we will fill '\0' ret = uffs_BufWrite(dev, buf, data == NULL ? NULL : (u8 *)data + wroteSize, pageOfs, size); uffs_BufPut(dev, buf); if (ret == U_FAIL) { uffs_Perror(UFFS_MSG_SERIOUS, "write inter data fail!"); break; } wroteSize += size; blockOfs += size; if (block_start + blockOfs > obj->node->u.file.len) obj->node->u.file.len = block_start + blockOfs; } return wroteSize; }
/** 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); }
/** * read data from obj * * \param[in] obj uffs object * \param[out] data output data buffer * \param[in] len required length of data to be read from object->pos * * \return return bytes of data have been read */ int uffs_ReadObject(uffs_Object *obj, void *data, int len) { uffs_Device *dev = obj->dev; TreeNode *fnode = NULL; u32 remain = len; u16 fdn; u32 read_start; TreeNode *dnode; u32 size; uffs_Buf *buf; u32 blockOfs; u16 page_id; u8 type; u32 pageOfs; if (obj == NULL) return 0; fnode = obj->node; if (obj->dev == NULL || obj->open_succ == U_FALSE) { obj->err = UEBADF; return 0; } if (obj->type == UFFS_TYPE_DIR) { uffs_Perror(UFFS_MSG_NOISY, "Can't read data from a dir object!"); obj->err = UEBADF; return 0; } if (obj->pos > fnode->u.file.len) { return 0; //can't read file out of range } if (obj->oflag & UO_WRONLY) { obj->err = UEACCES; return 0; } uffs_ObjectDevLock(obj); while (remain > 0) { read_start = obj->pos + len - remain; if (read_start >= fnode->u.file.len) { //uffs_Perror(UFFS_MSG_NOISY, "read point out of file ?"); break; } fdn = GetFdnByOfs(obj, read_start); if (fdn == 0) { dnode = obj->node; type = UFFS_TYPE_FILE; } else { type = UFFS_TYPE_DATA; dnode = uffs_TreeFindDataNode(dev, fnode->u.file.serial, fdn); if (dnode == NULL) { uffs_Perror(UFFS_MSG_SERIOUS, "can't get data node in entry!"); obj->err = UEUNKNOWN_ERR; break; } } blockOfs = GetStartOfDataBlock(obj, fdn); page_id = (read_start - blockOfs) / dev->com.pg_data_size; if (fdn == 0) { /** * fdn == 0: this means that the reading is start from the first block, * since the page 0 is for file attr, so we move to the next page ID. */ page_id++; } buf = uffs_BufGetEx(dev, type, dnode, (u16)page_id, obj->oflag); if (buf == NULL) { uffs_Perror(UFFS_MSG_SERIOUS, "can't get buffer when read obj."); obj->err = UEIOERR; break; } pageOfs = read_start % dev->com.pg_data_size; if (pageOfs >= buf->data_len) { //uffs_Perror(UFFS_MSG_NOISY, "read data out of page range ?"); uffs_BufPut(dev, buf); break; } size = (remain + pageOfs > buf->data_len ? buf->data_len - pageOfs : remain); uffs_BufRead(dev, buf, (u8 *)data + len - remain, pageOfs, size); uffs_BufPut(dev, buf); remain -= size; } obj->pos += (len - remain); if (HAVE_BADBLOCK(dev)) uffs_BadBlockRecover(dev); uffs_ObjectDevUnLock(obj); uffs_Assert(fnode == obj->node, "obj->node change!\n"); return len - remain; }
/** * 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; }
/** 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); }