自学教程：C++ uffs_Perror函数代码示例

/* * 函数功能: 创建一个文件 * 输入参数: 文件名称 * 返回参数:  */int uffs_mkfile(const char *name){	uffs_Object *fp;	int ret = 0;	int err = 0;	fp = uffs_GetObject();		if(fp != NULL) 	{		if(uffs_CreateObject(fp, name, UO_CREATE) != U_SUCC) 		{			err = fp->err;			ret = -1;			uffs_Perror(UFFS_ERR_NORMAL, "Create %s fail, err: %d", name, uffs_get_error());		}		else 		{			uffs_Perror(UFFS_ERR_NORMAL, "Create %s succ.", name);			uffs_CloseObject(fp);			ret = 0;		}		uffs_PutObject(fp);	}	else 	{		err = UEMFILE;		ret = -1;	}		uffs_set_error(-err);	return ret;}

/** compare [name] with tree [node] represented object name by loading	uffs_FileInfo from storage */UBOOL uffs_TreeCompareFileName(uffs_Device *dev,							   const char *name, u32 len, u16 sum,							   TreeNode *node, int type){	UBOOL matched = U_FALSE;	uffs_FileInfo *fi;	uffs_Buf *buf;	u16 data_sum;	buf = uffs_BufGetEx(dev, type, node, 0, 0);	if (buf == NULL) {		uffs_Perror(UFFS_MSG_SERIOUS, "can't get buf !/n ");		goto ext;	}	fi = (uffs_FileInfo *)(buf->data);	data_sum = uffs_MakeSum16(fi->name, fi->name_len);	if (data_sum != sum) {		uffs_Perror(UFFS_MSG_NORMAL,					"the obj's sum in storage is different with given sum!");		goto ext;	}	if (fi->name_len == len) {		if(uffs_CompareFileName(fi->name, fi->name_len, name) == U_TRUE) {			matched = U_TRUE;		}	}ext:	if (buf)		uffs_BufPut(dev, buf);	return matched;}

/**  * /brief build tree structure from flash * /param[in] dev uffs device */URET uffs_BuildTree(uffs_Device *dev){	URET ret;	/***** step one: scan all page spares, classify DIR/FILE/DATA nodes,		check bad blocks/uncompleted(conflicted) blocks as well *****/	/* if the disk is big and full filled of data this step could be		the most time consuming .... */	ret = _BuildTreeStepOne(dev);	if (ret != U_SUCC) {		uffs_Perror(UFFS_MSG_SERIOUS, "build tree step one fail!");		return ret;	}	/***** step two: randomize the erased blocks, for ware-leveling purpose *****/	/* this step is very fast :) */	ret = _BuildTreeStepTwo(dev);	if (ret != U_SUCC) {		uffs_Perror(UFFS_MSG_SERIOUS, "build tree step two fail!");		return ret;	}	/***** step three: check DATA nodes, find orphan nodes and erase them *****/	/* if there are a lot of files and disk is fully filled, this step 		could be very time consuming ... */	ret = _BuildTreeStepThree(dev);	if (ret != U_SUCC) {		uffs_Perror(UFFS_MSG_SERIOUS, "build tree step three fail!");		return ret;	}		return U_SUCC;}

/* * 函数功能: 格式化分区 * 输入参数: 分区名称 * 返回参数:  */int uffs_format(const char *name){	int ret;	const char *mount = "/";	uffs_Device *dev;	if(name) 	{		mount = name;	}	dev = uffs_GetDeviceFromMountPoint(mount);	if(dev == NULL) 	{		uffs_Perror(UFFS_ERR_NORMAL, "Can't get device from mount point.");	}	else 	{		if(dev->ref_count == 1) 		{			ret = uffs_FormatDevice(dev);			uffs_Perror(UFFS_ERR_NORMAL, "Format %s.",ret==RT_EOK?"succ":"fail");		}		else 		{			uffs_Perror(UFFS_ERR_NORMAL, "dev->ref_count: %d, can't format this device.", dev->ref_count);		}		uffs_PutDevice(dev);	}	return TRUE;	}

/* 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 check if there are anyone holding buf of this obj. *        If no one holding the buffers, expire the buffer. * /return *		0	: no one holding any buf of this obj *		>0	: the ref_count of buf which refer to this obj. */int _CheckObjBufRef(uffs_Object *obj){	uffs_Device *dev = obj->dev;	uffs_Buf *buf;	TreeNode *node = obj->node;	u16 parent, serial, last_serial;	// check the DIR or FILE block	for (buf = uffs_BufFind(dev, obj->parent, obj->serial, UFFS_ALL_PAGES);		 buf != NULL;		 buf = uffs_BufFindFrom(dev, buf->next, obj->parent, obj->serial, UFFS_ALL_PAGES))	{		if (buf->ref_count > 0) {			// oops ...			uffs_Perror(UFFS_MSG_SERIOUS, "someone still hold buf parent = %d, serial = %d, ref_count",				obj->parent, obj->serial, buf->ref_count);			return buf->ref_count;		}		else {			buf->mark = UFFS_BUF_EMPTY;		}	}	if (buf == NULL || buf->ref_count == 0) {		// check the DATA block		if (obj->type == UFFS_TYPE_FILE && node->u.file.len > 0) {			parent = obj->serial;			last_serial = GetFdnByOfs(obj, node->u.file.len - 1);			for (serial = 1; serial <= last_serial; serial++) {				for (buf = uffs_BufFind(dev, parent, serial, UFFS_ALL_PAGES);					 buf != NULL;					 buf = uffs_BufFindFrom(dev, buf->next, parent, serial, UFFS_ALL_PAGES))				{					if (buf->ref_count != 0) {						// oops ...						uffs_Perror(UFFS_MSG_SERIOUS, "someone still hold buf parent = %d, serial = %d, ref_count",							parent, serial, buf->ref_count);						return buf->ref_count;					}					else {						buf->mark = UFFS_BUF_EMPTY;					}				}			}		}	}	return 0;}

/**  * /brief initialize tree buffers * /param[in] dev uffs device */URET uffs_TreeInit(uffs_Device *dev){	int size;	int num;	uffs_Pool *pool;	int i;	size = sizeof(TreeNode);	num = dev->par.end - dev->par.start + 1;		pool = &(dev->mem.tree_pool);	if (dev->mem.tree_nodes_pool_size == 0) {		if (dev->mem.malloc) {			dev->mem.tree_nodes_pool_buf = dev->mem.malloc(dev, size * num);			if (dev->mem.tree_nodes_pool_buf)				dev->mem.tree_nodes_pool_size = size * num;		}	}	if (size * num > dev->mem.tree_nodes_pool_size) {		uffs_Perror(UFFS_MSG_DEAD,					"Tree buffer require %d but only %d available.",					size * num, dev->mem.tree_nodes_pool_size);		memset(pool, 0, sizeof(uffs_Pool));		return U_FAIL;	}	uffs_Perror(UFFS_MSG_NOISY, "alloc tree nodes %d bytes.", size * num);		uffs_PoolInit(pool, dev->mem.tree_nodes_pool_buf,					dev->mem.tree_nodes_pool_size, size, num, U_FALSE);	dev->tree.erased = NULL;	dev->tree.erased_tail = NULL;	dev->tree.erased_count = 0;	dev->tree.bad = NULL;	dev->tree.bad_count = 0;	for (i = 0; i < DIR_NODE_ENTRY_LEN; i++) {		dev->tree.dir_entry[i] = EMPTY_NODE;	}	for (i = 0; i < FILE_NODE_ENTRY_LEN; i++) {		dev->tree.file_entry[i] = EMPTY_NODE;	}	for (i = 0; i < DATA_NODE_ENTRY_LEN; i++) {		dev->tree.data_entry[i] = EMPTY_NODE;	}	dev->tree.max_serial = ROOT_DIR_SERIAL;		return U_SUCC;}

static URET _ScanAndFixUnCleanPage(uffs_Device *dev, uffs_BlockInfo *bc){	int page;	uffs_Tags *tag;	struct uffs_MiniHeaderSt header;	/* in most case, the valid block contents fewer free page,		so it's better scan from the last page ... to page 1.		note: scanning page 0 is not necessary, will check it later.		The worse case: read (pages_per_block - 1) * (mini header + spares) !		most case: read one spare.	*/	for (page = dev->attr->pages_per_block - 1; page > 0; page--) {		uffs_BlockInfoLoad(dev, bc, page);		tag = GET_TAG(bc, page);		if (TAG_IS_SEALED(tag))			break;	// tag sealed, no unclean page in this block.		if (TAG_IS_DIRTY(tag) || TAG_IS_VALID(tag)) {  // tag not sealed but dirty/valid ?			uffs_Perror(UFFS_MSG_NORMAL,					"unclean page found, block %d page %d",					bc->block, page);			// ok, an unclean page found.			// This unclean page can be identified by tag.			// We can leave it as it is, but performing a block recover would be good ?			// There won't be another unclean page in this block ... stop here.			break;		}		// now we have a clean tag (all 0xFF ?). Need to check mini header to see if it's an unclean page.		if (uffs_LoadMiniHeader(dev, bc->block, page, &header) == U_FAIL)			return U_FAIL;		if (header.status != 0xFF) {			// page data is dirty? this is an unclean page and we should explicitly mark tag as 'dirty and invalid'.			// This writing does not violate "no partial program" claim, because we are writing to a clean page spare.			uffs_Perror(UFFS_MSG_NORMAL,						"unclean page found, block %d page %d, mark it.",						bc->block, page);			uffs_FlashMarkDirtyPage(dev, bc, page);		}	}	return U_SUCC;}

URET uffs_InitDevice(uffs_Device *dev){    URET ret;    ret = uffs_InitDeviceConfig(dev);    if (ret != U_SUCC)        return U_FAIL;    if (dev->mem.init) {        if (dev->mem.init(dev) != U_SUCC) {            uffs_Perror(UFFS_MSG_SERIOUS, "Init memory allocator fail.");            return U_FAIL;        }    }    memset(&(dev->st), 0, sizeof(uffs_FlashStat));    uffs_DeviceInitLock(dev);    uffs_BadBlockInit(dev);    if (uffs_FlashInterfaceInit(dev) != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS, "Can't initialize flash interface !");        goto fail;    }    uffs_Perror(UFFS_MSG_NOISY, "init page buf");    ret = uffs_BufInit(dev, dev->cfg.page_buffers, dev->cfg.dirty_pages);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_DEAD, "Initialize page buffers fail");        goto fail;    }    uffs_Perror(UFFS_MSG_NOISY, "init block info cache");    ret = uffs_BlockInfoInitCache(dev, dev->cfg.bc_caches);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_DEAD, "Initialize block info fail");        goto fail;    }    ret = uffs_TreeInit(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS, "fail to init tree buffers");        goto fail;    }    ret = uffs_BuildTree(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS, "fail to build tree");        goto fail;    }    return U_SUCC;fail:    uffs_DeviceReleaseLock(dev);    return U_FAIL;}

/** Mark this block as bad block */URET uffs_FlashMarkBadBlock(uffs_Device *dev, int block){	int ret;	uffs_BlockInfo *bc;	uffs_Perror(UFFS_MSG_NORMAL, "Mark bad block: %d", block);	bc = uffs_BlockInfoGet(dev, block);	if (bc) {		uffs_BlockInfoExpire(dev, bc, UFFS_ALL_PAGES);	// expire this block, just in case it's been cached before		uffs_BlockInfoPut(dev, bc);	}	if (dev->ops->MarkBadBlock)		return dev->ops->MarkBadBlock(dev, block) == 0 ? U_SUCC : U_FAIL;#ifdef CONFIG_ERASE_BLOCK_BEFORE_MARK_BAD	ret = dev->ops->EraseBlock(dev, block);	if (ret != UFFS_FLASH_IO_ERR) {		// note: even EraseBlock return UFFS_FLASH_BAD_BLK,		//			we still process it ... not recommended for most NAND flash.#endif	if (dev->ops->WritePageWithLayout)		ret = dev->ops->WritePageWithLayout(dev, block, 0, NULL, 0, NULL, NULL);	else		ret = dev->ops->WritePage(dev, block, 0, NULL, 0, NULL, 0);#ifdef CONFIG_ERASE_BLOCK_BEFORE_MARK_BAD	}#endif	return ret == UFFS_FLASH_NO_ERR ? U_SUCC : U_FAIL;}

/* * Release resources */int femu_ReleaseFlash(uffs_Device *dev){	uffs_FileEmu *emu;	emu = (uffs_FileEmu *)(dev->attr->_private);	emu->initCount--;	if (emu->initCount == 0) {		uffs_Perror(UFFS_ERR_NORMAL,  "femu device release.");		if (emu->fp) {			fclose(emu->fp);			emu->fp = NULL;		}		if (emu->em_monitor_page)			free(emu->em_monitor_page);		if (emu->em_monitor_spare) 			free(emu->em_monitor_spare);		emu->em_monitor_page = NULL;		emu->em_monitor_spare = NULL;	}	return 0;}

/** * /brief Find a cached block in cache pool, *			if the cached block exist then return the pointer, *			if the block does not cached already, find a non-used cache. *			if all of cached are used out, return NULL. * /param[in] dev uffs device * /param[in] block block number to be found * /return found block cache buffer * /retval NULL caches used out * /retval non-NULL buffer pointer of given block */uffs_BlockInfo * uffs_BlockInfoGet(uffs_Device *dev, int block){    uffs_BlockInfo *work;    int i;    //search cached block    if ((work = uffs_BlockInfoFindInCache(dev, block)) != NULL) {        _MoveBcToTail(dev, work);        return work;    }    //can't find block from cache, need to find a free(unlocked) cache    for (work = dev->bc.head; work != NULL; work = work->next) {        if(work->ref_count == 0) break;    }    if (work == NULL) {        //caches used out !        uffs_Perror(UFFS_MSG_SERIOUS,  "insufficient block info cache");        return NULL;    }    work->block = block;    work->expired_count = dev->attr->pages_per_block;    for (i = 0; i < dev->attr->pages_per_block; i++) {        work->spares[i].expired = 1;        // TODO: init tag    }    work->ref_count = 1;    _MoveBcToTail(dev, work);    return work;}

/**  * create a new file on a free block * /param[in] dev uffs device * /param[in] parent parent dir serial num * /param[in] serial serial num of this new file * /param[in] bc block information * /param[in] fi file information * /note parent, serial, bc must be provided before, *		 and all information in fi should be filled well before. */URET uffs_CreateNewFile(uffs_Device *dev,						u16 parent, u16 serial,						uffs_BlockInfo *bc, uffs_FileInfo *fi){	uffs_Tags *tag;	uffs_Buf *buf;	uffs_BlockInfoLoad(dev, bc, 0);	tag = GET_TAG(bc, 0);	TAG_PARENT(tag) = parent;	TAG_SERIAL(tag) = serial;	TAG_DATA_LEN(tag) = sizeof(uffs_FileInfo);	buf = uffs_BufGet(dev, parent, serial, 0);	if (buf == NULL) {		uffs_Perror(UFFS_MSG_SERIOUS, "get buf fail.");		return U_FAIL;	}	memcpy(buf->data, fi, TAG_DATA_LEN(tag));	buf->data_len = TAG_DATA_LEN(tag);	return uffs_BufPut(dev, buf);}

static URET femu_releaseDevice(uffs_Device *dev){	uffs_FileEmu *emu;	uffs_Perror(UFFS_ERR_NORMAL,  "femu device release.");	emu = (uffs_FileEmu *)(dev->attr->_private);	emu->initCount--;	if (emu->initCount == 0) {		if (emu->fp) {			fclose(emu->fp);			emu->fp = NULL;		}		memset(emu, 0, sizeof(uffs_FileEmu));		if (emu->em_monitor_page)			free(emu->em_monitor_page);		if (emu->em_monitor_spare) 			free(emu->em_monitor_spare);		emu->em_monitor_page = NULL;		emu->em_monitor_spare = NULL;	}	return U_SUCC;}

/** * 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 = NULL;	int remain;	u32 pos;	int wrote = 0;	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_MSG_NOISY, "Can't write to an dir object!");		obj->err = UEACCES;		return 0;	}	if (obj->oflag == UO_RDONLY) {		obj->err = UEACCES;  // can't write to 'read only' mode opened file		return 0;	}	fnode = obj->node;	uffs_ObjectDevLock(obj);	if (obj->oflag & UO_APPEND)		obj->pos = fnode->u.file.len;	else {		if (obj->pos > fnode->u.file.len) {			// current pos pass over the end of file, need to fill the gap with '/0'			pos = obj->pos;	// save desired pos			obj->pos = fnode->u.file.len; // filling gap from the end of the file.			remain = do_WriteObject(obj, NULL, pos - fnode->u.file.len);  // Write filling bytes. Note: the filling data does not count as 'wrote' in this write operation.			obj->pos = pos - remain;			if (remain > 0)	// fail to fill the gap ? stop.				goto ext;		}	}	remain = do_WriteObject(obj, data, len);	wrote = len - remain;	obj->pos += wrote;ext:	if (HAVE_BADBLOCK(dev))		uffs_BadBlockRecover(dev);	uffs_ObjectDevUnLock(obj);	uffs_Assert(fnode == obj->node, "obj->node change!/n");	return wrote;}

/** * /brief load page spare data to given block info structure *			with given page number * /param[in] dev uffs device * /param[in] work given block info to be filled with * /param[in] page given page number to be read from, *			  if #UFFS_ALL_PAGES is presented, it will read *			  all pages, otherwise it will read only one given page. * /return load result * /retval U_SUCC successful * /retval U_FAIL fail to load * /note work->block must be set before load block info */URET uffs_BlockInfoLoad(uffs_Device *dev, uffs_BlockInfo *work, int page){    int i, ret;    uffs_PageSpare *spare;    if (page == UFFS_ALL_PAGES) {        for (i = 0; i < dev->attr->pages_per_block; i++) {            spare = &(work->spares[i]);            if (spare->expired == 0)                continue;            ret = uffs_FlashReadPageTag(dev, work->block, i,                                        &(spare->tag));            if (UFFS_FLASH_HAVE_ERR(ret)) {                uffs_Perror(UFFS_MSG_SERIOUS,                            "load block %d page %d spare fail.",                            work->block, i);                return U_FAIL;            }            spare->expired = 0;            work->expired_count--;        }    }    else {        if (page < 0 || page >= dev->attr->pages_per_block) {            uffs_Perror(UFFS_MSG_SERIOUS, "page out of range !");            return U_FAIL;        }        spare = &(work->spares[page]);        if (spare->expired != 0) {            ret = uffs_FlashReadPageTag(dev, work->block, page,                                        &(spare->tag));            if (UFFS_FLASH_HAVE_ERR(ret)) {                uffs_Perror(UFFS_MSG_SERIOUS,                            "load block %d page %d spare fail.",                            work->block, page);                return U_FAIL;            }            spare->expired = 0;            work->expired_count--;        }    }    return U_SUCC;}

static URET femu_initDevice(uffs_Device *dev){	uffs_Perror(UFFS_ERR_NORMAL,  "femu device init.");	dev->ops = &emu_flash_ops;							/* EMU device operations */	CheckInit(dev);	return U_SUCC;}

/** put a new block to the bad block waiting list */void uffs_BadBlockAdd(uffs_Device *dev, int block){	if (dev->bad.block == block)		return;	if (dev->bad.block != UFFS_INVALID_BLOCK)		uffs_Perror(UFFS_ERR_SERIOUS, "Can't add more then one bad block !");	else		dev->bad.block = block;}

URET uffs_InitDevice(uffs_Device *dev){	URET ret;	if (dev->mem.init) {		if (dev->mem.init(dev) != U_SUCC) {			uffs_Perror(UFFS_ERR_SERIOUS, "Init memory allocator fail.");			return U_FAIL;		}	}	memset(&(dev->st), 0, sizeof(uffs_FlashStat));	uffs_DeviceInitLock(dev);	uffs_BadBlockInit(dev);	if (uffs_FlashInterfaceInit(dev) != U_SUCC) {		uffs_Perror(UFFS_ERR_SERIOUS, "Can't initialize flash interface !");		goto fail;	}	uffs_Perror(UFFS_ERR_NOISY, "init page buf");	ret = uffs_BufInit(dev, MAX_PAGE_BUFFERS, MAX_DIRTY_PAGES_IN_A_BLOCK);	if (ret != U_SUCC) {		uffs_Perror(UFFS_ERR_DEAD, "Initialize page buffers fail");		goto fail;	}	uffs_Perror(UFFS_ERR_NOISY, "init block info cache");	ret = uffs_BlockInfoInitCache(dev, MAX_CACHED_BLOCK_INFO);	if (ret != U_SUCC) {		uffs_Perror(UFFS_ERR_DEAD, "Initialize block info fail");		goto fail;	}	ret = uffs_TreeInit(dev);	if (ret != U_SUCC) {		uffs_Perror(UFFS_ERR_SERIOUS, "fail to init tree buffers");		goto fail;	}	ret = uffs_BuildTree(dev);	if (ret != U_SUCC) {		uffs_Perror(UFFS_ERR_SERIOUS, "fail to build tree");		goto fail;	}	return U_SUCC;fail:	uffs_DeviceReleaseLock(dev);	return U_FAIL;}

void uffs_DeviceUnLock(uffs_Device *dev){	dev->lock.counter--;	if (dev->lock.counter != 0) {		uffs_Perror(UFFS_MSG_NORMAL,					"Unlock device, counter %d NOT zero?!", dev->lock.counter);	}		uffs_SemSignal(dev->lock.sem);}

UBOOL uffs_IsSrcNewerThanObj(int src, int obj){	switch (src - obj) {	case 0:		uffs_Perror(UFFS_MSG_SERIOUS,					"the two block have the same time stamp ?");		break;	case 1:	case -2:		return U_TRUE;	case -1:	case 2:		return U_FALSE;	default:		uffs_Perror(UFFS_MSG_SERIOUS,  "time stamp out of range !");		break;	}	return U_FALSE;}

void uffs_DeviceLock(uffs_Device *dev){	uffs_SemWait(dev->lock.sem);		if (dev->lock.counter != 0) {		uffs_Perror(UFFS_MSG_NORMAL,					"Lock device, counter %d NOT zero?!", dev->lock.counter);	}	dev->lock.counter++;}

URET uffs_InitMountTable(void){	struct uffs_MountTableEntrySt *tbl = uffs_GetMountTable();	struct uffs_MountTableEntrySt *work;	int dev_num = 0;	for (work = tbl; work; work = work->next) {		uffs_Perror(UFFS_ERR_NOISY, "init device for mount point %s ...", work->mount);		if (work->dev->Init(work->dev) == U_FAIL) {			uffs_Perror(UFFS_ERR_SERIOUS, "init device for mount point %s fail", work->mount);			return U_FAIL;		}		work->dev->par.start = work->start_block;		if (work->end_block < 0) 		{			work->dev->par.end = work->dev->attr->total_blocks + work->end_block;		}		else 		{			work->dev->par.end = work->end_block;		}		uffs_Perror(UFFS_ERR_NOISY, "mount partiton: %d,%d",			work->dev->par.start, work->dev->par.end);		if (uffs_InitDevice(work->dev) != U_SUCC) 		{			uffs_Perror(UFFS_ERR_SERIOUS, "init device fail !");			return U_FAIL;		}		work->dev->dev_num = dev_num++;	}	if (uffs_InitObjectBuf() == U_SUCC) {		if (uffs_InitDirEntryBuf() == U_SUCC) {			return U_SUCC;		}	}	return U_FAIL;}

URET uffs_ReleaseDevice(uffs_Device *dev){    URET ret;    ret = uffs_BlockInfoReleaseCache(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS,  "fail to release block info.");        goto ext;    }    ret = uffs_BufReleaseAll(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS,  "fail to release page buffers");        goto ext;    }    ret = uffs_TreeRelease(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS, "fail to release tree buffers!");        goto ext;    }    ret = uffs_FlashInterfaceRelease(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS, "fail to release tree buffers!");        goto ext;    }    if (dev->mem.release)        ret = dev->mem.release(dev);    if (ret != U_SUCC) {        uffs_Perror(UFFS_MSG_SERIOUS, "fail to release memory allocator!");    }    uffs_DeviceReleaseLock(dev);ext:    return ret;}

/** * /brief flush all buffers */URET uffs_BufFlushAll(struct uffs_DeviceSt *dev){    int slot;    for (slot = 0; slot < dev->cfg.dirty_groups; slot++) {        if(_BufFlush(dev, FALSE, slot) != U_SUCC) {            uffs_Perror(UFFS_MSG_NORMAL,                        "fail to flush buffer(slot %d)", slot);            return U_FAIL;        }    }    return U_SUCC;}

static URET _BuildTreeStepTwo(uffs_Device *dev){	//Randomise the start point of erased block to implement wear levelling	u32 startCount = 0;	u32 endPoint;	TreeNode *node;	uffs_Perror(UFFS_MSG_NOISY, "build tree step two");	endPoint = uffs_GetCurDateTime() % (dev->tree.erased_count + 1);	while (startCount < endPoint) {		node = uffs_TreeGetErasedNodeNoCheck(dev);		if (node == NULL) {			uffs_Perror(UFFS_MSG_SERIOUS, "No erased block ?");			return U_FAIL;		}		uffs_TreeInsertToErasedListTailEx(dev, node, -1);		startCount++;	}	return U_SUCC;}

static u16 _GetParentFromNode(u8 type, TreeNode *node){	switch (type) {	case UFFS_TYPE_DIR:		return node->u.dir.parent;	case UFFS_TYPE_FILE:		return node->u.file.parent;	case UFFS_TYPE_DATA:		return node->u.data.parent;	}	uffs_Perror(UFFS_MSG_SERIOUS, "unkown type, X-parent");	return INVALID_UFFS_SERIAL;}

void uffs_MemSetupStaticAllocator(uffs_MemAllocator *allocator,								  void *pool, int size){	allocator->buf_start = (char *)pool;	allocator->buf_size = size;	allocator->pos = 0;	allocator->malloc = static_malloc;	allocator->free = NULL;  //never free memory for static memory allocator	uffs_Perror(UFFS_MSG_NOISY,				"System static memory: %d bytes", allocator->buf_size);	}

static void * static_malloc(struct uffs_DeviceSt *dev, unsigned int size){	struct uffs_memAllocatorSt *mem = &dev->mem;	void *p = NULL;	size += (size % sizeof(long) ? sizeof(long) - (size % sizeof(long)) : 0);	if (mem->buf_size - mem->pos < (int)size) {		uffs_Perror(UFFS_MSG_SERIOUS,					"Memory alloc failed! (alloc %d, free %d)",					size, mem->buf_size - mem->pos);	}	else {		p = mem->buf_start + mem->pos;		mem->pos += size;		uffs_Perror(UFFS_MSG_NOISY,					"0x%p: Allocated %d, free %d",					p, size, mem->buf_size - mem->pos);	}	return p;}

static u16 _GetSerialFromNode(u8 type, TreeNode *node){	switch (type) {	case UFFS_TYPE_DIR:		return node->u.dir.serial;	case UFFS_TYPE_FILE:		return node->u.file.serial;	case UFFS_TYPE_DATA:		return node->u.data.serial;	}	uffs_Perror(UFFS_MSG_SERIOUS, "unkown type, X-serial");	return INVALID_UFFS_SERIAL;}