fsmvfs.c

norflash的文件系统。 用于中低端手机开发的参考

	FsP = FsmVfsFds[fd].VolumeP->FsDrvP;

	status = FsP->FsmIoCtrl(FsmVfsFds[fd].LowerFd, FSM_IOCTL_EOF, Eof);

	FsmVfsFds[fd].ErrorCode = status;

	FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);

	return status;
}


/*
* Function Name: FsmError
* Description  : get the error code for the Fd
* Arguments    : fd        : file descriptor
* First Edit 2003.7.23 wsm
*/

uint32 FsmError(uint32 fd)
{

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmError in %s,%d \n", __FILE__, __LINE__);
#endif

	if (fd >= MAX_VFS_FD)
	{
		return ERR_PARAM;
	}

	return FsmVfsFds[fd].ErrorCode;
}

/*
* Function Name: FsmGetAttrib
* Description  : get the information of the file
* Arguments    : fd        : file descriptor
*              : attrib    : output attribute buffer,space not alloced!
* First Edit 2003.7.23 wsm
*/

uint32 FsmGetAttrib(uint32 fd, FsmFileAttribT * attrib)
{
	uint32			status;
	FsmFsDrvT *		FsP;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmGetAttrib in %s,%d \n", __FILE__, __LINE__);
#endif

	if (fd >= MAX_VFS_FD)
	{
		return ERR_PARAM;
	}

	if (attrib == NULL)
	{
		FsmVfsFds[fd].ErrorCode = ERR_PARAM;
	    return ERR_PARAM;
	}

	if ((status = FsmGetMtxSem(FsmVfsFds[fd].MutexSem)) != ERR_NONE)
	{
		FsmVfsFds[fd].ErrorCode = status;
		return status;
	}

	if((FsmVfsFds[fd].Flag == VFD_FLAG_FREE)
		|| (FsmVfsFds[fd].LowerFd == (uint32)(-1))
		|| (FsmVfsFds[fd].VolumeP == NULL))
	{
		FsmVfsFds[fd].ErrorCode = ERR_PARAM;
		FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);
		return ERR_PARAM;
	}

	FsP = FsmVfsFds[fd].VolumeP->FsDrvP;

	status = FsP->FsmIoCtrl(FsmVfsFds[fd].LowerFd, FSM_IOCTL_GET_ATTRIB, (void *)attrib);

	FsmVfsFds[fd].ErrorCode = status;

	FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);

	return status;
}

/*
* Function Name: FsmGetAttribByName
* Description  : get the information of the file
* Arguments    : path      : file name
*              : attrib    : output attribute buffer,space alloced!
* First Edit 2003.7.23 wsm
*/

uint32 FsmGetAttribByName(const char * filename, FsmFileAttribT * attrib)
{
	uint32		fd;
	uint32		status;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmGetAttribByName in %s,%d \n", __FILE__, __LINE__);
#endif

	fd = FsmOpen(filename, FSM_OPEN_EXISTING | FSM_OPEN_READ | FSM_OPEN_FILE);

	if(fd == INVALID_FILE_HANDLE)
	{
		return ERR_UNKOWN;
	}

	status = FsmGetAttrib(fd, attrib);

	FsmClose(fd);

	return status;
}


/*
* Function Name: FsmSetAttrib
* Description  : Set the information of the file
* Arguments    : path      : file name
*              : attrib    : output attribute buffer
* First Edit 2003.7.23 wsm
* Currently unsupported
*/

uint32 FsmSetAttrib ( const char * path, FsmFileAttribT * attrib)
{
	return ERR_NOT_SUPPORT;
}

/*
* Function Name: FsmTruncate
* Description  : truncate the the lenghth file
* Arguments    : fd        : file descriptor
*              : size      : remain size
* First Edit 2003.7.23 wsm
*
*/

uint32 FsmTruncate(uint32 fd, uint32 size)
{
	uint32			status;
	FsmFsDrvT *		FsP;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmTruncate in %s,%d \n", __FILE__, __LINE__);
#endif

	if (fd >= MAX_VFS_FD)
	{
		return ERR_PARAM;
	}

	if ((status = FsmGetMtxSem(FsmVfsFds[fd].MutexSem)) != ERR_NONE)
	{
		FsmVfsFds[fd].ErrorCode = status;
		return status;
	}

	if((FsmVfsFds[fd].Flag == VFD_FLAG_FREE)
		|| (FsmVfsFds[fd].LowerFd == (uint32)(-1))
		|| (FsmVfsFds[fd].VolumeP == NULL))
	{
		FsmVfsFds[fd].ErrorCode = ERR_PARAM;
		FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);
		return ERR_PARAM;
	}

	FsP = FsmVfsFds[fd].VolumeP->FsDrvP;

	status = FsP->FsmIoCtrl(FsmVfsFds[fd].LowerFd, FSM_IOCTL_TRUNCATE, &size);

	FsmVfsFds[fd].ErrorCode = status;

	FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);

	return status;
}

/*
 * Function Name: FsmRemove
 * Description  : remove the file
 * Arguments    : filename  : file name
 * First Edit 2003.7.23 wsm
 */

uint32 FsmRemove(const char * filename)
{
	uint32			status;
	uint32			VolIndex;
	FsmFsDrvT *		FsP;
	char   *		path;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmRemove in %s,%d :Remove %s \n", __FILE__, __LINE__, path);
#endif

	if(strlen(filename) > MAX_PATH_LENGTH)
	{
		return ERR_PARAM;
	}

	path = (char *)filename;

    if ((status = FsmGetMtxSem(FsmVolumeMtxSem)) != ERR_NONE )
	{
		return status;
	}

	VolIndex = FsmGetMatchedVolume(&path);

	if (VolIndex == MAX_VOLUME_NUM)
	{
		FsmReleaseMtxSem(FsmVolumeMtxSem);

		return ERR_PARAM;
	}

	FsmVolumes[VolIndex].RefCnt++; /* prevent volume from being unmounted. */

	FsP = FsmVolumes[VolIndex].FsDrvP;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	status = FsP->FsmDelete(FsmVolumes[VolIndex].DevObjP, path);

	FsmGetMtxSem(FsmVolumeMtxSem);

	FsmVolumes[VolIndex].RefCnt--;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	return status;
}

/*
* Function Name: FsmRename
* Description  : Rename a file or a directory
* Arguments    : path     : file or directory path
*              : newname  : new name for the fiel or directory
* First Edit 2003.8.13 wsm
*/

uint32 FsmRename(const char *filename, const char *newname)
{
	uint32			status;
	uint32			VolIndex;
	FsmFsDrvT *		FsP;
	char   *		path;

	FsmIoctlRenameT		RenameArg;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmRename in %s,%d :Rename %s to %s \n", __FILE__, __LINE__, filename, newname);
#endif

	if(strlen(filename) > MAX_PATH_LENGTH)
	{
		return ERR_PARAM;
	}

	if(strlen(newname) > MAX_PATH_LENGTH)
	{
		return ERR_PARAM;
	}

	path = (char *)filename;

    if ((status = FsmGetMtxSem(FsmVolumeMtxSem)) != ERR_NONE )
	{
		return status;
	}

	VolIndex = FsmGetMatchedVolume(&path);

	if (VolIndex == MAX_VOLUME_NUM)
	{
		FsmReleaseMtxSem(FsmVolumeMtxSem);

		return ERR_PARAM;
	}

	FsmVolumes[VolIndex].RefCnt++; /* prevent volume from being unmounted. */

	FsP = FsmVolumes[VolIndex].FsDrvP;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	RenameArg.DevObjP = FsmVolumes[VolIndex].DevObjP;
	RenameArg.path    = path;
	RenameArg.newname = ExtractFilename(newname);

	status = FsP->FsmIoCtrl(INVALID_FILE_HANDLE, FSM_IOCTL_RENAME, (void *)&RenameArg);

	FsmGetMtxSem(FsmVolumeMtxSem);

	FsmVolumes[VolIndex].RefCnt--;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	return status;
}

/*
* Function Name: FsmMkdir
* Description  : Create a directory
* Arguments    : path     : file or directory path
* First Edit 2003.8.13 wsm
*/

uint32 FsmMakeDir(const char * dirname)
{
	uint32			status;
	uint32			VolIndex;
	FsmFsDrvT *		FsP;
	char   *		path;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmMkDir in %s,%d :Mkdir %s \n", __FILE__, __LINE__, dirname);
#endif

	if (strlen(dirname) > MAX_PATH_LENGTH)
	{
		return ERR_PARAM;
	}

	path = (char *)dirname;

    if ((status = FsmGetMtxSem(FsmVolumeMtxSem)) != ERR_NONE )
	{
		return status;
	}

	VolIndex = FsmGetMatchedVolume(&path);

	if (VolIndex == MAX_VOLUME_NUM)
	{
		FsmReleaseMtxSem(FsmVolumeMtxSem);

		return ERR_PARAM;
	}

	FsmVolumes[VolIndex].RefCnt++; /* prevent volume from being unmounted. */

	FsP = FsmVolumes[VolIndex].FsDrvP;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	FsP->FsmCreate( FsmVolumes[VolIndex].DevObjP,
					path,
					FSM_OPEN_DIR | FSM_CREATE_NEW | FSM_OPEN_READ,
					&status
					);

	FsmGetMtxSem(FsmVolumeMtxSem);

	FsmVolumes[VolIndex].RefCnt--;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	return status;
}

/*
* Function Name: FsmRemovedir
* Description  : Delete a empty directory
* Arguments    : path     : file or directory path
* First Edit 2003.8.13 wsm
*/

uint32 FsmRemoveDir(const char * dirname)
{
	uint32			status;
	uint32			VolIndex;
	FsmFsDrvT *		FsP;
	char   *		path;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmRemoveDir in %s,%d :Remove dir %s \n", __FILE__, __LINE__, dirname);
#endif

	if (strlen(dirname) > MAX_PATH_LENGTH)
	{
		return ERR_PARAM;
	}

	path = (char *)dirname;

    if ((status = FsmGetMtxSem(FsmVolumeMtxSem)) != ERR_NONE )
	{
		return status;
	}

	VolIndex = FsmGetMatchedVolume(&path);

	if (VolIndex == MAX_VOLUME_NUM)
	{
		FsmReleaseMtxSem(FsmVolumeMtxSem);

		return ERR_PARAM;
	}

	FsmVolumes[VolIndex].RefCnt++; /* prevent volume from being unmounted. */

	FsP = FsmVolumes[VolIndex].FsDrvP;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	status = FsP->FsmDelete(FsmVolumes[VolIndex].DevObjP, path);

	FsmGetMtxSem(FsmVolumeMtxSem);

	FsmVolumes[VolIndex].RefCnt--;

	FsmReleaseMtxSem(FsmVolumeMtxSem);

	return status;
}

/*
* Function Name: FsmFindFirstFile
* Description  : Delete a empty directory
* Arguments    : filename    : file name
*              : info        : content buffer
* First Edit 2003.8.13 wsm
*/

HENUM FsmFindFirstFile(const char * filename, FsmFileInfoT * Info)
{
	uint32		status;
	uint32      VolIndex;
	char		dir[MAX_PATH_LENGTH + 1];
	uint32		len;
	char   *	name;
	uint32      vfd;
	HENUM		hEnum;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmFindFirstFile in %s,%d :Lookup for %s \n", __FILE__, __LINE__, filename);
#endif

	if ((filename == NULL) || (Info == NULL))
	{
		return NULL;
	}

	if(strlen(filename) > MAX_PATH_LENGTH)
	{
		return NULL;
	}

	if(ExtractDir(filename, &len) != 0)
	{
		if(len > 0)
		{
			char	* path;

			FsmMemoryMove((uint8 *)dir, (uint8 *)filename, len);
			dir[len] = 0; /* It is a zero-end string now. */

			path = &dir[0];

			if ((status = FsmGetMtxSem(FsmVolumeMtxSem)) != ERR_NONE )
			{
				return NULL;
			}

			VolIndex = FsmGetMatchedVolume(&path);

			FsmReleaseMtxSem(FsmVolumeMtxSem);

			if(VolIndex == MAX_VOLUME_NUM)
			{
				return NULL;
			}

			/* path doesn't contain Volume Name now! */
			/* If it is not root dir, then discard the last slash. */
			if(strlen(path) != 1)
				dir[len - 1] = 0; 
		}
		else
		{
			return NULL;
		}
	}
	else
	{
		return NULL;
	}

	name = ExtractFilename(filename);

	if(name == NULL)
	{
		return NULL;
	}

	if(name[0] == 0)
	{
		return NULL;
	}

	if(strlen(name) > FILE_NAME_LENGTH)
	{
		return NULL;
	}

	hEnum = FsmMalloc(sizeof(FsmFileEnumT));

	if(hEnum == NULL)
	{
		return NULL;
	}

	vfd = FsmOpenDir((const char *)&dir[0]);

	if (vfd == INVALID_FILE_HANDLE)
	{
		FsmFree(hEnum);
		return NULL;
	}

	((FsmFileEnumT *)hEnum)->vfd = vfd;
	strcpy(((FsmFileEnumT *)hEnum)->pattern, name);

	while (FsmReadDir(vfd, Info) == ERR_NONE)
	{
	    if (FsmStringMatched(name, Info->FileName) == 1 )
	    {
		    return hEnum;
	    }
    }

	FsmCloseDir(vfd);
	FsmFree(hEnum);

    return NULL;
}

/*
* Function Name: FsmFindNextFile(Generated)
* Description  : Delete a empty directory
* Arguments    : fd          : file descriptor
*              : info        : content buffer
* First Edit 2003.8.13 wsm
*/

uint32 FsmFindNextFile(HENUM hEnum, FsmFileInfoT * Info)
{
	char *		name = NULL;
	uint32		fd;

	if(hEnum == NULL)
		return ERR_PARAM;

	fd = ((FsmFileEnumT *)hEnum)->vfd;

	if (fd >= MAX_VFS_FD)
	{
		return ERR_PARAM;
	}

	if (Info == NULL)
	{
		return ERR_PARAM;
	}

	name = &((FsmFileEnumT *)hEnum)->pattern[0];

	while (FsmReadDir(fd, Info) == ERR_NONE)
	{
	    if (FsmStringMatched(name, Info->FileName) == 1)
	    {
		    return ERR_NONE;
	    }
    }

    return ERR_NOTEXIST;
}

/*
* Function Name: FsmFindClose (Generated)
* Description  : Delete a empty directory
* Arguments    : fd          : file descriptor
* First Edit 2003.8.13 wsm
*/

uint32 FsmFindClose(HENUM hEnum)
{
	uint32		status;

	if(hEnum == NULL)
		return ERR_PARAM;

	status = FsmCloseDir(((FsmFileEnumT *)hEnum)->vfd);

	if(status == ERR_NONE)
	{
		status = FsmFree(hEnum);
	}

	return status;
}


/*
* Function Name: FsmFlush
* Description  : Delete a empty directory
* Arguments    : fd          : file descriptor
* First Edit 2003.8.13 wsm
*/

uint32 FsmFlush(uint32 fd)
{
	uint32			status;
	FsmFsDrvT *		FsP;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmFlush in %s,%d \n", __FILE__, __LINE__);
#endif

	if (fd >= MAX_VFS_FD)
	{
		return ERR_PARAM;
	}

	if ((status = FsmGetMtxSem(FsmVfsFds[fd].MutexSem)) != ERR_NONE)
	{
		FsmVfsFds[fd].ErrorCode = status;
		return status;
	}

	if((FsmVfsFds[fd].Flag == VFD_FLAG_FREE)
		|| (FsmVfsFds[fd].LowerFd == (uint32)(-1))
		|| (FsmVfsFds[fd].VolumeP == NULL))
	{
		FsmVfsFds[fd].ErrorCode = ERR_PARAM;
		FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);
		return ERR_PARAM;
	}

	FsP = FsmVfsFds[fd].VolumeP->FsDrvP;

	status = FsP->FsmIoCtrl(FsmVfsFds[fd].LowerFd, FSM_IOCTL_FLUSH, NULL);

	FsmVfsFds[fd].ErrorCode = status;

	FsmReleaseMtxSem(FsmVfsFds[fd].MutexSem);

	return status;
}

/*
* Function Name: FsmFlushAll
* Description  : Delete a empty directory
* Arguments    :
* First Edit 2003.8.13 wsm
*/

uint32 FsmFlushAll()
{

	uint32		fd;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmFlushAll in %s,%d \n", __FILE__, __LINE__);
#endif

	for (fd = 0; fd < MAX_VFS_FD; fd++)
	{
		FsmFlush(fd);
	}

	return ERR_NONE;
}

/*
* Function Name: FsmGetFreeSpace
* Description  : Delete a empty directory
* Arguments    : VolumeName      : the volumn path
*              : totalspace      : device space
*              : availablespace  : free space & dirty space
*              : freespace       : free space
* First Edit 2003.8.13 wsm
*/

uint32 FsmGetFreeSpace(const char * VolumeName, uint32 * total_space, uint32 * avail_space, uint32 * free_space)
{
	uint32			status;
	uint32			VolIndex;
	FsmFsDrvT *		FsP;
	char   *		path;

	FsmIoctlGetFreeSpaceT	GetFreeSpace;

#ifdef FSM_DEBUG
	MonPrintf("Interface FsmFlushAll in %s,%d \n", __FILE__, __LINE__);
#endif

    /* argument check */
	if ((total_space == NULL) && (avail_space == NULL) && (free_space == NULL))