scheduler.c

一个用于学习的操作系统

        tmp_task->start_time = 0;               //进程开始的时间
        tmp_task->rss = 0;                      //常驻内存的页面数，暂时不用
        tmp_task->tty = -1;                     /* -1 if no tty, so it must be signed */
        tmp_task->umask = 0;                    //文件创建属性屏蔽位
        tmp_task->pwd = NULL;                   //当前工作目录i节点
        tmp_task->root = NULL;                  //根目录i节点
        tmp_task->executable = NULL;            //执行文件i节点

        tmp_task->tss.cr3 = task0_page_dir;
        tmp_task->original_esp0 = (u32) tmp_task + PAGE_SIZE;
        global_tss.esp0 = tmp_task->original_esp0;

        return tmp_task;
    } else {
        panic("init_task: get pcb failed!");
    }
}

//唤醒一个进程
void wake_up(task_struct_t *task)
{
    if (task) {
        task->state = TASK_RUNNING;
        cli();
        move_wait_to_run(task);
        sti();
    }
}

static inline void __sleep_on(task_struct_t *task, s32 state)
{
    unsigned long flags;

    if (task == pinit_task) {
        panic("task[0] trying to sleep");
    }

    task->state = state;
    cli();
    move_run_to_wait(task);
    sti();
    scheduler();

    remove_wait_queue(task);
}

//可中断睡眠
void interruptible_sleep_on(task_struct_t *task)
{
    if (task) {
        __sleep_on(task, TASK_INTERRUPTIBLE);
    } else {
        printk("interruptible_sleep_on: task is null\n");
    }
}
//不可中断睡眠
void sleep_on(task_struct_t *task)
{
    if (task) {
        __sleep_on(task, TASK_UNINTERRUPTIBLE);
    } else {
        printk("sleep_on: task is null\n");
    }
}

static void init_timer();

//初始化进程调度模块
void init_sched()
{
    init_timer();                   //初始化定时器

    pinit_task = init_task();       //初始化进程0的进程控制块
    //sleep_task = pinit_task;
    current = pinit_task;


    //设置TSS全局描述附
    setup_GDT_entry(&gdt[5], (u32) & global_tss, sizeof(tss_struct), ACS_TSS, 0);

    //gdtr.base = gdt;
    //gdtr.limit = 0x01FF;
    //lgdt(&gdtr);

    load_fs(0x23);
    load_gs(0x23);

    lldt(0);
    ltr(0x28);                  // 加载tr寄存器
}






//--------------------------------------------------------------------
//对定时器进行操作
//--------------------------------------------------------------------
//初始化定时器
static void init_timer()
{
    int i;
    INIT_LIST_HEAD(&timer_head.list);
    timer_head.timer = 0;
    timer_head.timer_dirver = NULL;

    INIT_LIST_HEAD(&free_timer_head.list);
    free_timer_head.timer = 0;
    free_timer_head.timer_dirver = NULL;


    for (i = 0; i < MAX_TIME_REQUESTS; ++i) {
        INIT_LIST_HEAD(&timer_list[i].list);
        timer_list[i].timer = 0;
        timer_list[i].timer_dirver = NULL;

        //此处中断还没有打开
        list_add(&timer_list[i].list,
                 (&free_timer_head.list),
                 free_timer_head.list.next);
    }
}

//取得一个空闲的定时器结构
static timer_struct * get_free_timer_node()
{
    if (free_timer_head.list.next != free_timer_head.list.prev) {
        return (timer_struct *) free_timer_head.list.next;
    } else {
        return NULL;
    }
}

//设置一个定时器
//timer次心跳之后触发
//函数可以优化，在加入时并排序，这样当触发定时器时就不用全部遍历了
int add_timer(u32 timer, dotimefun_ptr timer_trigger, s32 handle)
{
    timer_struct *timer_node = NULL;
    if (!timer) {
        return -1;
    }

    if (timer <= 0) {
        (*timer_trigger) (handle);
        return 0;
    }

    //关中断，需要同步
    cli();
    timer_node = get_free_timer_node();
    if (!timer_node) {
        sti();
        return -1;
    }

    timer_node->timer = timer;
    timer_node->timer_dirver = timer_trigger;
    timer_node->handle = handle;

    list_del((&timer_node->list));
    list_add(&timer_node->list, (&timer_head.list), timer_head.list.next);

    sti();
    return 0;
}

//触发定时器
//当add_timer排序加入时，以后就不用全部遍历了
void spring_timer()
{
    int index = 0;
    int i;
    timer_struct *timer_node = (timer_struct *) timer_head.list.next;
    timer_struct *delete_timer_node[MAX_TIME_REQUESTS];

    memset((void *)delete_timer_node, 0, sizeof(delete_timer_node));

    //遍历定时器列表，触发已到时的触发器
    while (timer_node != (timer_struct *) &timer_head) {
        timer_node->timer -= 1;
        if (timer_node->timer <= 0) {
            (*timer_node->timer_dirver) (timer_node->handle);
            delete_timer_node[index++] = timer_node;
        }

        timer_node = (timer_struct *) timer_node->list.next;
    }

    //删除已经触发过的定时器
    for (i = 0; i < MAX_TIME_REQUESTS; ++i) {
        if (delete_timer_node[i] == NULL) {
            break;
        }

        //此处不需要关中断
        list_del((&delete_timer_node[i]->list));
        list_add(&delete_timer_node[i]->list,
                 (&free_timer_head.list),
                 free_timer_head.list.next);
    }
}

//--------------------------------------------------------------------
//对进程列表进行操作
//--------------------------------------------------------------------
//先简单实现之
//将一个进程的pcb加入到可调度队列中
void add_run_queue(task_struct_t *task)
{
    if (task) {
        list_add(&(task->list), &(pinit_task->list), pinit_task->list.next);
    } else {
        panic("add_run_takk:task is NULL\n");
    }
}

//将一个进程的pcb移出到可调度队列
void remove_run_queue(task_struct_t *task)
{
    if (task) {
        list_del(&(task->list));
    } else {
        panic("delete_run_task:task is NULL\n");
    }
}

//将一个进程的pcb从可调度队列移出到睡眠队列
void move_run_to_wait(task_struct_t *task)
{
    if (task) {
        list_del(&(task->list));
        list_add(&(task->list), &(sleep_task->list), sleep_task->list.next);
    } else {
        panic("move_run_to_sleep:task is NULL\n");
    }
}

//将一个进程的pcb从睡眠队列移出到可调度队列
void move_wait_to_run(task_struct_t *task)
{
    if (task) {
        list_del(&(task->list));
        list_add(&(task->list), &(pinit_task->list), pinit_task->list.next);
    } else {
        panic("move_sleep_to_run:task is NULL\n");
    }
}

//将一个进程的pcb加入到睡眠队列中
void add_wait_queue(task_struct_t *task)
{
    if (task) {
        list_add(&(task->list), &(sleep_task->list), sleep_task->list.next);
    } else {
        panic("add_sleep_task:task is NULL\n");
    }
}

//将一个进程的pcb移出到睡眠度队列
void remove_wait_queue(task_struct_t *task)
{
    if (task) {
        list_del(&(task->list));
    } else {
        panic("delete_sleep_task:task is NULL\n");
    }
}
//--------------------------------------------------------------------