/* EDF common data structures and utility functions shared by all EDF 
 * based scheduler plugins
 */

/* CLEANUP: Add comments and make it less messy.
 *
 */

#ifndef __UNC_EDF_COMMON_H__
#define __UNC_EDF_COMMON_H__

struct _edf_domain;

typedef int (*edf_check_resched_needed_t)(struct _edf_domain *edf);
typedef struct _edf_domain {
	/* runnable rt tasks are in here */
	rwlock_t 			ready_lock;
	struct list_head 		ready_queue; 

	/* real-time tasks waiting for release are in here */
	spinlock_t 			release_lock;
	struct list_head 		release_queue;

	/* how do we check if we need to kick another CPU? */
	edf_check_resched_needed_t	check_resched;
} edf_domain_t;

#define next_ready(edf) \
	(list_entry((edf)->ready_queue.next, struct task_struct, rt_list))

void edf_domain_init(edf_domain_t *edf, edf_check_resched_needed_t f);

int edf_higher_prio(struct task_struct* first, 
		    struct task_struct* second);

void __add_ready(edf_domain_t* edf, struct task_struct *new);
void __add_release(edf_domain_t* edf, struct task_struct *task);

struct task_struct* __take_ready(edf_domain_t* edf);
struct task_struct* __peek_ready(edf_domain_t* edf);


void try_release_pending(edf_domain_t* edf);
void __release_pending(edf_domain_t* edf);
void __prepare_new_release(struct task_struct *t, jiffie_t start);
#define prepare_new_release(t) __prepare_new_release(t, jiffies)
void prepare_for_next_period(struct task_struct *t);
void prepare_new_releases(edf_domain_t *edf, jiffie_t start);
void __prepare_new_releases(edf_domain_t *edf, jiffie_t start);
int preemption_needed(edf_domain_t* edf, struct task_struct *t);
long edf_sleep_next_period(void);

#define job_completed(t) (!is_be(t) && \
	(t)->rt_param.times.exec_time == (t)->rt_param.basic_params.exec_cost)

static inline void add_ready(edf_domain_t* edf, struct task_struct *new)
{
	unsigned long flags;	
	/* first we need the write lock for edf_ready_queue */	
	write_lock_irqsave(&edf->ready_lock, flags);
	__add_ready(edf, new);
	write_unlock_irqrestore(&edf->ready_lock, flags);
}

static inline void add_release(edf_domain_t* edf, struct task_struct *task)
{
	unsigned long flags;	
	/* first we need the write lock for edf_ready_queue */	
	spin_lock_irqsave(&edf->release_lock, flags);
	__add_release(edf, task);
	spin_unlock_irqrestore(&edf->release_lock, flags);
}

int edf_set_hp_task(struct pi_semaphore *sem);
int edf_set_hp_cpu_task(struct pi_semaphore *sem, int cpu);

#endif