Subversion Repositories c0or1k

/*

 * Thread Control Block, kernel portion.

 *

 * Copyright (C) 2007-2009 Bahadir Bilgehan Balban

 */

#ifndef __TCB_H__

#define __TCB_H__

#include <l4/lib/list.h>

#include <l4/lib/mutex.h>

#include <l4/lib/spinlock.h>

#include <l4/generic/scheduler.h>

#include <l4/generic/resource.h>

#include <l4/generic/capability.h>

#include <l4/generic/space.h>

#include INC_GLUE(memory.h)

#include INC_GLUE(syscall.h)

#include INC_GLUE(message.h)

#include INC_GLUE(context.h)

#include INC_SUBARCH(mm.h)

/*

 * These are a mixture of flags that indicate the task is

 * in a transitional state that could include one or more

 * scheduling states.

 */

#define TASK_INTERRUPTED                (1 << 0)

#define TASK_SUSPENDING                 (1 << 1)

#define TASK_RESUMING                   (1 << 2)

#define TASK_PENDING_SIGNAL             (TASK_SUSPENDING)

#define TASK_REALTIME                   (1 << 5)

/*

 * This is to indicate a task (either current or one of

 * its children) exit has occured and cleanup needs to be

 * called

 */

#define TASK_EXITED                     (1 << 3)

/* Task states */

enum task_state {

        TASK_INACTIVE   = 0,

        TASK_SLEEPING   = 1,

        TASK_RUNNABLE   = 2,

};

#define TASK_CID_MASK                   0xFF000000

#define TASK_ID_MASK                    0x00FFFFFF

#define TASK_CID_SHIFT                  24

static inline l4id_t tid_to_cid(l4id_t tid)

{

        return (tid & TASK_CID_MASK) >> TASK_CID_SHIFT;

}

/* Values that rather have special meaning instead of an id value */

static inline int tid_special_value(l4id_t id)

{

        /* Special ids have top 2 nibbles all set */

        return (id & TASK_CID_MASK) == TASK_CID_MASK;

}

#define TASK_ID_INVALID                 0xFFFFFFFF

struct task_ids {

        l4id_t tid;

        l4id_t spid;

        l4id_t tgid;

};

struct container;

struct ktcb {

        /* User context */

        task_context_t context;

        /*

         * Reference to the context on stack

         * saved at the beginning of a syscall trap.

         */

        syscall_context_t *syscall_regs;

        /* Runqueue related */

        struct link rq_list;

        struct runqueue *rq;

        /* Thread Id information (See space for space id) */

        l4id_t tid;             /* Global thread id */

        l4id_t tgid;            /* Global thread group id */

        /* CPU affinity */

        int affinity;

        /* Other related threads */

        l4id_t pagerid;

        /* Flags to indicate various task status */

        unsigned int flags;

        /* IPC flags */

        unsigned int ipc_flags;

        /* Lock for blocking thread state modifications via a syscall */

        struct mutex thread_control_lock;

        /* To protect against thread deletion/modification */

        struct spinlock thread_lock;

        u32 ts_need_resched;    /* Scheduling flag */

        enum task_state state;

        struct link task_list; /* Global task list. */

        /* UTCB related, see utcb.txt in docs */

        unsigned long utcb_address;     /* Virtual ref to task's utcb area */

        /* Thread times */

        u32 kernel_time;        /* Ticks spent in kernel */

        u32 user_time;          /* Ticks spent in userland */

        u32 ticks_left;         /* Timeslice ticks left for reschedule */

        u32 ticks_assigned;     /* Ticks assigned to this task on this HZ */

        u32 sched_granule;      /* Granularity ticks left for reschedule */

        int priority;           /* Task's fixed, default priority */

        /* Number of locks the task currently has acquired */

        int nlocks;

        /* Task exit code */

        unsigned int exit_code;

        /* Page table information */

        struct address_space *space;

        /* Container */

        struct container *container;

        struct pager *pager;

        /* Capability lists */

        struct cap_list cap_list; /* Own private capabilities */

        /* Fields for ipc rendezvous */

        struct waitqueue_head wqh_recv;

        struct waitqueue_head wqh_send;

        l4id_t expected_sender;

        /* Waitqueue for notifiactions */

        struct waitqueue_head wqh_notify;

        /* Waitqueue for pagers to wait for task states */

        struct waitqueue_head wqh_pager;

        /* Tells where we are when we sleep */

        struct spinlock waitlock;

        struct waitqueue_head *waiting_on;

        struct waitqueue *wq;

        /*

         * Extended ipc size and buffer that

         * points to the space after ktcb

         */

        unsigned long extended_ipc_size;

        char extended_ipc_buffer[];

};

/* Per thread kernel stack unified on a single page. */

union ktcb_union {

        struct ktcb ktcb;

        char kstack[PAGE_SIZE];

};

/*

 * Each task is allocated a unique global id. A thread group can only belong to

 * a single leader, and every thread can only belong to a single thread group.

 * These rules allow the fact that every global id can be used to define a

 * unique thread group id. Thread local ids are used as an index into the thread

 * group's utcb area to discover the per-thread utcb structure.

 */

static inline void set_task_ids(struct ktcb *task, struct task_ids *ids)

{

        task->tid = ids->tid;

        task->tgid = ids->tgid;

}

struct ktcb *tcb_find(l4id_t tid);

struct ktcb *tcb_find_lock(l4id_t tid);

void tcb_add(struct ktcb *tcb);

void tcb_remove(struct ktcb *tcb);

void tcb_init(struct ktcb *tcb);

struct ktcb *tcb_alloc_init(l4id_t cid);

void tcb_delete(struct ktcb *tcb);

void tcb_delete_zombies(void);

void ktcb_list_remove(struct ktcb *task, struct ktcb_list *ktcb_list);

void ktcb_list_add(struct ktcb *new, struct ktcb_list *ktcb_list);

void init_ktcb_list(struct ktcb_list *ktcb_list);

void task_update_utcb(struct ktcb *task);

int tcb_check_and_lazy_map_utcb(struct ktcb *task, int page_in);

#endif /* __TCB_H__ */