第十章-输入输出系统

Ⅰ.锁

本质是互斥操作

原因:针对公共资源访问时,临界区若不加以互斥限制,可能导致执行过程中突然的中断导致出现异常。

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)设计思路:
  1. 如果是一些用于操作方面的控制键,简称操作控制键,如<shift>、<ctrl>、<caps lock>,它通常是组合键,需要与其他键一起考虑,然后做出具体的行为展现,在键盘驱动中完成处理。
  2. 如果是一些用于字符方面的键,无论是可见字符,或是字符方面的控制键(简称字符控制键),如<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);
    }
}
  1. 判断缓冲区是否满了
  2. 满了则请求锁,并wait,阻塞当前线程,释放锁
  3. 反之,头插法,在队列头插入新元素
  4. 唤醒消费者
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;
}
  1. 判断缓冲区是否为空
  2. 为空则请求锁,并wait,阻塞当前线程,释放锁
  3. 反之,从队尾取出新元素
  4. 唤醒生产者

over

相关推荐
WZF-Sang17 小时前
Linux—进程学习-01
linux·服务器·数据库·学习·操作系统·vim·进程
Goboy1 天前
0帧起步:3分钟打造个人博客,让技术成长与职业发展齐头并进
程序员·开源·操作系统
结衣结衣.1 天前
【Linux】Linux管道揭秘:匿名管道如何连接进程世界
linux·运维·c语言·数据库·操作系统
OpenAnolis小助手2 天前
龙蜥副理事长张东:加速推进 AI+OS 深度融合,打造最 AI 的服务器操作系统
ai·开源·操作系统·龙蜥社区·服务器操作系统·anolis os
小蜗的房子3 天前
SQL Server 2022安装要求(硬件、软件、操作系统等)
运维·windows·sql·学习·microsoft·sqlserver·操作系统
邂逅岁月4 天前
【多线程奇妙屋】 Java 的 Thread类必会小技巧,教你如何用多种方式快速创建线程,学并发编程必备(实践篇)
java·开发语言·操作系统·线程·进程·并发编程·javaee
CXDNW6 天前
【系统面试篇】进程和线程类(1)(笔记)——区别、通讯方式、同步、互斥、死锁
笔记·操作系统·线程·进程·互斥·死锁
Anemone_6 天前
MIT 6.S081 Lab3
操作系统
掘了7 天前
持久化内存 | Persistent Memory
c++·架构·操作系统
结衣结衣.8 天前
【Linux】掌握库的艺术:我的动静态库封装之旅
linux·运维·服务器·c语言·操作系统·