yaffsfsd.c

FAT32文件系统详细介绍

}

BOOL YFSD_ReadFileWithSeek( 
	PFILE pFile, 
	PVOID pBuffer, 
	DWORD cbRead, 
	PDWORD pcbRead, 
	OVERLAPPED *pOverlapped, 
	DWORD dwLowOffset, 
	DWORD dwHighOffset )
{
	BOOL result;
	DWORD rememberedOffset;

	RETAILMSG (MSGSTATE, (L"YAFFS::ReadFileWithSeek %d bytes at %d high %d pcbRead %X\r\n",cbRead,dwLowOffset,dwHighOffset,pcbRead));

	// To determine if paging is supported, the kernel calls this with all parameters except pFile
	// being zero.
	if(!pBuffer && !cbRead && !pcbRead && !pOverlapped && !dwLowOffset && !dwHighOffset)
	{
		return TRUE; // paging suppported
		//return FALSE; // paging not supported
	}

	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	yfsd_LockYAFFS();

	rememberedOffset = pFile->offset;

	pFile->offset = dwLowOffset;
	// ignore high offset for now

	result = yfsd_DoReadFile(pFile,pBuffer,cbRead,pcbRead);

	//pFile->offset = rememberedOffset;

	yfsd_UnlockYAFFS();

	return result;


}


BOOL yfsd_DoWriteFile( 
	PFILE pFile, 
	PCVOID pBuffer, 
	DWORD cbWrite, 
	PDWORD pcbWritten)
{
	int nwritten = 0;
	yaffs_Object *obj = NULL;
	
	RETAILMSG (MSGSTATE, (L"YAFFS::DoWriteFile size %d\r\n",cbWrite));
	
	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	if(!pFile->writePermitted)
	{
			*pcbWritten = 0;
			SetLastError(ERROR_ACCESS_DENIED);
			return FALSE;
	}

	obj = pFile->obj;

	*pcbWritten = 0;


		nwritten = yaffs_WriteDataToFile(obj,pBuffer,pFile->offset,cbWrite);
		if(nwritten >= 0)
		{
			pFile->offset += nwritten;
			*pcbWritten = nwritten;
		}
		if(nwritten != cbWrite)
		{
			SetLastError(ERROR_DISK_FULL);
		}


	return nwritten != cbWrite? FALSE : TRUE; 
}


BOOL YFSD_WriteFile( 
	PFILE pFile, 
	PCVOID pBuffer, 
	DWORD cbWrite, 
	PDWORD pcbWritten, 
	OVERLAPPED *pOverlapped )
{
	BOOL result;

	yfsd_LockYAFFS();
	RETAILMSG (MSGSTATE, (L"YAFFS::WriteFile\r\n"));

	result = yfsd_DoWriteFile(pFile,pBuffer,cbWrite,pcbWritten);

	yfsd_UnlockYAFFS();

	return result;
}

BOOL YFSD_WriteFileWithSeek( 
	PFILE pFile, 
	PCVOID pBuffer, 
	DWORD cbWrite, 
	PDWORD pcbWritten, 
	OVERLAPPED *pOverlapped,
	DWORD dwLowOffset, 
	DWORD dwHighOffset )
{
	BOOL result;
	DWORD rememberedOffset;
	RETAILMSG (MSGSTATE, (L"YAFFS::WriteFileWithSeek %d bytes at %d,%d pcbWritten %X\r\n",cbWrite,dwHighOffset,dwLowOffset,pcbWritten));

	

	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	yfsd_LockYAFFS();

	rememberedOffset = pFile->offset;

	pFile->offset = dwLowOffset;
	// ignore high offset for now

	result = yfsd_DoWriteFile(pFile,pBuffer,cbWrite,pcbWritten);

	//pFile->offset = rememberedOffset;

	yfsd_UnlockYAFFS();

	return result;
}

DWORD YFSD_SetFilePointer( 
	PFILE pFile, 
	LONG lDistanceToMove, 
	PLONG pDistanceToMoveHigh, 
	DWORD dwMoveMethod )
{
	// ignore high offset for now

	DWORD offset = 0xFFFFFFFF;
	DWORD oldPos;
	int fileSize;
	int seekNegative = 0;


	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return offset;
	}

	yfsd_LockYAFFS();


	oldPos = pFile->offset;

	if(dwMoveMethod == FILE_BEGIN)
	{
		if(lDistanceToMove >= 0)
		{	
			offset = pFile->offset = lDistanceToMove;
		}
		else
		{
			seekNegative = 1;
		}
	}
	else if(dwMoveMethod == FILE_END)
	{
		fileSize = yaffs_GetObjectFileLength(pFile->obj);
		if(fileSize >= 0 &&
		   (fileSize + lDistanceToMove) >= 0)
		{
			offset = pFile->offset = fileSize + lDistanceToMove;
		}
		else
		{
			seekNegative = 1;
		}
	}
	else if(dwMoveMethod == FILE_CURRENT)
	{
		if(pFile->offset + lDistanceToMove >= 0)
		{
			offset = pFile->offset = pFile->offset + lDistanceToMove;		
		}
		else
		{
				seekNegative = 1;
		}
	}

	if(seekNegative)
	{
			SetLastError(ERROR_NEGATIVE_SEEK);
			
	}

	yfsd_UnlockYAFFS();

	RETAILMSG (MSGSTATE, (L"YAFFS::SetFilePtr method %d distance %d high %X oldpos %d newpos %d\r\n",
		                  dwMoveMethod,lDistanceToMove,pDistanceToMoveHigh,oldPos,offset));

	return offset;

}

DWORD YFSD_GetFileSize( 
	PFILE pFile, 
	PDWORD pFileSizeHigh )
{
	int fileSize;
	
	RETAILMSG (MSGSTATE, (L"YAFFS::GetFileSize high %X\r\n",pFileSizeHigh));
	

	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return -1;
	}

	yfsd_LockYAFFS();

	fileSize = yaffs_GetObjectFileLength(pFile->obj);

	yfsd_UnlockYAFFS();
	if(pFileSizeHigh)
		 *pFileSizeHigh = 0;

	return fileSize;

}


BOOL YFSD_GetFileInformationByHandle( 
	PFILE pFile,
	PBY_HANDLE_FILE_INFORMATION pFileInfo )
{
	RETAILMSG (MSGSTATE, (L"YAFFS::GetFileInfoByHandle\r\n"));

	if(!pFile || !pFile->obj || !pFileInfo)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	yfsd_LockYAFFS();

	pFileInfo->dwFileAttributes = yfsd_GetObjectWinAttributes(pFile->obj);
	yfsd_U32sToWinFileTime(pFile->obj->win_ctime,&pFileInfo->ftCreationTime);
	yfsd_U32sToWinFileTime(pFile->obj->win_atime,&pFileInfo->ftLastAccessTime);
	yfsd_U32sToWinFileTime(pFile->obj->win_mtime,&pFileInfo->ftLastWriteTime);
	pFileInfo->dwVolumeSerialNumber = 0; //todo is this OK? 
	pFileInfo->nFileSizeHigh = 0;
	pFileInfo->nFileSizeLow = yaffs_GetObjectFileLength(pFile->obj); 
	pFileInfo->nNumberOfLinks = 1; // only primary link supported like FAT
	pFileInfo->nFileIndexHigh = 0; 
	pFileInfo->nFileIndexLow = pFile->obj->objectId;
	pFileInfo->dwOID = (CEOID)(INVALID_HANDLE_VALUE);

	yfsd_UnlockYAFFS();

	return TRUE;
}

BOOL YFSD_FlushFileBuffers(PFILE pFile )
{
	WCHAR fpn[YFSD_FULL_PATH_NAME_SIZE];
	int nameExists = 0;
	yfsd_Volume *vol = NULL;
	DWORD attribs = 0;
	DWORD objSize = 0;
	DWORD mtime[2];


	RETAILMSG (MSGSTATE, (L"YAFFS::FlushFileBuffers\r\n"));

	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	yfsd_LockYAFFS();

	yaffs_FlushFile(pFile->obj,1);
	attribs = yfsd_GetObjectWinAttributes(pFile->obj);
	objSize = yaffs_GetObjectFileLength(pFile->obj);
	mtime[0] = pFile->obj->win_mtime[0];
	mtime[1] = pFile->obj->win_mtime[1];
	if(pFile->fullName)
	{
		wcscpy(fpn,pFile->fullName);
		nameExists = 1;
	}
	vol = pFile->myVolume;

	yfsd_UnlockYAFFS();
	
	if(vol && vol->shellFunction && nameExists)
	{
			FILECHANGEINFO fc;
		
			fc.cbSize = sizeof(FILECHANGEINFO);
			fc.wEventId = SHCNE_UPDATEITEM;
			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)fpn;
			fc.dwItem2 = 0;
			fc.dwAttributes = attribs;
			yfsd_U32sToWinFileTime(mtime,&fc.ftModified);
			fc.nFileSize = objSize;

			vol->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));
			//yfsd_ShellDirectoryChanged(vol,fpn);
	}

	
	return TRUE;
}

BOOL YFSD_GetFileTime( 
	PFILE pFile, 
	FILETIME *pCreation, 
	FILETIME *pLastAccess, 
	FILETIME *pLastWrite )
{

	RETAILMSG (MSGSTATE, (L"YAFFS::GetFileTime\r\n"));
	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	yfsd_LockYAFFS();

	if(pCreation) yfsd_U32sToWinFileTime(pFile->obj->win_ctime,pCreation);
	if(pLastAccess) yfsd_U32sToWinFileTime(pFile->obj->win_atime,pLastAccess);
	if(pLastWrite) yfsd_U32sToWinFileTime(pFile->obj->win_mtime,pLastWrite);

	yfsd_UnlockYAFFS();

	return TRUE;
}

BOOL YFSD_SetFileTime( 
	PFILE pFile, 
	CONST FILETIME *pCreation, 
	CONST FILETIME *pLastAccess, 
	CONST FILETIME *pLastWrite )
{
	WCHAR fpn[YFSD_FULL_PATH_NAME_SIZE];
	int nameExists = 0;
	int result = FALSE;
	yfsd_Volume *vol = NULL;
	DWORD attribs = 0;
	DWORD objSize = 0;
	DWORD mtime[2];

	
	RETAILMSG (MSGSTATE, (L"YAFFS::SetFileTime\r\n"));

	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}
	
	
	yfsd_LockYAFFS();

	if(pCreation) 
	{
		 yfsd_WinFileTimeToU32s(pCreation,pFile->obj->win_ctime);
		pFile->obj->dirty = 1;
	}
	if(pLastAccess)
	{
		yfsd_WinFileTimeToU32s(pLastAccess,pFile->obj->win_atime);
		pFile->obj->dirty = 1;
	}
	if(pLastWrite)
	{
		yfsd_WinFileTimeToU32s(pLastWrite,pFile->obj->win_mtime);
		pFile->obj->dirty = 1;
	}
	if(pCreation || pLastAccess || pLastWrite)
	{
		result = yaffs_FlushFile(pFile->obj,0);
	}

	if(result)
	{
		attribs = yfsd_GetObjectWinAttributes(pFile->obj);
		objSize = yaffs_GetObjectFileLength(pFile->obj);
		mtime[0] = pFile->obj->win_mtime[0];
		mtime[1] = pFile->obj->win_mtime[1];
		if(pFile->fullName)
		{
			wcscpy(fpn,pFile->fullName);
			nameExists = 1;
		}
		vol = pFile->myVolume;
	}

	yfsd_UnlockYAFFS();

	// Call shell function
	if(nameExists && result && vol && vol->shellFunction)
	{
			FILECHANGEINFO fc;
		
			fc.cbSize = sizeof(FILECHANGEINFO);
			fc.wEventId = SHCNE_UPDATEITEM;
			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)fpn;
			fc.dwItem2 = 0;
			fc.dwAttributes = attribs;
			yfsd_U32sToWinFileTime(mtime,&fc.ftModified);
			fc.nFileSize = objSize;

			vol->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));
			//yfsd_ShellDirectoryChanged(vol,fpn);
	}

	return TRUE;
}
   
BOOL YFSD_SetEndOfFile( 
PFILE pFile )
{

	WCHAR fpn[YFSD_FULL_PATH_NAME_SIZE];
	int nameExists = 0;
	yfsd_Volume *vol = NULL;
	DWORD attribs = 0;
	DWORD objSize = 0;
	DWORD mtime[2];
	static unsigned char zeros[512];

	int result;
	BOOL retVal = FALSE;

	RETAILMSG (MSGSTATE, (L"YAFFS::SetEOF\r\n"));

	if(!pFile || !pFile->obj)
	{
		SetLastError(ERROR_INVALID_HANDLE);
		return FALSE;
	}

	yfsd_LockYAFFS();
	result = yaffs_ResizeFile(pFile->obj,pFile->offset);

	RETAILMSG (MSGSTATE, (L"YAFFS::SetEOF resizing to %d, result %d\r\n",pFile->offset,result));

	// Resize only works if we're shortening the file.
	// If the result is shorter than the offset, then we need to write zeros....
	// 
	if(result != pFile->offset)
	{
		if(result < pFile->offset)
		{

			int nBytes = pFile->offset - result;
			int thisWriteSize;
			int written;
			BOOL ok = TRUE;

			memset(zeros,0,512);

			pFile->offset = result;
			RETAILMSG (MSGSTATE, (L"YAFFS::SetEOF expanding file by %d bytes\r\n",nBytes));
			while(nBytes > 0 && ok)
			{
				thisWriteSize = (nBytes > 512) ? 512  : nBytes;

				ok = yfsd_DoWriteFile(pFile,zeros,thisWriteSize,&written);	
				if(written != thisWriteSize)
				{
					ok = FALSE;
				}

				nBytes -= thisWriteSize;
			}

			retVal = ok;
		}
		else
		{

			SetLastError(ERROR_ACCESS_DENIED);
			retVal = FALSE;
		}
	}
	else
	{
		retVal = TRUE;
	}
	if(retVal)
	{
		attribs = yfsd_GetObjectWinAttributes(pFile->obj);
		objSize = yaffs_GetObjectFileLength(pFile->obj);
		mtime[0] = pFile->obj->win_mtime[0];
		mtime[1] = pFile->obj->win_mtime[1];
		if(pFile->fullName)
		{
			wcscpy(fpn,pFile->fullName);
			nameExists = 1;
		}
		vol = pFile->myVolume;
	}


	yfsd_UnlockYAFFS();

	if(nameExists && retVal && vol && vol->shellFunction)
	{
			FILECHANGEINFO fc;
		
			fc.cbSize = sizeof(FILECHANGEINFO);
			fc.wEventId = SHCNE_UPDATEITEM;
			fc.uFlags = SHCNF_PATH;
			fc.dwItem1 = (DWORD)fpn;
			fc.dwItem2 = 0;
			fc.dwAttributes = attribs;
			yfsd_U32sToWinFileTime(mtime,&fc.ftModified);
			fc.nFileSize = objSize;

			vol->shellFunction(&fc);
			RETAILMSG (MSGSTATE, (L"YAFFS::shell function called\r\n"));
			//yfsd_ShellDirectoryChanged(vol,fpn);
	}

	RETAILMSG (MSGSTATE, (L"YAFFS::SetEOF file size %d\r\n",yaffs_GetObjectFileLength(pFile->obj)));


	
	return retVal;
}

BOOL YFSD_DeviceIoControl( 
	PFILE pFile, 
	DWORD dwIoControlCode, 
	PVOID pInBuf, 
	DWORD nInBufSiz