Ⅰ.锁
本质是互斥操作
原因：针对公共资源访问时，临界区若不加以互斥限制，可能导致执行过程中突然的中断导致出现异常。
1.互斥过程
设定互斥量M为二值信号量，0/1，P-，V+，现有两个进程A、B共同访问公共资源R，则有
1.线程A访问R，P-，M=0
2.线程B访问R，P-，M<0，阻塞线程B，P+
3.线程A访问R结束，V+，唤醒线程B
4.线程B开始执行
阻塞功能 ：阻塞是线程主动的行为 。己阻塞的线程是由别人来唤醒的，通常是锁的持有者。不让线程在就绪队列中出现就行了，这样线程便没有机会运行。
线程自主阻塞之后，保存当前的寄存器，栈信息，当唤醒后，并不会从头开始执行，而是从线程阻塞的部分开始重新执行，并且时间片依旧是阻塞前的数值。
（1）实现线程阻塞和唤醒
c
/* 阻塞过程：
* 1.关中断
* 2.更改当前线程状态为阻塞态
* 3.调用schedule()，从就绪队列中取出下一个就绪线程列执行
* 4.开中断
*/
void thread_blocked(enum task_status state){
// 原子操作，必须关中断
enum intr_status old_status = intr_distable();
// 只有是传入下面三种状态才可以被阻塞
ASSERT((state == TASK_BLOCKED) || (state == TASK_HANGING) || (state == TASK_WAITING));
struct task_struct * cur_thread = running_thread();
cur_thread->status = state;
schedule();
// list_pop(&thread_ready_list, &cur_thread->general_tag);
intr_set_status(old_status);
}
/* 唤醒线程
* 1.关中断
* 2.判断当前线程是否在就绪队列中
* 3.不在，则添加；在，则PANIC
* 4.当前线程加入就绪队列
* 5.修改状态为TASK_READY
* 6.开中断
*/
// 被阻塞的进程由于没有执行，因此不可以调度schedule()函数
void thread_unblocked(struct task_struct* pthread){
enum intr_status old_status = intr_disable();
ASSERT((pthread->status == TASK_BLOCKED) || (pthread->status == TASK_HANGING) || (pthread->status == TASK_WAITING));
if(pthread->status != TASK_READY){
ASSERT(!elem_find(&thread_ready_list, &pthread->general_tag));
if(elem_find(&thread_ready_list, &pthread->general_tag)){
PANIC("thread_unblock:blocked thread in ready_list");
}
list_push(&thread_ready_list, &pthread->general_tag);
pthread->status = TASK_RUNNING;
}
intr_set_status(old_status);
}（2）实现PV操作
c
/* P操作，存在线程阻塞
* 1.关中断
* 2.判断当前semophore==0
* 3.为0，循环等待，并将当前线程加入信号量等待队列，并阻塞当前线程
* 4.不为0，semophore-1
* 5.开中断
*/
void sema_down(struct semaphore* psema) {
emum intr_status old_status = intr_disable();
while(psema->value == 0){
ASSERT(!elem_find(&psema->waiters, &running_thread()->general_tag));
if(elem_find(&psema->waiters, &running_thread()->general_tag)){
PANIC("sema_down:P op failed");
}
list_append(&psema->waiters, &running_thread()->general_tag);
thread_blocked(TASK_BLOCKED);
}
psema->value--;
ASSERT(psema->value == 0);
intr_set_status(old_status);
}
/* V操作，存在线程唤醒
* 1.关中断
* 2.判断当前信号量等待队列不为空，根据elem2entry找到队头线程的PCB地址,并唤醒
* 3.为空，semophore++
* 4.开中断
*/
void sema_up(struct semaphore* psema) {
emum intr_status old_status = intr_disable();
ASSERT(psema->value == 0);
if(!list_empty(&psema->waiters)){
struct task_struct* wait_thread = elem2entry(struct task_struct, general_tag, list_pop(&psema->waiters));
thread_unblocked(wait_thread);
}
psema->value++;
ASSERT(psema->value == 1);
intr_set_status(old_status);
}（3）实现获得锁、释放锁操作
c
/* 获得锁
* 1.先判断自己是不是锁的持有者
* 2.不是，P操作，持有锁，持有次数+1
* 3.反之，持有次数+1
*/
void lock_acquire (struct lock* plock) {
/* 排除曾经自己已经持有锁但还未将其释放的情况 */
if(plock->holder != running_thread()){
sema_down(&plock->semaphore);
plock->holder = running_thread();
ASSERT(plock->holder_repeat_nr == 0);
plock->holder_repeat_nr = 1;
}else{
plock->holder_repeat_nr++;
}
}
/* 释放锁
* 1.ASSERT()判断是否拥有锁
* 2.判断持有锁的次数，防止进程需要多次访问资源。
* 3.清空锁
* 3.V操作
*/
void lock_release (struct lock* plock) {
ASSERT(plock->holder == running_thread());
if(plock->holder_repeat_nr > 1){
plock->holder_repeat_nr--;
return;
}
ASSERT(plock->holder_repeat_nr == 1);
plock->holder = NULL;
plock->holder_repeat_nr = 0;
sema_up(&plock->semaphore);
}Ⅱ.从键盘获取输入
键的扫描码 ：一个键的状态要么是按下，要么是弹起，因此一个键便有两个编码，按键被按下时的编码叫通码，也就是表示按键上的触点接通了内部电路，使硬件产生了一个码，故通码也称为 makecode。按键在被按住不松手时会持续产生相同的码，直到按键被松开时才终止，因此按键被松开弹起时产生的编码叫断码，也就是电路被断开了，不再持续产生码了，故断码也称为 breakcode。一个键的扫描码是由通码和断码组成的。
键盘编码器 ：键盘是个独立的设备，在它内部有个叫作键盘编码器 的芯片，通常是 Intel 8048 或兼容芯片，它的作用是：每当键盘上发生按键操作，它就向键盘控制器报告哪个键被按下，以及键的扫描码。
键盘控制器 ：在主机内部的主板上，通常是 Intel 8042 或兼容芯片，接收来自键盘编码器的按键信息，将其解码后保存，然后向中断代理发中断，之后处理器执行相应的中断处理程序读入 8042 处理保存过的按键信息。
1.从键盘读取输入的过程
• 扫描码有 3 套，现在一般键盘中的 8048 芯片支持的是第二套扫描码 。 因此每当有击键发生时， 8048发给 8042 的都是第二套键盘扫描码。
• 8042 为了兼容性，将接收到的第二套键盘扫描码转换成第一套扫描码。 8042 是按字节来处理的，每处理一个字节的扫描码后，将其存储到自己的输出缓冲区寄存器 。
• 然后向中断代理 8259A 发中断信号，这样我们的键盘中断处理程序通过读取 8042 的输出缓冲区寄存器，会获得第一套键盘扫描码。
2.键盘扫描码
根据键盘的更新迭代，出现了3种常用的键盘扫描码，为了兼容第一套键盘扫描码对应的中断处理程序，不管键盘用的是何种键盘扫描码，当键盘将扫描码发送到 8042 后，都由 8042 转换成第一套扫描码。
8042介于8048与处理器中间，担任中间人的职责，完成处理器对8048的设置，以及8048的扫描码输入给处理器。因此8042作为输入输出缓存区，包括输入、输出缓冲寄存器，以及状态、控制寄存器。
Ⅲ.键盘驱动程序
对于键盘驱动程序而言，每次都需要读取输出寄存器，取出键盘的扫描码并完成转为ASCII码的工作。
键盘驱动程序，初始化（注册键盘中断处理程序）
c
#define KEY_BUF_PORT 0x60 // 键盘 buffer 寄存器端口号为 0x60
/* 键盘中断处理程序 */
static void intr_keyboard_handler(void) {
/* 必须要读取输出缓冲区寄存器,否则8042不再继续响应键盘中断 */
uint8_t scancode = inb(KBD_BUF_PORT);
put_int(scancode);
return;
}
/* 键盘初始化，注册键盘中断处理程序 */
void keyboard_init() {
put_str("keyboard init start\n");
register_handler(0x21, intr_keyboard_handler);
put_str("keyboard init done\n");
}1.C语言中有3中转义字符
(1） 一般转义字符，'\＋单个字母' 的形式。
(2）八进制转义字符，'\0＋三位八进制数字表示的 ASCII 码' 的形式 。
(3）十六进制转义字符，'\x＋两位十六进制数字表示的 ASCII 码' 的形式 。
2.处理扫描码
键盘驱动程序需要完成 键盘扫描码->按键的ASCII码 的映射过程
（1）设计思路：
- 如果是一些用于操作方面的控制键，简称操作控制键，如＜shift＞、＜ctrl＞、＜caps lock＞，它通常是组合键，需要与其他键一起考虑，然后做出具体的行为展现，在键盘驱动中完成处理。
- 如果是一些用于字符方面的键，无论是可见字符，或是字符方面的控制键（简称字符控制键），如＜backspace＞，统统交给字符处理程序完成。
对于第一阶段，它与字符无直接的关系，因此咱们就在键盘驱动中处理。
对于第二阶段，咱们得知道用户按下的是什么宇符，不能把操作控制键当成字符传给字符处理程序，比如把 shift键的扫描码传给 put_char，这不就乱了吗？因此，咱们得把按键的扫描码转换成对应的字符，也就是将通码转换为字符的 ASCII 码，这就是前面所说的源到目标的映射关系。
**简言之：需要区分什么按键是需要显示的，什么按键是负责控制的。**这就需要建立扫描码和ASCII码的映射表，对键盘输入加以判定。
（2）建立键盘字符与通码映射关系
keymap[][0]表示未与shift组合的按键值，keymap[][1]表示与shift组合的按键值
c
/* 以通码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}
/*其它按键暂不处理*/
};(3)更新键盘驱动程序
（3.1）读取扫描码
c
static void intr_keyboard_handler(void) {
......
bool break_code;
uint16_t scancode = inb(KBD_BUF_PORT);
/* 若扫描码是e0开头的,表示此键的按下将产生多字节的扫描码,如shift、alt、ctrl、caps_lock等扫描码为2字节
* 所以马上结束此次中断处理函数,等待下一个扫描码进来*/
if (scancode == 0xe0) {
ext_scancode = true; // 打开e0标记
return;
}
/* 如果上次是以0xe0开头,将扫描码合并 */
if (ext_scancode) {
scancode = ((0xe000) | scancode);
ext_scancode = false; // 关闭e0标记
}
break_code = ((scancode & 0x0080) != 0); // 获取break_code
......
}（3.2）需要判断当前键盘是处于断码/通码
通码的扫描码scancode第8位为0，断码为1。
若为断码，需要将操作方面的控制键状态改为false，如shift、alt。将他们的断码的第8位改为0，作为通码访问keyb_map获取具体是哪个控制键，然后更改状态即可。
c
/*---------------续上----------------*/
if (break_code) { // 若是断码break_code(按键弹起时产生的扫描码)
/* 由于ctrl_r 和alt_r的make_code和break_code都是两字节,
所以可用下面的方法取make_code,多字节的扫描码暂不处理 */
uint16_t make_code = (scancode &= 0xff7f); // 得到其make_code(按键按下时产生的扫描码)
/* 若是任意以下三个键弹起了,将状态置为false */
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;
} /* 由于caps_lock不是弹起后关闭,所以需要单独处理 */
return; // 直接返回结束此次中断处理程序
} 若为通码，分为操作键和字符键两类，先要读取操作键，如shift、ctrl、alt、caps_lock，然后修改操作键的状态，根据操作键的状态确定映射的字符。
c
/*---------------续上----------------*/
/* 若为通码,只处理数组中定义的键以及alt_right和ctrl键,全是make_code */
else if ((scancode > 0x00 && scancode < 0x3b) ||
(scancode == alt_r_make) ||
(scancode == ctrl_r_make))
{
bool shift = false; // 判断是否与shift组合,用来在一维数组中索引对应的字符
if ((scancode < 0x0e) || (scancode == 0x29) ||
(scancode == 0x1a) || (scancode == 0x1b) ||
(scancode == 0x2b) || (scancode == 0x27) ||
(scancode == 0x28) || (scancode == 0x33) ||
(scancode == 0x34) || (scancode == 0x35))
{
/****** 代表两个字母的键 ********
0x0e 数字'0'~'9',字符'-',字符'='
0x29 字符'`'
0x1a 字符'['
0x1b 字符']'
0x2b 字符'\\'
0x27 字符';'
0x28 字符'\''
0x33 字符','
0x34 字符'.'
0x35 字符'/'
*******************************/
if (shift_down_last)
{ // 如果同时按下了shift键
shift = true;
}
}
else
{ // 默认为字母键
if (shift_down_last && caps_lock_last)
{ // 如果shift和capslock同时按下
shift = false;
}
else if (shift_down_last || caps_lock_last)
{ // 如果shift和capslock任意被按下
shift = true;
}
else
{
shift = false;
}
}
uint8_t index = (scancode &= 0x00ff); // 将扫描码的高字节置0,主要是针对高字节是e0的扫描码.
char cur_char = keymap[index][shift]; // 在数组中找到对应的字符
/* 只处理ascii码不为0的键 */
if (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键,当再次按下时则状态取反,
* 即:已经开启时,再按下同样的键是关闭。关闭时按下表示开启。*/
caps_lock_status = !caps_lock_status;
}
}
else
{
put_str("unknown key\n");
}Ⅳ.环形输入缓冲区
构建缓冲区保存键盘扫描码转换的字符，每次从缓冲区取出字符，完成打印。
利用生产者消费者模式构建环形队列，实现字符的取出和保存。主要完成缓冲区存储状态、添加1字节、删除1字节等操作。
1.环形队列结构体
c
/* 环形队列 */
struct ioqueue {
struct lock lock;
struct task_struct *producer;
struct task_struct *consumer;
// 缓冲区大小
char buf[bufsize];
// 队首，数据往队首处写入
int32_t head;
// 队尾，数据从队尾处读出
int32_t tail;
};2.缓冲区满
c
/* 返回 pos 在缓冲区中的下一个位置值 */
static int32_t next_pos (int32_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;
}3.缓冲区为空
c
/* 采用头插法加入元素，判断队列是否为空 */
bool ioq_empty(struct ioqueue* ioq) {
ASSERT(intr_get_status() == INTR_OFF);
return ioq->head == ioq->tail;
}4.缓冲区为空时，等待
c
/* 当前生产者或消费者在此缓冲区上等待 */
static void ioq_wait(struct task_struct ** waiter) {
ASSERT((waiter != NULL) && (&waiter == NULL));
*waiter = running_thread();
thread_blocked(TASK_BLOCKED);
}5.缓冲区不为空，唤醒waiterr
c
/* 唤醒 waiter */
static void wakeup(struct task_struct** waiter) {
ASSERT(&waiter != NULL);
thread_unblocked(*waiterr);
*waiterr = NULL;
}6.缓冲区添加一字节
c
/* 生产者往 ioq 队列中写入一个字符 byte */
void ioq_putchar(struct ioqueue* ioq, char byte) {
ASSERT(intr_get_intr() == INTR_OFF);
while(ioq_full(ioq)){
lock_acquire(&ioq->lock);
ioq_wait(&ioq);
lock_release(&ioq->lock);
}
ioq->buf[ioq->head] = byte;
ioq->head = next_pos(ioq->head);
if(ioq->consumer != NULL){
wakeup(&ioq->consumer);
}
}- 判断缓冲区是否满了
- 满了则请求锁，并wait，阻塞当前线程，释放锁
- 反之，头插法，在队列头插入新元素
- 唤醒消费者
7.缓冲区取出一字节
c
/* 消费者从 ioq 队列中获取一个字符 */
char ioq_getchar(struct ioqueue* ioq) {
ASSERT(intr_get_status() == INTR_OFF);
while(ioq_empty(ioq)){
lock_acquire(&ioq->lock);
ioq_wait(&ioq);
lock_release(&ioq->lock);
}
char byte = ioq->buf[ioq->tail];
ioq->tail = next_pos(ioq->tail);
if(ioq->producer != NULL){
wakeup(&ioq->consumer);
}
return byte;
}- 判断缓冲区是否为空
- 为空则请求锁，并wait，阻塞当前线程，释放锁
- 反之，从队尾取出新元素
- 唤醒生产者
over