【Linux】进程控制

【Linux】进程控制

1、进程创建（fork函数）

fork()函数是一个在Unix和类Unix操作系统中使用的系统调用，用于创建一个新的进程，称为子进程。子进程是父进程的一个副本，它从fork()函数的调用点开始执行。

以下是fork()函数的原型：

#include 

pid_t fork(void);

fork()函数返回两次：在父进程中返回子进程的进程ID（PID），在子进程中返回0。这样，通过检查返回值，可以确定当前代码是在父进程还是子进程中执行。

下面是一个简单的示例程序，展示了fork()函数的基本用法：

#include 
#include 

int main() {
    pid_t pid = fork();
    
    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Hello from the child process!\n");
    } else {
        // 父进程代码
        printf("Hello from the parent process! Child's PID is %d.\n", pid);
    }
    
    return 0;
}

当你运行上述程序时，它会创建一个子进程，并在父进程和子进程中分别输出不同的消息。你可以尝试运行这段代码，观察输出结果。

需要注意的是，fork()函数会将当前进程的整个地址空间（包括代码、数据和堆栈）复制到子进程中。因此，父进程和子进程将在fork()调用点之后的代码处开始并发地执行，但它们各自有自己的地址空间和系统资源。

1.1 调用过程

在调用fork()函数后，当控制转移到内核中的fork()代码时，内核会执行以下操作：

1. 分配新的内存块和内核数据结构给子进程：内核会为子进程分配新的地址空间，并为其创建相应的内核数据结构，用于跟踪和管理子进程的状态和资源。

2. 将父进程部分数据结构内容拷贝至子进程：内核会将父进程的一部分数据结构内容（如进程上下文、文件描述符表、信号处理程序等）拷贝到子进程的对应数据结构中。这样，子进程就成为了父进程的一个副本，但拥有自己的独立执行环境。

3. 添加子进程到系统进程列表中：内核将子进程添加到系统的进程列表中，以便对其进行进程调度和管理。子进程会被分配一个唯一的进程ID（PID），以标识它在系统中的唯一性。

4. fork()返回，开始调度器调度：在完成子进程的初始化之后，fork()函数会返回两次。在父进程中，返回子进程的PID（大于0）；在子进程中，返回0。接下来，内核会使用调度器决定如何分配CPU时间片，以允许父进程和子进程并发地执行。

需要注意的是，fork()函数只会复制父进程的数据结构，不会复制整个地址空间的内容。子进程与父进程共享父进程的物理内存页，这是通过页表机制实现的。只有在父进程或子进程中修改内存内容时，才会进行实际的复制操作（称为写时复制，Copy-on-Write）。

这些是fork()函数在内核中的一般操作。具体的实现可能会因操作系统的不同而有所差异。

写时拷贝

写时拷贝（Copy-on-Write，COW）是一种内存管理技术，常用于处理fork()函数创建子进程时的内存复制操作。

在初始阶段，父进程和子进程共享同一份物理内存页。这意味着它们访问相同的物理内存内容，并且在内核的页表中指向相同的页帧。这样可以节省内存和复制数据的时间。

当父进程或子进程尝试对这些共享内存页进行写入操作时，就会触发写时拷贝机制。内核会将相关的内存页复制一份，分配给修改数据的进程，而不影响其他进程。这样，父进程和子进程各自拥有了自己的独立内存副本，它们之间的写操作不再相互干扰。

写时拷贝的好处在于，只有在需要修改共享数据时才会进行复制操作，而在只读情况下，父进程和子进程共享同一份内存，节省了内存和复制的开销。

以下是写时拷贝的典型流程：

1. fork()函数创建子进程。
2. 父进程和子进程共享同一份物理内存页。
3. 当父进程或子进程尝试对共享内存页进行写操作时，触发写时拷贝。
4. 内核将相关的内存页复制一份，分配给修改数据的进程。
5. 父进程和子进程分别拥有自己的独立内存副本。
6. 父进程和子进程可以独立进行写操作，互不干扰。

写时拷贝技术在实现fork()函数时非常有用，因为它避免了不必要的内存复制，提高了性能和效率。

1.2 常规用法

fork()函数在常规用法中有两种常见情况：

1. 创建子进程来执行不同的代码段：
   在这种情况下，父进程会调用fork()函数来创建一个新的子进程，然后父子进程可以并发地执行不同的代码段。

   示例代码：

   #include 
   #include 
   
   int main() {
       pid_t pid = fork();
   
       if (pid < 0) {
           // 错误处理
           fprintf(stderr, "Fork failed.\n");
           return 1;
       } else if (pid == 0) {
           // 子进程代码
           printf("Child process executing.\n");
           // 执行子进程特定的代码
       } else {
           // 父进程代码
           printf("Parent process executing.\n");
           // 执行父进程特定的代码
       }
   
       return 0;
   }
   

   在上述示例中，父进程和子进程根据fork()的返回值判断执行的代码段，从而实现了并发执行不同的代码。

2. 子进程执行不同的程序（使用exec()函数）：
   在这种情况下，父进程通过fork()函数创建子进程，并且子进程在fork()返回后调用exec()函数来加载并执行一个全新的程序，替换自身的代码段和数据段。

   示例代码：

   #include 
   #include 
   #include 
   #include 
   
   int main() {
       pid_t pid = fork();
   
       if (pid < 0) {
           // 错误处理
           fprintf(stderr, "Fork failed.\n");
           return 1;
       } else if (pid == 0) {
           // 子进程代码
           printf("Child process executing.\n");
           execl("/bin/ls", "ls", "-l", NULL);
           // 如果exec函数调用成功，子进程的代码段和数据段将被替换为ls程序的代码段和数据段
       } else {
           // 父进程代码
           printf("Parent process executing.\n");
           wait(NULL); // 等待子进程执行完毕
           printf("Child process completed.\n");
       }
   
       return 0;
   }
   

   在上述示例中，父进程创建子进程后，子进程调用execl()函数来加载并执行ls命令，替换自身的代码段和数据段。父进程在等待子进程执行完毕后继续执行。

这些是fork()函数的两种常见用法，用于实现父子进程的并发执行和执行不同的程序。通过结合其他系统调用，可以实现更丰富的进程间通信和控制。

1.3 调用失败原因

fork()调用失败的原因可能有以下几种：

1. 系统中有太多的进程：在一个系统中，同时运行的进程数量是有限的。如果系统中已经达到了进程数量的上限，那么fork()调用就无法创建新的进程，从而失败。

   解决方法：可以通过增加系统的进程数量限制或者关闭一些不必要的进程来释放资源，以便fork()调用能够成功创建新的进程。

2. 实际用户的进程数超过了限制：在某些系统上，每个用户都有一个进程数量的限制。如果一个用户已经达到了进程数量的限制，那么该用户的fork()调用也会失败。

   解决方法：可以增加用户的进程数量限制或者关闭该用户的一些不必要的进程，以便fork()调用能够成功创建新的进程。

3. 系统资源不足：fork()调用需要分配新的内存空间和其他资源给子进程，如果系统资源不足，比如内存不足或者文件描述符达到上限，那么fork()调用也会失败。

   解决方法：释放一些系统资源，如关闭不必要的文件描述符，或者增加系统的资源限制，以便fork()调用能够成功分配所需的资源。

需要注意的是，fork()函数的失败并不一定是永久性的，可能是由于临时的系统状态或资源限制导致的。因此，如果fork()调用失败，可以适当延时并重试，或者采取相应的措施来解决资源问题。

另外，fork()函数在调用失败时会返回一个负值，通常是-1，可以通过检查返回值来判断fork()是否成功。

2、进程终止

2.1 进程退出场景

进程退出的场景可以分为以下几种情况：

1. 代码运行完毕，结果正确：这是最理想的情况，代码成功完成了它的任务，并且得到了正确的结果。在这种情况下，进程可以通过返回0作为退出状态码来表示成功。

2. 代码运行完毕，结果不正确：有时候，代码可能会完成执行，但是得到了不正确的结果。在这种情况下，进程可以通过返回一个非零的退出状态码来表示失败或错误。具体的退出状态码的含义可以根据具体的程序来定义，通常非零值表示出现了某种错误或异常情况。

3. 代码异常终止：在某些情况下，代码可能会遇到无法处理的错误或异常情况，导致程序无法继续执行。这可能是由于内存访问错误、除零错误、无效的指针引用等引起的。在这种情况下，进程会异常终止，并且操作系统会捕获到异常，并可能采取一些默认的处理方式，如终止进程并生成错误报告。

在C语言中，程序可以通过在main()函数中使用return语句来指定进程的退出状态码。例如：

int main() {
    // 代码执行完毕，结果正确
    return 0;
}

int main() {
    // 代码执行完毕，结果不正确
    return 1;
}

对于异常终止的情况，操作系统通常会将非零的退出状态码返回给父进程，父进程可以根据这个状态码来判断子进程的异常终止原因。

需要注意的是，进程的退出状态码的具体含义可以根据程序的需求自定义。常见的做法是使用非零的状态码表示不同的错误或异常情况，方便在调用程序时进行错误处理和故障排除。

2.2 进程退出方法

2.2.1 正常终止

在进程中，常见的退出方法可以归纳为以下几种情况：

1. 从main()函数返回：当程序执行完main()函数中的所有代码后，正常退出时会自动返回。返回的值会成为进程的退出状态码。通常情况下，返回0表示成功，非零值表示出现了错误或异常情况。

   示例代码：

   #include 
   
   int main() {
       // 代码执行完毕
       return 0;
   }
   

2. 调用exit()函数：exit()函数是C标准库中的一个函数，可以用于显式地终止进程并指定退出状态码。

   示例代码：

   #include 
   #include 
   
   int main() {
       // 代码执行完毕
       exit(0);  // 退出并返回状态码 0
   }
   

3. 通过信号终止：进程可以通过接收到特定的信号来终止。例如，通过在终端中按下Ctrl+C键，会发送一个SIGINT信号给进程，导致进程终止。在这种情况下，进程的退出状态码通常是非零值。

4. return语句是一种常见的退出进程的方法，特别是在main()函数中。在C语言中，main()函数的返回值被视为进程的退出状态码，并且会被传递给系统的退出处理机制。

   根据C标准，如果main()函数中使用return语句显式返回一个值，这个返回值会被当做进程的退出状态码。这个退出状态码可以在其他程序中通过调用wait()或类似的函数来获取。

   示例代码：

   #include 
   
   int main() {
       // 代码执行完毕
       return 0;  // 退出并返回状态码 0
   }
   

   在这个示例中，main()函数使用return 0语句来表示正常终止，并将状态码0作为进程的退出状态码。

   需要注意的是，return语句在其他函数中的使用与进程的退出无关。在其他函数中，return语句是用于函数的返回值，而不是用于退出整个进程。

以上是进程常见的退出方法。可以通过检查进程的退出状态码来获取进程的退出状态信息，如在Linux终端中使用echo $?命令可以查看进程的退出码。

需要注意的是，不同的操作系统和编程语言可能会有不同的退出方法和约定。上述示例中的代码是基于C语言和类Unix系统的示例。

2.2.2 异常退出

调用_exit()或_Exit()函数：_exit()或_Exit()函数是系统调用，用于立即终止进程，不执行任何清理操作，直接返回到操作系统。这些函数通常在异常情况下使用，例如发生严重错误时。

示例代码：

#include 
#include 

int main() {
    // 发生错误，需要立即终止进程
    _exit(1);  // 立即退出并返回状态码 1
}

2.2.3 _exit与exit函数

_exit()函数和exit()函数都可以用于终止进程，但它们之间存在一些差异。

_exit()函数：

• 是一个系统调用（system call），提供给操作系统使用。
• 立即终止进程，不执行任何进程清理操作，包括不刷新缓冲区、不执行终止处理程序等。
• 不会关闭打开的文件描述符，不会执行任何清理操作，也不会发送终止信号给父进程。
• 其返回值直接传递给操作系统作为进程的退出状态码。

示例代码：

#include 

int main() {
    // 发生错误，需要立即终止进程
    _exit(1);  // 立即退出并返回状态码 1
}

exit()函数：

• 是C标准库中的函数，提供给应用程序使用。
• 终止进程前会执行一些清理操作，例如关闭文件描述符、刷新缓冲区、调用终止处理程序（通过atexit()注册的函数）等。
• 最终会调用系统调用_exit()来终止进程。
• 其返回值会传递给操作系统作为进程的退出状态码。

示例代码：

#include 

int main() {
    // 代码执行完毕
    exit(0);  // 退出并返回状态码 0
}

在正常情况下，exit()函数和_exit()函数的使用方式和效果是相似的。但需要注意的是，由于exit()函数会执行一些清理操作，可能会导致一些未完成的I/O操作完成，因此在某些情况下，使用_exit()函数可以更加直接和快速地终止进程。

3、进程等待

3.1 进程等待必要性

进程等待是必要的，特别是在父进程需要获取子进程的退出状态、回收资源以及避免僵尸进程问题时。

以下是一些重要的原因：

1. 避免僵尸进程：当子进程退出后，其进程描述符和其他资源仍然保留在系统中，这样的子进程称为僵尸进程。如果父进程不对子进程进行等待操作，僵尸进程可能会一直存在，导致资源泄漏和系统性能问题。

2. 回收子进程资源：通过等待子进程，父进程能够及时回收子进程占用的资源，例如内存、打开的文件描述符等。这确保了系统资源的有效利用，防止资源泄漏。

3. 获取子进程退出状态：等待子进程的另一个重要目的是获取子进程的退出状态码。退出状态码可以提供关于子进程执行的信息，例如是否成功执行、出现的错误类型等。父进程可以根据子进程的退出状态码采取相应的处理逻辑。

示例代码：

#include 
#include 
#include 
#include 
#include 

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
        exit(0);  // 子进程正常退出
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        int status;
        wait(&status);  // 等待子进程退出
        if (WIFEXITED(status)) {
            int exit_status = WEXITSTATUS(status);
            printf("Child process exited with status: %d\n", exit_status);
        }
    }

    return 0;
}

在上述示例中，父进程通过调用wait()函数等待子进程的退出。然后，通过WIFEXITED和WEXITSTATUS宏，父进程获取子进程的退出状态码并进行相应的处理。

通过进程等待，父进程能够及时处理子进程的退出，回收资源，并获取子进程的退出状态信息，实现了进程间的协同与交互。

3.2 进程等待方法

在父进程中，可以使用以下方法来等待子进程的退出：

1. wait()函数：wait()函数会使父进程阻塞，直到任一子进程退出。它会返回被等待子进程的进程ID，并通过指针参数获取子进程的退出状态信息。

   示例代码：

   #include 
   #include 
   #include 
   #include 
   
   int main() {
       pid_t pid = fork();
   
       if (pid < 0) {
           // 错误处理
           fprintf(stderr, "Fork failed.\n");
           return 1;
       } else if (pid == 0) {
           // 子进程代码
           printf("Child process executing.\n");
           // 执行子进程特定的代码
           return 0;
       } else {
           // 父进程代码
           printf("Parent process executing.\n");
           int status;
           pid_t child_pid = wait(&status); // 等待任一子进程退出
           if (child_pid > 0) {
               if (WIFEXITED(status)) {
                   int exit_status = WEXITSTATUS(status);
                   printf("Child process %d exited with status: %d\n", child_pid, exit_status);
               }
           }
       }
   
       return 0;
   }
   

2. waitpid()函数：waitpid()函数可以等待指定的子进程退出。通过指定子进程的进程ID和选项，可以灵活地控制等待的行为。该函数也会返回子进程的进程ID，并通过指针参数获取子进程的退出状态信息。

   示例代码：

   #include 
   #include 
   #include 
   #include 
   
   int main() {
       pid_t pid = fork();
   
       if (pid < 0) {
           // 错误处理
           fprintf(stderr, "Fork failed.\n");
           return 1;
       } else if (pid == 0) {
           // 子进程代码
           printf("Child process executing.\n");
           // 执行子进程特定的代码
           return 0;
       } else {
           // 父进程代码
           printf("Parent process executing.\n");
           int status;
           pid_t child_pid = waitpid(pid, &status, 0); // 等待指定子进程退出
           if (child_pid == pid) {
               if (WIFEXITED(status)) {
                   int exit_status = WEXITSTATUS(status);
                   printf("Child process %d exited with status: %d\n", child_pid, exit_status);
               }
           }
       }
   
       return 0;
   }
   

以上是两种常用的等待子进程退出的方法：wait()和waitpid()。它们都提供了一种方式来等待子进程的退出，并获取子进程的退出状态码。

需要注意的是，wait()和waitpid()函数都会将父进程阻塞，直到子进程退出。可以通过设置选项和使用信号处理来灵活地控制等待的行为。

3.3 获取子进程status

wait()和waitpid()函数中的status参数是一个输出型参数，用于接收子进程的退出状态信息。如果传递NULL，则表示父进程不关心子进程的退出状态信息，而如果提供一个指向int类型的变量的指针，则操作系统会将子进程的退出信息填充到该变量中。

status参数可以被视为一个位图，其中不同的位表示了不同的退出状态信息。通过使用预定义的宏，可以从status参数中提取特定的退出状态信息。

一些常用的宏包括：

• WIFEXITED(status): 如果子进程正常退出，则返回非零值。
• WEXITSTATUS(status): 如果子进程正常退出，则返回子进程的退出状态码。
• WIFSIGNALED(status): 如果子进程是由于信号而终止的，则返回非零值。
• WTERMSIG(status): 如果子进程是由于信号而终止的，则返回导致子进程终止的信号编号。
• WIFSTOPPED(status): 如果子进程当前处于停止状态，则返回非零值。
• WSTOPSIG(status): 如果子进程当前处于停止状态，则返回导致子进程停止的信号编号。

示例代码：

#include 
#include 
#include 
#include 

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
        return 0;
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        int status;
        pid_t child_pid = wait(&status); // 等待子进程退出
        if (child_pid > 0) {
            if (WIFEXITED(status)) {
                int exit_status = WEXITSTATUS(status);
                printf("Child process %d exited with status: %d\n", child_pid, exit_status);
            }
        }
    }

    return 0;
}

在上述示例中，使用WIFEXITED()和WEXITSTATUS()宏来检查子进程是否正常退出，并获取子进程的退出状态码。

需要注意的是，status参数的具体格式和使用可能因操作系统的不同而有所差异。在特定的操作系统和环境下，可以查阅相关的文档来了解status参数的具体格式和可用的宏。

4、进程程序替换

4.1 替换原理

当一个进程调用exec()函数族中的某个函数时，该进程的用户空间代码和数据会完全被一个新程序替换，从新程序的启动例程开始执行。调用exec()函数并不会创建新的进程，因此进程的标识符（PID）在调用前后保持不变。

exec()函数族提供了多个函数，如execl(),execv(),execle(),execve()等，用于加载并执行一个新的程序。这些函数会接受一个可执行文件的路径，以及一系列的参数（命令行参数）来传递给新程序。

调用exec()函数族时，操作系统会执行以下步骤：

1. 打开并读取指定的可执行文件。
2. 创建一个新的地址空间，用于新程序的代码段、数据段和堆栈。
3. 将可执行文件的代码和数据加载到新的地址空间。
4. 设置新程序的入口点（启动例程）。
5. 通过参数传递机制，将命令行参数传递给新程序。
6. 清理原来进程的资源（代码、数据等）。
7. 跳转到新程序的入口点开始执行。

因此，调用exec()函数后，原进程的代码和数据都被替换成了新程序的代码和数据，从而实现了进程的程序替换。新程序开始执行时，进程的标识符保持不变，因为进程并没有创建新的进程。

这种能力可以用于实现进程的动态加载和更新，以及执行不同的程序。通过fork()创建子进程，再在子进程中调用exec()函数，可以在子进程中执行不同的程序，实现更加灵活和多样化的应用场景。

需要注意的是，exec()函数调用成功后，原进程的代码和数据都被替换，之前的状态和执行上下文都会丢失。因此，在调用exec()函数之前，通常需要进行必要的清理和准备工作。

4.2 替换函数

在UNIX和类UNIX操作系统中，有六种以exec开头的函数，它们统称为exec函数。这些函数是exec()函数族的成员。

这六种函数是：

1. execl()：用于在当前进程中执行一个新程序，并通过参数列表传递命令行参数。
2. execle()：与execl()类似，但可以通过环境变量指定新程序的环境。
3. execv()：用于在当前进程中执行一个新程序，并通过参数数组传递命令行参数。
4. execve()：与execv()类似，但可以通过环境变量指定新程序的环境。
5. execvp()：根据给定的文件名查找可执行文件，并在当前进程中执行该程序，通过参数数组传递命令行参数。
6. execvpe()：与execvp()类似，但可以通过环境变量指定新程序的环境。

这些函数都可以用来加载并执行一个新的程序，将当前进程的用户空间代码和数据替换为新程序的代码和数据。它们可以根据需要选择不同的参数传递方式，例如使用参数列表或参数数组来传递命令行参数。

这些exec函数在实际使用中具有灵活性和可扩展性，可以满足不同的需求。通过调用这些函数，可以在当前进程中动态加载和执行不同的程序，实现进程的程序替换和更新。

需要注意的是，exec函数调用成功后，原进程的代码和数据都会被替换，之前的状态和执行上下文会丢失。因此，在调用这些函数之前，通常需要进行必要的清理和准备工作。

4.3 函数解释

对于exec函数族中的函数，如果调用成功，则加载新的程序并从新程序的启动代码开始执行，它们不会返回到原调用的位置。因此，如果exec函数成功执行，它们不会返回成功的返回值。

如果exec函数调用出错，则返回值为-1，表示调用失败。这通常是由于以下情况之一导致的：

• 指定的可执行文件不存在或无法访问。
• 没有足够的权限执行指定的可执行文件。
• 指定的可执行文件格式不正确。

在调用exec函数失败后，原进程的状态和代码段保持不变，并可以根据返回值进行错误处理。

示例代码：

#include 
#include 

int main() {
    char* args[] = { "/path/to/executable", "arg1", "arg2", NULL };
    int ret = execvp(args[0], args);

    if (ret == -1) {
        perror("execvp");
        // 错误处理
        return 1;
    }

    // 不会执行到这里

    return 0;
}

在上述示例中，execvp()函数用于执行指定路径的可执行文件，并将命令行参数传递给新程序。如果execvp()调用失败，它会返回-1，并通过perror()函数打印出错误信息。

需要注意的是，成功的exec函数调用不会返回到原调用的位置，因为原进程的代码和数据已经被替换为新程序。如果希望在exec函数调用成功后执行某些操作，可以在exec函数调用前执行相应的代码。

exec函数只有出错的返回值，而没有成功的返回值。成功的调用会替换当前进程的代码和数据，从新程序的启动代码开始执行。

4.4 命名理解

exec函数族中的函数原型看起来相似，但掌握了一些规律后，它们就很容易记忆和理解。

以下是常见的命名规律：

1. l（list）：这种形式的exec函数使用参数列表（list）来传递命令行参数。函数接受可变数量的参数，最后一个参数必须是NULL，用于表示参数列表的结束。

   示例：execl()

2. v（vector）：这种形式的exec函数使用参数数组（vector）来传递命令行参数。函数接受一个指向参数数组的指针，其中数组的最后一个元素必须是NULL，用于表示参数数组的结束。

   示例：execv()

3. p（path）：这种形式的exec函数会自动搜索环境变量PATH指定的目录来查找可执行文件。它们接受一个可执行文件的名称，而不需要提供完整的路径。

   示例：execvp()

4. e（env）：这种形式的exec函数可以通过参数来指定新程序的环境变量。它们接受一个额外的参数，用于传递环境变量。

   示例：execle()

通过理解这些命名规律，我们可以根据函数的命名来推测函数的功能和使用方式。这样能够更轻松地选择适当的exec函数并正确使用它们。

需要注意的是，这些命名规律并不是绝对的，具体的函数实现和操作系统的差异可能会导致某些例外情况。因此，在使用exec函数时，最好参考相关的文档和标准规范，以确保使用正确的函数和参数。

5、简易shell

要编写一个简单的Shell，可以按照以下步骤进行循环处理：

1. 获取命令行：从用户那里获取命令行输入，可以使用标准输入函数如fgets()来读取用户输入的命令行。

2. 解析命令行：对获取到的命令行进行解析，将命令和参数分离。可以使用字符串处理函数如strtok()来拆分命令行字符串。

3. 建立子进程（fork）：使用fork()函数创建一个子进程。子进程将用于执行用户输入的命令。

4. 替换子进程（execvp）：在子进程中使用execvp()函数来替换子进程的代码和数据为用户输入的命令。通过传递解析得到的命令和参数数组给execvp()函数来执行相应的命令。

5. 父进程等待子进程退出（wait）：在父进程中使用wait()或waitpid()函数等待子进程的退出。这样父进程就可以等待子进程执行完毕并获取子进程的退出状态。

整体的循环结构可以类似于以下示例代码：

#include 
#include 
#include 
#include 
#include 
#include 

#define MAX_COMMAND_LENGTH 100

int main() {
    while (1) {
        char command[MAX_COMMAND_LENGTH];
        printf("Shell> ");
        fgets(command, MAX_COMMAND_LENGTH, stdin);

        // 去除命令行末尾的换行符
        command[strcspn(command, "\n")] = '\0';

        // 解析命令行，获取命令和参数
        char* args[MAX_COMMAND_LENGTH];
        int arg_count = 0;
        char* token = strtok(command, " ");
        while (token != NULL) {
            args[arg_count] = token;
            arg_count++;
            token = strtok(NULL, " ");
        }
        args[arg_count] = NULL; // 参数数组最后一个元素必须为NULL

        pid_t pid = fork();

        if (pid < 0) {
            // 错误处理
            fprintf(stderr, "Fork failed.\n");
            return 1;
        } else if (pid == 0) {
            // 子进程执行命令
            execvp(args[0], args);

            // execvp调用失败
            fprintf(stderr, "Command not found.\n");
            exit(1);
        } else {
            // 父进程等待子进程退出
            int status;
            wait(&status);
        }
    }

    return 0;
}

在上述示例中，通过一个无限循环来持续接收用户输入的命令行。每次循环都会解析命令行、创建子进程、替换子进程执行命令，并在父进程中等待子进程退出。

需要注意的是，上述示例只是一个简单的Shell示例，可能还需要进行错误处理、环境变量的处理、重定向等更多的功能扩展。此外，还应考虑特殊命令（如退出Shell）的处理逻辑。