haiku.git

// FDManager.cpp

#include <new>

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/resource.h>

#include <Directory.h>
#include <Entry.h>
#include <File.h>
#include <fs_attr.h>

#include "AutoLocker.h"
#include "FDManager.h"

// FD constants
static const int32 kDefaultFDLimit = 512;
static const int32 kFDLimitIncrement = 128;


// constructor
FDManager::FDManager()
	: fLock("FD manager"),
	  fFDLimit(kDefaultFDLimit)
{
}

// destructor
FDManager::~FDManager()
{
}

// Init
status_t
FDManager::Init()
{
	// ask for a bunch more file descriptors
	struct rlimit rl;
	rl.rlim_cur = fFDLimit;
	rl.rlim_max = RLIM_SAVED_MAX;
	if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
		return errno;

	return B_OK;
}

// CreateDefault
status_t
FDManager::CreateDefault()
{
	if (sManager)
		return B_OK;

	FDManager* manager = new(std::nothrow) FDManager;
	if (!manager)
		return B_NO_MEMORY;

	status_t error = manager->Init();
	if (error != B_OK) {
		delete manager;
		return error;
	}

	sManager = manager;
	return B_OK;
}

// DeleteDefault
void
FDManager::DeleteDefault()
{
	if (sManager) {
		delete sManager;
		sManager = NULL;
	}
}

// GetDefault
FDManager*
FDManager::GetDefault()
{
	return sManager;
}

// SetDirectory
status_t
FDManager::SetDirectory(BDirectory* directory, const node_ref* ref)
{
	status_t error = directory->SetTo(ref);

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();
		error = directory->SetTo(ref);
	}

	return error;
}

// SetEntry
status_t
FDManager::SetEntry(BEntry* entry, const entry_ref* ref)
{
	status_t error = entry->SetTo(ref);

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();
		error = entry->SetTo(ref);
	}

	return error;
}

// SetEntry
status_t
FDManager::SetEntry(BEntry* entry, const char* path)
{
	status_t error = entry->SetTo(path);

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();
		error = entry->SetTo(path);
	}

	return error;
}

// SetFile
status_t
FDManager::SetFile(BFile* file, const char* path, uint32 openMode)
{
	status_t error = file->SetTo(path, openMode);

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();
		error = file->SetTo(path, openMode);
	}

	return error;
}

// SetNode
status_t
FDManager::SetNode(BNode* node, const entry_ref* ref)
{
	status_t error = node->SetTo(ref);

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();
		error = node->SetTo(ref);
	}

	return error;
}

// Open
status_t
FDManager::Open(const char* path, uint32 openMode, mode_t mode, int& fd)
{
	status_t error = B_OK;
	fd = open(path, openMode, mode);
	if (fd < 0)
		error = errno;

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();

		error = B_OK;
		fd = open(path, openMode, mode);
		if (fd < 0)
			error = errno;
	}

	return error;
}

// OpenDir
status_t
FDManager::OpenDir(const char* path, DIR*& dir)
{
	status_t error = B_OK;
	dir = opendir(path);
	if (!dir)
		error = errno;

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();

		error = B_OK;
		dir = opendir(path);
		if (!dir)
			error = errno;
	}

	return error;
}

// OpenAttrDir
status_t
FDManager::OpenAttrDir(const char* path, DIR*& dir)
{
	status_t error = B_OK;
	dir = fs_open_attr_dir(path);
	if (!dir)
		error = errno;

	if (error == B_NO_MORE_FDS) {
		GetDefault()->_IncreaseLimit();

		error = B_OK;
		dir = fs_open_attr_dir(path);
		if (!dir)
			error = errno;
	}

	return error;
}

// _IncreaseLimit
status_t
FDManager::_IncreaseLimit()
{
	AutoLocker<Locker> _(fLock);

	int32 newLimit = fFDLimit + kFDLimitIncrement;

	struct rlimit rl;
	rl.rlim_cur = newLimit;
	rl.rlim_max = RLIM_SAVED_MAX;
	if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
		return errno;

	fFDLimit = newLimit;

	return B_OK;
}


// sManager
FDManager* FDManager::sManager = NULL;