kal_sched.h

Go to the documentation of this file.

#ifndef __KAL_TASK_H__
#define __KAL_TASK_H__

#include <linux/aquosa/qos_debug.h>

#ifdef QOS_KS

//#include <linux/autoconf.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/sched.h>
#include <linux/hardirq.h>

typedef struct task_struct kal_task_t;

typedef uid_t kal_uid_t;

typedef gid_t kal_gid_t;

#if LINUX_VERSION_CODE<KERNEL_VERSION(2,6,0)

#  define set_tsk_need_resched(tsk) do { (tsk)->need_resched = 1; } while (0)

#else /* LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,0) */

#  define for_each_task(t)         for_each_process(t)

#endif

#if LINUX_VERSION_CODE<KERNEL_VERSION(2,6,27)

# define current_uid()          (current->uid)
# define current_gid()          (current->gid)
# define current_euid()         (current->euid)
# define current_egid()         (current->egid)

# define task_uid(task)         ((task)->uid)
# define task_gid(task)         ((task)->gid)
# define task_euid(task)        ((task)->euid)
# define task_egid(task)        ((task)->egid)

#elif LINUX_VERSION_CODE>KERNEL_VERSION(2,6,28)

#  define task_gid(task)        (task_cred_xxx((task), gid))
#  define task_egid(task)       (task_cred_xxx((task), egid))

#endif

static inline kal_uid_t kal_get_current_uid(void)
{
  return current_uid();
}

static inline kal_uid_t kal_get_current_gid(void)
{
  return current_gid();
}

static inline kal_uid_t kal_task_get_uid(kal_task_t *p_task)
{
  return task_euid(p_task);
}

static inline kal_gid_t kal_task_get_gid(kal_task_t *p_task)
{
  return task_egid(p_task);
}

static inline kal_task_t *kal_task_current(void)
{
  return (kal_task_t *) current;
}

static inline void kal_task_link_data(kal_task_t *task, void *data) {
  task->private_data = data;
}

static inline void kal_task_unlink_data(kal_task_t *task) {
  task->private_data = NULL;
}

static inline void *kal_task_get_data(kal_task_t *task) {
  qos_chk_do(task != NULL, return NULL);
  return task->private_data;
}

static inline int kal_task_get_id(kal_task_t *task) {
  qos_chk(task != NULL);
  return task->pid;
}

static inline int kal_task_alive(struct task_struct *task) {
  return (task->flags & PF_EXITING) == 0;
}

#if LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,27)
#  define kal_find_task_by_pid find_task_by_vpid
#else
#  define kal_find_task_by_pid find_task_by_pid
#endif

typedef unsigned long kal_irq_state;
typedef spinlock_t kal_lock_t;

#define kal_lock_define(name) \
  spinlock_t name __cacheline_aligned = SPIN_LOCK_UNLOCKED

#define kal_spin_lock_irqsave(p_lock, p_state) do { \
  spin_lock_irqsave(p_lock, *p_state); \
  qos_log_debug("Acquired spinlock"); \
} while (0)

#define kal_spin_unlock_irqrestore(p_lock, p_state) do { \
  qos_log_debug("Releasing spinlock"); \
  spin_unlock_irqrestore(p_lock, *p_state); \
} while (0)

#define kal_atomic() (in_atomic() || irqs_disabled())

/* @todo maybe task_ready goes here ? */

#else /* !QOS_KS */

#include <sys/types.h>
#include <linux/types.h>
#include "kal_generic.h"
#include "qos_list.h"

#define TASK_RUNNING 0

struct task_struct;

typedef struct task_struct kal_task_t;

extern void *current;  
extern void *idle;  
extern int need_resched;
extern struct list_head kernel_task_list;


#define set_tsk_need_resched(x) do { need_resched = 1; } while (0)

typedef uid_t kal_uid_t;

typedef gid_t kal_gid_t;

static inline uid_t kal_get_current_uid(void)
{
  return current_uid();
}

static inline gid_t kal_get_current_gid(void)
{
  return current_gid();
}

#define for_each_task(t, pos) \
        for ((pos) = kernel_task_list.next, prefetch((pos)->next); \
        (t) = (list_entry((pos), struct task_struct, task_list)), (pos) != &kernel_task_list; \
                (pos) = (pos)->next, prefetch((pos)->next))

extern void (*block_hook)(struct task_struct *tsk);
extern void (*unblock_hook)(struct task_struct *tsk, long old_state);
extern void (*stop_hook)(struct task_struct *tsk);
extern void (*continue_hook)(struct task_struct *tsk, long old_state);
extern void (*fork_hook)(struct task_struct *tsk);
extern void (*cleanup_hook)(struct task_struct *tsk);
extern rwlock_t hook_lock;

void set_task_rr_prio(kal_task_t *p, int priority);

void kal_task_link_data(kal_task_t *task, void *data);
void kal_task_unlink_data(kal_task_t *task);
void *kal_task_get_data(kal_task_t *task);
int kal_task_get_id(kal_task_t *task);
int kal_task_ready(kal_task_t * task);

#endif /* QOS_KS */


#endif /* __KAL_TASK_H__ */

---