Print done when done.

1 files changed, 415 insertions, 0 deletions

diff --git a/indra/llvfs/llvfile.cpp b/indra/llvfs/llvfile.cpp
new file mode 100644
index 0000000000..36ac569d02
--- /dev/null
+++ b/indra/llvfs/llvfile.cpp
@@ -0,0 +1,415 @@
+/** 
+ * @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);
+	
+	// FIXME
+	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;
+	
+	// FIXME: 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);
+	}
+}