haiku.git

/*
 * Copyright 2003-2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <kernel_daemon.h>

#include <new>
#include <stdlib.h>

#include <KernelExport.h>

#include <elf.h>
#include <lock.h>
#include <util/AutoLock.h>
#include <util/DoublyLinkedList.h>


struct daemon : DoublyLinkedListLinkImpl<struct daemon> {
	daemon_hook	function;
	void*		arg;
	int32		frequency;
	bigtime_t	last;
	bool		executing;
};


typedef DoublyLinkedList<struct daemon> DaemonList;


class KernelDaemon {
public:
			status_t			Init(const char* name);

			status_t			Register(daemon_hook function, void* arg,
									int frequency);
			status_t			Unregister(daemon_hook function, void* arg);

			void				Dump();

private:
	static	status_t			_DaemonThreadEntry(void* data);
			struct daemon*		_NextDaemon(struct daemon& marker);
			status_t			_DaemonThread();
			bool				_IsDaemon() const;

private:
			recursive_lock		fLock;
			DaemonList			fDaemons;
			sem_id				fDaemonAddedSem;
			thread_id			fThread;
			ConditionVariable	fUnregisterCondition;
			int32				fUnregisterWaiters;
};


static KernelDaemon sKernelDaemon;
static KernelDaemon sResourceResizer;


status_t
KernelDaemon::Init(const char* name)
{
	recursive_lock_init(&fLock, name);

	fDaemonAddedSem = create_sem(0, "kernel daemon added");
	if (fDaemonAddedSem < 0)
		return fDaemonAddedSem;

	fThread = spawn_kernel_thread(&_DaemonThreadEntry, name, B_LOW_PRIORITY,
		this);
	if (fThread < 0)
		return fThread;

	resume_thread(fThread);
	fUnregisterCondition.Init(this, name);

	return B_OK;
}


status_t
KernelDaemon::Register(daemon_hook function, void* arg, int frequency)
{
	if (function == NULL || frequency < 1)
		return B_BAD_VALUE;

	struct ::daemon* daemon = new(std::nothrow) (struct ::daemon);
	if (daemon == NULL)
		return B_NO_MEMORY;

	daemon->function = function;
	daemon->arg = arg;
	daemon->frequency = frequency;
	daemon->last = 0;
	daemon->executing = false;

	RecursiveLocker locker(fLock);
	fDaemons.Add(daemon);
	locker.Unlock();

	release_sem(fDaemonAddedSem);
	return B_OK;
}


status_t
KernelDaemon::Unregister(daemon_hook function, void* arg)
{
	RecursiveLocker locker(fLock);

	DaemonList::Iterator iterator = fDaemons.GetIterator();

	// search for the daemon and remove it from the list
	while (iterator.HasNext()) {
		struct daemon* daemon = iterator.Next();

		if (daemon->function == function && daemon->arg == arg) {
			// found it!
			if (!_IsDaemon()) {
				// wait if it's busy
				while (daemon->executing) {
					fUnregisterWaiters++;
					fUnregisterCondition.Wait(locker.Get());
				}
			}

			iterator.Remove();
			delete daemon;
			return B_OK;
		}
	}

	return B_ENTRY_NOT_FOUND;
}


void
KernelDaemon::Dump()
{
	DaemonList::Iterator iterator = fDaemons.GetIterator();

	while (iterator.HasNext()) {
		struct daemon* daemon = iterator.Next();
		const char* imageName;
		const char* symbol;
		bool exactMatch;

		status_t status = elf_debug_lookup_symbol_address(
			(addr_t)daemon->function, NULL, &symbol, &imageName, &exactMatch);
		if (status == B_OK && exactMatch) {
			if (strchr(imageName, '/') != NULL)
				imageName = strrchr(imageName, '/') + 1;

			kprintf("\t%s:%s (%p)", imageName, symbol, daemon->function);
		} else
			kprintf("\t%p", daemon->function);

		kprintf(", arg %p%s\n", daemon->arg,
			daemon->executing ? " (running) " : "");
	}
}


/*static*/ status_t
KernelDaemon::_DaemonThreadEntry(void* data)
{
	return ((KernelDaemon*)data)->_DaemonThread();
}


struct daemon*
KernelDaemon::_NextDaemon(struct daemon& marker)
{
	struct daemon* daemon;

	if (marker.arg == NULL) {
		// The marker is not part of the list yet, just return the first entry
		daemon = fDaemons.Head();
	} else {
		daemon = fDaemons.GetNext(&marker);
		fDaemons.Remove(&marker);
	}

	marker.arg = daemon;

	if (daemon != NULL)
		fDaemons.InsertAfter(daemon, &marker);

	return daemon;
}


status_t
KernelDaemon::_DaemonThread()
{
	struct daemon marker;
	const bigtime_t start = system_time(), iterationToUsecs = 100 * 1000;

	marker.arg = NULL;

	while (true) {
		RecursiveLocker locker(fLock);

		bigtime_t timeout = INT64_MAX;

		// iterate through the list and execute each daemon if needed
		while (struct daemon* daemon = _NextDaemon(marker)) {
			daemon->executing = true;
			locker.Unlock();

			const bigtime_t time = system_time();
			bigtime_t next = (daemon->last +
				(daemon->frequency * iterationToUsecs)) - time;
			if (next <= 0) {
				daemon->last = time;
				next = daemon->frequency * iterationToUsecs;
				daemon->function(daemon->arg, (time - start) / iterationToUsecs);
			}
			timeout = min_c(timeout, next);

			locker.Lock();
			daemon->executing = false;
		}

		if (fUnregisterWaiters != 0) {
			fUnregisterCondition.NotifyAll();
			fUnregisterWaiters = 0;
		}

		locker.Unlock();

		acquire_sem_etc(fDaemonAddedSem, 1, B_RELATIVE_TIMEOUT, timeout);
	}

	return B_OK;
}


bool
KernelDaemon::_IsDaemon() const
{
	return find_thread(NULL) == fThread;
}


// #pragma mark -


static int
dump_daemons(int argc, char** argv)
{
	kprintf("kernel daemons:\n");
	sKernelDaemon.Dump();

	kprintf("\nresource resizers:\n");
	sResourceResizer.Dump();

	return 0;
}


//	#pragma mark -


extern "C" status_t
register_kernel_daemon(daemon_hook function, void* arg, int frequency)
{
	return sKernelDaemon.Register(function, arg, frequency);
}


extern "C" status_t
unregister_kernel_daemon(daemon_hook function, void* arg)
{
	return sKernelDaemon.Unregister(function, arg);
}


extern "C" status_t
register_resource_resizer(daemon_hook function, void* arg, int frequency)
{
	return sResourceResizer.Register(function, arg, frequency);
}


extern "C" status_t
unregister_resource_resizer(daemon_hook function, void* arg)
{
	return sResourceResizer.Unregister(function, arg);
}


//	#pragma mark -


extern "C" status_t
kernel_daemon_init(void)
{
	new(&sKernelDaemon) KernelDaemon;
	if (sKernelDaemon.Init("kernel daemon") != B_OK)
		panic("kernel_daemon_init(): failed to init kernel daemon");

	new(&sResourceResizer) KernelDaemon;
	if (sResourceResizer.Init("resource resizer") != B_OK)
		panic("kernel_daemon_init(): failed to init resource resizer");

	add_debugger_command("daemons", dump_daemons,
		"Shows registered kernel daemons.");
	return B_OK;
}