第24章 任务中定时器的设计与实现

最新推荐文章于 2022-09-04 22:05:22 发布
最新推荐文章于 2022-09-04 22:05:22 发布
阅读量803 收藏 1
点赞数
分类专栏： 1KOS开发 文章标签： 任务 timer struct descriptor null list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/metaxen/article/details/6747631
版权

目标：实现定时器功能，实现系统调用sleep。


定时器的定义如下所示，系统使用定时器链表管理定时器。

struct timer{
    struct task_struct *task;
    struct timer *next, *prev;
    int time_slice;
};

struct timer_list{
    unsigned long timer_nr;
    struct timer *head, *tail;
};



任务调用sleep(int ms)函数时，会在定时器链表上插入一个定时器，然后任务挂起。每次时钟中断，内核都会检查定时器链表上的定时器，假如定时器到点，则删除定时器，并唤醒与该定时器关联的任务。定时器插入算法就是遍历链表，算法复杂度为O(n)。定时器检查算法的复杂度为O(1)。

假设
任务A睡20秒
任务B睡5秒
任务C睡9秒
任务D睡2秒
任务E睡14秒
任务F睡40秒
任务 DBCEAF
时刻0259142040
定时器的时间长度值 2345620


也就是在定时器链表上，第1个定时器的时间值是2秒，对应的任务是D；第2个定时器的时间值是3秒，对应的任务是B；
定时器插入函数如下所示
//把定时器插入到定时器链表中
//每个定时器代表一段距离，表示离左边定时器的时间片距离
struct timer * add_timer(struct timer *t)
{
   if(!t)
      return NULL;

   //当定时器链表为空时
   if(task_timer_list.head == NULL)
   {
    task_timer_list.head = task_timer_list.tail = t;
    ++task_timer_list.timer_nr;
    return t;
   }

   //当定时器不为空时
   struct timer *p = NULL;
   p = task_timer_list.head;
   while(p && p->time_slice <= t->time_slice)
   {
    t->time_slice -= p->time_slice;
    p = p->next;
   }

   if(p == task_timer_list.head) //插在最前面
   {
        p->time_slice -= t->time_slice;

    p->prev = t;
    t->next = p;
    t->prev = NULL;
    task_timer_list.head = t;
   }
   else if(p == NULL) //插在最后面
   {
    task_timer_list.tail->next = t;
    t->prev = task_timer_list.tail;
    t->next = NULL;
    task_timer_list.tail = t;
   }
   else  //插在中间
   {
        p->time_slice -= t->time_slice;
    
    p->prev->next = t;
    t->next = p;
    t->prev = p->prev;
    p->prev = t;    
   }

   ++task_timer_list.timer_nr;

   return t;
}

定时器检查函数如下所示

void check_timer()
{

    struct timer *p = NULL , *tmp = NULL;
    p = task_timer_list.head;
    //检查定时器链表
    if(p)    //链表上有定时器
    {
    //定时器到点
    if(--(p->time_slice) == 0)
    {
        //可能有多个定时器到点
        while(p && p->time_slice == 0)
        {
    
        if(p->next == NULL)    //只剩下一个定时器
        {
            task_timer_list.head = task_timer_list.tail = NULL;
        }
        else     //剩下多个定时器
        {
           task_timer_list.head = p->next;
           task_timer_list.head->prev = NULL; 
        }

            
        //定时器的任务为空可能是因为该任务已被删除(sys_remove_task)
        //定时器指定的任务有可能已经被其他任务唤醒了（使用resume_task系统调用）
        if(p->task && p->task->state == TASK_STATE_SUSPEND)
        {
            //从挂起队列中移除任务
            remove_task_from_suspend(p->task);

            //把任务插入到运行队列
            insert_task_to_running(p->task, cpu0.expired);
        }
            
        tmp = p;
        p = p->next;
        
        //初始化定时器
        init_task_timer(tmp);
        }
    }


    }
}

timer.c源代码如下所示

#include "asm.h"
#include "io.h"
#include "idt.h"
#include "video.h"
#include "kernel.h"
#include "8259.h"
#include "timer.h"
#include "task.h"


void init_timer(unsigned int hz)
{
    unsigned int divisor = CLOCK_RATE/hz;
    outportb(0x43, 0x36);        //选择计数器0，输出模式3
    outportb(0x40, divisor&0xff);   //把初始值的低字节写入LSB中
    outportb(0x40, (divisor>>8)&0xff);    //把初始值的高字节写入MSB中
}

volatile unsigned long  timer_ticks = 0;
void do_timer(void)
{
    timer_ticks++;
    //检查定时器链表
    check_timer();

    //管理当前任务的时间片
    manage_time_slice();

    outportb(M_PIC, EOI);   //告诉PIC1，中断处理函数已经结束，可以处理新来的中断。
                //因为定时器是连接到PIC1的IRQ0上，所以不许要通知PIC2
    //调度
    scheduler();
}


最终的task.c源代码如下所示

#include "define.h"
#include "task.h"
#include "kernel.h"
#include "asm.h"
#include "video.h"

static unsigned long task0_stack[1024] = {0};

struct task_struct task0 = {
    //tss
    {
    //back_link
    0,
    //esp0, ss0
    (unsigned int)&(task0_stack[1023]), DATA_SEL,
    //esp1, ss1
    0, 0,
    //esp2, ss2
    0, 0,
    //cr3
    0,
    //eip
    0,
    //eflags
    0,
    //eax,ecx,edx,ebx
    0, 0, 0, 0,
    //esp,ebp
    0, 0,
    //esi,edi
    0, 0,
    //es,cs,ss,ds,fs,gs
    USER_DATA_SEL, USER_CODE_SEL, USER_DATA_SEL, USER_DATA_SEL, USER_DATA_SEL, USER_DATA_SEL,
    //ldt
    0x20,
    //trace_iobitmap
    0x0
    },
    //tss_descriptor
    0,
    //ldt_descriptor
    0,
    //ldt[2];
    {DEFAULT_LDT_CODE, DEFAULT_LDT_DATA},
    //task_function
    0,
    //stack0
    NULL,
    //stack3
    NULL,
    //stack0_size
    0,
    //stack3_size
    0,
    //state
    TASK_STATE_RUNNING,    
    //priority
    0,
    //time_slice
    INITIAL_TIME_SLICE,
    //pid
    0,
    //ppid
    0,
    //next
    NULL,
    //prev
    NULL,
    //hnext
    NULL,
    //hprev
    NULL,
    //prio_array *
    NULL,
    //timer
    {
    //strcut task_struct *task
    NULL,
    //struct timer *next, *prev
    NULL,NULL,
    //int slice
    0
    },
    //msgbox
    {
    //msg_nr
    0,
    //msg_start
    0,
    //msg_end
    0,
    //box
    {}
    }
};

struct task_struct *current = &task0;
struct run cpu0;

static int newpid = 0;

static int get_newpid()
{
    return ++newpid;
}

unsigned long long set_tss(unsigned long long tss_offset)
{
    unsigned long long tss_descriptor = 0x0000890000000067ULL;
    tss_descriptor |= (tss_offset<<16)&0xffffff0000ULL;
    tss_descriptor |= (tss_offset<<32)&0xff00000000000000ULL;
    return ((unsigned long long *)GDT_ADDR)[CURRUENT_TASK_TSS] = tss_descriptor;
}


unsigned long long set_ldt(unsigned long long ldt_offset)
{
    unsigned long long ldt_descriptor = 0x000082000000000fULL;
    ldt_descriptor |= (ldt_offset<<16)&0xffffff0000ULL;
    ldt_descriptor |= (ldt_offset<<32)&0xff00000000000000ULL;
    return ((unsigned long long *)GDT_ADDR)[CURRUENT_TASK_LDT] = ldt_descriptor;
}


unsigned long long get_tss(void)
{
    return ((unsigned long long *)GDT_ADDR)[CURRUENT_TASK_TSS];
}

unsigned long long get_ldt(void)
{
    return ((unsigned long long *)GDT_ADDR)[CURRUENT_TASK_LDT];
}


void init_task_timer(struct timer *timer)
{
    if(!timer)
    return NULL;
    timer->task = NULL;  //表示当前定时器非使用状态
    timer->next = timer->prev = NULL;
    timer->time_slice = 0;
}

struct timer_list task_timer_list = {0, NULL, NULL};

//初始化定时器链表
void init_task_timer_list()
{
    task_timer_list.timer_nr = 0;
    task_timer_list.head = task_timer_list.tail = NULL;
}

//把定时器插入到定时器链表中
//每个定时器代表一段距离，表示离左边定时器的时间片距离
struct timer * add_timer(struct timer *t)
{
   if(!t)
      return NULL;

   //当定时器链表为空时
   if(task_timer_list.head == NULL)
   {
    task_timer_list.head = task_timer_list.tail = t;
    ++task_timer_list.timer_nr;
    return t;
   }

   //当定时器不为空时
   struct timer *p = NULL;
   p = task_timer_list.head;
   while(p && p->time_slice <= t->time_slice)
   {
    t->time_slice -= p->time_slice;
    p = p->next;
   }

   if(p == task_timer_list.head) //插在最前面
   {
        p->time_slice -= t->time_slice;

    p->prev = t;
    t->next = p;
    t->prev = NULL;
    task_timer_list.head = t;
   }
   else if(p == NULL) //插在最后面
   {
    task_timer_list.tail->next = t;
    t->prev = task_timer_list.tail;
    t->next = NULL;
    task_timer_list.tail = t;
   }
   else  //插在中间
   {
        p->time_slice -= t->time_slice;
    
    p->prev->next = t;
    t->next = p;
    t->prev = p->prev;
    p->prev = t;    
   }

   ++task_timer_list.timer_nr;

   return t;
}


//从定时器链表上移除指定任务的定时器
//被sys_delete_task sys_resume_task sys_suspend_task 函数调用
void remove_task_timer(struct task_struct *task)
{
    if(!task)
    return ;
    if(!(task->timer.task))
    return ;
    //定时器在链表中的位置有三种：表头；表尾；表中间
    if(task_timer_list.head == &(task->timer)) //表头
    {
    if(task_timer_list.tail == &(task->timer))
    {
        task_timer_list.head = task_timer_list.tail = NULL;
    }
    else
    {
        task_timer_list.head = task->timer.next;
        task_timer_list.head->prev = NULL;
        task_timer_list.head->time_slice += task->timer.time_slice;  //这条语句是必须的
    }

    }
    else if(task_timer_list.tail == &(task->timer))  //表尾
    {
    task_timer_list.tail = task->timer.prev;
    task_timer_list.tail->next = NULL;
    }
    else  //表中间
    {
    task->timer.prev->next = task->timer.next;
    task->timer.next->prev = task->timer.prev;
    task->timer.next->time_slice += task->timer.time_slice;  //这条语句是必须的
    }

    init_task_timer(&(task->timer));
}

//添加任务到任务链表尾部
void add_task(struct list_pcd * list, struct task_struct *task)
{
    
    if(list->head == NULL) //队列为空
    {
    list->head = list->tail = task;
    task->next = task->prev = NULL;
    }
    else    //队列不为空
    {
    list->tail->next = task;
    task->prev = list->tail;
    task->next = NULL;
    list->tail = task;
    }
}


//从任务链表中删除任务
void remove_task(struct list_pcd * list, struct task_struct *task)
{

    //该任务在队列中有三种情况：队头；队尾；队中
    if(list->head == task)  //队头
    {
    if(task->next)//队列有多个任务
    {
        list->head = task->next;
        list->head->prev = NULL;
    }
    else //队列只有一个任务
    {
        list->head = list->tail = NULL;
    }

    }
    else if(list->tail == task) //队尾
    {
    if(task->prev) //队列有多个任务
    {
        list->tail = task->prev;
        list->tail->next = NULL;
    }
    else //队列只有一个任务
    {
        list->head = list->tail = NULL;
    }
    }
    else //队中
    {
    task->prev->next = task->next;
    task->next->prev = task->prev;
    }    

}


//把任务插入优先级数组中
//被sys_create_task()和manage_time_slice()函数调用
//本函数访问共享资源cpu0，因此要保证调用本函数时不能被打断
void insert_task_to_running(struct task_struct *task, struct prio_array *py)
{

    //都是把任务插在链表尾部
    add_task(py->queue + task->priority, task);

    //更新任务结构
    task->py = py;
    task->state = TASK_STATE_RUNNING;

    //更新优先级数组
    ++(py->task_nr);
    py->bitmap |= (1 << task->priority);
}

//把任务从优先级数组上移除
void remove_task_from_running(struct task_struct* task)
{
    if(task->state != TASK_STATE_RUNNING)
    return;
    struct list_pcd *list = NULL;
    list = (struct list_pcd*)(task->py->queue + task->priority);
    //把任务从运行队列中移除
    remove_task(list, task);
    
    
    //更新优先级数组
    --(task->py->task_nr);

    //假如任务所在的优先级链表已空，则更新优先级位图
    if(list->head == NULL)
    task->py->bitmap &= ~(1 << task->priority);    
}

//初始化CPU0，把任务0插入active优先级数组中
void init_cpu0(void)
{
    struct list_pcd * list_pcd_ptr = NULL;
    int i = 0, j = 0;
    for(i = 0; i < 2; i++)
    {
    cpu0.pa[i].task_nr = 0;
    cpu0.pa[i].bitmap = 0x0;
    for(j = 0; j < PRIO_NR; j++)
    {
        cpu0.pa[i].queue[j].head = NULL;
        cpu0.pa[i].queue[j].tail = NULL;
    }
    }
    
    cpu0.active = cpu0.pa;
    cpu0.expired = cpu0.pa+1;
    
    //把任务0插入active优先级数组中去,一定要插入active优先级数组，这很重要
    insert_task_to_running(&task0, cpu0.active);
    
    //把任务0插到任务HASH表中去
    add_task_to_hash(&task0);
}

void init_tasks(void)
{
    //设置GDT中的TSS和LDT
    set_tss((unsigned long long)&(task0.tss));
    set_ldt((unsigned long long)&(task0.ldt));
    __asm__("ltrw %%ax\n\t"::"a"(TSS_SEL));
    __asm__("lldt %%ax\n\t"::"a"(LDT_SEL));

    //初始化CPU0，把任务0插入expired优先级数组中
    init_cpu0();

    //初始化定时器链表
    init_task_timer_list();

}

//系统调用，创建新的任务
//返回新任务的PID
int  sys_create_task(unsigned int task_function, unsigned int stack0_size, unsigned int stack3_size)
{
    int pid = 0;
    struct task_struct *task = NULL;
    void *stack0 = NULL, *stack3 = NULL;

    stack0_size = (stack0_size ? stack0_size : DEFAULT_STACK_SIZE);
    stack3_size = (stack3_size ? stack3_size : DEFAULT_STACK_SIZE);

    task = (struct task_struct *)malloc(sizeof(struct task_struct));
    stack0 = malloc(stack0_size);
    stack3 = malloc(stack3_size);
    if(!task || !stack0 || !stack3)
    {
    free(task);
    free(stack0);
    free(stack3);
    return -1;
    }

    *task = task0;

    task->tss.esp0 = stack0 + stack0_size;
    task->tss.eip = task_function;
    //task->tss.eflags = 0x3202;    // I(中断位)=1，使能INTR引脚，开中断
                        // IOPL（i/o优先级）=3，当任务的优先级高于或等于IOPL时，I/O指令才能顺利执行。
    task->tss.eflags = 0x202;        //不需要设置IOPL了，通过系统调用执行I/O指令
    task->tss.esp = stack3 + stack3_size;

    task->task_function = task_function;
    task->stack0 = stack0 + stack0_size;
    task->stack3 = stack3 + stack3_size;
    task->stack0_size = stack0_size;
    task->stack3_size = stack3_size;

    task->state = TASK_STATE_RUNNING;
    //设置时间片
    task->time_slice = INITIAL_TIME_SLICE;

    //设置PID和PPID
    pid = task->pid = get_newpid();
    task->ppid = current->pid;

    //设置优先级
    task->priority = ( task->pid % PRIO_NR);
    //task->priority = INITIAL_PRIO;

    //初始化定时器
    init_task_timer(&(task->timer));

    //初始化任务的信箱
    task->msgbox.msg_nr = 0;
    task->msgbox.msg_start = task->msgbox.msg_end = 0;

    //插入到cpu0中的expired优先级数组中
    cli();
    insert_task_to_running(task, cpu0.expired);
    
    //插到任务HASH表中
    add_task_to_hash(task);
    sti();


    return pid;
}

//计算当前任务的时间片，假如当前任务的时间片用完，则从新分配时间片，并把任务插入到expired优先级数组中
//这里存在一个假设，即当前任务是所在优先级队列的第一个任务；
//本函数需要访问共享资源cpu0,因此需要保证该调用该函数时不能被打断
void manage_time_slice(void)
{
    struct list_pcd * list_pcd_ptr = NULL;
    list_pcd_ptr = cpu0.active->queue + current->priority;  //指向当前任务所在的优先级队列

    //计算当前任务的时间片
    if(--current->time_slice > 0) //当前任务还有时间片
    {
    if(list_pcd_ptr->head != list_pcd_ptr->tail) //该优先级上还有>1个任务
    {
        //轮转算法，把当前任务插到队尾
        list_pcd_ptr->head = current->next;
        list_pcd_ptr->tail->next = current;
        current->prev = list_pcd_ptr->tail;
        list_pcd_ptr->tail = current;
        current->next = NULL;
        list_pcd_ptr->head->prev = NULL;
    }
    }
    else  //当前任务没有时间片,从队列中摘掉该任务
    {
    //摘取当前任务
    if(list_pcd_ptr->head != list_pcd_ptr->tail) //该优先级上还有>1个任务
    {
        list_pcd_ptr->head = current->next;
        list_pcd_ptr->head->prev = NULL;
    }
    else    //该优先级上只有当前任务
    {
        list_pcd_ptr->head = list_pcd_ptr->tail = NULL;
        //更新优先级数组位图
        cpu0.active->bitmap &= ~(1 << current->priority);
    }

    //更替新优先级数组
    --(cpu0.active->task_nr);
    //重新给任务分配时间片
    current->time_slice = INITIAL_TIME_SLICE;
    //把任务插入expired优先级数组中
    insert_task_to_running(current,cpu0.expired);
    }


}

static inline unsigned long  sched_find_first_bit(const unsigned long word)
{
    unsigned long index = word;
    __asm__ ("bsfl %1, %0 \n\t" \
    :"=r"(index):"rm"(index));
    return index;
}

//时间片轮转调度算法
//本函数需要访问共享资源cpu0,因此需要保证该调用该函数时不能被打断,该函数必须在临界区内，不能开中断。
//而且scheduler调用的函数也不能开中断
void scheduler(void)
{
    struct task_struct *v = NULL;
    struct list_pcd * list_pcd_ptr = NULL;
    struct prio_array *py = NULL;
    unsigned long index = 0;

    //加入active优先级数组中没有可运行的任务，则调换active和expired的指针。

    py = cpu0.active;
    if(py->task_nr == 0)
    {
    cpu0.active = cpu0.expired;
    cpu0.expired = py;
    py = cpu0.active;
    }

    if(py->task_nr == 0)
    {
        sys_kprint(char_attr(BLACK,RED),"\tScheduler Error: no running task in priority array.\n");
        while(1);
    }

    //在active优先级数组中找到具有任务的优先级最高的任务队列，取得任务队列的头个任务
    index = sched_find_first_bit(py->bitmap);
    list_pcd_ptr = py->queue + index;
    v = list_pcd_ptr->head;


    if(v != current)
    {
    current->tss_descriptor = get_tss();
    current->ldt_descriptor = get_ldt();
    v->tss_descriptor = set_tss((unsigned long long)&(v->tss));
    v->ldt_descriptor = set_ldt((unsigned long long)&(v->ldt));
    current = v;
    __asm__ volatile("ljmp  {1}quot; TSS_SEL_STR ", $0\n\t");
    }
}

//挂起任务队列
struct task_list suspend_tasks;
//死亡任务队列
struct task_list  dead_tasks;


void init_suspend_tasks()
{
    suspend_tasks.task_nr = 0;
    suspend_tasks.list.head = NULL;
    suspend_tasks.list.tail = NULL;
}

void init_dead_tasks()
{
    dead_tasks.task_nr = 0;
    dead_tasks.list.head = NULL;
    dead_tasks.list.tail = NULL;
}

//插入任务到挂起任务队列队尾
void insert_task_to_suspend(struct task_struct *task)
{
    task->state = TASK_STATE_SUSPEND;
    add_task(&(suspend_tasks.list), task);
    ++suspend_tasks.task_nr;
}






//插入任务到死亡任务队列队尾
void insert_task_to_dead(struct task_struct *task)
{

    task->state = TASK_STATE_DEAD;
    add_task(&(dead_tasks.list), task);
    ++dead_tasks.task_nr;

}

//从挂起任务队列中删除指定的任务
void remove_task_from_suspend(struct task_struct *task)
{
    if(task->state != TASK_STATE_SUSPEND)
    return ;
    remove_task(&(suspend_tasks.list), task);
    --suspend_tasks.task_nr;
}

void remove_task_from_dead(struct task_struct *task)
{
    if(task->state != TASK_STATE_DEAD)
    return ;
    remove_task(&(dead_tasks.list), task);
    --dead_tasks.task_nr;
}


struct task_hash tasks_hash;
void init_tasks_hash()
{
    tasks_hash.task_nr = 0;
    int i = 0;
    for(i = 0; i < TASK_HASH_NR;i++)
    {
    tasks_hash.table[i].head = tasks_hash.table[i].tail = NULL;
    }
}

void add_task_to_hash(struct task_struct *task)
{
    
    struct list_pcd *list = NULL;
    list = &(tasks_hash.table[task->pid%TASK_HASH_NR]);
    if(list->head == NULL) //队列为空
    {
    list->head = list->tail = task;
    task->hnext = task->hprev = NULL;
    }
    else    //队列不为空
    {
    list->tail->hnext = task;
    task->hprev = list->tail;
    task->hnext = NULL;
    list->tail = task;
    }

    ++tasks_hash.task_nr;
}

void remove_task_from_hash(struct task_struct *task)
{
    struct list_pcd *list = NULL;
    list = &(tasks_hash.table[task->pid%TASK_HASH_NR]);
    //该任务在队列中有三种情况：队头；队尾；队中
    if(list->head == task)  //队头
    {
    if(task->hnext)//队列有多个任务
    {
        list->head = task->hnext;
        list->head->hprev = NULL;
    }
    else //队列只有一个任务
    {
        list->head = list->tail = NULL;
    }

    }
    else if(list->tail == task) //队尾
    {
    if(task->hprev) //队列有多个任务
    {
        list->tail = task->hprev;
        list->tail->hnext = NULL;
    }
    else //队列只有一个任务
    {
        list->head = list->tail = NULL;
    }
    }
    else //队中
    {
    task->hprev->hnext = task->hnext;
    task->hnext->hprev = task->hprev;
    }    
    --tasks_hash.task_nr;    
}

struct task_struct * query_task_from_hash(int pid)
{
    struct task_struct *t;
    t = tasks_hash.table[pid%TASK_HASH_NR].head;
    for(; t; t = t->hnext )
    {
    if(t->pid == pid)
        return t;    
    }

    return NULL;
}

//挂起任务
//该函数访问共享资源，因此需要关中断
int sys_suspend_task(int pid)
{
    int ret = 0;
    struct task_struct *task = NULL;

    cli();
    if(pid < 0)
    {
    ret = 1;
    goto end;
    }
    
    //查询是否存在这个pid的任务
    task = query_task_from_hash(pid);
    if(!task)
    {
    ret = 2;
    goto end;
    }
    
    //判断该任务的状态，是否是RUNNING态
    if(task->state != TASK_STATE_RUNNING)
    {
    ret = 3;
    goto end;
    }

    //把该任务从运行队列移除
    remove_task_from_running(task);    
    
    //把该任务添加到挂起队列
    insert_task_to_suspend(task);
    
    //判断当前运行队列是否为空，假如为空则唤醒任务0
    if(cpu0.active->task_nr == 0 && cpu0.expired->task_nr == 0)
    {
    //把该任务从挂起队列删除
    remove_task_from_suspend(&task0);    

    //删除任务0上的定时器
    remove_task_timer(&task0);
    
        //把该任务添加到运行队列
    insert_task_to_running(&task0, cpu0.expired);

    }
    //判断该PID是否是当前任务的PID
    if(task == current)
    {
    scheduler();
    }
    
end:
    sti();
    return ret;
}

//把任务从挂起态唤醒
//该函数访问共享资源，因此需要关中断
int sys_resume_task(int pid)
{
    int ret = 0;
    struct task_struct *task = NULL;

    cli();
    if(pid < 0)
    {
    ret = 1;
    goto end;
    }
    
    //查询是否存在这个pid的任务
    task = query_task_from_hash(pid);
    if(!task)
    {
    ret = 2;
    goto end;
    }
    
    //判断该任务的状态，是否是SUSPEND态
    if(task->state != TASK_STATE_SUSPEND)
    {
    ret = 3;
    goto end;
    }

    //把该任务从挂起队列删除
    remove_task_from_suspend(task);    

    //删除任务上的定时器
    remove_task_timer(task);
    
    //把该任务添加到运行队列
    insert_task_to_running(task, cpu0.expired);
    
    
end:
    sti();
    return ret;
}


//删除任务
//该函数访问共享资源，因此需要关中断
int sys_delete_task(int pid)
{
    int ret = 0;
    struct task_struct *task = NULL;

    cli();
    if(pid <= 0)  //不能删除任务0,因为任务0有回收死亡任务的作用  
    {
    ret = 1;
    goto end;
    }
    
    //查询是否存在这个pid的任务
    task = query_task_from_hash(pid);
    if(!task)
    {
    ret = 2;
    goto end;
    }
    
    //判断该任务的状态
    switch(task->state)
    {
    case TASK_STATE_RUNNING:
        //把该任务从运行队列移除
        remove_task_from_running(task);    
        break;

    case TASK_STATE_SUSPEND:
        //把该任务从挂起队列删除
        remove_task_from_suspend(task);
        break;

    case TASK_STATE_DEAD:
        ret = 3;
        goto end;
        break;

    default:
        break;
    }
    

    //删除该任务上的定时器
    remove_task_timer(task);

    //把该任务添加到死亡队列
    insert_task_to_dead(task);


    //判断当前运行队列是否为空，假如为空则唤醒任务0
    if(cpu0.active->task_nr == 0 && cpu0.expired->task_nr == 0)
    {
    //把该任务从挂起队列删除
    remove_task_from_suspend(&task0);    
    
    //删除任务0上的定时器
    remove_task_timer(&task0);

        //把该任务添加到运行队列
    insert_task_to_running(&task0, cpu0.expired);

    }
    
    //判断该PID是否是当前任务的PID
    if(task == current)
    {
    scheduler();
    }
    
end:
    sti();
    return ret;
}



//移除死亡任务，从任务HASH表上删除，并释放任务所占的资源（比如内存）
//该函数访问共享资源，因此需要关中断
int sys_clear_dead_task()
{
    //关中断
    cli();

    int ret = 0;    
    //查看死亡队列是否为空
    if(dead_tasks.list.head == NULL)
    {
    ret = 1;
    goto end;
    }

    //遍历死亡队列
    struct task_struct *p = dead_tasks.list.head;
    struct task_struct *tmp = NULL;
    while(p)
    {
    printf("clear dead task pid=%d\n", p->pid);
    //从hash表中移除该任务
    remove_task_from_hash(p);

    //从死亡队列中移除该任务
    remove_task_from_dead(p);
    
    //回收死亡任务所占的资源
    //回收内存
    free((void*)(p->stack0 - p->stack0_size));
    free((void*)(p->stack3 - p->stack3_size));
    tmp = p;
    p = p->next;
    free((void*)tmp);
    }

end:

    //开中断
    sti();
    return ret;
}



//睡眠函数，已ms为单位 1s = 1000ms
//参数ms == 0时表示该任务需要挂起，然后等待其他任务唤醒
int sys_sleep(int ms)
{
    int ret = 0;
    if(ms < 0)
        return 1;

    //先把睡眠时间转换为时间片
    int time_slice = 0;
    time_slice = ms*HZ/1000;
    if(time_slice == 0)
    time_slice = 1;

    //初始化定时器
    current->timer.task = current;
    current->timer.next = current->timer.prev = NULL;
    current->timer.time_slice = time_slice;

    //关中断
    cli();

    //把定时器插入定时器链表
    add_timer(&(current->timer));

    //调用sys_suspend_task函数，把自己挂起
    ret = sys_suspend_task(current->pid);

    //开中断
    sti();

    return ret;
}

void check_timer()
{

    struct timer *p = NULL , *tmp = NULL;
    p = task_timer_list.head;
    //检查定时器链表
    if(p)    //链表上有定时器
    {
    //定时器到点
    if(--(p->time_slice) == 0)
    {
        //可能有多个定时器到点
        while(p && p->time_slice == 0)
        {
    
        if(p->next == NULL)    //只剩下一个定时器
        {
            task_timer_list.head = task_timer_list.tail = NULL;
        }
        else     //剩下多个定时器
        {
           task_timer_list.head = p->next;
           task_timer_list.head->prev = NULL; 
        }

            
        //定时器的任务为空可能是因为该任务已被删除(sys_remove_task)
        //定时器指定的任务有可能已经被其他任务唤醒了（使用resume_task系统调用）
        if(p->task && p->task->state == TASK_STATE_SUSPEND)
        {
            //从挂起队列中移除任务
            remove_task_from_suspend(p->task);

            //把任务插入到运行队列
            insert_task_to_running(p->task, cpu0.expired);
        }
            
        tmp = p;
        p = p->next;
        
        //初始化定时器
        init_task_timer(tmp);
        }
    }


    }
}


int sys_send_msg(int pid, struct msg *msg)
{
    
    int ret = 0;
    struct task_struct *task = NULL;

    cli();
    if(pid < 0 || !msg)
    {
    ret = 1;
    goto end;
    }
    
    //查询是否存在这个pid的任务
    task = query_task_from_hash(pid);
    if(!task)
    {
    ret = 2;
    goto end;
    }

    //查看任务的信箱是否有空位
    if(task->msgbox.msg_nr < TASK_MSG_NR) //有空位
    {
    //复制消息到任务的信箱的空位中
    task->msgbox.msg_end = ++(task->msgbox.msg_end)%TASK_MSG_NR;
    task->msgbox.box[task->msgbox.msg_end] = *msg;

    //消息数目增1
    ++(task->msgbox.msg_nr); 
    }
    else //无空位
    {
    ret = 3;
    goto end;
    }
end:
    sti();
    return ret;
}


int sys_receive_msg(struct msg *msg)
{
    int ret = 0;

    cli();
    if(!msg)
    {
    ret = 1;
    goto end;
    }

    //查看任务的信箱是否有消息
    if(current->msgbox.msg_nr > 0) //有消息
    {
    //复制任务信箱中的消息到msg中
    current->msgbox.msg_start = ++(current->msgbox.msg_start)%TASK_MSG_NR;
        *msg =     current->msgbox.box[current->msgbox.msg_start];

    //消息数目减1
    --(current->msgbox.msg_nr); 
    }
    else //无消息
    {
    ret = 2;
    goto end;
    }
end:
    sti();
    return ret;
}


metaxen
关注
专栏目录
定时器/计数器设计实验
行也思君
12-12 3569
要求：了解定时器的各种工作方式， 掌握定时器/计数器的使用和编程方法  实验题目：采用12MHZ时钟频率的单片机，通过一个开关输入，触发定时计数。按下开关10次，计算按键的平均时间，并通过数码管显示出来。 #include #include #define uint unsigned int #define uchar unsigned char uchar code DSY_COD
定时器 / 计数器 实验报告
10-20
实验目的 1.学会8253芯片和微机接口的原理和方法。 2.掌握8253定时器/计数器的工作方式和编程原理。 实验环境 系统平台：Windows XP 编译环境：启东试验教学平台
任务定时器
qq_39691716的博客
11-19 280
任务定时器模块（后续会随着经验增加不断完善） using System.Collections; using System.Collections.Generic; using UnityEngine; public delegate void TaskTimerCallBack(object param); public class TaskTimer { private Dictionary<TaskTimerCallBack, TaskTimerParameter> _dicTo
高效软件定时器的设计
亦大乐谍的嵌入式分享小站——思考/验证/总结/分享
07-08 5012
软件定时器在协议栈等很多场景都有广泛的应用，有时候会有大量的定时器同时处于工作状态，需要管理，它们的超时时间各异，要高效的保证每个定时器都能够较为准确的超时并执行到其回调函数并不是一件易事。本文分析嵌入式实时操作系统Nucleus的定时器方案，它巧妙的管理了一条按照相对时间来排序的双向链表，避免每次tick中断都要遍历链表检查超时和更新剩余时间，实现了一种相当高效的软件定时器。
聊聊C++任务定时器的设计与具体实现
FlushHip
11-03 9178
在项目中，经常会遇到这种场景：在特定的时间点去执行一些任务，这就是定时任务。 如何实现定时任务呢？如果不用任何技巧，我们可以把当前线程睡一睡，睡到特定的时间点再起来执行特定任务。看起来是解决了这个问题，但是，如果在睡一睡的这个过程，我还想执行一些其他的任务，怎么办？好像也可以解决，开一条新的线程去睡；如果在睡的过程中我不想再执行这个任务了，怎么办，直接中断线程？C++11没有这个机制，虽然这个机制...
Linux内核设计与实现 总结笔记（第十一章）定时器和时间管理
weixin_30781775的博客
06-25 271
时间管理在内核中占用非常重要的地位，内核中有大量的函数都需要基于时间驱动的，内核对相对时间和绝对时间都非常需要。 一、内核中的时间概念 内核必须在硬件的帮助下才能计算和管理时间，系统定时器以某种频率自行触发（击中hitting或者射中popping）时钟中断，该频率可以通过编程预定，称作节拍率。 因为预编的节拍率对内核来说是可知的，所以内核知道连续两次时钟中断的间隔时间，这个间隔时间称为节拍...
Linux内核设计与实现 第四章 进程调度
weixin_55255438的博客
09-04 879
进程调度程序（常简称调度程序）可看做在运行态进程之间分配有限的处理器时间资源的内核子系统。最大限度地利用处理器时间的原则是：只要有可执行的进程，那么就总会有进程正在执行。但是只要系统中可运行的进程的数量比处理器的个数多，就注定某一给定时刻会有一些进程不能执行。这些进程在等待运行。在一组处于可运行状态的进程中选择一个来执行，是调度程序所需完成的基本工作。
《STM32嵌入式系统设计与应用》 课件第6章 STM32定时器系统.pptx
03-25
本文将深入探讨《STM32嵌入式系统设计与应用》课件第六章的内容——STM32定时器系统，详细介绍STM32定时器的基本概念、类型以及应用实例。 #### 二、STM32定时器概述 STM32微控制器内置了多种类型的定时器，以满足...
嵌入式复习-第八章 定时器原理及应用
最新发布
06-10
1. **SysTick定时器**：这是一个24位递减计数器，用于提供基本的时间基准，常用于实现简单的延迟或定时任务。 2. **实时时钟(RTC)**：用于实现高精度的日期和时间管理，适用于长时间运行的系统。 3. **看门狗...
第3章 MCS-51单片机指令系统与汇编语言程序设计.pdf
06-11
在深入探讨MCS-51单片机指令系统与汇编语言程序设计之前，我们需要了解单片机的基本概念及其在程序设计中的重要性。单片机，又称微控制器，是一种集成电路芯片，它将CPU、存储器、各种输入输出接口等集成在一块芯片...
c语言流水灯定时器延时,实现流水灯以间隔500ms的时间闪烁（系统定时器SysTick实现的精确延时）...
weixin_32143729的博客
05-22 5078
/********************************************************************************* @file main.c* @author iuc* @version version 1.0* @date 2015-5-19 19:37:52* @brief 流水灯闪烁*********************...
用四位led数码管作显示器的篮球比赛24秒计时器求c语言代码,篮球比赛计时器的设计与实现...
weixin_29127653的博客
05-25 2731
摘要本文主要介绍：篮球比赛计时器。本文首先介绍单片机的相关知识，对单片机进行相应的研究，并将其与74HC595串行显示电路配合使用。本电路主要核心是AT89S51，利用软件和硬件的结合实现开机自动置节计数器为第一节，节计时器为12分00秒，24秒违例为24秒。用数字显示篮球比赛当时节数，每节时间及24秒的倒计时，采用单片机串行显示。最后，本文会详细叙述此电路的安装与调试，并对调试过程中出现的问题做...
定时任务设计(二)：Quartz
寒士一枚
12-01 1178
核心接口和类Scheduler接口：调度器接口，包含任务的调度管理；Job接口：自定义的“定时程序”实现此接口的 void execute(JobExecutionContext arg0)方法，Job还有一类为有状态的StatefulJob接口，如果我们需要在上一个作业执行完后，根据其执行结果再进行下次作业的执行，则需要实现此接口。JobDetail类：具体某个定时程序的详细描述，包括Name,
定时器的设计的几种思路
zj
10-19 2728
原文：高效定时器的设计_青萍之末的博客-CSDN博客 文章目录 一、timerfd 二、定时器的概念 三、排序链表 四、最小堆（优先队列） 五、时间轮（环形队列+双向链表） 五、红黑树（std::set自动排序） 一、timerfd 调用timerfd_create()创建一个时间文件描述符即把时间变为文件描述符，定时器超时则文件描述符会变得可读，这样可以和epoll结合起来，统一处理I/O事件和超时事件。可以把timerfd和时间戳一起作为key，避免两个定时器相同的情况。 二、定时器的概念 网络编程
linux定时任务的作用和意义是什么,Linux /etc/cron.d作用（转自 定时任务crontab cron.d）...
weixin_28812205的博客
05-14 446
一、cron.d增加定时任务当我们要增加全局性的计划任务时，一种方式是直接修改/etc/crontab。但是，一般不建议这样做，/etc/cron.d目录就是为了解决这种问题而创建的。例如，增加一项定时的备份任务，我们可以这样处理：在/etc/cron.d目录下新建文件backup.sh，内容如下：# m h dom mon dow user command* 1 * * * root /sbin...
第9章 设置ISR(中断处理函数)
存储实验室
09-04 2337
中断处理有三个阶段 1、进入阶段：栈保存(带出错码的中断、不带出错码的中断) 2、处理阶段：中断处理 3、退出阶段：恢复栈 80x86中有特权级的概念，不同的特权级有不同的栈，所以中断发生时要保存中断前的栈地址。 查看intel使用手册
第10章 时钟中断(PIT编程)
存储实验室
09-04 1830
设置时钟中断就是给操作系统加上心跳。设置时钟中断就是是设置PIT（8253/54芯片），可参考 《IBM-PC汇编语言程序设计 第2版》p384。 PIT有一个控制寄存器(0x43)和三个计数寄存器(0x40~0x42)。三个计数寄存器是16位的，有两种表示形式(BCD
第4章 进入保护模式(设置GDT全局描述符表)
存储实验室
09-04 1646
进入保护模式的步骤是： 1、关中断； 2、打开A20地址线，使之能访问1M以上的内存； 3、设置GDT； GDT知识可查看《Intel微处理器 第8版》p541 也可以查看 Intel开发手册 4、加载GDT； 5、进入保护模式，跳转到setup.s bo
电子时钟课程设计：基于AT89C51的接口与中断系统
第二章详细介绍了系统功能模块的设计，包括时间的计算和显示。分和时通常通过软件计数器管理，每过60秒或60分钟进行一次进位。考虑到实际显示需要十进制格式，但在程序中处理的是十六进制数据，因此需要在程序中实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值