GeekOS源代码学习(6)Main函数中Init_Traps 和 Init_Timer 和 Init_Keyboard

妖狐艹你老母 2022-06-13 11:56 141阅读 0赞

回到Main中，看下一个函数Init\_Traps()

位于./src/geekos/trap.c

/*
     * Initialize handlers for processor traps.
     */
    void Init_Traps(void)
    {
        Install_Interrupt_Handler(12, &GPF_Handler);  /* stack exception */
        Install_Interrupt_Handler(13, &GPF_Handler);  /* general protection fault */
    }

为中断向量12和13安装了一个中断处理函数GPF\_Handler  
GPF\_Handler函数输出当前寄存器状态，并结束当前线程。  
位于/src/geekos/trap.c

/*
     * Handler for general protection faults and other bad errors.
     * Kill the current thread (which caused the fault).
     */
    static void GPF_Handler(struct Interrupt_State* state)
    {
        /* Send the thread to the reaper... */
        Print("Exception %d received, killing thread %p\n",
    	state->intNum, g_currentThread);
        Dump_Interrupt_State(state);
    
        Exit(-1);
    
        /* We will never get here */
        KASSERT(false);
    }

再看Main中的下一个函数Init\_Timer初始化定时器

位于./src/geekos/timer.c

void Init_Timer(void)
    {
        /*
         * TODO: reprogram the timer to set the frequency.
         * In bochs, it defaults to 18Hz, which is actually pretty
         * reasonable.
         */
    
        Print("Initializing timer...\n");
    
    
        /* Calibrate for delay loop */
        Calibrate_Delay();
        Print("Delay loop: %d iterations per tick\n", s_spinCountPerTick);
    
        /* Install an interrupt handler for the timer IRQ */
        Install_IRQ(TIMER_IRQ, &Timer_Interrupt_Handler);
        Enable_IRQ(TIMER_IRQ);
    }

首先的Calbrate\_Delay()函数用于测试系统时钟。  
Calbrate\_Delay位于./src/geekos/timer.c

/*
     * Calibrate the delay loop.
     * This will initialize s_spinCountPerTick, which indicates
     * how many iterations of the loop are executed per timer tick.
     */
    static void Calibrate_Delay(void)
    {
        Disable_Interrupts();
    
        /* Install temporarily interrupt handler */
        Install_IRQ(TIMER_IRQ, &Timer_Calibrate);
        Enable_IRQ(TIMER_IRQ);
    
        Enable_Interrupts();
    
        /* Wait a few ticks */
        while (g_numTicks < CALIBRATE_NUM_TICKS)
    	;
    
        /*
         * Execute the spin loop.
         * The temporary interrupt handler will overwrite the
         * loop counter when the next tick occurs.
         */
        Spin(INT_MAX);
    
        Disable_Interrupts();
    
        /*
         * Mask out the timer IRQ again,
         * since we will be installing a real timer interrupt handler.
         */
        Disable_IRQ(TIMER_IRQ);
        Enable_Interrupts();
    }

初始化中断函数Timer\_Calibrate后，它进入了while()循环，g\_numTicks全局变量会在中断函数Timer\_Calibrate中增加到CALIBRATE\_NUM\_TICKS。  
看while()后面的Spin(INT\_MAX)函数，这是理解的关键。

位于./src/geekos/timer.c

/*
     * Delay loop; spins for given number of iterations.
     */
    static void Spin(int count)
    {
        /*
         * The assembly code is the logical equivalent of
         *      while (count-- > 0) { // waste some time }
         * We rely on EAX being used as the counter
         * variable.
         */
    
        int result;
        __asm__ __volatile__ (
    	"1: decl %%eax\n\t"
    	"cmpl $0, %%eax\n\t"
    	"nop; nop; nop; nop; nop; nop\n\t"
    	"nop; nop; nop; nop; nop; nop\n\t"
    	"jg 1b"
    	: "=a" (result)
    	: "a" (count)
        );
    }

Spin()先设置eax为INT\_MAX也就是4B的整型数最大值，为2147483647，然后循环，直到eax为0为止。  
Calibrate\_Delay中的while循环只是先让时钟中断运行起来。  
看一下这个用于校正的中断函数Timer\_Calibrate  
位于/src/geekos/timer.c

/*
     * Temporary timer interrupt handler used to calibrate
     * the delay loop.
     */
    static void Timer_Calibrate(struct Interrupt_State* state)
    {
        Begin_IRQ(state);
        if (g_numTicks < CALIBRATE_NUM_TICKS)
    	++g_numTicks;
        else {
    	/*
    	 * Now we can look at EAX, which reflects how many times
    	 * the loop has executed
    	 */
    	/*Print("Timer_Calibrate: eax==%d\n", state->eax);*/
    	s_spinCountPerTick = INT_MAX  - state->eax;
    	state->eax = 0;  /* make the loop terminate */
        }
        End_IRQ(state);
    }

当增加变量g\_numTicks的值到CALIBRATE\_NUM\_TICKS之后，得到s\_spinCountPerTick的值。

流程如下：当g\_numTicks==CALIBRATE\_NUM\_TICKS时，Calibrate\_Delay函数中的循环退出，开始Spin()递减eax,过了一个tick之后，时钟中断触发，再时钟中断函数里看减了几次eax，以此来估计一次时钟中断的时间间隔。  
  
随后才安装了真正的时钟中断函数Timer\_Interrupt\_Handler  
时钟中断为0号外部中断，中断向量为32。  
位于src/geekos/timer.c

static void Timer_Interrupt_Handler(struct Interrupt_State* state)
    {
        struct Kernel_Thread* current = g_currentThread;
    
        Begin_IRQ(state);
    
        /* Update global and per-thread number of ticks */
        ++g_numTicks;
        ++current->numTicks;
    
    
        /*
         * If thread has been running for an entire quantum,
         * inform the interrupt return code that we want
         * to choose a new thread.
         */
        if (current->numTicks >= g_Quantum) {
    	g_needReschedule = true;
        }
    
    
        End_IRQ(state);
    }

可以看到，在时钟中断处理函数中增加了当前的全局时钟g\_numTicks和当前进程的时钟current->numTicks计数。  
如果当前进程的时钟计数达到g\_Quantum则标志需要重新调度。  
g\_currentThread和g\_needReschedule均是全局变量。

再看Main中最后一个初始化函数！Init\_Keyboard

位于./src/geekos/keyboard.c

void Init_Keyboard(void)
    {
        ushort_t irqMask;
    
        Print("Initializing keyboard...\n");
    
        /* Start out with no shift keys enabled. */
        s_shiftState = 0;
    
        /* Buffer is initially empty. */
        s_queueHead = s_queueTail = 0;
    
        /* Install interrupt handler */
        Install_IRQ(KB_IRQ, Keyboard_Interrupt_Handler);
    
        /* Enable IRQ1 (keyboard) */
        irqMask = Get_IRQ_Mask();
        irqMask &= ~(1 << KB_IRQ);
        Set_IRQ_Mask(irqMask);
    }

可以看到它为键盘中断安装了中断响应函数Keyboard\_Interrupt\_Handler

Keyboard\_Interrupt\_Handler位于./src/geekos/keyboard.c

/*
     * Handler for keyboard interrupts.
     */
    static void Keyboard_Interrupt_Handler(struct Interrupt_State* state)
    {
        uchar_t status, scanCode;
        unsigned flag = 0;
        bool release = false, shift;
        Keycode keycode;//Keycode是两个字节
    
        Begin_IRQ(state);
    
        status = In_Byte(KB_CMD);
        IO_Delay();
    
        if ((status & KB_OUTPUT_FULL) != 0) {
    	/* There is a byte available */
    	scanCode = In_Byte(KB_DATA);//得到扫描码，按下键和松开键都会产生扫描码
    	IO_Delay();
    /*
     *	Print("code=%x%s\n", scanCode, (scanCode&0x80) ? " [release]" : "");
     */
    
    	if (scanCode & KB_KEY_RELEASE) {//处理键盘松开时产生的扫描码
    	    release = true;
    	    scanCode &= ~(KB_KEY_RELEASE);
    	}
    
    	if (scanCode >= SCAN_TABLE_SIZE) {
    	    Print("Unknown scan code: %x\n", scanCode);
    	    goto done;
    	}
    
    	/* Process the key */
    	shift = ((s_shiftState & SHIFT_MASK) != 0);//s_shiftState 是全局的变量，用于保存上一个按下的功能键
    	keycode = shift ? s_scanTableWithShift[scanCode] : s_scanTableNoShift[scanCode];
    
    	/* Update shift, control and alt state */
    	switch (keycode) {
    	case KEY_LSHIFT:
    	    flag = LEFT_SHIFT;//flag标志用于记录其他功能键
    	    break;
    	case KEY_RSHIFT:
    	    flag = RIGHT_SHIFT;
    	    break;
    	case KEY_LCTRL:
    	    flag = LEFT_CTRL;
    	    break;
    	case KEY_RCTRL:
    	    flag = RIGHT_CTRL;
    	    break;
    	case KEY_LALT:
    	    flag = LEFT_ALT;
    	    break;
    	case KEY_RALT:
    	    flag = RIGHT_ALT;
    	    break;
    	default:
    	    goto noflagchange;
    	}
    	//代码运行到这里说明扫描码是属于功能键
    	if (release)//是松开而产生的扫描码，比如说松开ctrl键
    	    s_shiftState &= ~(flag);
    	else	
    	    s_shiftState |= flag;//保存标志
    			//功能键松开和按下的扫描码就是flag那一位的不同
    	/*
    	 * Shift, control and alt keys don't have to be
    	 * queued, flags will be set!
    	 */
    	goto done;
    
    noflagchange:
    	/* Format the new keycode */
    	if (shift)
    	    keycode |= KEY_SHIFT_FLAG;
    	if ((s_shiftState & CTRL_MASK) != 0)//处理功能键按下的字符。
    	    keycode |= KEY_CTRL_FLAG;
    	if ((s_shiftState & ALT_MASK) != 0)
    	    keycode |= KEY_ALT_FLAG;
    	if (release)
    	    keycode |= KEY_RELEASE_FLAG;
    		
    	/* Put the keycode in the buffer */
    	Enqueue_Keycode(keycode);
    
    	/* Wake up event consumers */
    	Wake_Up(&s_waitQueue);//唤醒在队列上等待读取缓冲区的进程
    
    	/*
    	 * Pick a new thread upon return from interrupt
    	 * (hopefully the one waiting for the keyboard event)
    	 */
    	g_needReschedule = true;//标记全局变量，让系统进行任务调度
        }
    
    done:
        End_IRQ(state);
    }

按键按下和松开都会产生扫描码，同一个按键按下和松开的扫描码只有最高位的不同。

通过一系列的对功能键的处理和判断，最后得到keycode，放入键盘缓冲区中。

至此，Main中的所有初始化函数结束，在接下来的学习中，我们会对系统有一个更深入的理解。。