Пример #1
0
void _benmain(void)
{
	struct FIFO32 fifo;
	int keybuf[128]={0};
	fifo32_init(&fifo, 128, keybuf);
	struct TSS32 tss_a = {0};
	cons_init();
	env_init();

	/* keyboard setting */
	init_kb(&fifo, 256);

	tss_a.ldtr = 0;
	tss_a.iomap = 0x40000000;
	set_segmdesc(gdt + 0, 103, (int) &tss_a, AR_TSS32);

	task_init(memman);
	/* Unfortunate try the switch back to 0*8 (_benmain) with farjmp but not working.
	* And the reason still unknown.
	* So that I use another thread_kb_io() to catch the keyboard interrupt.
	*/
	load_tr(0 * 8); // record current working task to tss_a
	task_create((int) &thread_kb_io, memman, "bshell", 1);
	task_create((int) &thread_events, memman, "events", 0);

	/* strange issue encountered if run pci_init at the setup_hw() */
	puts("pci scan bus\n");
	pci_init();
	farjmp(0, 4*8);

	puts("\nSystem Halted                                    \n");
	_syshalt();
}
Пример #2
0
void task_sleep(struct TASK *task)
{
     int i;
     char ts = 0;
     if (task->flags == 2) {
	if (task == taskctl->tasks[taskctl->now]) {
	   ts = 1;
	}

	for (i = 0; i < taskctl->running; i++) {
	    if (taskctl->tasks[i] == task) {

		break;
	    }
	}
	taskctl->running--;
	if (i < taskctl->now) {
	   taskctl->now--;
	}
	
	for (; i < taskctl->running; i++) {
	    taskctl->tasks[i] = taskctl->tasks[i + 1];
	}
	task->flags = 1;
	if (ts != 0) {
	
	    if (taskctl->now >= taskctl->running) {

		taskctl->now = 0;
	    }
	    farjmp(0, taskctl->tasks[taskctl->now]->sel);
	}
     }
     return;
}
Пример #3
0
void task_sleep(struct TASK *task)
{
	int i;
	char ts = 0;
	if (task->flags == 2) {		/* 指定タスクがもし起きていたら */
		if (task == taskctl->tasks[taskctl->now]) {
			ts = 1; /* 自分自身を寝かせるので、あとでタスクスイッチする */
		}
		/* taskがどこにいるかを探す */
		for (i = 0; i < taskctl->running; i++) {
			if (taskctl->tasks[i] == task) {
				/* ここにいた */
				break;
			}
		}
		taskctl->running--;
		if (i < taskctl->now) {
			taskctl->now--; /* ずれるので、これもあわせておく */
		}
		/* ずらし */
		for (; i < taskctl->running; i++) {
			taskctl->tasks[i] = taskctl->tasks[i + 1];
		}
		task->flags = 1; /* 動作していない状態 */
		if (ts != 0) {
			/* タスクスイッチする */
			if (taskctl->now >= taskctl->running) {
				/* nowがおかしな値になっていたら、修正する */
				taskctl->now = 0;
			}
			farjmp(0, taskctl->tasks[taskctl->now]->sel);
		}
	}
	return;
}
Пример #4
0
void task_b_main (struct SHEET *sht_back)
{
  struct FIFO32 fifo;
  struct TIMER *timer_ts, *timer_put;
  int i, fifobuf[128], count = 0;

  fifo32_init(&fifo, 128, fifobuf);
  timer_ts = timer_alloc();
  timer_init(timer_ts, &fifo, 2);
  timer_settime(timer_ts, 2);
  timer_put = timer_alloc();
  timer_init(timer_put, &fifo, 1);
  timer_settime(timer_put, 1);
  
  for (;;) {
    count++;
    io_cli();
    if (fifo32_status(&fifo) == 0) {
      io_stihlt();
    } else {
      i = fifo32_get(&fifo);
      io_sti();
      if (i == 1) {
        char s[11];
        sprintf (s, "%d", count);
        putfonts8_asc_sht (sht_back, 0, 144, COL8_FFFFFF, COL8_008484, s, 11);
        timer_settime (timer_put, 1);
      } else if (i == 2) {  // timeout 5 sec
        farjmp(0, 3 * 8);
        timer_settime(timer_ts, 2);
      }
    }
  }
}
Пример #5
0
/* will be directly called by inthandler20 */
void task_switch(void) {
	struct TASKLEVEL *tl = &taskctl->level[taskctl->now_lv];
	struct TASK *new_task, *now_task = tl->tasks[tl->now];

	/* 
		why can't we use this??
		tl->now = (tl->now + 1) % (tl->running);
	*/
		
	tl->now++;
	if (tl->now == tl->running) {
		tl->now = 0;
	}

	/* need to make sure we are runnig the curret task, update correct running level */
	if(taskctl->lv_change != 0) {
		task_switchsub();
		tl = &taskctl->level[taskctl->now_lv];
	}

	new_task = tl->tasks[tl->now];
	/* align time slice to new task now */
	timer_settime(task_timer, new_task->priority);

	/* if it's not the same task jump to the new task */
	if(new_task != now_task) {
		farjmp(0, new_task->sel);
	}
	return;
}
Пример #6
0
void task_b_main(void)
{
	struct FIFO32 fifo;
	struct TIMER *timer_ts;
	int i, fifobuf[128];

	fifo32_init(&fifo, 128, fifobuf);
	timer_ts = timer_alloc();
	timer_init(timer_ts, &fifo, 1);
	timer_settime(timer_ts, 2);

	for (;;) {
		io_cli();
		if (fifo32_status(&fifo) == 0) {
			io_sti();
			io_hlt();
		} else {
			i = fifo32_get(&fifo);
			io_sti();
			if (i == 1) { /* タスクスイッチ */
				farjmp(0, 3 * 8);
				timer_settime(timer_ts, 2);
			}
		}
	}
}
Пример #7
0
void _benmain(void)
{
	int i;
	int c = 0;
	int keybuf[128]={0};
	struct FIFO32 fifo;
	struct TIMER *timer;
	fifo32_init(&fifo, 128, keybuf);
	struct TSS32 tss_a, tss_c;
	env_init();

	/* keyboard setting */
	init_kb(&fifo, 256);

	i=0;	

	timer = timer_alloc();
	timer_init(timer, &fifo, 1);
	timer_settime(timer, 50);

	tss_a.ldtr = 0;
	tss_a.iomap = 0x40000000;
	tss_c.ldtr = 0;
	tss_c.iomap = 0x40000000;
	set_segmdesc(gdt + 3, 103, (int) &tss_a, AR_TSS32);

	task_init(memman);

	/* Unfortunate try the switch back to 3*8 (_benmain) with farjmp but not working.
	* And the reason still unknown.
	* So that I use another thread_kb_io() to catch the keyboard interrupt.
	*/

	load_tr(3 * 8); // record current working task to tss_a
	task_create((int) &thread_kb_io, memman, "bshell");

	/* strange issue encountered if run pci_init at the setup_hw() */
	puts("pci scan bus\n");
	pci_init();
	for (;;) {
		asm_cli();
		if (fifo32_status(&fifo) == 0) {
			asm_stihlt(); // wake while keyboard input 
			// got a interrupt
		} else { /* scan_code input */
			c=fifo32_get(&fifo);
			asm_sti();
			if (c == 1) { 
				farjmp(0, 4*8);
			} else {
				puts("disabled boot options.\n");
			}
		}
	}
	puts("\nSystem Halted                                    \n");
	_syshalt();
}
Пример #8
0
/* 任务切换函数 */
void mt_taskswitch(void)
{
	if (mt_tr == 3 * 8) {
		mt_tr = 4 * 8;
	} else {
		mt_tr = 3 * 8;
	}
	timer_settime(mt_timer, 2);
	farjmp(0, mt_tr);				/* 远跳转 */
	return;
}
Пример #9
0
void task_switch(void)
{
	timer_settime(task_timer, 2);
	if (taskctl->running >= 2) {
		taskctl->now++;
		if (taskctl->now == taskctl->running) {
			taskctl->now = 0;
		}
		farjmp(0, taskctl->tasks[taskctl->now]->sel);
	}
	return;
}
Пример #10
0
//任务切换
void task_switch(void)
{
	timer_set(task_timer, 2);
	if(taskctl->running_number >= 2)			//只要当前运行中的任务有两个以上,就进行任务切换,否则直接结束
	{
		taskctl->task_now++;
		if(taskctl->task_now == taskctl->running_number)
		{
			taskctl->task_now = 0;
		}
		farjmp(0, taskctl->running_tasks[taskctl->task_now]->selector);
	}
	return ;
}
Пример #11
0
void task_switch(void)
{
	struct TASK *task;
	taskctl->now++;
	if (taskctl->now == taskctl->running) {
		taskctl->now = 0;
	}
	task = taskctl->tasks[taskctl->now];
	timer_settime(task_timer, task->priority);
	if (taskctl->running >= 2) {
		farjmp(0, task->sel);
	}
	return;
}
Пример #12
0
void task_sleep(task_t* task)
{
    task_t* now_task;
    if (task->flags == 2) {
        /* 活动中 */
        now_task = task_now();
        task_remove(task); /* flags变1 */
        if (task == now_task) {
            /* 如果是让自己休眠,则需要切换任务 */
            task_switchsub();
            now_task = task_now(); /* 设置后获取当前任务值 */
            farjmp(0, now_task->sel);
        }
    }
}
Пример #13
0
void task_sleep(struct TASK *task)
{
  struct TASK *now_task;
  if (task->flags == 2) { // if specified task is waken
	now_task = task_now();
	task_remove (task);
	if (task == now_task) {
	  task_switchsub ();
	  now_task = task_now ();
	  farjmp (0, now_task->sel);
	}
  }

  return;
}
Пример #14
0
void task_sleep(TASK* task) {
  if (task->flags != RUNNING)
    return;

  // TODO: Need to prevent interrupt?

  TASK* now_task = task_now();
  task_remove(task);  // This makes the task ALLOCATED (sleep).
  if (task == now_task) {
    // Sleep by self => need task switch.
    task_switchsub();
    now_task = task_now();
    farjmp(0, now_task->sel);
  }
}
Пример #15
0
void task_sleep(struct TASK *task)
{
	struct TASK *now_task;
	if (task->flags == 2) {
		/* 動作中だったら */
		now_task = task_now();
		task_remove(task); /* これを実行するとflagsは1になる */
		if (task == now_task) {
			/* 自分自身のスリープだったので、タスクスイッチが必要 */
			task_switchsub();
			now_task = task_now(); /* 設定後での、「現在のタスク」を教えてもらう */
			farjmp(0, now_task->sel);
		}
	}
	return;
}
Пример #16
0
/* 使某任务睡眠 */
void task_sleep(struct TASK *task)
{
	struct TASK *now_task;
	if (task->flags == 2) {
		/* 如果处于活动状态 */
		now_task = task_now();	/* 获得当前正在运行的任务的task指针 */
		task_remove(task); /* 执行词语句的话flag会等于1 */
		if (task == now_task) {
			/* 如果是让自己休眠 则需要任务切换 */
			task_switchsub();
			now_task = task_now(); /* 在设定后获取新的level中待运行的任务 */
			farjmp(0, now_task->sel);	/* 切换任务 */
		}
	}
	return;
}
Пример #17
0
/* remove task from its level */
void task_sleep(struct TASK *task) {
	struct TASK *current_task;
	/* if the task is running then we remove it from running buffer and mark it as not running */
	if(task->flags == 2) {
		current_task = task_now();
		/*task->flags would become 1 */
		task_remove(task);

		/* if a task is termination it self, need to explicitly jump to the new running task */
		if(task == current_task) {
			task_switchsub();
			current_task = task_now();
			farjmp(0, current_task->sel);
		}
	}
	return;
}
Пример #18
0
//任务休眠
void task_sleep(TASK *task)
{
	TASK *now_task;
	if (task->flags == RUNNING) 
	{
		now_task = task_now();
		task_remove(task);		//执行这行代码之后只是把task从level中移除了,并且flags变成SLEEP状态,但是task本身并没有被释放
		if (task == now_task)
		{
			/*如果是自己让自己休眠的情况还需要任务转换*/
			level_switch();
			now_task = task_now(); 
			farjmp(0, now_task->selector);
		}
	}
	return;
}
Пример #19
0
void Task::sleep(){

	Task *now_task;
	//もし対象のタスクが動いていたら
	if(this->flags == 2){

	  now_task = TaskControll::task_now();
	  TaskControll::task_remove(this); //flags = 1
	  if(this == now_task){
		//自身が現在のタスクでスリープにするとき
		TaskControll::task_switchsub();
		now_task = TaskControll::task_now();
		farjmp(0,now_task->sel);
	  }
	}
	return;
}
Пример #20
0
/**
 *	@description	休眠任务
 *	@param			task:欲休眠的任务
 *	@notice			休眠任务自己将会引起任务切换
 */
void task_sleep(struct TASK *task){
	struct TASK *now_task;

	//TODO 任务有效性检查
	if (task->flags == 2) {
		now_task = task_now();
		task_remove(task);
		if (task == now_task) {
			//TODO 当前任务,则立即休眠
			task_switchsub();
			//TODO 获得跳转的目标任务,以跳转
			now_task = task_now();
			farjmp(0, now_task->sel);
		}
	}
	return;
}
Пример #21
0
/**
 *	@description	任务调度
 */
void task_switch(void){
	struct TASKLEVEL *tl = &taskctl->level[taskctl->now_lv];
	struct TASK *new_task, *now_task = tl->tasks[tl->now];
	tl->now++;
	if (tl->now == tl->running) {
		tl->now = 0;
	}
	if (taskctl->lv_change != 0) {
		task_switchsub();
		tl = &taskctl->level[taskctl->now_lv];
	}
	new_task = tl->tasks[tl->now];
	timer_settime(task_timer, new_task->priority);
	if (new_task != now_task) {
		farjmp(0, new_task->sel);
	}
	return;
}
Пример #22
0
////将该任务从可裕兴队列中移除,同时设置为参数指定的状态
//参数:task -- 需要操作的任务, task_status -- task被设成这个任务状态
static void _task_change_status(struct TASK *task, enum TASK_STATUS task_status)
{
	struct TASK *now_task;
	if (task->flags == TASK_STATUS_RUNNING) {
		/* 如果处于活动状态 */
		now_task = task_now();
		task_remove(task, task_status); 
		if (task == now_task) {
			/* 如果是让自己休眠,则需要进行任务切换 */
			task_switchsub();
			now_task = task_now(); /* 在设定后获取当前任务的值 */
			//debug("process[%d,%s] go to sleep, process[%d,%s] is running",task->pid,task->name,now_task->pid,now_task->name);
			farjmp(0, now_task->sel);
			
		}
	}
	return;
}
Пример #23
0
void task_sleep(struct _task *task) {
    struct _task *now_task;
    if (task->flags == TASK_RUNNING) {
        /* If current task is running */
        now_task = task_now();
        /* Set 'task' back to READY state */
        task_remove(task);
        /* Sleep yourself */
        if (task == now_task) {
            /* Recalebrate Level */
            task_switchsub();
            /* Switch Current Task */
            now_task = task_now();
            /* JMP */
            farjmp(0, now_task->sel);
        }
    }
    return;
}
Пример #24
0
void scheduler()
{
    while(true) {
        cli();
        while(ready.size == 0) {
            __asm__ volatile(
                "sti;"
                "hlt;"
            );
        }
        CURRENT_TASK = ready.head;
        CURRENT_TASK->status = RUNNING;
        ready.head = CURRENT_TASK->next;
        if(--ready.size == 0)
            ready.tail = NULL;
        farjmp(0, CURRENT_TASK->pid << 3);
        sti();
    }
}
Пример #25
0
void task_switch(void) {
  if (taskctl->now_lv >= MAX_TASKLEVELS) {
    io_stihlt();
    return;
  }

  TASKLEVEL* tl = &taskctl->level[taskctl->now_lv];
  TASK* now_task = tl->tasks[tl->now++];
  if (tl->now >= tl->running)
    tl->now = 0;
  if (taskctl->lv_change) {
    task_switchsub();
    tl = &taskctl->level[taskctl->now_lv];
  }
  TASK* new_task = tl->tasks[tl->now];
  timer_settime(task_timer, new_task->priority);
  if (new_task != now_task)
    farjmp(0, new_task->sel);
}
Пример #26
0
/* 该函数只在void inthandler20(int *esp)时钟中断处理中被调用 */
void task_switch(void)
{
	struct TASKLEVEL *tl = &taskctl->level[taskctl->now_lv];
	struct TASK *new_task, *now_task = tl->tasks[tl->now];
	tl->now++;
	if (tl->now == tl->running) {
	/* 当now出现异常时调整它 */
		tl->now = 0;
	}	
	if (taskctl->lv_change != 0) {		/* 是否需要检测level */
		task_switchsub();	/* 寻找最上层的level */
		tl = &taskctl->level[taskctl->now_lv];	/* 修改tl让它指向最上层的level */
	}
	new_task = tl->tasks[tl->now];
	timer_settime(task_timer, new_task->priority);
	if (new_task != now_task) {
		farjmp(0, new_task->sel);
	}
	return;
}
Пример #27
0
void cmd_hlt(struct CONSOLE *cons, int *fat)
{
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	struct FILEINFO *finfo = file_search("HLT.HRB", (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
	char *p;
	if (finfo != 0) {
		/* ファイルが見つかった場合 */
		p = (char *) memman_alloc_4k(memman, finfo->size);
		file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
		set_segmdesc(gdt + 1003, finfo->size - 1, (int) p, AR_CODE32_ER);
		farjmp(0, 1003 * 8);
		memman_free_4k(memman, (int) p, finfo->size);
	} else {
		/* ファイルが見つからなかった場合 */
		putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
		cons_newline(cons);
	}
	cons_newline(cons);
	return;
}
Пример #28
0
void TaskControll::task_switch(void){

  TaskLevel *tl = &TaskControll::level[TaskControll::now_lv];
  Task *now_task = tl->tasks[tl->now];
  Task *new_task;
  tl->now++;
  if(tl->now == tl->running){
	tl->now = 0;
  }
  //タスクレベルの切り替え
  if(TaskControll::lv_change != 0){
	task_switchsub();
	tl = &TaskControll::level[TaskControll::now_lv];
  }
  new_task = tl->tasks[tl->now];
  TaskControll::timer->settime(new_task->priority);
  //実際のタスクの切り替え
  if(new_task != now_task){
	farjmp(0,new_task->sel);
  }
	return;
}
Пример #29
0
void task_switch(void) {
    struct _tasklevel *tl = &taskctl->level[taskctl->now_lv];
    struct _task *new_task, *now_task = tl->tasks[tl->now];
    /* Switch to current level:next task */
    tl->now++;
    /* Reset to beginning when proceed to the end */
    if (tl->now == tl->running) {
        tl->now = 0;
    }
    /* If it requires level switching */
    if (taskctl->lv_change != 0) {
        task_switchsub();
        tl = &taskctl->level[taskctl->now_lv];
    }
    new_task = tl->tasks[tl->now];
    /* Timeslice allocation depends on its priority */
    timer_settime(task_timer, new_task->priority);
    /* Only do JMP when there is different task */
    if (new_task != now_task) {
        farjmp(0, new_task->sel);
    }
    return;
}
Пример #30
0
//任务切换,主要是给timer的中断处理程序调用的
void task_switch(void)
{
	TASKLEVEL *tl = &taskctl->task_level[taskctl->lv_now];
	TASK *new_task, *now_task = tl->tasks_lv[tl->task_now];
	tl->task_now++;
	//先把任务所在的当前level中的任务调整好
	if (tl->task_now == tl->running_number)		//如果running_number到最后一个了,就重新回到第一个
	{
		tl->task_now = 0;
	}
	if (taskctl->lv_change != 0)				//如果需要改变level的情况
	{
		level_switch();						//找出当前的最高级level
		tl = &taskctl->task_level[taskctl->lv_now];
	}
	//找出要转换到的那个任务,并且设置好timer,然后执行任务跳转
	new_task = tl->tasks_lv[tl->task_now];
	timer_set(task_timer, new_task->priority);
	if (new_task != now_task) 		//如果转换任务之后发现还是当前任务,就不用跳转了
	{
		farjmp(0, new_task->selector);
	}
	return;
}