---

task.h

Go to the documentation of this file.

/*!     \file include/kernel/task.h
 *      \brief Headers for the task manager.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-12-16
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

#ifndef TASK_H
#define TASK_H

#include <arch/paging.h>
#include <arch/i386.h>

//! Stack size in byte for every kernel-mode task.
#define STACK_SIZE              0x8000

//! The address where the user-privilege task stack is placed.
#define TASK_STACK_START        0xC0000000
//! The start of the heap for a user-mode task.
#define TASK_HEAP_START         0x40000000
//! The size of the heap for a user-mode task.
#define TASK_HEAP_DEFAULT_SIZE  0x40000000

#define READY                   1 //!< The task is ready for the CPU.
#define WAIT                    2 //!< The task is waiting for I/O.
#define ZOMBIE                  3 //!< The task is dying.

#define KTHREAD_T               0x00 //!< A kernel thread type.
#define PROCESS_T               0x01 //!< A task type.

#define KERNEL_PRIVILEGE        0 //!< Max privilege (kernel).
#define USER_PRIVILEGE          3 //!< Min privilege (user).

//! TSS without I/O bit map.
typedef struct tss
{
        uint32_t        link;
        uint32_t        esp0;
        uint16_t        ss0, __ss0h;
        uint32_t        esp1;
        uint16_t        ss1, __ss1h;
        uint32_t        esp2;
        uint16_t        ss2, __ss2h;
        uint32_t        cr3;
        uint32_t        eip;
        uint32_t        eflags;
        uint32_t        eax, ecx, edx, ebx;
        uint32_t        esp;
        uint32_t        ebp;
        uint32_t        esi;
        uint32_t        edi;
        uint16_t        es, __esh;
        uint16_t        cs, __csh;
        uint16_t        ss, __ssh;
        uint16_t        ds, __dsh;
        uint16_t        fs, __fsh;
        uint16_t        gs, __gsh;
        uint16_t        ldtr, __ldtrh;
        uint16_t        trace, io_map_addr;
} tss_t;

//! TSS with I/O bit map.
typedef struct tss_IO
{
        uint32_t        link;
        uint32_t        esp0;
        uint16_t        ss0, __ss0h;
        uint32_t        esp1;
        uint16_t        ss1, __ss1h;
        uint32_t        esp2;
        uint16_t        ss2, __ss2h;
        uint32_t        cr3;
        uint32_t        eip;
        uint32_t        eflags;
        uint32_t        eax, ecx, edx, ebx;
        uint32_t        esp;
        uint32_t        ebp;
        uint32_t        esi;
        uint32_t        edi;
        uint16_t        es, __esh;
        uint16_t        cs, __csh;
        uint16_t        ss, __ssh;
        uint16_t        ds, __dsh;
        uint16_t        fs, __fsh;
        uint16_t        gs, __gsh;
        uint16_t        ldtr, __ldtrh;
        uint16_t        trace, io_map_addr;
        uint8_t         io_map[8192];   //!< I/O redirection bit map.
} tss_IO_t;

//! The task structure.
typedef struct task
{
        tss_IO_t        tss; //! MUST BE THE FIRST!!!
        word            tss_sel;
        pid_t           pid;
        size_t          pl0_stack;
        size_t          heap_start, heap_size;
        byte            state;
        struct task     *father;
        int             console;
        byte            type;
        byte            priority;
        char            name[256];
} task_t;

//! \brief
//!     Halt the CPU until an interrupt occurs.
static __inline__ void idle()
{
        __asm__ __volatile__ ("hlt");
}

//! \brief
//!     Perform a context switch between two tasks.
//! \param tss_sel
//!     The selector of the next task.
/*!
 *      This is an asm routine to jump to a TSS (TSS-based multitasking)
 */
static __inline__ void jmp_to_tss(word tss_sel)
{
        static struct {
        unsigned eip : 32; // 32 bit
        unsigned cs  : 16; // 16 bit
        } __attribute__ ((packed)) tss_link = {0, 0};

        // Set the TSS link                                             //
        tss_link.cs = tss_sel;

        // Jump to the task                                             //
        __asm__ __volatile__ ("ljmp *(%0)" : : "m" (tss_link));
}

void dispatcher();
void init_multitasking();
int get_pid();
char *get_pname();
task_t *get_curr_task();

//! Macro equivalent to get_curr_task() routine.
#define MYSELF  ( get_curr_task() )

void do_idle();

task_t *create_kthread(void *address, char *pname);
task_t *create_process(void *address, void *buffer, size_t size, char *pname, int privilege);
task_t *new_task(char *filename, int argc, char **argv, int privilege);

void auto_kill(int n);

//! Macro equivalent to auto_kill() (...for now).
/*!
 *      \todo
 *      The exit returning values between tasks.
 */
#define _exit(n)        auto_kill(n)

bool kill(pid_t pid);
pid_t waitpid(pid_t pid, int *status, int options);
void sleep_task(task_t *p);
void wakeup_task(task_t *p);

void sched_enter_critical_region();
void sched_leave_critical_region();
bool is_sched_enabled();

void ps();

#endif

---