菜鸟教程 – 学的不仅是技术，更是梦想！

技术网站，更是交流网站

Linux

《简易制作 Linux Shell：详细分析原理、设计与实践》

likuolei

《简易制作 Linux Shell：详细分析原理、设计与实践》

Linux Shell 是用户与内核互动的桥梁，负责命令解析、执行和环境管理。自己做一个简易 Shell，能让你深刻理解操作系统原理（如进程管理、I/O 重定向、管道）。
这个指南基于 2026 年主流 Linux 内核（6.x 系列），用 C 语言实现一个极简版 Shell（支持基本命令、管道、I/O 重定向）。
我们从原理入手，到设计框架，再到实践代码。整个实现不到 300 行代码，适合入门者。

第一部分：Shell 原理详细分析

Shell 本质是一个命令解释器（interpreter），它读取用户输入、解析成内核可懂的指令、执行并反馈结果。不同于脚本解释器（如 bash），它还是一个交互式 REPL（Read-Eval-Print Loop）。

Shell 的核心工作流程（2026 年视角）

步骤描述内核机制 / 系统调用示例常见问题 / 挑战
Read读取用户输入（stdin）read() / fgets()处理多行输入、TAB 补全（可选）
Parse解析命令：拆分 token、处理引号/转义自定义 lexer/parser（字符串分割）语法错误（如未闭合引号）、变量扩展
Eval执行：fork 子进程、execve 替换镜像fork()、execve()、waitpid()权限、路径查找（$PATH）、内置命令（如 cd）
Print输出结果（stdout/stderr）write() 或直接重定向错误处理、信号（如 Ctrl+C → SIGINT）
Loop循环等待下一命令while 循环历史记录、别名（高级可选）

关键原理扩展：

  • 进程模型：Shell 本身是父进程，每条命令 fork 子进程执行（避免阻塞）。内置命令（如 echo、cd）在父进程内执行，无需 fork。
  • 管道（Pipe）：用 pipe() 系统调用创建匿名管道，实现 cmd1 | cmd2（cmd1 stdout → cmd2 stdin）。
  • I/O 重定向：用 dup2() 替换文件描述符（fd），如 cmd > file 把 stdout 指向文件。
  • 信号处理：用 signal() 或 sigaction() 处理 SIGINT（Ctrl+C）、SIGCHLD（子进程结束）。
  • 环境变量：用 getenv()、setenv() 管理 $PATH、$HOME 等。
  • 安全性：简单 Shell 易受注入攻击（如 rm -rf /），生产 Shell（如 bash）有严格解析器。

形象比喻：Shell 像餐厅服务员——读菜单（输入）、传菜（解析执行）、上菜（输出）。

第二部分：简易 Shell 设计框架

设计一个最小 viable Shell（MVS），名为 mysh。目标：支持外部命令、管道（单级）、重定向（>、<、>>）、内置 cd/exit、基本错误处理。

架构组件（模块化设计）

组件功能实现要点复杂度（1-5）
主循环REPL 循环while(1) { prompt(); read_line(); }1
解析器拆分命令、参数、操作符strtok() 分割空格；识别> < >>
执行器处理内置/外部命令、管道、重定向if builtin else fork+execve; pipe() for
错误处理捕获执行失败、信号perror(); signal(SIGINT, handler)2
环境管理$PATH 查找命令路径getenv(“PATH”); strstr() 路径拼接2

设计原则（2026 年最佳实践）：

  • 模块化：每个组件独立函数，便于调试/扩展。
  • 鲁棒性：处理空输入、未知命令、权限错误。
  • 性能：避免不必要 fork（内置命令直执行）。
  • 扩展点：后期加变量扩展（$VAR）、通配符（*）、后台（&）。
  • 工具链：用 gcc 编译，valgrind 查内存泄漏。

潜在扩展：加 readline 库支持 TAB 补全/历史（需安装 libreadline-dev）。

第三部分：实践——一步步实现 mysh

用 C 语言写（Linux 原生，最贴近内核）。假设你有 gcc 和 make。

步骤1：准备环境

# Ubuntu/Debian
sudo apt update && sudo apt install build-essential libreadline-dev valgrind

# 创建项目
mkdir mysh && cd mysh
touch mysh.c Makefile

Makefile 示例：

CC = gcc
CFLAGS = -Wall -Wextra -g
LIBS = -lreadline

mysh: mysh.c
    $(CC) $(CFLAGS) -o mysh mysh.c $(LIBS)

clean:
    rm -f mysh

步骤2：核心代码（完整 mysh.c）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <readline/readline.h>
#include <readline/history.h>

#define MAX_CMD_LEN 1024
#define MAX_ARGS 64
#define MAX_PATHS 32

// 信号处理：忽略 Ctrl+C 在子进程
void sigint_handler(int sig) { /* do nothing */ }

// 查找命令完整路径
char* find_cmd_path(const char* cmd) {
    if (strchr(cmd, '/')) return strdup(cmd);  // 绝对路径
    char* path = getenv("PATH");
    if (!path) return NULL;

    char* path_copy = strdup(path);
    char* dir = strtok(path_copy, ":");
    static char full_path[1024];

    while (dir) {
        snprintf(full_path, sizeof(full_path), "%s/%s", dir, cmd);
        if (access(full_path, X_OK) == 0) {
            free(path_copy);
            return strdup(full_path);
        }
        dir = strtok(NULL, ":");
    }
    free(path_copy);
    return NULL;
}

// 解析命令行：拆分 args，返回是否有管道/重定向
int parse_cmd(char* line, char** args, char** pipe_args, char** redir_in, char** redir_out, int* append) {
    *redir_in = NULL; *redir_out = NULL; *append = 0; *pipe_args = NULL;
    char* token = strtok(line, " ");
    int i = 0, is_pipe = 0;
    while (token && i < MAX_ARGS - 1) {
        if (strcmp(token, "|") == 0) {
            args[i] = NULL;  // 结束第一个命令
            is_pipe = 1;
            token = strtok(NULL, " ");
            int j = 0;
            while (token && j < MAX_ARGS - 1) {
                pipe_args[j++] = strdup(token);
                token = strtok(NULL, " ");
            }
            pipe_args[j] = NULL;
            return is_pipe;
        } else if (strcmp(token, "<") == 0) {
            *redir_in = strdup(strtok(NULL, " "));
        } else if (strcmp(token, ">") == 0) {
            *redir_out = strdup(strtok(NULL, " "));
        } else if (strcmp(token, ">>") == 0) {
            *redir_out = strdup(strtok(NULL, " "));
            *append = 1;
        } else {
            args[i++] = strdup(token);
        }
        token = strtok(NULL, " ");
    }
    args[i] = NULL;
    return is_pipe;
}

// 执行单个命令
void exec_cmd(char** args, char* redir_in, char* redir_out, int append) {
    pid_t pid = fork();
    if (pid == 0) {  // 子进程
        signal(SIGINT, SIG_DFL);  // 子进程响应 Ctrl+C

        if (redir_in) {
            int fd = open(redir_in, O_RDONLY);
            if (fd < 0) { perror("open in"); exit(1); }
            dup2(fd, STDIN_FILENO);
            close(fd);
        }
        if (redir_out) {
            int flags = O_WRONLY | O_CREAT | (append ? O_APPEND : 0);
            int fd = open(redir_out, flags, 0644);
            if (fd < 0) { perror("open out"); exit(1); }
            dup2(fd, STDOUT_FILENO);
            close(fd);
        }

        char* path = find_cmd_path(args[0]);
        if (!path) { fprintf(stderr, "%s: command not found\n", args[0]); exit(127); }
        execve(path, args, environ);
        perror("execve");
        exit(1);
    } else if (pid > 0) {
        waitpid(pid, NULL, 0);
    } else {
        perror("fork");
    }
}

// 执行带管道的命令
void exec_pipe(char** args1, char** args2, char* redir_in, char* redir_out, int append) {
    int pipefd[2];
    if (pipe(pipefd) < 0) { perror("pipe"); return; }

    pid_t pid1 = fork();
    if (pid1 == 0) {
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[0]); close(pipefd[1]);
        if (redir_in) { /* 同上 */ }  // 简化，类似 exec_cmd
        char* path = find_cmd_path(args1[0]);
        execve(path, args1, environ);
        exit(1);
    }

    pid_t pid2 = fork();
    if (pid2 == 0) {
        dup2(pipefd[0], STDIN_FILENO);
        close(pipefd[0]); close(pipefd[1]);
        if (redir_out) { /* 同上 */ }
        char* path = find_cmd_path(args2[0]);
        execve(path, args2, environ);
        exit(1);
    }

    close(pipefd[0]); close(pipefd[1]);
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);
}

// 内置命令
int builtin_cmd(char** args) {
    if (strcmp(args[0], "cd") == 0) {
        if (chdir(args[1] ? args[1] : getenv("HOME")) < 0) perror("cd");
        return 1;
    } else if (strcmp(args[0], "exit") == 0) {
        exit(0);
    }
    return 0;
}

int main() {
    signal(SIGINT, sigint_handler);  // 父进程忽略 Ctrl+C
    char* line;
    while (1) {
        line = readline("mysh$ ");
        if (!line || !*line) continue;
        add_history(line);

        char* args[MAX_ARGS] = {0};
        char* pipe_args[MAX_ARGS] = {0};
        char* redir_in = NULL, *redir_out = NULL;
        int append = 0;

        char line_copy[MAX_CMD_LEN];
        strcpy(line_copy, line);
        int has_pipe = parse_cmd(line_copy, args, pipe_args, &redir_in, &redir_out, &append);

        if (args[0]) {
            if (builtin_cmd(args)) { /* handled */ }
            else if (has_pipe) exec_pipe(args, pipe_args, redir_in, redir_out, append);
            else exec_cmd(args, redir_in, redir_out, append);
        }

        // 清理
        for (int i = 0; args[i]; i++) free(args[i]);
        for (int i = 0; pipe_args[i]; i++) free(pipe_args[i]);
        free(redir_in); free(redir_out);
        free(line);
    }
    return 0;
}

步骤3：编译 & 测试

make
./mysh

# 测试命令
ls -l
echo hello > test.txt
cat test.txt
ls | grep txt
cd /tmp
exit

调试技巧：

  • 用 valgrind ./mysh 查内存泄漏。
  • 加打印日志调试 parse/exec。
  • 常见错误：忘记 free() 内存、dup2() 后未 close fd、PATH 未处理。

步骤4：扩展练习

  • 加后台支持：解析 &，用 nohup + setsid。
  • 加变量：解析 $VAR，用 getenv 替换。
  • 加多级管道：递归解析 |，多 fork。
  • 性能优化：用 hash 表缓存命令路径。

总结一句话口诀

“Shell REPL 读解析执，fork execve 管道重定向；内置 cd exit 父进程跑，信号环境加持成高手。”

这个简易版是起点，实际 bash 有 10 万+ 行代码。
想深入哪块？

  • 完整多级管道实现代码
  • 用 Python / Rust 重写（更现代）
  • Shell vs Kernel 更深对比
  • 常见 Shell 漏洞分析（e.g., Shellshock）

直接告诉我，我继续展开～

网站 http://yingjuxia.com
文章已创建 4050

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

相关文章

开始在上面输入您的搜索词，然后按回车进行搜索。按ESC取消。

返回顶部