《操作系统真象还原》从零开始自制操作系统自写源码实现（device相关文件）

落日映苍穹つ 2022-09-04 15:56 180阅读 0赞

### 文章目录 ###

*   *  专栏博客链接
     *  device相关文件
     *   *  编写完的console.c
         *  编写完的console.h
         *  编写完的ide.c
         *  编写完的ide.h
         *  编写完的ioqueue.c
         *  编写完的ioqueue.h
         *  编写完的keyboard.c
         *  编写完的keyboard.h
         *  编写完的timer.c
         *  编写完的timer.h

--------------------

## 专栏博客链接 ##

--------------------

**[《操作系统真象还原》从零开始自制操作系统 全章节博客链接][Link 1]**

--------------------

## device相关文件 ##

--------------------

### 编写完的console.c ###

--------------------

#include "console.h"
    #include "print.h"
    #include "../thread/sync.h"
    
    struct lock console_lock;
    
    void console_init()
    { 
        lock_init(&console_lock);
    }
    
    void console_acquire()
    { 
        lock_acquire(&console_lock);
    }
    
    void console_release()
    { 
        lock_release(&console_lock);
    }
    
    void console_put_str(char* str)
    { 
        console_acquire();
        put_str(str);
        console_release();
    }
    
    void console_put_int(uint32_t num)
    { 
        console_acquire();
        put_int(num);
        console_release();
    }
    
    void console_put_char(uint8_t chr)
    { 
        console_acquire();
        put_char(chr);
        console_release();
    }

--------------------

### 编写完的console.h ###

--------------------

#ifndef __DEVICE__CONSOLE_H
    #define __DEVICE__CONSOLE_H
    
    #include "console.h"
    #include "print.h"
    #include "../thread/sync.h"
    
    
    void console_init(void);
    void console_acquire(void);
    void console_release(void);
    void console_put_str(char* str);
    void console_put_int(uint32_t num);
    void console_put_char(uint8_t chr);
    
    #endif

--------------------

### 编写完的ide.c ###

--------------------

#include "ide.h"
    #include "stdint.h"
    #include "debug.h"
    #include "stdio-kernel.h"
    #include "stdio.h"
    #include "global.h"
    #include "../thread/sync.h"
    #include "io.h"
    #include "timer.h"
    #include "interrupt.h"
    #include "memory.h"
    #include "../fs/fs.h"
    
    #define reg_data(channel) (channel->port_base + 0)
    #define reg_error(channel) (channel->port_base + 1)
    #define reg_sect_cnt(channel) (channel->port_base + 2)
    #define reg_lba_l(channel) (channel->port_base + 3)
    #define reg_lba_m(channel) (channel->port_base + 4)
    #define reg_lba_h(channel) (channel->port_base + 5)
    #define reg_dev(channel) (channel->port_base + 6)
    #define reg_status(channel) (channel->port_base + 7)
    #define reg_cmd(channel) (reg_status(channel))
    #define reg_alt_status(channel) (channel->port_base + 0x206)
    #define reg_ctl(channel) reg_alt_status(channel)
    
    #define BIT_STAT_BSY 0X80 //硬盘忙
    #define BIT_STAT_DRDY 0X40 //驱动器准备好啦
    #define BIT_STAT_DRQ 0x8 //数据传输准备好了
    #define BIT_DEV_MBS 0XA0 
    #define BIT_DEV_LBA 0X40
    #define BIT_DEV_DEV 0X10
    
    #define CMD_IDENTIFY 0XEC //identify指令
    #define CMD_READ_SECTOR 0X20 //读扇区指令
    #define CMD_WRITE_SECTOR 0X30 //写扇区指令
    
    #define max_lba ((80*1024*1024/512) - 1) //调试用
    
    uint8_t channel_cnt;		  //通道数
    struct ide_channel channels[2];  //两个ide通道
    
    int32_t ext_lba_base = 0;	  //记录总拓展分区lba 初始为0
    uint8_t p_no = 0,l_no = 0;	  //记录硬盘主分区下标 逻辑分区下标
    struct list partition_list;	  //分区队列
    
    //选择读写的硬盘
    void select_disk(struct disk* hd)
    { 
        uint8_t reg_device = BIT_DEV_MBS | BIT_DEV_LBA;
        if(hd->dev_no == 1)    //主盘0 从盘1
        	reg_device |= BIT_DEV_DEV;
        outb(reg_dev(hd->my_channel),reg_device);
    }
    
    //向硬盘控制器写入起始扇区和读写的扇区数
    void select_sector(struct disk* hd,uint32_t lba,uint8_t sec_cnt)
    { 
        ASSERT(lba <= max_lba);
        struct ide_channel* channel = hd->my_channel;
        
        outb(reg_sect_cnt(channel),sec_cnt);
        outb(reg_lba_l(channel),lba);
        outb(reg_lba_m(channel),lba>>8);
        outb(reg_lba_h(channel),lba>>16);
        
        outb(reg_dev(channel),BIT_DEV_MBS | BIT_DEV_LBA | (hd->dev_no == 1 ? BIT_DEV_DEV : 0) | lba >> 24);
    }
    
    //向通道channel发命令cmd
    void cmd_out(struct ide_channel* channel,uint8_t cmd)
    { 
        channel->expecting_intr = true;
        outb(reg_cmd(channel),cmd);
    }
    
    //从扇区读数据
    void read_from_sector(struct disk* hd,void* buf,uint8_t sec_cnt)
    { 
        uint32_t size_in_byte;
        if(sec_cnt == 0)
        	size_in_byte = 256*512;
        else
        	size_in_byte = sec_cnt*512;
        insw(reg_data(hd->my_channel),buf,size_in_byte/2);	//读如数据到buf
    }
    
    //将 sec_cnt 扇区数据写入硬盘
    void write2sector(struct disk* hd,void* buf,uint8_t sec_cnt)
    { 
        uint32_t size_in_byte;
        if(sec_cnt == 0)	size_in_byte = 256*512;
        else	size_in_byte = sec_cnt * 512;
        outsw(reg_data(hd->my_channel),buf,size_in_byte/2);
    }
    
    //最多等待三十秒 任务应该都在30秒内完成 读取硬盘相应给了整整30秒
    bool busy_wait(struct disk* hd)
    { 
        struct ide_channel* channel = hd->my_channel;
        uint16_t time_limit = 30 * 1000;
        while(time_limit -= 10 >= 0)
        { 
        	if(!(inb(reg_status(channel)) & BIT_STAT_BSY))
        	    return (inb(reg_status(channel)) & BIT_STAT_DRQ);
        	else  mtime_sleep(10);
        }
        return false;
    }
    
    //从硬盘读取sec_cnt扇区到buf
    void ide_read(struct disk* hd,uint32_t lba,void* buf,uint32_t sec_cnt)
    { 
        ASSERT(lba <= max_lba);
        ASSERT(sec_cnt > 0);
        lock_acquire(&hd->my_channel->lock);
        
        select_disk(hd);
        
        
        uint32_t secs_op;
        uint32_t secs_done = 0;
        while(secs_done < sec_cnt)
        { 
            if((secs_done + 256) <= sec_cnt)    secs_op = 256;
            else	secs_op = sec_cnt - secs_done;
        	
            select_sector(hd,lba + secs_done, secs_op);
            cmd_out(hd->my_channel,CMD_READ_SECTOR); //执行命令
           
    	
            /*在硬盘开始工作时 阻塞自己 完成读操作后唤醒自己*/
            sema_down(&hd->my_channel->disk_done);
    	
            /*检测是否可读*/
            if(!busy_wait(hd))
            { 
                char error[64];
                sprintf(error,"%s read sector %d failed!!!!\n",hd->name,lba);
                PANIC(error);
            }
          	read_from_sector(hd,(void*)((uint32_t)buf +secs_done * 512),secs_op);
          	secs_done += secs_op;
        }
        lock_release(&hd->my_channel->lock);   
    }
    
    void ide_write(struct disk* hd,uint32_t lba,void* buf,uint32_t sec_cnt)
    { 
        ASSERT(lba <= max_lba);
        ASSERT(sec_cnt > 0);
        lock_acquire(&hd->my_channel->lock);
        
        select_disk(hd);
        uint32_t secs_op;
        uint32_t secs_done = 0;
        
        while(secs_done < sec_cnt)
        { 
            if((secs_done + 256) <= sec_cnt)    secs_op = 256;
            else	secs_op = sec_cnt - secs_done;
            
        	select_sector(hd,lba+secs_done,secs_op);
        	cmd_out(hd->my_channel,CMD_WRITE_SECTOR);
        	
        	if(!busy_wait(hd))
        	{ 
        	    char error[64];
        	    sprintf(error,"%s write sector %d failed!!!!!!\n",hd->name,lba);
        	    PANIC(error);
        	}
        	
        	write2sector(hd,(void*)((uint32_t)buf + secs_done * 512),secs_op);
        	
        	//硬盘响应期间阻塞
        	sema_down(&hd->my_channel->disk_done);
        	secs_done += secs_op;
        }
        lock_release(&hd->my_channel->lock);
    }
    
    //硬盘结束任务中断程序
    void intr_hd_handler(uint8_t irq_no)
    { 
        ASSERT(irq_no == 0x2e || irq_no == 0x2f);
        uint8_t ch_no = irq_no - 0x20 - 0xe;
        struct ide_channel* channel = &channels[ch_no];
        ASSERT(channel->irq_no == irq_no);
        if(channel->expecting_intr)
        { 
    	channel->expecting_intr = false;//结束任务了
    	sema_up(&channel->disk_done);
    	inb(reg_status(channel));
        }   
    }
    
    //将dst中len个相邻字节交换位置存入buf 因为读入的时候字节顺序是反的 所以我们再反一次即可
    void swap_pairs_bytes(const char* dst,char* buf,uint32_t len)
    { 
        uint8_t idx;
        for(idx = 0;idx < len;idx += 2)
        { 
        	buf[idx+1] = *(dst++);
        	buf[idx]   = *(dst++);
        }
    }
    
    void partition_scan(struct disk* hd,uint32_t ext_lba)
    { 
        struct boot_sector* bs = sys_malloc(sizeof(struct boot_sector));
        ide_read(hd,ext_lba,bs,1);
        uint8_t part_idx = 0;
        struct partition_table_entry* p = bs->partition_table; //p为分区表开始的位置
        while((part_idx++) < 4)
        { 
        	if(p->fs_type == 0x5) //拓展分区
        	{ 
        	    
        	    if(ext_lba_base != 0)
        	    { 
        	    	partition_scan(hd,p->start_lba + ext_lba_base);	//继续递归转到下一个逻辑分区再次得到表
        	    }
        	    else //第一次读取引导块
        	    { 
        	    	ext_lba_base = p->start_lba;
        	    	partition_scan(hd,ext_lba_base);
        	    }
        	}
        	else if(p->fs_type != 0)
        	{ 
        	    if(ext_lba == 0)	//主分区
        	    { 
        	    	hd->prim_parts[p_no].start_lba = ext_lba + p->start_lba;
        	    	hd->prim_parts[p_no].sec_cnt = p->sec_cnt;
        	    	hd->prim_parts[p_no].my_disk = hd;
        	    	list_append(&partition_list,&hd->prim_parts[p_no].part_tag);
        	    	sprintf(hd->prim_parts[p_no].name,"%s%d",hd->name,p_no+1);
        	    	p_no++;
        	    	ASSERT(p_no<4);	//0 1 2 3 最多四个
        	    }
        	    else		//其他分区
        	    { 
        	    	hd->logic_parts[l_no].start_lba = ext_lba + p->start_lba;
        	    	hd->logic_parts[l_no].sec_cnt = p->sec_cnt;
        	    	hd->logic_parts[l_no].my_disk = hd;
        	    	list_append(&partition_list,&hd->logic_parts[l_no].part_tag);
        	    	sprintf(hd->logic_parts[l_no].name,"%s%d",hd->name,l_no+5); //从5开始
        	    	l_no++;
        	    	if(l_no >= 8)	return; //只支持8个
        	    }
        	}
        	++p;
        }
        sys_free(bs);
    }
    
    bool partition_info(struct list_elem* pelem,int arg)
    { 
        struct partition* part = elem2entry(struct partition,part_tag,pelem);
        printk(" %s start_lba:0x%x,sec_cnt:0x%x\n",part->name,part->start_lba,part->sec_cnt);
        return false; //list_pop完
    }
    
    void identify_disk(struct disk* hd)
    { 
        char id_info[512];
        select_disk(hd);
        cmd_out(hd->my_channel,CMD_IDENTIFY);
        
        if(!busy_wait(hd))
        { 
        	char error[64];
        	sprintf(error,"%s identify failed!!!!!!\n");
        	PANIC(error);
        }
        read_from_sector(hd,id_info,1);//现在硬盘已经把硬盘的参数准备好了了 我们把参数读到自己的缓冲区中
        
        char buf[64] = { 0};
        uint8_t sn_start = 10 * 2,sn_len = 20,md_start = 27*2,md_len = 40;
        swap_pairs_bytes(&id_info[sn_start],buf,sn_len);
        printk(" disk %s info: SN: %s\n",hd->name,buf);
        swap_pairs_bytes(&id_info[md_start],buf,md_len);
        printk(" MODULE: %s\n",buf);
        uint32_t sectors = *(uint32_t*)&id_info[60*2];
        printk(" SECTORS: %d\n",sectors);
        printk(" CAPACITY: %dMB\n",sectors * 512 / 1024 / 1024);
    } 
    
    
    
    //初始化硬盘数据
    void ide_init(void)
    { 
        printk("ide_init start\n");
        uint8_t hd_cnt = *((uint8_t*)(0x475));     //获取硬盘数量
        ASSERT(hd_cnt > 0);
        channel_cnt = DIV_ROUND_UP(hd_cnt,2);      //两个硬盘一个ide 通过硬盘推ide
        ASSERT(channel_cnt > 0);
        
        struct ide_channel* channel;
        uint8_t channel_no = 0,dev_no = 0;
        list_init(&partition_list);
        
        while(channel_no < channel_cnt)
        { 
        	channel = &channels[channel_no];
        	sprintf(channel->name,"ide%d",channel_no);
        	
        	switch(channel_no)
        	{ 
        	    case 0:
        		channel->port_base = 0x1f0;		//ide0 起始端口号0x1f0
        		channel->irq_no    = 0x2e;		//8259a 中断引脚
        		break;
        	    case 1:
        		channel->port_base = 0x170;		//ide1 起始端口号0x170
        		channel->irq_no    = 0x2f;
        		break;
        	}
    	register_handler(channel->irq_no,intr_hd_handler);
        	channel->expecting_intr = false;		//不期待中断
        	lock_init(&channel->lock);
        	sema_init(&channel->disk_done,0);
        	
        	while(dev_no < 2)
        	{ 
        	    struct disk* hd = &channel->devices[dev_no];
        	    hd->my_channel = channel;
        	    hd->dev_no = dev_no;
        	    sprintf(hd->name,"sd%c",'a' + channel_no * 2 + dev_no);
        	    identify_disk(hd);
        	    if(dev_no != 0)
        	    	partition_scan(hd,0);
        	    p_no = 0,l_no = 0;
        	    dev_no++;
        	}
        	dev_no = 0;
        	channel_no++;
        }
        printk("\n all partition info\n");
        list_traversal(&partition_list,partition_info,(int)NULL);
        printk("ide_init done\n");
    }

--------------------

### 编写完的ide.h ###

--------------------

#ifndef __DEVICE_IDE_H
    #define __DEVICE_IDE_H
    
    #include "stdint.h"
    #include "bitmap.h"
    #include "list.h"
    #include "../thread/sync.h"
    #include "../fs/super_block.h"
    
    //分区结构
    struct partition
    { 
        uint32_t start_lba;          //起始扇区
        uint32_t sec_cnt;            //扇区数
        struct disk* my_disk;        //分区所属硬盘
        struct list_elem part_tag;   //所在队列中的标记
        char name[8];                //分区名字
        struct super_block* sb;	  //本分区 超级块
        struct bitmap block_bitmap;  //块位图
        struct bitmap inode_bitmap;  //i结点位图
        struct list open_inodes;     //本分区打开
    };
    
    struct partition_table_entry
    { 
        uint8_t bootable;		  //是否可引导
        uint8_t start_head;	  //开始磁头号
        uint8_t start_sec;		  //开始扇区号
        uint8_t start_chs;		  //起始柱面号
        uint8_t fs_type;		  //分区类型
        uint8_t end_head;		  //结束磁头号
        uint8_t end_sec;		  //结束扇区号
        uint8_t end_chs;		  //结束柱面号
        uint32_t start_lba;	  //本分区起始的lba地址
        uint32_t sec_cnt;		  //本扇区数目
    } __attribute__ ((packed));
    
    struct boot_sector
    { 
        uint8_t other[446];	  			//446 + 64 + 2 446是拿来占位置的
        struct partition_table_entry partition_table[4];  //分区表中4项 64字节
        uint16_t signature;				//最后的标识标志 魔数0x55 0xaa 
    } __attribute__ ((packed));
    
    //硬盘
    struct disk
    { 
        char name[8];		      //本硬盘的名称
        struct ide_channel* my_channel;    //这块硬盘归属于哪个ide通道
        uint8_t dev_no;		      //0表示主盘 1表示从盘
        struct partition prim_parts[4];  //主分区顶多是4个
        struct partition logic_parts[8]; //逻辑分区最多支持8个
    };
    
    // ata 通道结构
    struct ide_channel
    { 
        char name[8];		      //ata通道名称
        uint16_t port_base;	      //本通道的起始端口号
        uint8_t  irq_no;		      //本通道所用的中断号
        struct lock lock;                //通道锁 一个硬盘一通道 不能同时
        bool expecting_intr;	      //期待硬盘中断的bool
        struct semaphore disk_done;      //用于阻塞 唤醒驱动程序 和锁不一样 把自己阻塞后 把cpu腾出来
        struct disk devices[2];	      //一通道2硬盘 1主1从
    };
    
    extern uint8_t channel_cnt;
    extern struct ide_channel channels[2];
    extern struct list partition_list;
    
    void ide_init(void);
    void select_disk(struct disk* hd);
    void select_sector(struct disk* hd,uint32_t lba,uint8_t sec_cnt);
    void cmd_out(struct ide_channel* channel,uint8_t cmd);
    void read_from_sector(struct disk* hd,void* buf,uint8_t sec_cnt);
    void write2sector(struct disk* hd,void* buf,uint8_t sec_cnt);
    bool busy_wait(struct disk* hd);
    void ide_read(struct disk* hd,uint32_t lba,void* buf,uint32_t sec_cnt);
    void ide_write(struct disk* hd,uint32_t lba,void* buf,uint32_t sec_cnt);
    void intr_hd_handler(uint8_t irq_no);
    void swap_pairs_bytes(const char* dst,char* buf,uint32_t len);
    void identify_disk(struct disk* fd);
    void partition_scan(struct disk* hd,uint32_t ext_lba);
    bool partition_info(struct list_elem* pelem,int arg);
    
    #endif

--------------------

### 编写完的ioqueue.c ###

--------------------

#include "ioqueue.h"
    #include "interrupt.h"
    #include "global.h"
    #include "debug.h"
    
    
    void init_ioqueue(struct ioqueue* ioq)
    { 
        lock_init(&ioq->lock);
        ioq->consumer = ioq->producer = NULL;
        ioq->head = ioq->tail = 0;
    }
    
    uint32_t next_pos(uint32_t pos)
    { 
        return (pos+1)%bufsize;
    }
    
    bool ioq_full(struct ioqueue* ioq)
    { 
        ASSERT(intr_get_status() == INTR_OFF);
        return next_pos(ioq->head) == ioq->tail;
    }
    
    bool ioq_empty(struct ioqueue* ioq)
    { 
        ASSERT(intr_get_status() == INTR_OFF);
        return ioq->head == ioq->tail;
    }
    
    void ioq_wait(struct task_struct** waiter)
    { 
        ASSERT(waiter != NULL && *waiter == NULL);
        *waiter = running_thread();
        thread_block(TASK_BLOCKED);
    }
    
    void wakeup(struct task_struct** waiter)
    { 
        ASSERT(*waiter != NULL);
        thread_unblock(*waiter);
        *waiter = NULL;
    }
    
    char ioq_getchar(struct ioqueue* ioq)
    { 
        ASSERT(intr_get_status() == INTR_OFF);
        
        //空的时候就需要动锁了 把另外的消费者卡住
        while(ioq_empty(ioq))
        { 
            lock_acquire(&ioq->lock);
            ioq_wait(&ioq->consumer);
            lock_release(&ioq->lock);
        }
        
        char retchr = ioq->buf[ioq->tail];
        ioq->tail = next_pos(ioq->tail);
        
        if(ioq->producer)
        	wakeup(&ioq->producer);
        return retchr;
    }
    
    void ioq_putchar(struct ioqueue* ioq,char chr)
    { 
        ASSERT(intr_get_status() == INTR_OFF);
        
        while(ioq_full(ioq))
        { 
        	lock_acquire(&ioq->lock);
        	ioq_wait(&ioq->producer);
        	lock_release(&ioq->lock);
        }
        
        ioq->buf[ioq->head] = chr;
        ioq->head = next_pos(ioq->head);
        
        if(ioq->consumer)
        	wakeup(&ioq->consumer);
    }

--------------------

### 编写完的ioqueue.h ###

--------------------

#ifndef __DEVICE__IOQUEUE_H
    #define __DEVICE__IOQUEUE_H
    
    #include "stdint.h"
    #include "../thread/thread.h"
    #include "../thread/sync.h"
    
    #define bufsize 64
    
    struct ioqueue
    { 
        struct lock lock;
        struct task_struct* consumer;
        struct task_struct* producer;
        char buf[bufsize];
        uint32_t head;			//头部读入数据
        uint32_t tail;			//尾部拿数据
    };
    
    void init_ioqueue(struct ioqueue* ioq);
    uint32_t next_pos(uint32_t pos);
    bool ioq_full(struct ioqueue* ioq);
    bool ioq_empty(struct ioqueue* ioq);
    void ioq_wait(struct task_struct** waiter); //这里是waiter的二级指针 取二级指针的原因是这样可以对指针的地址值进行修改
    void wakeup(struct task_struct** waiter); 
    char ioq_getchar(struct ioqueue* ioq);
    void ioq_putchar(struct ioqueue* ioq,char chr);
    
    #endif

--------------------

### 编写完的keyboard.c ###

--------------------

#include "keyboard.h"
    #include "print.h"
    #include "io.h"
    #include "interrupt.h"
    #include "global.h"
    #include "stdint.h"
    #include "ioqueue.h"
    
    #define KBD_BUF_PORT 0X60
    struct ioqueue ioqueue;
    
    #define esc '\033' //esc 和 delete都没有
    #define delete '\0177'
    #define enter '\r'
    #define tab '\t'
    #define backspace '\b'
    
    #define char_invisible 0 //功能性 不可见字符均设置为0
    #define ctrl_l_char char_invisible
    #define ctrl_r_char char_invisible 
    #define shift_l_char char_invisible
    #define shift_r_char char_invisible
    #define alt_l_char char_invisible
    #define alt_r_char char_invisible
    #define caps_lock_char char_invisible
    
    #define shift_l_make 0x2a
    #define shift_r_make 0x36
    #define alt_l_make 0x38
    #define alt_r_make 0xe038
    #define alt_r_break 0xe0b8
    #define ctrl_l_make 0x1d
    #define ctrl_r_make 0xe01d
    #define ctrl_r_break 0xe09d
    #define caps_lock_make 0x3a
    
    bool ctrl_status = false,shift_status = false,alt_status = false,caps_lock_status = false,ext_scancode = false;
    
    
    /* 以通码make_code为索引的二维数组 */
    static char keymap[][2] = { 
    /* 扫描码 未与shift组合 与shift组合*/
    /* ---------------------------------- */
    /* 0x00 */	{ 0,	0},		
    /* 0x01 */	{ esc,	esc},		
    /* 0x02 */	{ '1',	'!'},		
    /* 0x03 */	{ '2',	'@'},		
    /* 0x04 */	{ '3',	'#'},		
    /* 0x05 */	{ '4',	'$'},		
    /* 0x06 */	{ '5',	'%'},		
    /* 0x07 */	{ '6',	'^'},		
    /* 0x08 */	{ '7',	'&'},		
    /* 0x09 */	{ '8',	'*'},		
    /* 0x0A */	{ '9',	'('},		
    /* 0x0B */	{ '0',	')'},		
    /* 0x0C */	{ '-',	'_'},		
    /* 0x0D */	{ '=',	'+'},		
    /* 0x0E */	{ backspace, backspace},	
    /* 0x0F */	{ tab,	tab},		
    /* 0x10 */	{ 'q',	'Q'},		
    /* 0x11 */	{ 'w',	'W'},		
    /* 0x12 */	{ 'e',	'E'},		
    /* 0x13 */	{ 'r',	'R'},		
    /* 0x14 */	{ 't',	'T'},		
    /* 0x15 */	{ 'y',	'Y'},		
    /* 0x16 */	{ 'u',	'U'},		
    /* 0x17 */	{ 'i',	'I'},		
    /* 0x18 */	{ 'o',	'O'},		
    /* 0x19 */	{ 'p',	'P'},		
    /* 0x1A */	{ '[',	'{'},		
    /* 0x1B */	{ ']',	'}'},		
    /* 0x1C */	{ enter,  enter},
    /* 0x1D */	{ ctrl_l_char, ctrl_l_char},
    /* 0x1E */	{ 'a',	'A'},		
    /* 0x1F */	{ 's',	'S'},		
    /* 0x20 */	{ 'd',	'D'},		
    /* 0x21 */	{ 'f',	'F'},		
    /* 0x22 */	{ 'g',	'G'},		
    /* 0x23 */	{ 'h',	'H'},		
    /* 0x24 */	{ 'j',	'J'},		
    /* 0x25 */	{ 'k',	'K'},		
    /* 0x26 */	{ 'l',	'L'},		
    /* 0x27 */	{ ';',	':'},		
    /* 0x28 */	{ '\'',	'"'},		
    /* 0x29 */	{ '`',	'~'},		
    /* 0x2A */	{ shift_l_char, shift_l_char},	
    /* 0x2B */	{ '\\',	'|'},		
    /* 0x2C */	{ 'z',	'Z'},		
    /* 0x2D */	{ 'x',	'X'},		
    /* 0x2E */	{ 'c',	'C'},		
    /* 0x2F */	{ 'v',	'V'},		
    /* 0x30 */	{ 'b',	'B'},		
    /* 0x31 */	{ 'n',	'N'},		
    /* 0x32 */	{ 'm',	'M'},		
    /* 0x33 */	{ ',',	'<'},		
    /* 0x34 */	{ '.',	'>'},		
    /* 0x35 */	{ '/',	'?'},
    /* 0x36 */	{ shift_r_char, shift_r_char},	
    /* 0x37 */	{ '*',	'*'},    	
    /* 0x38 */	{ alt_l_char, alt_l_char},
    /* 0x39 */	{ ' ',	' '},		
    /* 0x3A */	{ caps_lock_char, caps_lock_char}
    };
    
    void keyboard_init()
    { 
        put_str("keyboard init start\n");
        register_handler(0x21,intr_keyboard_handler);
        init_ioqueue(&ioqueue);
        put_str("keyboard init done\n");
    }
    
    void intr_keyboard_handler(void)
    { 
        bool ctrl_down_last = ctrl_status;
        bool shift_down_last = shift_status;
        bool caps_lock_last = caps_lock_status;
        
        bool break_code;
        uint16_t scancode = inb(KBD_BUF_PORT);
        
        if(scancode == 0xe0)	//多字节处理
        { 
        	ext_scancode = true;
        	return;
        }
        
        break_code = ((scancode & 0x0080) != 0); //断码 = 通码 + 0x80 通码最小比0x80小 则只有断码才可以有
        
        if(break_code)
        { 
        	uint16_t make_code = (scancode &= 0xff7f); //多字节不处理
        	if(make_code == ctrl_l_make || make_code == ctrl_r_make) ctrl_status = false;
        	else if(make_code == shift_l_make || make_code == shift_r_make) shift_status = false;
        	else if(make_code == alt_l_make || make_code == alt_r_make) alt_status = false;
        	return;
        }
        else if((scancode > 0x00 && scancode < 0x3b) || (scancode == alt_r_make) || (scancode == ctrl_r_make))
        { 
        	bool shift = false; //先默认设置成false
        	if((scancode < 0x0e) || (scancode == 0x29) || (scancode == 0x1a) || \
        	(scancode == 0x1b) || (scancode == 0x2b) || (scancode == 0x27) || \
        	(scancode == 0x28) || (scancode == 0x33) || (scancode == 0x34) || \
        	(scancode == 0x35))
        	{ 
        	    if(shift_down_last)	shift = true;
        	}
        	else
        	{ 
        	    if(shift_down_last && caps_lock_last)	shift = false; //效果确实是这样子的 我试了一下
        	    else if(shift_down_last || caps_lock_last) shift = true; //其中任意一个都是大写的作用
        	    else shift = false;
        	}
        	
        	uint8_t index = (scancode & 0x00ff);
            char cur_char = keymap[index][shift];
            
            if((ctrl_down_last && cur_char == 'l') || (ctrl_down_last && cur_char == 'u'))
                cur_char -= 'a';
            
            if(cur_char)
            { 
            	if(!ioq_full(&ioqueue))
            		ioq_putchar(&ioqueue,cur_char);
            	//put_char(cur_char);
    	    	return;
    	}
        
    	if(scancode == ctrl_l_make || scancode == ctrl_r_make)    	
    	    ctrl_status = true;
    	else if(scancode == shift_l_make || scancode == shift_r_make)
                shift_status = true;
    	else if(scancode == alt_l_make || scancode == alt_r_make)
    	    alt_status = true;
    	else if(scancode == caps_lock_make)
    	    caps_lock_status = !caps_lock_status;
    	else put_str("unknown key\n");
        }
        
        return;
    }

--------------------

### 编写完的keyboard.h ###

--------------------

#ifndef __DEVICE_KEYBOARD_H
    #define __DEVICE_KEYBOARD_H
    
    extern struct ioqueue ioqueue;
    void intr_keyboard_handler(void);
    void keyboard_init(void);
    
    #endif

--------------------

### 编写完的timer.c ###

--------------------

#include "timer.h"
    #include "io.h"
    #include "print.h"
    #include "../kernel/interrupt.h"
    #include "../thread/thread.h"
    #include "debug.h"
    #include "global.h"
    
    #define IRQ0_FREQUENCY 100
    #define INPUT_FREQUENCY 1193180
    #define COUNTER0_VALUE INPUT_FREQUENCY / IRQ0_FREQUENCY
    #define COUNTER0_PORT 0X40
    #define COUNTER0_NO 0
    #define COUNTER_MODE 2
    #define READ_WRITE_LATCH 3
    #define PIT_COUNTROL_PORT 0x43
    #define mil_second_per_init 1000 / IRQ0_FREQUENCY
    
    //自中断开启以来总的滴答数
    uint32_t ticks;
    
    void frequency_set(uint8_t counter_port ,uint8_t counter_no,uint8_t rwl,uint8_t counter_mode,uint16_t counter_value)
    { 
        outb(PIT_COUNTROL_PORT,(uint8_t) (counter_no << 6 | rwl << 4 | counter_mode << 1));
        outb(counter_port,(uint8_t)counter_value);
        outb(counter_port,(uint8_t)counter_value >> 8);
        return;
    } 
    
    void intr_timer_handler(void)
    { 
        struct task_struct* cur_thread = running_thread();   //得到pcb指针
        ASSERT(cur_thread->stack_magic == 0x23333333);	       //检测栈是否溢出
        
        ++ticks;
        ++cur_thread->elapsed_ticks;
        if(!cur_thread->ticks)
        { 
        	schedule();
        }
        else    
        	--cur_thread->ticks;
        return;
    }
    
    void timer_init(void)
    { 
        put_str("timer_init start!\n");
        frequency_set(COUNTER0_PORT,COUNTER0_NO,READ_WRITE_LATCH,COUNTER_MODE,COUNTER0_VALUE);
        register_handler(0x20,intr_timer_handler);	        //注册时间中断函数 0x20向量号函数更换
        put_str("timer_init done!\n");
        return;
    }
    
    //休息n个时间中断期
    void ticks_to_sleep(uint32_t sleep_ticks)
    { 
        uint32_t start_tick = ticks;
        while(ticks - start_tick < sleep_ticks)
        	thread_yield();
    }
    
    //毫秒为单位 通过毫秒的中断数来调用ticks_to_sleep 来达到休息毫秒的作用
    void mtime_sleep(uint32_t m_seconds)
    { 
        uint32_t sleep_ticks = DIV_ROUND_UP(m_seconds,mil_second_per_init);
        ASSERT(sleep_ticks > 0);
        ticks_to_sleep(sleep_ticks);
    }

--------------------

### 编写完的timer.h ###

--------------------

#ifndef __DEVICE_TIME_H
    #define __DEVICE_TIME_H
    #include "stdint.h"
    void frequency_set(uint8_t counter_port ,uint8_t counter_no,uint8_t rwl,uint8_t counter_mode,uint16_t counter_value);
    void intr_timer_handler(void);
    void timer_init(void);
    void mtime_sleep(uint32_t m_seconds);
    void ticks_to_sleep(uint32_t sleep_ticks);
    #endif

[Link 1]: https://love6.blog.csdn.net/article/details/119133589