Pseudo-terminals, and what tmux and htop needed around them

- /dev/ptmx and /dev/pts/N: Unix98 pairs with a full line discipline, window sizes, job control and hangup (kernel/dev/pty.c). - The console speaks scroll regions, insert/delete line, SU/SD, RI/IND/NEL, DECSC/DECRC; swallows charset designations and private CSI sequences; and LF only returns the carriage under ONLCR. - setsid() drops the controlling terminal, so a pane's pty becomes its ctty. - pipe2() honours O_NONBLOCK and O_CLOEXEC (libevent's signal pipe). - File modes are stored and enforced: chmod, fchmod(at), umask, creation modes; /tmp is 1777. - /proc/stat has real user/system/idle; /proc/<pid>/task; kthread flag. - SO_PEERCRED, IOV_MAX 1024. - /proc/strace: name a program and its syscalls go to the kernel log. - World gains htop, btop, tmux, mc, ncdu, fastfetch, games, X toys, NetSurf. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01S1giNvrHTrPMPw7V6x1kQ4
2026-10-25 02:11:10 +01:00 · 2026-10-25 02:11:10 +01:00 · fd9d392416
commit fd9d392416
parent c65bfa3fa3
28 changed files with 1577 additions and 47 deletions
--- a/kernel/dev/pty.c
+++ b/kernel/dev/pty.c
@ -0,0 +1,709 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+//
+// Pseudo-terminals.
+//
+// A terminal emulator, tmux, sshd and script(1) all want the same thing: a
+// terminal with a program on one side and *themselves* on the other, instead of
+// a keyboard and a screen. Unix98 spells that /dev/ptmx -- each open makes a new
+// pair and hands back its master -- and /dev/pts/N, the slave, which the program
+// gets as its stdin, stdout and controlling terminal. There were none of these,
+// so xterm had nothing to run a shell in and tmux could not start a server.
+//
+// Between the two sides sits a line discipline, the console's in miniature
+// (kernel/core/console.c): what the master writes is the slave's *input* --
+// canonical editing, echo, ^C as SIGINT to the foreground group -- and what the
+// slave writes is its *output*, NL turned into CR NL, read back by the master.
+//
+// Every pair shares one lock. The paths are short and a second lock per pair
+// would only be one more thing to take in the wrong order.
+
+#include "core/types.h"
+#include "core/defs.h"
+#include "core/param.h"
+#include "core/spinlock.h"
+#include "core/sleeplock.h"
+#include "core/proc.h"
+#include "fs/fs.h"
+#include "fs/file.h"
+#include "core/uaccess.h"
+#include "uapi/posix.h"
+#include "uapi/errno.h"
+#include "dev/pty.h"
+
+#define PTY_BUF 4096
+
+#define TIOCGPTN    0x80045430
+#define TIOCSPTLCK  0x40045431
+#define TIOCGPTPEER 0x5441
+#define TIOCNOTTY   0x5422
+#define TIOCGSID    0x5429
+#define TIOCOUTQ    0x5411
+#define TIOCPKT     0x5420
+
+#define POLLIN_  0x001
+#define POLLOUT_ 0x004
+#define POLLHUP_ 0x010
+
+struct pty {
+  int used;
+  int mopen, sopen;          // open file descriptions on each side
+  int slave_seen;            // the slave has been opened at least once
+  struct termios tio;
+  struct winsize ws;
+  int fg_pgrp, sid;
+
+  // The slave's input, after the line discipline. [r, w) is ready to read;
+  // [w, e) is the line still being edited in canonical mode.
+  char in[PTY_BUF];
+  uint ir, iw, ie;
+  int  eof;                  // ^D on an empty line: the next read returns 0
+  int  abort_read;           // ^C: wake the reader with EINTR
+
+  // The slave's output, for the master to read.
+  char out[PTY_BUF];
+  uint or, ow;
+};
+
+static struct spinlock ptylock;
+static struct pty ptys[NPTY];
+
+#define CTRL(x) ((x) & 0x1f)
+
+static void
+termios_defaults(struct termios *t)
+{
+  memset(t, 0, sizeof(*t));
+  t->c_iflag = ICRNL | IUTF8;
+  t->c_oflag = OPOST | ONLCR;
+  t->c_cflag = CS8 | CREAD;
+  t->c_lflag = ISIG | ICANON | ECHO | ECHOE | IEXTEN;
+  t->c_cc[VINTR]  = CTRL('C');
+  t->c_cc[VQUIT]  = CTRL('\\');
+  t->c_cc[VERASE] = 0x7f;
+  t->c_cc[VKILL]  = CTRL('U');
+  t->c_cc[VEOF]   = CTRL('D');
+  t->c_cc[VSUSP]  = CTRL('Z');
+  t->c_cc[VWERASE]= CTRL('W');
+  t->c_cc[VMIN]   = 1;
+  t->c_ispeed = 15;
+  t->c_ospeed = 15;
+}
+
+void
+pty_init(void)
+{
+  initlock(&ptylock, "pty");
+}
+
+int
+pty_alloc(void)
+{
+  acquire(&ptylock);
+  for (int i = 0; i < NPTY; i++) {
+    struct pty *p = &ptys[i];
+    if (p->used)
+      continue;
+    memset(p, 0, sizeof(*p));
+    p->used = 1;
+    termios_defaults(&p->tio);
+    p->ws.ws_row = 24;
+    p->ws.ws_col = 80;
+    release(&ptylock);
+    return i;
+  }
+  release(&ptylock);
+  return -1;
+}
+
+int
+pty_used(int n)
+{
+  return n >= 0 && n < NPTY && ptys[n].used;
+}
+
+static struct pty *
+pty_of(struct inode *ip)
+{
+  if (ip->minor < 0 || ip->minor >= NPTY)
+    return 0;
+  return &ptys[ip->minor];
+}
+
+// /dev/ptmx, opened: a new pair, and the master in place of the ptmx inode.
+// Called with ip locked, as open() holds it; hands back the master the same way.
+struct inode *
+ptmx_open(struct inode *ip)
+{
+  int n = pty_alloc();
+  struct inode *m;
+
+  if (n < 0)
+    return 0;
+  m = devfs_pty_master(n);
+  if (m == 0) {
+    ptys[n].used = 0;
+    return 0;
+  }
+  iunlockput(ip);
+  ilock(m);
+  return m;
+}
+
+static void
+maybe_free(struct pty *p)
+{
+  if (p->mopen == 0 && p->sopen == 0)
+    p->used = 0;
+}
+
+// --- output: the slave writes, the master reads ------------------------------
+
+static int
+out_room(struct pty *p)
+{
+  return PTY_BUF - (int)(p->ow - p->or);
+}
+
+// One byte of output, with OPOST processing. Caller holds the lock and has made
+// sure there is room for two.
+static void
+out_put(struct pty *p, int c)
+{
+  if ((p->tio.c_oflag & OPOST) && (p->tio.c_oflag & ONLCR) && c == '\n')
+    p->out[p->ow++ % PTY_BUF] = '\r';
+  p->out[p->ow++ % PTY_BUF] = (char)c;
+}
+
+// Echo goes into the same queue, and is dropped rather than waited for when
+// the master has stopped reading: the writer here is whoever typed, and
+// blocking it on its own echo would deadlock a master that writes and reads
+// from one thread.
+static void
+echo_put(struct pty *p, int c)
+{
+  if (out_room(p) < 2)
+    return;
+  out_put(p, c);
+}
+
+static void
+echo(struct pty *p, int c)
+{
+  if (c == '\n') {
+    if (p->tio.c_lflag & (ECHO | ECHONL))
+      echo_put(p, '\n');
+    return;
+  }
+  if (!(p->tio.c_lflag & ECHO))
+    return;
+  if (c < 32 && c != '\t' && c != '\r') {
+    echo_put(p, '^');
+    echo_put(p, c + '@');
+  } else {
+    echo_put(p, c);
+  }
+}
+
+static void
+erase_one(struct pty *p)
+{
+  if (p->ie == p->iw)
+    return;
+  p->ie--;
+  if ((p->tio.c_lflag & ECHO) && (p->tio.c_lflag & ECHOE)) {
+    echo_put(p, '\b');
+    echo_put(p, ' ');
+    echo_put(p, '\b');
+  }
+}
+
+// --- input: the master writes, the slave reads -------------------------------
+
+// One byte through the line discipline. Returns a signal to send to the
+// foreground group, or 0. Caller holds the lock.
+static int
+input_byte(struct pty *p, int c)
+{
+  struct termios *t = &p->tio;
+
+  if (t->c_iflag & ISTRIP)
+    c &= 0x7f;
+  if (c == '\r') {
+    if (t->c_iflag & IGNCR)
+      return 0;
+    if (t->c_iflag & ICRNL)
+      c = '\n';
+  } else if (c == '\n' && (t->c_iflag & INLCR)) {
+    c = '\r';
+  }
+
+  if (t->c_lflag & ISIG) {
+    int sig = 0;
+    if (c == t->c_cc[VINTR])      sig = SIGINT;
+    else if (c == t->c_cc[VQUIT]) sig = SIGQUIT;
+    else if (c == t->c_cc[VSUSP]) sig = SIGTSTP;
+    if (sig && c != 0) {
+      echo(p, c);
+      if (!(t->c_lflag & NOFLSH))
+        p->ie = p->iw = p->ir;
+      p->abort_read = 1;
+      return sig;
+    }
+  }
+
+  if (t->c_lflag & ICANON) {
+    if (c == t->c_cc[VERASE] || c == CTRL('H')) {
+      erase_one(p);
+      return 0;
+    }
+    if (c == t->c_cc[VKILL]) {
+      while (p->ie != p->iw && p->in[(p->ie - 1) % PTY_BUF] != '\n')
+        erase_one(p);
+      return 0;
+    }
+    if (c == t->c_cc[VWERASE] && (t->c_lflag & IEXTEN)) {
+      while (p->ie != p->iw && p->in[(p->ie - 1) % PTY_BUF] == ' ')
+        erase_one(p);
+      while (p->ie != p->iw && p->in[(p->ie - 1) % PTY_BUF] != ' ')
+        erase_one(p);
+      return 0;
+    }
+    if (c == t->c_cc[VEOF]) {
+      if (p->ie == p->iw)
+        p->eof = 1;
+      p->iw = p->ie;
+      return 0;
+    }
+  }
+
+  if (p->ie - p->ir >= PTY_BUF)
+    return 0;                           // full: dropped, as a console does
+  p->in[p->ie++ % PTY_BUF] = (char)c;
+  echo(p, c);
+  if (!(t->c_lflag & ICANON) || c == '\n' || p->ie - p->ir >= PTY_BUF)
+    p->iw = p->ie;
+  return 0;
+}
+
+int
+ptm_write(struct inode *ip, uint64 off, char *src, int n)
+{
+  struct pty *p = pty_of(ip);
+  char kbuf[128];
+  int done = 0;
+
+  (void)off;
+  if (p == 0 || !p->used)
+    return -EIO;
+  iunlock(ip);
+  while (done < n) {
+    int chunk = n - done < (int)sizeof(kbuf) ? n - done : (int)sizeof(kbuf);
+    if (copy_from_user(kbuf, (addr_t)(src + done), chunk) < 0) {
+      ilock(ip);
+      return done ? done : -EFAULT;
+    }
+    acquire(&ptylock);
+    for (int i = 0; i < chunk; i++) {
+      // Raw-mode input waits for room rather than vanishing: a paste into an
+      // editor is a burst of thousands of bytes, and dropping the tail of it
+      // is worse than making the writer wait for the reader.
+      while (!(p->tio.c_lflag & ICANON) && p->ie - p->ir >= PTY_BUF &&
+             p->sopen > 0) {
+        if (myproc()->killed) {
+          release(&ptylock);
+          ilock(ip);
+          return done + i ? done + i : -EINTR;
+        }
+        sleep(&p->ie, &ptylock);
+      }
+      int sig = input_byte(p, kbuf[i] & 0xff);
+      if (sig) {
+        int pg = p->fg_pgrp;
+        wakeup(&p->ir);
+        release(&ptylock);
+        if (pg > 0)
+          sigsend_pgrp(pg, sig);
+        acquire(&ptylock);
+      }
+    }
+    wakeup(&p->ir);
+    wakeup(&p->or);                   // the echo
+    release(&ptylock);
+    done += chunk;
+  }
+  poll_kick();
+  ilock(ip);
+  return n;
+}
+
+int
+ptm_read(struct inode *ip, uint64 off, char *dst, int n)
+{
+  struct pty *p = pty_of(ip);
+  char kbuf[256];
+  int got = 0;
+
+  (void)off;
+  if (p == 0 || !p->used)
+    return -EIO;
+  iunlock(ip);
+  acquire(&ptylock);
+  while (p->or == p->ow) {
+    // Every slave descriptor closed, after there was one: the program on the
+    // other side has gone. Linux says EIO, and that is what terminal
+    // emulators and tmux take as "the shell exited".
+    if (p->slave_seen && p->sopen == 0) {
+      release(&ptylock);
+      ilock(ip);
+      return -EIO;
+    }
+    if (myproc()->killed) {
+      release(&ptylock);
+      ilock(ip);
+      return -EINTR;
+    }
+    sleep(&p->or, &ptylock);
+  }
+  while (got < n && got < (int)sizeof(kbuf) && p->or != p->ow)
+    kbuf[got++] = p->out[p->or++ % PTY_BUF];
+  wakeup(&p->ow);
+  release(&ptylock);
+  poll_kick();
+  ilock(ip);
+  if (copy_to_user((addr_t)dst, kbuf, got) < 0)
+    return -EFAULT;
+  return got;
+}
+
+int
+ptm_ready(struct inode *ip)
+{
+  struct pty *p = pty_of(ip);
+  return p && (p->or != p->ow || (p->slave_seen && p->sopen == 0));
+}
+
+void
+ptm_open(struct inode *ip)
+{
+  struct pty *p = pty_of(ip);
+  if (p) {
+    acquire(&ptylock);
+    p->mopen++;
+    release(&ptylock);
+  }
+}
+
+// The master is gone: the slave side has been hung up on. Its readers see end
+// of file, its writers EIO, and its session SIGHUP -- which is how closing an
+// xterm window ends the shell inside it.
+void
+ptm_close(struct inode *ip)
+{
+  struct pty *p = pty_of(ip);
+  int sid = 0, pg = 0;
+
+  if (p == 0)
+    return;
+  acquire(&ptylock);
+  if (p->mopen > 0)
+    p->mopen--;
+  if (p->mopen == 0) {
+    sid = p->sid;
+    pg = p->fg_pgrp;
+    wakeup(&p->ir);
+    wakeup(&p->ow);
+    wakeup(&p->ie);
+  }
+  maybe_free(p);
+  release(&ptylock);
+  if (sid > 0)
+    sigsend_pgrp(sid, SIGHUP);
+  if (pg > 0 && pg != sid)
+    sigsend_pgrp(pg, SIGHUP);
+  poll_kick();
+}
+
+// --- the slave ---------------------------------------------------------------
+
+int
+pts_read(struct inode *ip, uint64 off, char *dst, int n)
+{
+  struct pty *p = pty_of(ip);
+  char kbuf[256];
+  int got = 0, c;
+
+  (void)off;
+  if (p == 0 || !p->used)
+    return -EIO;
+  if (n > (int)sizeof(kbuf))
+    n = sizeof(kbuf);
+  iunlock(ip);
+  acquire(&ptylock);
+  while (got < n) {
+    while (p->ir == p->iw) {
+      if (p->eof) {
+        p->eof = 0;
+        goto done;
+      }
+      if (p->mopen == 0)
+        goto done;                      // hung up: end of file
+      // VMIN 0 is a poll, and a program that asked for one must not block.
+      if (!(p->tio.c_lflag & ICANON) && p->tio.c_cc[VMIN] == 0)
+        goto done;
+      if (got > 0 && !(p->tio.c_lflag & ICANON))
+        goto done;
+      if (myproc()->killed || p->abort_read) {
+        p->abort_read = 0;
+        release(&ptylock);
+        ilock(ip);
+        return got ? got : -EINTR;
+      }
+      sleep(&p->ir, &ptylock);
+    }
+    c = p->in[p->ir++ % PTY_BUF];
+    kbuf[got++] = (char)c;
+    if ((p->tio.c_lflag & ICANON) && c == '\n')
+      break;
+    if (!(p->tio.c_lflag & ICANON) &&
+        got >= (p->tio.c_cc[VMIN] ? p->tio.c_cc[VMIN] : 1) && p->ir == p->iw)
+      break;
+  }
+done:
+  wakeup(&p->ie);
+  release(&ptylock);
+  poll_kick();
+  ilock(ip);
+  if (got && copy_to_user((addr_t)dst, kbuf, got) < 0)
+    return -EFAULT;
+  return got;
+}
+
+int
+pts_write(struct inode *ip, uint64 off, char *src, int n)
+{
+  struct pty *p = pty_of(ip);
+  char kbuf[128];
+  int done = 0;
+
+  (void)off;
+  if (p == 0 || !p->used)
+    return -EIO;
+  iunlock(ip);
+  while (done < n) {
+    int chunk = n - done < (int)sizeof(kbuf) ? n - done : (int)sizeof(kbuf);
+    if (copy_from_user(kbuf, (addr_t)(src + done), chunk) < 0) {
+      ilock(ip);
+      return done ? done : -EFAULT;
+    }
+    acquire(&ptylock);
+    for (int i = 0; i < chunk; i++) {
+      while (out_room(p) < 2) {
+        if (p->mopen == 0 || myproc()->killed) {
+          release(&ptylock);
+          ilock(ip);
+          return done + i ? done + i : (p->mopen == 0 ? -EIO : -EINTR);
+        }
+        wakeup(&p->or);
+        sleep(&p->ow, &ptylock);
+      }
+      if (p->mopen == 0) {
+        release(&ptylock);
+        ilock(ip);
+        return done + i ? done + i : -EIO;
+      }
+      out_put(p, kbuf[i] & 0xff);
+    }
+    wakeup(&p->or);
+    release(&ptylock);
+    done += chunk;
+  }
+  poll_kick();
+  ilock(ip);
+  return n;
+}
+
+int
+pts_ready(struct inode *ip)
+{
+  struct pty *p = pty_of(ip);
+  return p && (p->ir != p->iw || p->eof || p->mopen == 0);
+}
+
+// Opening a terminal makes it the caller's controlling terminal when the
+// caller leads a session that has none -- the System V rule, which Linux keeps
+// and which xterm relies on: its child calls setsid() and opens the slave, and
+// expects ^C to work from then on without a TIOCSCTTY.
+void
+pts_open(struct inode *ip)
+{
+  struct pty *p = pty_of(ip);
+  struct proc *me = myproc();
+
+  if (p == 0)
+    return;
+  acquire(&ptylock);
+  p->sopen++;
+  p->slave_seen = 1;
+  if (me && me->sid == me->pid && me->ctty == 0 && p->sid == 0) {
+    me->ctty = PTY_CTTY + ip->minor;
+    p->sid = me->sid;
+    p->fg_pgrp = me->pgid;
+  }
+  release(&ptylock);
+}
+
+void
+pts_close(struct inode *ip)
+{
+  struct pty *p = pty_of(ip);
+
+  if (p == 0)
+    return;
+  acquire(&ptylock);
+  if (p->sopen > 0)
+    p->sopen--;
+  if (p->sopen == 0) {
+    p->sid = 0;
+    p->fg_pgrp = 0;
+    wakeup(&p->or);                     // the master reads EIO now
+  }
+  maybe_free(p);
+  release(&ptylock);
+  poll_kick();
+}
+
+// --- ioctl and poll ----------------------------------------------------------
+
+int
+pty_ioctl(struct inode *ip, uint request, addr_t arg)
+{
+  struct pty *p = pty_of(ip);
+  int master = ip->major == PTM_MAJOR;
+  int v;
+
+  if (p == 0 || !p->used)
+    return -EIO;
+
+  switch (request) {
+  case TIOCGPTN:
+    if (!master)
+      return -ENOTTY;
+    v = ip->minor;
+    return put_user(v, arg) < 0 ? -EFAULT : 0;
+  case TIOCSPTLCK:
+  case TIOCPKT:
+    // Slaves are never locked here, so unlockpt() has nothing to undo; packet
+    // mode is not offered, and nothing in the image asks for it.
+    return master ? 0 : -ENOTTY;
+  case TCGETS: {
+    struct termios t;
+    acquire(&ptylock);
+    t = p->tio;
+    release(&ptylock);
+    return copy_to_user(arg, &t, sizeof(t)) < 0 ? -EFAULT : 0;
+  }
+  case TCSETS: case TCSETSW: case TCSETSF: {
+    struct termios t;
+    if (copy_from_user(&t, arg, sizeof(t)) < 0)
+      return -EFAULT;
+    acquire(&ptylock);
+    p->tio = t;
+    if (request == TCSETSF)
+      p->ie = p->iw = p->ir;
+    // Leaving canonical mode hands over the line being edited, as on the
+    // console: a shell that switches to raw mid-line must not lose it.
+    if (!(t.c_lflag & ICANON))
+      p->iw = p->ie;
+    wakeup(&p->ir);
+    release(&ptylock);
+    poll_kick();
+    return 0;
+  }
+  case TCFLSH:
+    acquire(&ptylock);
+    if (arg == TCIFLUSH || arg == TCIOFLUSH) {
+      p->ie = p->iw = p->ir;
+      p->eof = 0;
+    }
+    if (arg == TCOFLUSH || arg == TCIOFLUSH)
+      p->or = p->ow;
+    wakeup(&p->ie);
+    wakeup(&p->ow);
+    release(&ptylock);
+    return 0;
+  case TIOCGWINSZ:
+    return copy_to_user(arg, &p->ws, sizeof(p->ws)) < 0 ? -EFAULT : 0;
+  case TIOCSWINSZ: {
+    struct winsize ws;
+    int changed, pg;
+    if (copy_from_user(&ws, arg, sizeof(ws)) < 0)
+      return -EFAULT;
+    acquire(&ptylock);
+    changed = ws.ws_row != p->ws.ws_row || ws.ws_col != p->ws.ws_col;
+    p->ws = ws;
+    pg = p->fg_pgrp;
+    release(&ptylock);
+    // The program inside learns of a resize the way it would on Linux.
+    if (changed && pg > 0)
+      sigsend_pgrp(pg, SIGWINCH);
+    return 0;
+  }
+  case FIONREAD:
+    v = master ? (int)(p->ow - p->or) : (int)(p->iw - p->ir);
+    return put_user(v, arg) < 0 ? -EFAULT : 0;
+  case TIOCOUTQ:
+    v = master ? 0 : (int)(p->ow - p->or);
+    return put_user(v, arg) < 0 ? -EFAULT : 0;
+  case TIOCGPGRP:
+    v = p->fg_pgrp;
+    return put_user(v, arg) < 0 ? -EFAULT : 0;
+  case TIOCSPGRP:
+    if (copy_from_user(&v, arg, sizeof(v)) < 0)
+      return -EFAULT;
+    if (v <= 0)
+      return -EINVAL;
+    p->fg_pgrp = v;
+    return 0;
+  case TIOCGSID:
+    if (p->sid == 0)
+      return -ENOTTY;
+    v = p->sid;
+    return put_user(v, arg) < 0 ? -EFAULT : 0;
+  case TIOCSCTTY:
+    if (master)
+      return -EINVAL;
+    myproc()->ctty = PTY_CTTY + ip->minor;
+    p->sid = myproc()->sid;
+    p->fg_pgrp = myproc()->pgid;
+    return 0;
+  case TIOCNOTTY:
+    if (myproc()->ctty == PTY_CTTY + ip->minor)
+      myproc()->ctty = 0;
+    return 0;
+  }
+  return -ENOTTY;
+}
+
+int
+pty_poll(struct inode *ip, int events, int readable, int writable)
+{
+  struct pty *p = pty_of(ip);
+  int rev = 0;
+
+  if (p == 0 || !p->used)
+    return POLLHUP_;
+  if (ip->major == PTM_MAJOR) {
+    if (readable && (events & POLLIN_) && p->or != p->ow)
+      rev |= POLLIN_;
+    if (p->slave_seen && p->sopen == 0)
+      rev |= POLLHUP_ | (events & POLLIN_);
+  } else {
+    if (readable && (events & POLLIN_) && (p->ir != p->iw || p->eof))
+      rev |= POLLIN_;
+    if (p->mopen == 0)
+      rev |= POLLHUP_ | (events & POLLIN_);
+  }
+  if (writable && (events & POLLOUT_))
+    rev |= POLLOUT_;
+  return rev;
+}