自制操作系统 - 任务会话与tty设备

typedef struct task_t
{
    pid_t pid;                          // 任务 id
    pid_t ppid;                         // 父任务 id
    pid_t pgid;                         // 进程组
    pid_t sid;                          // 进程会话
    // ....
    u32 magic;                          // 内核魔数，用于检测栈溢出
} task_t;

bool _inline task_leader(task_t *task)   // 设置指定进程为会话首领
{
    return task->sid == task->pid;
}

int sys_setpgid(int pid, int pgid)   // 给指定进程加入现有进程组
    task_t *current = running_task();   // 获取当前进程
    if (!pid)                       // 如果没有指定被设置的进程，那就是给当前进程设置进程组
        pid = current->pid;
    if (!pgid)                      // 如果没有指定进程组id，那就是设置当前进程为进程组id
        pgid = current->pid;

    for (int i = 0; i < TASK_NR; i++)   // 遍历任务列表，找到pid的任务结构
    {
        task_t *task = task_table[i];
        if (!task)            // 如果没有任务则跳过
            continue;
        if (task->pid != pid)   // 如果是当前进程，则跳过
            continue;
        if (task_leader(task))  // 如果进程已有会话首领了  返回错误，没有操作许可
            return -EPERM;
        if (task->sid != current->sid)  // 如果进程的会话首领不等于当前进程的会话首领，返回错误，没有操作许可
            return -EPERM;
        task->pgid = pgid;   // 设置进程的进程组为指定进程组id
        return EOK;
    }
    return -ESRCH;    // 返回错误，指定的进程不存在
}

int sys_getpgrp()     //  返回调用进程的进程组 ID
{
    task_t *task = running_task();   
    return task->pgid;
}

int sys_setsid()    // 设置会话id
{
    task_t *task = running_task();   // 获取当前进程
    if (task_leader(task))  // 如果当前进程是会话首领，返回错误，没有操作许可。
        return -EPERM;
    task->sid = task->pgid = task->pid;   // 设置进程会话id等于进程组id等于进程id， 并返回。
    return task->sid;
}

void dev_init()
{
    mkdir("/dev", 0755);
    // ....
    device = device_find(DEV_TTY, 0);
    mknod("/dev/tty", IFCHR | 0600, device->dev);
    link("/dev/tty", "/dev/stdout");
    link("/dev/tty", "/dev/stderr");
    link("/dev/tty", "/dev/stdin");
}

int sys_ioctl(fd_t fd, int cmd, void *args)  // 控制设备输入输出
{
    if (fd >= TASK_FILE_NR)   // 判断文件描述符是否超过最大限制
        return -EBADF;
    task_t *task = running_task();   // 获取当前进程
    file_t *file = task->files[fd];  // 获取文件描述符对应的文件结构
    if (!file)
        return -EBADF;

    int mode = file->inode->desc->mode;   // 文件必须是某种设备
    if (!ISCHR(mode) && !ISBLK(mode))
        return -EINVAL;
    dev_t dev = file->inode->desc->zone[0];   // 得到设备号
    if (dev >= DEVICE_NR)
        return -ENOTTY;
    return device_ioctl(dev, cmd, args, 0);   // 进行设备控制
}

typedef struct tty_t
{
    dev_t rdev; // 读设备号
    dev_t wdev; // 写设备号
    pid_t pgid; // 进程组
} tty_t;

#define TIOCSPGRP 0x5410   // ioctl 设置进程组命令
static tty_t typewriter;

int tty_rx_notify(char *ch, bool ctrl, bool shift, bool alt)   // tty设备处理输入字符
{
    switch (*ch)
    {
    case '\r':
        *ch = '\n';
        break;
    default:
        break;
    }
    if (!ctrl)   // ctrl没有被按下，返回0， 即字符不被处理。
        return 0;

    tty_t *tty = &typewriter;
    switch (*ch)
    {
    case 'c':
    case 'C':
        LOGK("CTRL + C Pressed\n");
        break;
    case 'l':
    case 'L':
        // 清屏
        device_write(tty->wdev, "\x1b[2J\x1b[0;0H\r", 12, 0, 0);  // 这里使用了CSI序列清屏
        *ch = '\r';
        return 0;
    default:
        return 1;
    }
    return 1;
}

int tty_read(tty_t *tty, char *buf, u32 count)  // TTY 读， 直接调用设备读
{
    return device_read(tty->rdev, buf, count, 0, 0);
}

int tty_write(tty_t *tty, char *buf, u32 count)    // TTY 写， 直接调用设备写
{
    return device_write(tty->wdev, buf, count, 0, 0);
}

int tty_ioctl(tty_t *tty, int cmd, void *args, int flags)  // 目前支持一个控制指令，即设置进程组
{
    switch (cmd)
    {
    case TIOCSPGRP:  // 设置 tty 参数
        tty->pgid = (pid_t)args;   // 设置tty的进程组为args 
        break;
    default:
        break;
    }
    return -EINVAL;
}

void tty_init()   // 初始化串口
{
    device_t *device = NULL;
    tty_t *tty = &typewriter;
    device = device_find(DEV_KEYBOARD, 0);  // 输入设备是键盘
    tty->rdev = device->dev;
    device = device_find(DEV_CONSOLE, 0);  // 输出设备是控制台
    tty->wdev = device->dev;
    device_install(DEV_CHAR, DEV_TTY, tty, "tty", 0, tty_ioctl, tty_read, tty_write);  // 安装tty设备
}

void keyboard_handler(int vector)
{
    assert(vector == 0x21);
    send_eoi(vector); // 向中断控制器发送中断处理结束的信息
    // ...
    char ch = 0;
    if (tty_rx_notify(&ch, ctrl_state, shift_state, alt_state) > 0)  // 通知 tty 设备处理输入字符
        return;

    fifo_put(&fifo, ch);
    if (waiter != NULL)
    {
        task_unblock(waiter, EOK);
        waiter = NULL;
    }
}

// 设置 TTY 进程组为 osh
ioctl(STDIN_FILENO, TIOCSPGRP, getpid());

// 释放 TTY 设备
if (task_leader(task) && task->tty > 0)
{
    device_t *device = device_get(task->tty);
    tty_t *tty = (tty_t *)device->ptr;
    tty->pgid = 0;
}