haiku.git

/*
 * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "RequestThread.h"

#include <new>

#include <TLS.h>

#include "FileSystem.h"
#include "ServerDefs.h"
#include "UserlandRequestHandler.h"
#include "Volume.h"


static const int32 sTLSVariable = tls_allocate();


// constructor
RequestThreadContext::RequestThreadContext(Volume* volume,
	KernelRequest* request)
	:
	fPreviousContext(NULL),
	fThread(NULL),
	fVolume(volume),
	fRequest(request)
{
	fThread = RequestThread::GetCurrentThread();
	if (fThread) {
		fPreviousContext = fThread->GetContext();
		fThread->SetContext(this);
	}

	volume->GetFileSystem()->InitRequestThreadContext(this);
}

// destructor
RequestThreadContext::~RequestThreadContext()
{
	if (fThread)
		fThread->SetContext(fPreviousContext);
}

// GetThread
RequestThread*
RequestThreadContext::GetThread() const
{
	return fThread;
}

// GetVolume
UserlandFS::Volume*
RequestThreadContext::GetVolume() const
{
	return fVolume;
}


// RequestThread

// constructor
RequestThread::RequestThread()
	: fThread(-1),
	  fFileSystem(NULL),
	  fPort(NULL),
	  fContext(NULL),
	  fTerminating(false)
{
}

// destructor
RequestThread::~RequestThread()
{
	PrepareTermination();
	Terminate();
	delete fPort;
}

// Init
status_t
RequestThread::Init(FileSystem* fileSystem)
{
	if (!fileSystem)
		return B_BAD_VALUE;
	// create the port
	fPort = new(std::nothrow) RequestPort(kRequestPortSize);
	if (!fPort)
		return B_NO_MEMORY;
	status_t error = fPort->InitCheck();
	if (error != B_OK)
		return error;
	// spawn the thread
	fThread = spawn_thread(_ThreadEntry, "request thread", B_NORMAL_PRIORITY,
		this);
	if (fThread < 0)
		return fThread;
	fFileSystem = fileSystem;
	return B_OK;
}

// Run
void
RequestThread::Run()
{
	resume_thread(fThread);
}

// PrepareTermination
void
RequestThread::PrepareTermination()
{
	if (fTerminating)
		return;
	fTerminating = true;
	if (fPort)
		fPort->Close();
}

// Terminate
void
RequestThread::Terminate()
{
	if (fThread >= 0) {
		int32 result;
		wait_for_thread(fThread, &result);
		fThread = -1;
	}
}

// GetPortInfo
const Port::Info*
RequestThread::GetPortInfo() const
{
	return (fPort ? fPort->GetPortInfo() : NULL);
}

// GetFileSystem
UserlandFS::FileSystem*
RequestThread::GetFileSystem() const
{
	return fFileSystem;
}

// GetPort
RequestPort*
RequestThread::GetPort() const
{
	return fPort;
}

// GetContext
RequestThreadContext*
RequestThread::GetContext() const
{
	return fContext;
}

// GetCurrentThread
RequestThread*
RequestThread::GetCurrentThread()
{
	return (RequestThread*)tls_get(sTLSVariable);
}

// SetContext
void
RequestThread::SetContext(RequestThreadContext* context)
{
	fContext = context;
}

// _ThreadEntry
int32
RequestThread::_ThreadEntry(void* data)
{
	return ((RequestThread*)data)->_ThreadLoop();
}

// _ThreadLoop
int32
RequestThread::_ThreadLoop()
{
	tls_set(sTLSVariable, this);
	if (!fTerminating) {
		UserlandRequestHandler handler(fFileSystem, false);
		return fPort->HandleRequests(&handler);
	}
	return B_OK;
}