path: root/indra/llvfs/llvfile.cpp

/** 
 * @file llvfile.cpp
 * @brief Implementation of virtual file
 *
 * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
 * $License$
 */

#include "linden_common.h"

#include "llvfile.h"

#include "llerror.h"
#include "llthread.h"
#include "llvfs.h"

const S32 LLVFile::READ			= 0x00000001;
const S32 LLVFile::WRITE		= 0x00000002;
const S32 LLVFile::READ_WRITE	= 0x00000003;  // LLVFile::READ & LLVFile::WRITE
const S32 LLVFile::APPEND		= 0x00000006;  // 0x00000004 & LLVFile::WRITE

//----------------------------------------------------------------------------
LLVFSThread* LLVFile::sVFSThread = NULL;
BOOL LLVFile::sAllocdVFSThread = FALSE;
BOOL LLVFile::ALLOW_ASYNC = TRUE;
//----------------------------------------------------------------------------

//============================================================================

LLVFile::LLVFile(LLVFS *vfs, const LLUUID &file_id, const LLAssetType::EType file_type, S32 mode)
{
	mFileType =	file_type;

	mFileID =	file_id;
	mPosition = 0;
	mMode =		mode;
	mVFS =		vfs;

	mBytesRead = 0;
	mHandle = LLVFSThread::nullHandle();
	mPriority = 128.f;

	mVFS->incLock(mFileID, mFileType, VFSLOCK_OPEN);
}

LLVFile::~LLVFile()
{
	if (!isReadComplete())
	{
		if (mHandle != LLVFSThread::nullHandle())
		{
			if (!(mMode & LLVFile::WRITE))
			{
				// 			llwarns << "Destroying LLVFile with pending async read/write, aborting..." << llendl;
				sVFSThread->abortRequest(mHandle, LLVFSThread::AUTO_COMPLETE);
			}
			else // WRITE
			{
				sVFSThread->setFlags(mHandle, LLVFSThread::AUTO_COMPLETE);
			}
		}
	}
	mVFS->decLock(mFileID, mFileType, VFSLOCK_OPEN);
}

BOOL LLVFile::read(U8 *buffer, S32 bytes, BOOL async, F32 priority)
{
	if (! (mMode & READ))
	{
		llwarns << "Attempt to read from file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << llendl;
		return FALSE;
	}

	if (mHandle != LLVFSThread::nullHandle())
	{
		llwarns << "Attempt to read from vfile object " << mFileID << " with pending async operation" << llendl;
		return FALSE;
	}
	mPriority = priority;
	
	BOOL success = TRUE;

	// We can't do a read while there are pending async writes
	waitForLock(VFSLOCK_APPEND);
	
	// *FIX: (???)
	if (async)
	{
		mHandle = sVFSThread->read(mVFS, mFileID, mFileType, buffer, mPosition, bytes, threadPri());
	}
	else
	{
		// We can't do a read while there are pending async writes on this file
		mBytesRead = sVFSThread->readImmediate(mVFS, mFileID, mFileType, buffer, mPosition, bytes);
		mPosition += mBytesRead;
		if (! mBytesRead)
		{
			success = FALSE;
		}
	}

	return success;
}

//static
U8* LLVFile::readFile(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, S32* bytes_read)
{
	U8 *data;
	LLVFile file(vfs, uuid, type, LLVFile::READ);
	S32 file_size = file.getSize();
	if (file_size == 0)
	{
		// File is empty.
		data = NULL;
	}
	else
	{
		data = new U8[file_size];
		file.read(data, file_size);
		
		if (file.getLastBytesRead() != (S32)file_size)
		{
			delete[] data;
			data = NULL;
			file_size = 0;
		}
	}
	if (bytes_read)
	{
		*bytes_read = file_size;
	}
	return data;
}
	
void LLVFile::setReadPriority(const F32 priority)
{
	mPriority = priority;
	if (mHandle != LLVFSThread::nullHandle())
	{
		sVFSThread->setPriority(mHandle, threadPri());
	}
}

BOOL LLVFile::isReadComplete()
{
	BOOL res = TRUE;
	if (mHandle != LLVFSThread::nullHandle())
	{
		LLVFSThread::Request* req = (LLVFSThread::Request*)sVFSThread->getRequest(mHandle);
		LLVFSThread::status_t status = req->getStatus();
		if (status == LLVFSThread::STATUS_COMPLETE)
		{
			mBytesRead = req->getBytesRead();
			mPosition += mBytesRead;
			sVFSThread->completeRequest(mHandle);
			mHandle = LLVFSThread::nullHandle();
		}
		else
		{
			res = FALSE;
		}
	}
	return res;
}

S32 LLVFile::getLastBytesRead()
{
	return mBytesRead;
}

BOOL LLVFile::eof()
{
	return mPosition >= getSize();
}

BOOL LLVFile::write(const U8 *buffer, S32 bytes)
{
	if (! (mMode & WRITE))
	{
		llwarns << "Attempt to write to file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << llendl;
	}
	if (mHandle != LLVFSThread::nullHandle())
	{
		llerrs << "Attempt to write to vfile object " << mFileID << " with pending async operation" << llendl;
		return FALSE;
	}
	BOOL success = TRUE;
	
	// *FIX: allow async writes? potential problem wit mPosition...
	if (mMode == APPEND) // all appends are async (but WRITEs are not)
	{	
		U8* writebuf = new U8[bytes];
		memcpy(writebuf, buffer, bytes);
		S32 offset = -1;
		mHandle = sVFSThread->write(mVFS, mFileID, mFileType,
									writebuf, offset, bytes,
									LLVFSThread::AUTO_COMPLETE | LLVFSThread::AUTO_DELETE);
		mHandle = LLVFSThread::nullHandle(); // AUTO_COMPLETE means we don't track this
	}
	else
	{
		// We can't do a write while there are pending reads or writes on this file
		waitForLock(VFSLOCK_READ);
		waitForLock(VFSLOCK_APPEND);

		S32 pos = (mMode & APPEND) == APPEND ? -1 : mPosition;

		S32 wrote = sVFSThread->writeImmediate(mVFS, mFileID, mFileType, (U8*)buffer, pos, bytes);

		mPosition += wrote;
		
		if (wrote < bytes)
		{	
			llwarns << "Tried to write " << bytes << " bytes, actually wrote " << wrote << llendl;

			success = FALSE;
		}
	}
	return success;
}

//static
BOOL LLVFile::writeFile(const U8 *buffer, S32 bytes, LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
{
	LLVFile file(vfs, uuid, type, LLVFile::WRITE);
	file.setMaxSize(bytes);
	return file.write(buffer, bytes);
}

BOOL LLVFile::seek(S32 offset, S32 origin)
{
	if (mMode == APPEND)
	{
		llwarns << "Attempt to seek on append-only file" << llendl;
		return FALSE;
	}

	if (-1 == origin)
	{
		origin = mPosition;
	}

	S32 new_pos = origin + offset;

	S32 size = getSize(); // Calls waitForLock(VFSLOCK_APPEND)

	if (new_pos > size)
	{
		llwarns << "Attempt to seek past end of file" << llendl;

		mPosition = size;
		return FALSE;
	}
	else if (new_pos < 0)
	{
		llwarns << "Attempt to seek past beginning of file" << llendl;

		mPosition = 0;
		return FALSE;
	}

	mPosition = new_pos;
	return TRUE;
}

S32 LLVFile::tell() const
{
	return mPosition;
}

S32 LLVFile::getSize()
{
	waitForLock(VFSLOCK_APPEND);
	S32 size = mVFS->getSize(mFileID, mFileType);

	return size;
}

S32 LLVFile::getMaxSize()
{
	S32 size = mVFS->getMaxSize(mFileID, mFileType);

	return size;
}

BOOL LLVFile::setMaxSize(S32 size)
{
	if (! (mMode & WRITE))
	{
		llwarns << "Attempt to change size of file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << llendl;

		return FALSE;
	}

	if (!mVFS->checkAvailable(size))
	{
		LLFastTimer t(LLFastTimer::FTM_VFILE_WAIT);
		S32 count = 0;
		while (sVFSThread->getPending() > 1000)
		{
			if (count % 100 == 0)
			{
				llinfos << "VFS catching up... Pending: " << sVFSThread->getPending() << llendl;
			}
			if (sVFSThread->isPaused())
			{
				sVFSThread->updateQueue(0);
			}
			ms_sleep(10);
		}
	}
	return mVFS->setMaxSize(mFileID, mFileType, size);
}

BOOL LLVFile::rename(const LLUUID &new_id, const LLAssetType::EType new_type)
{
	if (! (mMode & WRITE))
	{
		llwarns << "Attempt to rename file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << llendl;

		return FALSE;
	}

	if (mHandle != LLVFSThread::nullHandle())
	{
		llwarns << "Renaming file with pending async read" << llendl;
	}

	waitForLock(VFSLOCK_READ);
	waitForLock(VFSLOCK_APPEND);

	// we need to release / replace our own lock
	// since the renamed file will inherit locks from the new name
	mVFS->decLock(mFileID, mFileType, VFSLOCK_OPEN);
	mVFS->renameFile(mFileID, mFileType, new_id, new_type);
	mVFS->incLock(new_id, new_type, VFSLOCK_OPEN);
	
	mFileID = new_id;
	mFileType = new_type;

	return TRUE;
}

BOOL LLVFile::remove()
{
// 	llinfos << "Removing file " << mFileID << llendl;
	
	if (! (mMode & WRITE))
	{
		// Leaving paranoia warning just because this should be a very infrequent
		// operation.
		llwarns << "Remove file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << llendl;
	}

	if (mHandle != LLVFSThread::nullHandle())
	{
		llwarns << "Removing file with pending async read" << llendl;
	}
	
	// why not seek back to the beginning of the file too?
	mPosition = 0;

	waitForLock(VFSLOCK_READ);
	waitForLock(VFSLOCK_APPEND);
	mVFS->removeFile(mFileID, mFileType);

	return TRUE;
}

// static
void LLVFile::initClass(LLVFSThread* vfsthread)
{
	if (!vfsthread)
	{
		if (LLVFSThread::sLocal != NULL)
		{
			vfsthread = LLVFSThread::sLocal;
		}
		else
		{
			vfsthread = new LLVFSThread();
			sAllocdVFSThread = TRUE;
		}
	}
	sVFSThread = vfsthread;
}

// static
void LLVFile::cleanupClass()
{
	if (sAllocdVFSThread)
	{
		delete sVFSThread;
	}
	sVFSThread = NULL;
}

bool LLVFile::isLocked(EVFSLock lock)
{
	return mVFS->isLocked(mFileID, mFileType, lock) ? true : false;
}

void LLVFile::waitForLock(EVFSLock lock)
{
	LLFastTimer t(LLFastTimer::FTM_VFILE_WAIT);
	// spin until the lock clears
	while (isLocked(lock))
	{
		if (sVFSThread->isPaused())
		{
			sVFSThread->updateQueue(0);
		}
		ms_sleep(1);
	}
}