src/thread/thread.hpp

Idź do dokumentacji tego pliku.

/* header file for src/thread/thread.cpp */

#ifndef _CORE_THREAD_THREAD_HPP
#define _CORE_THREAD_THREAD_HPP

/* necessary includes */
#include "src/common/blist.hpp"
#include "src/arch/x86/context.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/ipc/msg.hpp"
#include "src/ipc/sem.hpp"
#include "src/memory/pager.hpp"

// const uint32 SEM_MESSAGE     = 0x0003;       //waiting for a message

struct threnv_t
 {
//here the chain_handler() function stores the actual info on the interrupt frame. this is necessary
//so that when the interrupt handler called wants to terminate a thread/process, it can free the stack
//the interrupt works on.
        struct Arch::x86::Interr::except2_t *cd;
 };

namespace Thread {


/* general consts */
const uint32 THREAD_NAME                = 0x20;
const uint32 THREAD_QUEUES              = 32;   //thread prorities count
const uint32 LOWEST_PRIORITY            = 31;   //lowest priority
/* thread states */
const uint32 TH_BUSY                    = 0x0004;       //running at the moment
const uint32 TH_ACTIVE                  = 0x0008;       //is ready for schedule
const uint32 TH_ASLEEP                  = 0x0010;       //asleep
const uint32 TH_DYING                   = 0x0020;       //dying & to be cleaned up
const uint32 TH_BLOCKED                 = 0x0040;       //blocked for some reason. no access to the thread's data structure
const uint32 TH_IDLE                    = 0x0080;       //not scheduled if not needed

//vars
extern class IPC::Lock::lock_t lock_queues;
extern class IPC::Lock::lock_t lock_sleep;
extern class blist_t threads_queue[THREAD_QUEUES];
// extern class blist_t threads_ran;    //threads which have been ran
extern class blist_t threads_sleep;     //sleeping threads
extern class blist_t threads_dead;      //the cementary
extern class Memory::Heap::heapbox heap;        //the heap for the queues

//a thread's datatype
struct thread_t
 {
        context_t context;      //arch dependant thread context

        class process_t *proc;  //the owner process
        IPC::Message::mailbox inbox;    //message box
        struct threnv_t env;    //thread environment
        char name[THREAD_NAME]; //the name

        int no; //the thread's no

// thread environment
        uint32 state;
        uint32 priority;        //priority level
        uint32 worst_priority;  //the worst priority the thread should get
        uint32 best_priority;
        int prior_diff;         //for the scheduler
        uint64 awake_time;      //when to awake the thread
        uint64 work_time;       //the last time the thread was setup to run
        uint64 creation_time;   //the time when the thread has been created
        uint64 running_time;    //how much time has been used by the thread
        uint64 save1_time;
        uint64 run1_time;
        uint64 save2_time;
        uint64 run2_time;
        uint32 load;


        struct sem_t volatile *sem_id;  //whether a semaphore is holding the thread
        uint64 volatile sem_dt;         //internal info of the semaphor (8bytes)
 };

//create a context for the thread, code in arch modules
void allocate_context(Thread::thread_t *obj, bool supervisor, uint32 stack, uint32 proc_addr);

int enqueue_thread(thread_t *thread, blist_t *queue);
int unqueue_thread(thread_t *thread, blist_t *queue);

uint32 thread_load(thread_t *thread);   //counts the load

int sleepcompar(const void *a, const void *b);  //compare two threads for sleeping time
int sleep(thread_t *thread, uint64 time);       //sleep a thread
int sleep(uint64 time);
int awake(thread_t *thread);                    //awake a thread
int wake_threads();     //wake the sleeping threads

int sem_sleep(thread_t *thread, struct sem_t *sem_id, uint64 sem_dt);
int sem_sleep(struct sem_t *sem_id, uint64 sem_dt);
int sem_awake(thread_t *thread);

thread_t *ThreadGet(int procno, int threadno);
int ThreadKill(thread_t *thread);
int ThreadKill(int procno, int threadno);

#define ThreadFail(...)         do { complain(__VA_ARGS__); ::Thread::ThreadKill(current_thread); } while (0)

 };     /*namespace Thread*/
extern volatile struct ::Thread::thread_t *current_thread;

#endif

---