中断

    终端设备（比如 VT100）                          主机（跑 xv6 的机器）
  ┌──────────────────────┐                   ┌──────────────────────┐
  │ 键盘 ──→ 终端UART TX ─┼──────────────────→┼─ RX 主机UART ──→ CPU  │
  │ 屏幕 ←── 终端UART RX ─┼←──────────────────┼─ TX 主机UART ←── CPU  │
  └──────────────────────┘                   └──────────────────────┘
                        两根信号线 + 一根地线（TX 与 RX 交叉）

struct {
  struct spinlock lock;
 
  // input circular buffer
#define INPUT_BUF_SIZE 128
  char buf[INPUT_BUF_SIZE];
  uint r; // Read index
  uint w; // Write index
  uint e; // Edit index
} cons;

           0 ...... r ........... w .......... e ............ 127
         [ 已读/废弃 ]  [ 已提交可读 ]  [ 正在编辑区 ]
            r          w-r 字节        e-w 字节

  // connect read and write system calls
  // to consoleread and consolewrite.
  devsw[CONSOLE].read = consoleread;
  devsw[CONSOLE].write = consolewrite;

struct devsw {
  int (*read)(int, uint64, int);
  int (*write)(int, uint64, int);
};
extern struct devsw devsw[];

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].read)
      return -1;
    r = devsw[f->major].read(1, addr, n);
  }

target = n;
acquire(&cons.lock);
while (n > 0) {
  while (cons.r == cons.w) {              // 没有完整行可读
    if (killed(myproc())) { release; return -1; }
    sleep_prepare(&cons.r);               // 登记：我在等 &cons.r 这个事件
    release(&cons.lock);                  // 睡之前必须放锁！
    sleep();                              // 挂起，让出 CPU
    acquire(&cons.lock);                  // 醒来重新拿锁
  }
  c = cons.buf[cons.r++ % INPUT_BUF_SIZE];     // 取一个字节
  if (c == C('D')) {                            // Ctrl-D = EOF
    if (n < target) cons.r--;                   // 本次已读到数据 → 留到下次处理
    break;                                      // 否则返回 0
  }
  cbuf = c;
  either_copyout(..., &cbuf, 1);                // 拷到用户空间
  dst++; --n;
  if (c == '\n') break;                         // 整行取完
}
release(&cons.lock);
return target - n;                              // 实际读到的字节数

ReadReg(ISR);                       // 读一下，确认中断
if (ReadReg(LSR) & LSR_TX_IDLE)
  wakeup(&tx_chan);                 // 发送完成 → 唤醒写者（见输出部分）
while (1) {
  int c = uartgetc();               // 有字符返回字符，没有返回 -1
  if (c == -1) break;
  consoleintr(c);
}

acquire(&cons.lock);
switch (c) {
case C('P'): procdump(); break;                        // Ctrl-P 打印进程表
case C('U'): 删到行首，cons.e-- + consputc(BACKSPACE); break;   // Ctrl-U 杀整行
case C('H'): case '\x7f': 删一个；break;                // 退格 / Delete
default:
  if (c != 0 && cons.e - cons.r < INPUT_BUF_SIZE) {    // 缓冲满就丢弃
    c = (c == '\r') ? '\n' : c;                        // 回车统一成换行
    consputc(c);                                       // 立即回显
    cons.buf[cons.e++ % INPUT_BUF_SIZE] = c;           // 存进缓冲
    if (c == '\n' || c == C('D') || cons.e - cons.r == INPUT_BUF_SIZE) {
      cons.w = cons.e;                                 // 交付整行
      wakeup(&cons.r);                                 // 唤醒读者
    }
  }
}
release(&cons.lock);

char buf[32];
while (i < n) {
  int nn = min(sizeof(buf), n - i);
  either_copyin(buf, user_src, src + i, nn);   // 用户指针不能直接解引用
  uartwrite(buf, nn);
  i += nn;
}
return i;

void uartwrite(char buf[], int n) {
  acquiresleep(&tx_lock);              // 串行化多个写者
  int i = 0;
  while (i < n) {
    sleep_prepare(&tx_chan);           // 先登记"我会等发送完成"
    if (ReadReg(LSR) & LSR_TX_IDLE) {  // 硬件能收吗
      WriteReg(THR, buf[i]);           // 能就写一个字节
      i += 1;
    } else {
      sleep();                         // 不能就睡，等中断叫
    }
  }
  releasesleep(&tx_lock);
}

void uartintr(void) {
  ReadReg(ISR);                        // 确认中断
  if (ReadReg(LSR) & LSR_TX_IDLE) {    // 是"发送完成"吗
    wakeup(&tx_chan);                  // 叫醒可能在 uartwrite 里睡的进程
  }
  while (1) {                          // 输入部分
    int c = uartgetc();
    if (c == -1) break;
    consoleintr(c);
  }
}

w_menvcfg(r_menvcfg() | MENVCFG_STCE);  // 打开 Sstc（否则写 stimecmp 非法）
w_mcounteren(r_mcounteren() | 2);       // 允许 S 模式读 time
w_stimecmp(r_time() + 1000000);         // 第一次定时：约 0.1 秒后（QEMU）

else if (scause == 0x8000000000000005L) {
    // timer interrupt.
    clockintr();
    return 2;
  }

if (cpuid() == 0) {          // 只有 CPU0 推进全局时钟
  acquire(&tickslock);
  ticks++;
  wakeup(&ticks);            // 叫醒在等时间流逝的进程（如 sys_pause）
  release(&tickslock);
}
w_stimecmp(r_time() + 1000000);   // 每个 CPU 都安排自己的下一次

// usertrap（用户态被打断）
if (which_dev == 2) yield();
 
// kerneltrap（内核态被打断）
if (which_dev == 2 && myproc() != 0) yield();