/*
 * Copyright 2014, Paweł Dziepak, pdziepak@quarnos.org.
 * Distributed under the terms of the MIT License.
 */
#ifndef KERNEL_SCHEDULER_LOCKING_H
#define KERNEL_SCHEDULER_LOCKING_H


#include <util/AutoLock.h>

#include "scheduler_cpu.h"


namespace Scheduler {


class CPURunQueueLocking {
public:
	inline bool Lock(CPUEntry* cpu)
	{
		cpu->LockRunQueue();
		return true;
	}

	inline void Unlock(CPUEntry* cpu)
	{
		cpu->UnlockRunQueue();
	}
};

typedef AutoLocker<CPUEntry, CPURunQueueLocking> CPURunQueueLocker;


class CoreRunQueueLocking {
public:
	inline bool Lock(CoreEntry* core)
	{
		core->LockRunQueue();
		return true;
	}

	inline void Unlock(CoreEntry* core)
	{
		core->UnlockRunQueue();
	}
};

typedef AutoLocker<CoreEntry, CoreRunQueueLocking> CoreRunQueueLocker;

class CoreCPUHeapLocking {
public:
	inline bool Lock(CoreEntry* core)
	{
		core->LockCPUHeap();
		return true;
	}

	inline void Unlock(CoreEntry* core)
	{
		core->UnlockCPUHeap();
	}
};

typedef AutoLocker<CoreEntry, CoreCPUHeapLocking> CoreCPUHeapLocker;

class SchedulerModeLocking {
public:
	bool Lock(int* /* lockable */)
	{
		CPUEntry::GetCPU(smp_get_current_cpu())->EnterScheduler();
		return true;
	}

	void Unlock(int* /* lockable */)
	{
		CPUEntry::GetCPU(smp_get_current_cpu())->ExitScheduler();
	}
};

class SchedulerModeLocker :
	public AutoLocker<int, SchedulerModeLocking> {
public:
	SchedulerModeLocker(bool alreadyLocked = false, bool lockIfNotLocked = true)
		:
		AutoLocker<int, SchedulerModeLocking>(&fDummy, alreadyLocked,
			lockIfNotLocked)
	{
	}

private:
	int		fDummy;
};

class InterruptsSchedulerModeLocking {
public:
	bool Lock(int* lockable)
	{
		*lockable = disable_interrupts();
		CPUEntry::GetCPU(smp_get_current_cpu())->EnterScheduler();
		return true;
	}

	void Unlock(int* lockable)
	{
		CPUEntry::GetCPU(smp_get_current_cpu())->ExitScheduler();
		restore_interrupts(*lockable);
	}
};

class InterruptsSchedulerModeLocker :
	public AutoLocker<int, InterruptsSchedulerModeLocking> {
public:
	InterruptsSchedulerModeLocker(bool alreadyLocked = false,
		bool lockIfNotLocked = true)
		:
		AutoLocker<int, InterruptsSchedulerModeLocking>(&fState, alreadyLocked,
			lockIfNotLocked)
	{
	}

private:
	int		fState;
};

class InterruptsBigSchedulerLocking {
public:
	bool Lock(int* lockable)
	{
		*lockable = disable_interrupts();
		for (int32 i = 0; i < smp_get_num_cpus(); i++)
			CPUEntry::GetCPU(i)->LockScheduler();
		return true;
	}

	void Unlock(int* lockable)
	{
		for (int32 i = 0; i < smp_get_num_cpus(); i++)
			CPUEntry::GetCPU(i)->UnlockScheduler();
		restore_interrupts(*lockable);
	}
};

class InterruptsBigSchedulerLocker :
	public AutoLocker<int, InterruptsBigSchedulerLocking> {
public:
	InterruptsBigSchedulerLocker()
		:
		AutoLocker<int, InterruptsBigSchedulerLocking>(&fState, false, true)
	{
	}

private:
	int		fState;
};


}	// namespace Scheduler


#endif	// KERNEL_SCHEDULER_LOCKING_H