硬件中断

if(open("console", O_RDWR) < 0){
                mknod("console", CONSOLE, 0);
                open("console", O_RDWR);
}

dup(0);  // stdout
dup(0);  // stderr

else if(f->type == FD_DEVICE){
                if(f->major < 0 || f->major >= NDEV || !devsw[f->major].write)
                                return -1;
                ret = devsw[f->major].write(1, addr, n);
}

int
consolewrite(int user_src, uint64 src, int n)
{
                int i;

                for(i = 0; i < n; i++){ // 循环遍历要写入的字节数
                                char c;
                                // either_copyin(&c, user_src, src+i, 1) 用于从指定的源空间（用户或内核）拷贝一个字节到变量 c
                                // 如果拷贝失败（返回 -1），则提前结束循环
                                if(either_copyin(&c, user_src, src+i, 1) == -1)
                                                break;
                                uartputc(c); // 将读取的字符发送到 UART 设备进行输出
                }

                return i; // 返回实际写入的字节数
}

void
uartputc(int c)
{
                acquire(&uart_tx_lock); // 获取 UART 发送缓冲区的自旋锁

                //这段代码在检测到系统处于 panic 状态时，让当前执行流陷入一个空转的无限循环，从而“冻结”在当前位置
                // panicked 通常是内核级的全局标志，一旦发生致命错误被置位，后续路径（例如 UART 输出）就不再继续执行
                // 以避免进一步破坏系统状态或与其他 CPU/上下文交错输出，确保 panic 信息的可读性与一致性
                if(panicked){
                                for(;;)
                                                ;
                }
                while(uart_tx_w == uart_tx_r + UART_TX_BUF_SIZE){ // 如果发送缓冲区已满，阻塞等待
                                // buffer is full.
                                // wait for uartstart() to open up space in the buffer.
                                sleep(&uart_tx_r, &uart_tx_lock); // 休眠，等待 uartstart() 释放缓冲区空间
                }
                uart_tx_buf[uart_tx_w % UART_TX_BUF_SIZE] = c; // 将字符 c 添加到发送缓冲区
                uart_tx_w += 1; // 发送缓冲区写指针前移
                uartstart(); // 启动 UART 发送缓冲区中的数据
                release(&uart_tx_lock); // 释放 UART 发送缓冲区的自旋锁
}

void
uartstart()
{
                while(1){
                                if(uart_tx_w == uart_tx_r){ // 缓冲区的读指针和写指针相等，表示没有数据可发送 
                                                // transmit buffer is empty.
                                                ReadReg(ISR); // 读取 UART 的中断状态寄存器（Interrupt Status Register） 
                                                // 虽然这里没有对读取结果进行处理，通常这样做是为了清除某些硬件状态或中断标志，确保 UART 状态保持同步
                                                return;
                                }

                                // 读取 UART 的线路状态寄存器（Line Status Register），然后与 LSR_TX_IDLE 进行按位与运算
                                if((ReadReg(LSR) & LSR_TX_IDLE) == 0){ 
                                                // the UART transmit holding register is full,
                                                // so we cannot give it another byte.
                                                // it will interrupt when it's ready for a new byte.
                                                // 如果结果为 0，说明发送寄存器当前已满，不能再写入新的字节
                                                // 此时，代码会直接 return，暂时停止发送操作
                                                // 当发送寄存器满时，UART 会在准备好接收新字节时通过中断通知系统，届时再继续发送
                                                return;
                                }

                                // 从发送缓冲区读取下一个待发送的字符 
                                // 取模是为了实现缓冲区的循环利用，防止指针越界
                                int c = uart_tx_buf[uart_tx_r % UART_TX_BUF_SIZE]; // 从环形缓冲区 uart_tx_buf 中读取当前读指针 uart_tx_r 指向的字符
                                uart_tx_r += 1; // 读指针前移 

                                // maybe uartputc() is waiting for space in the buffer.
                                // 可能有 uartputc() 正在等待缓冲区有空间可用
                                // 调用 wakeup 唤醒所有等待 uart_tx_r 地址的进程
                                wakeup(&uart_tx_r);

                                // 刚刚取出的字符写入 UART 的发送保持寄存器（THR），触发硬件实际发送该字节
                                WriteReg(THR, c);
                }
}

uint64 scause = r_scause(); // 读取（监督者陷入原因）寄存器

if(scause == 0x8000000000000009L){ // 处理外部中断
                // this is a supervisor external interrupt, via PLIC.

                // irq indicates which device interrupted.
                int irq = plic_claim(); // 读取中断向量号，以此判断是哪个设备触发的

                if(irq == UART0_IRQ){ // 串口中断
                                uartintr(); // 处理串口中断
                } else if(irq == VIRTIO0_IRQ){ // 虚拟磁盘中断
                                virtio_disk_intr(); // 处理虚拟磁盘中断
                } else if(irq){ // 无法判断
                                printf("unexpected interrupt irq=%d\n", irq);
                }
// ....
}

// 当 UART 设备产生中断时（可能是因为有新数据到达，或者发送缓冲区可以继续发送数据），系统会调用该函数进行响应
// 该函数通常由设备中断分发函数 devintr() 调用
void
uartintr(void)
{
                // read and process incoming characters.
                // 循环读取和处理UART 接收到的字符
                while(1){
                                int c = uartgetc(); // 从 UART 读取一个输入字符
                                if(c == -1) // 如果没有新字符可读，跳出循环
                                                break;
                                consoleintr(c); // 通常是将字符传递给控制台输入处理逻辑，比如命令行或终端
                }

                // send buffered characters.
                // 发送缓冲区中的字符
                // 注意：需要给缓存区加锁，以避免不同线程同时访问引发数据竞争
                acquire(&uart_tx_lock);
                uartstart(); // 调用 uartstart() 发送缓冲区中的字符
                release(&uart_tx_lock);
}

else if(f->type == FD_DEVICE){
                if(f->major < 0 || f->major >= NDEV || !devsw[f->major].read)
                                return -1;
                r = devsw[f->major].read(1, addr, n);
}

int
consoleread(int user_dst, uint64 dst, int n)
{
                uint target; // 目标字节数，记录要读取的总字节数
                int c; // 用于存储从控制台读取的字符
                char cbuf; // 用于存储从控制台读取的字符，准备写入用户空间或内核空间

                target = n; // 保存初始的要读取的字节数，以便在函数结束时返回 
                acquire(&cons.lock); // 获取控制台自旋锁，确保对控制台缓冲区的独占访问
                while(n > 0){ 
                                // wait until interrupt handler has put some
                                // input into cons.buffer.
                                // 等待控制台缓冲区有可读数据
                                // 如果 cons.r 等于 cons.w，表示缓冲区为空，进入休眠
                                // 当 cons.r 不等于 cons.w 时，表示有数据可读
                                while(cons.r == cons.w){
                                                if(killed(myproc())){ // 检查当前进程是否被杀死，如果是，则释放锁并返回 -1
                                                                release(&cons.lock); 
                                                                return -1;
                                                }
                                                sleep(&cons.r, &cons.lock); // 休眠，等待控制台输入
                                }

                                // 从控制台缓冲区读取一个字符，并更新读取索引 cons.r 
                                // 这里使用模运算确保索引在缓冲区大小范围内循环
                                c = cons.buf[cons.r++ % INPUT_BUF_SIZE];  


                                // 这段代码用于处理控制台输入中的文件结束符（EOF），即用户按下 Ctrl+D 的情况
                                if(c == C('D')){  // end-of-file 即 Ctrl+D）时，表示用户希望结束输入，相当于到达文件末尾
                                                if(n < target){ // 已经读取了一些数据（n < target），说明本次读取还没有消耗掉所有请求的字节数
                                                                // Save ^D for next time, to make sure
                                                                // caller gets a 0-byte result.
                                                                // 为了保证下次读取时还能正确检测到 EOF，代码会将读取索引 cons.r 回退一位，把 Ctrl+D 留在缓冲区中
                                                                // 这样，下一次读取操作会立即遇到 EOF，返回 0 字节，符合标准输入行为
                                                                // 这种处理方式确保了 Ctrl+D 能正确地作为输入结束标志，并且多次读取时行为一致
                                                                cons.r--;
                                                }
                                                break; // 直接跳出循环，结束读取
                                }

                                // copy the input byte to the user-space buffer.
                                // 拷贝读取的字符到用户空间或内核空间
                                cbuf = c;
                                if(either_copyout(user_dst, dst, &cbuf, 1) == -1)
                                                break;

                                dst++; // 更新目标地址，准备写入下一个字符
                                --n; // 减少剩余要读取的字节数

                                if(c == '\n'){ // 如果读取到换行符（\n），表示一行输入结束
                                                // a whole line has arrived, return to
                                                // the user-level read().
                                                break; // 跳出循环，结束读取
                                }
                }
                release(&cons.lock); // 释放控制台自旋锁，允许其他线程访问控制台缓冲区

                return target - n; // 返回实际读取的字节数，即初始请求的字节数减去剩余未读取的字节数
}

// 注意：该函数不会阻塞等待数据
int
uartgetc(void)
{
                // ReadReg(LSR) 读取 UART 的线路状态寄存器（Line Status Register）
                // 该寄存器的最低位（0x01）用于指示接收缓冲区是否有数据准备好
                if(ReadReg(LSR) & 0x01){
                                // input data is ready.
                                return ReadReg(RHR); // 从接收保持寄存器（RHR）读取并返回输入字符
                } else {
                                return -1; // 如果没有数据可读，返回 -1
                }
}

// handle a uart interrupt, raised because input has
// arrived, or the uart is ready for more output, or
// both. called from devintr().

// 当 UART 设备产生中断时（可能是因为有新数据到达，或者发送缓冲区可以继续发送数据），系统会调用该函数进行响应
// 该函数通常由设备中断分发函数 devintr() 调用
void
uartintr(void)
{
                // read and process incoming characters.
                // 循环读取和处理UART 接收到的字符
                while(1){
                                int c = uartgetc(); // 从 UART 读取一个输入字符
                                if(c == -1) // 如果没有新字符可读，跳出循环
                                                break;
                                consoleintr(c); // 通常是将字符传递给控制台输入处理逻辑，比如命令行或终端
                }

                // send buffered characters.
                // 发送缓冲区中的字符
                // 注意：需要给缓存区加锁，以避免不同线程同时访问引发数据竞争
                acquire(&uart_tx_lock);
                uartstart(); // 调用 uartstart() 发送缓冲区中的字符
                release(&uart_tx_lock);
}

// 该函数会处理输入中的删除（erase）和行清除（kill）操作
// 并将有效字符追加到控制台输入缓冲区 cons.buf 中
// 
// 如果用户输入了一整行（通常以回车或换行结束），函数会唤醒正在等待输入的 consoleread()
// 让其可以读取完整的一行数据
void
consoleintr(int c)
{
                acquire(&cons.lock); // 获取控制台自旋锁，确保对控制台缓冲区的独占访问

                switch(c){
                case C('P'):  // Print process list. 
                                procdump(); // 打印当前进程列表
                                break;
                case C('U'):  // Kill line. 删除行
                                // 一次性删除当前输入行的所有字符，直到遇到上一行的换行符 \n 或缓冲区为空 
                                // cons.e 是编辑索引，指向当前正在编辑的位置；cons.w 是写入索引，指向输入缓冲区的起始位置 
                                // cons.e != cons.w 保证不会越过当前输入的起始位置，防止删除超出本行的内容 
                                // cons.buf[(cons.e-1) % INPUT_BUF_SIZE] != '\n' 检查当前要删除的字符是否为换行符
                                // 如果遇到换行符就停止，确保只删除本行内容
                                while(cons.e != cons.w &&
                                          cons.buf[(cons.e-1) % INPUT_BUF_SIZE] != '\n'){
                                                cons.e--; // 将编辑索引向前移动一位
                                                consputc(BACKSPACE); // 在终端上执行退格操作，视觉上删除一个字符
                                }
                                break;
                case C('H'): // Backspace 
                case '\x7f': // Delete key
                                // 如果用户输入了退格键或删除键，检查是否有字符可以删除
                                if(cons.e != cons.w){
                                                cons.e--;
                                                consputc(BACKSPACE);
                                }
                                break; 
                default: // 处理控制台输入字符的常规情况，并将其存入输入缓冲区
                                if(c != 0 && cons.e-cons.r < INPUT_BUF_SIZE){ // 检查输入字符 c 是否有效且缓冲区未满 
                                                c = (c == '\r') ? '\n' : c; // 如果输入的是回车符 \r，会被转换为换行符 \n，以统一行结束符的处理 

                                                // echo back to the user.
                                                consputc(c); // 将输入的字符回显到控制台

                                                // store for consumption by consoleread().
                                                // 字符被存入输入缓冲区 cons.buf，
                                                cons.buf[cons.e++ % INPUT_BUF_SIZE] = c; // 编辑索引 cons.e 递增，确保缓冲区循环利用 

                                                if(c == '\n' || c == C('D') || cons.e-cons.r == INPUT_BUF_SIZE){ 
                                                                // wake up consoleread() if a whole line (or end-of-file)
                                                                // has arrived.
                                                                // 如果输入的是换行符、Ctrl+D（文件结束符，C('D')），或 缓冲区已满 
                                                                cons.w = cons.e; // 将写入索引 cons.w 更新为当前编辑索引 cons.e
                                                                // 唤醒等待输入的进程（如 consoleread()），表示一整行输入或输入结束已经到达，可以被读取
                                                                // 这保证了控制台输入的同步和行缓冲行为
                                                                wakeup(&cons.r); 
                                                }
                                }
                                break;
                }

                release(&cons.lock); // 释放控制台自旋锁，允许其他线程访问控制台缓冲区
}