Linux之进程控制&&进程终止&&进程等待&&进程的程序替换&&替换函数&&实现简易shell

这篇具有很好参考价值的文章主要介绍了Linux之进程控制&&进程终止&&进程等待&&进程的程序替换&&替换函数&&实现简易shell。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、进程创建

1.1 fork的使用

  • 我们可以使用man指令来查看一下
man 2 fork
  • 子进程会复制父进程的PCB,之间代码共享,数据独有,拥有各自的进程虚拟地址空间。

linux shell &&,Linux,linux,运维,服务器,c

  • 这里就有一个代码共享,并且子进程是拷贝了父进程的PCB,虽然他们各自拥有自己的进程虚拟地址空间,数据是拷贝过来的,通过页表映射到同一块物理内存中,在上篇文章【Linux进程地址空间详解】也讲解过写时拷贝,这里就不再过多赘述~
  • 大概流程可以看一下下图:

linux shell &&,Linux,linux,运维,服务器,c

  • 在上图中我们还可以看到返回类型是pid_t如果创建子进程失败,会返回小于0的数字,而如果创建子进程成功,该函数则会返回俩个值。它会给子进程返回0值,而给父进程返回子进程的pid(一个大于0的数),创建成功后我们可以对此进行使用if语句进行分流~~

  • 下面简单验证再来验证一下:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int g_val = 100;

int main()
{
    pid_t pid = fork();
    if(pid < 0) {
        printf("fork error!\n");
        exit(-1); 
    }
    else if(pid == 0) {
        //child
        g_val = 200;
        printf("This is Child! g_val = %d, p = %p\n",g_val,&g_val);
    }
    else {
        //parent
        sleep(1);
        printf("This is Parent! g_val = %d, p = %p\n",g_val,&g_val);
    }
    return 0;
}
  • 很显而易见,这里的地址是虚拟的地址空间,真正的值是存储在物理内存中的。而这时通过页表的映射,本质上内存中已经是指向了不同的物理地址

linux shell &&,Linux,linux,运维,服务器,c

二、进程终止

顾名思义,就是直接让进程终止,我们来了解一下:

2.1 终止是在做什么?

  • 释放内核数据结构—>task_struct:Z(僵尸状态)

2.2 终止的3种情况&&退出码的理解

  1. 代码运行完毕,结果正确
  2. 代码运行完毕,结果不正确
  3. 代码异常终止

  • 在上面的1和2中可通过退出码进行决定,这里什么是退出码呢?我们在C语言每次写的时候为什么最后写一个return 0呢?这里我们可以实验一下:
#include <stdio.h>
int main()
{
    return 1;
}
  • 这里我们还要了解一个命令
echo $?
  • 作用是打印出上一次进程的退出码,而我们C语言刚刚最后写的退出码是1,最后记录了刚刚的退出码,所以打印的是1

linux shell &&,Linux,linux,运维,服务器,c


  • 第三个是代码执行的时候出现了异常,被提前退出了,我们可以再来验证一下:
  • 下面这个代码很明显是野指针的访问:
int main()
{
    int* p = NULL;
    *p = 10;
    return 0;
}

linux shell &&,Linux,linux,运维,服务器,c

  • 在编译运行的时候,出现了异常,提前退出了,操作系统发现了不该做的事情,OS杀死了进程

  • 一旦出现了异常,退出码也就没有意义了,那么为什么出现了异常,是因为进程收到了OS发给进程的信号

  • 在Linux中,可以使用kill -l查看所表示的信号,可以看到0表示成功~,所以一般正常运行完成之后退出码就写成0,非0表示失败

linux shell &&,Linux,linux,运维,服务器,c

2.3 进程常见退出方法

  • 正常退出
  1. 从main函数返回
  2. 调用exit函数
  3. 调用_exit函数
  • 异常退出

Ctrl+C,信号终止等

  • 在我们平时使用的kill -9就是给OS发送一个信号,对程序做出动作

linux shell &&,Linux,linux,运维,服务器,c

  • 例如,使用-9信号杀死进程

linux shell &&,Linux,linux,运维,服务器,c

  • 刚刚上面的段错误就可以发送11
  • 每个对应的编号都有对应的错误描述

linux shell &&,Linux,linux,运维,服务器,c


exit退出函数和_exit退出函数:

  • 可以使用man手册来查看
  • stauts定义了进程的终止状态,由用户自己传递,父进程可以通过wait来获取该值

linux shell &&,Linux,linux,运维,服务器,c

  • exit是库函数,_exit是系统调用函数,而库函数内部封装了系统调用。 也就是说,调用exit函数最终也会调用_exit来使进程退出,只不过在其调用_exit之前,会将缓冲区进行刷新

return退出

  • return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返 回值当做 exit的参数。

衡量一个进程退出,我们只需要两个数字:退出码和退出信号

三、进程等待

3.1 为什么要进行进程等待?

  • 如果子进程先于父进程退出,而父进程并没有关心子进程的退出状况,从而无法回收子进程的资源,就会导致子进程变成僵尸进程,这里的僵尸状态使用kill也杀不掉,会导致内存泄露
  • 如果想要解决这个僵尸状态就要进行进程等待,等待父进程回收子进程的资源,获取子进程的退出状态

在父进程中,使用wait或waitpid接口来完成进程等待。

linux shell &&,Linux,linux,运维,服务器,c

  • 这里的参数是一级指针status,它其实是个输出型参数,用于获取子进程的退出状态,如果不关心则可以设置为NULL
  • 成功会返回被等待进程的pid,失败则会返回-1
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()                                                
{
    pid_t id=fork();
    if(id==0)
    {
        // child process
        int cnt=10;
        while(cnt)
        {
            printf("我是子进程:%d,父进程:%d,cnt:%d\n",getpid(),getppid(),cnt--);
            sleep(1);
        }
        exit(0);// 子进程退出
    }
    sleep(15);
    pid_t ret=wait(NULL);
    if(ret>0)
    {
        printf("wait success:%d!\n",ret);
    }
    sleep(5);
    return 0;
}

linux shell &&,Linux,linux,运维,服务器,c


waitpid:

  • 等待成功正常返回则返回被等待进程的pid
  • 如果第三个参数options设置成了WNOHANG,而此时没有子进程退出(没有成功等待到子进程),就会返回0,而不是阻塞在函数内部
  • 调用出错则返回-1

参数:

  • pid,设置成-1则表示等待任意一个子进程,同wait;如果>0则表示等待一个指定的子进程,pid就是被等待子进程的进程号
  • status,获取子进程的退出状态,同wait
  • options,可以设置为0或WNOHANG。设置为0则与wait一样,如果没有等待到子进程退出会一直阻塞;而设置为WNOHANG则表示非阻塞,如果被等待的子进程未退出,则会返回0值,成功等待到子进程则会返回被等待子进程的pid

这里就不再演示了~~

3.2 取子进程退出信息status

  • 我们已经知道status是一个出参,由操作系统为其赋值,用户可以传递NULL值表示不关心,而如果传入参数,操作系统就会根据该参数,将子进程的退出信息反馈给父进程,由status最终被赋予的值来体现。

  • 如何通过status来获取子进程的退出信息呢?

  • status是一个int类型的值,意味着它应该有32个比特位,但它又不能被当初普通的整形来看待,因为其高16位的值并不被使用,而只使用其低16个比特位:

linux shell &&,Linux,linux,运维,服务器,c

  • 不论是正常退出还是异常退出,status的高8个比特位(只讨论低16个比特位)都表示子进程的退出码,而这个退出码一般是return的返回值或者exit的参数;正常退出时,status的低8个比特位为全0;而异常退出时,其第8个比特位则为core dump标志位,用来标志是否会有core dump文件产生,而低7个比特位则是退出信号。

退出码:(status >> 8) & 0xFF

低7位(检测子进程是否异常退出):status & 0x7F

  • 结果为0则表示正常退出

  • 不为0则说明是异常退出,因为有终止信号

  • core dump标志位:(status >> 7) & 0x1

  • 结果为0则表示没有core dump产生

  • 等于1则说明有core dump产生

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()                                                
{
    pid_t id=fork();
    if(id==0)
    {
        // child process
        int cnt=10;
        while(cnt)
        {
            printf("我是子进程:%d,父进程:%d,cnt:%d\n",getpid(),getppid(),cnt--);
            sleep(1);
        }
        exit(6);// 子进程退出
    }
    sleep(15);
    int status = 0;
    pid_t ret=waitpid(id,&status,0);
    if(ret>0)
    {
        printf("wait success:%d!\n",ret);
        printf("status:%d,退出码是%d,退出信号是%d\n",status,(status>>8)&0xFF,status&0x7F);
    }
    sleep(5);
    return 0;
}

linux shell &&,Linux,linux,运维,服务器,c

  • 执行结果

linux shell &&,Linux,linux,运维,服务器,c


  • 我们还可以演示一下异常退出
  • 我们在子进程里写一个野指针访问
int* p = NULL;
*p = 100; 
  • 这里也就很显而易见了~~

linux shell &&,Linux,linux,运维,服务器,c

3.3 宏WIFEXITED和WEXITSTATUS(获取进程终止情况和退出码)

  • WIFEXITED(status):若子进程是正常终止,则返回结果为真,用于查看进程是否正常退出。

  • WEXITSTATUS(status):若进程正常终止,也就是进程终止信号为0,这时候会返回子进程的退出码。

下面我们可以写一个代码来演示一下

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    pid_t id = fork();
    assert(id != -1);
    if(id == 0)
    {
        // child 
        int cnt = 10;
        while(cnt)
        {
            printf("child process running,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt--);
            sleep(1);
        }
        exit(10);
    }

    // 等待子进程
    int status=0;
    int ret = waitpid(id,&status,0);
    if(ret > 0)
    {
        if(WIFEXITED(status))
        {
            printf("child process exit normally,exit code:%d\n",WEXITSTATUS(status));
        }
        else
        {
            printf("child process don't exit normally\n");
        }
        // printf("wait success,exit code:%d,signal number:%d\n",(status>>8)&0xFF,status & 0x7F);
    }
    return 0;
}
  • 正常退出

linux shell &&,Linux,linux,运维,服务器,c

  • 异常退出

linux shell &&,Linux,linux,运维,服务器,c

3.4 进程的阻塞和非阻塞等待

  • 当子进程还没有死的时候,也就是没有退出的时候,父进程调用的wait或waitpit需要等待子进程退出,系统调用接口也不返回,这段时间父进程什么都没做,就一直等待子进程退出,这样的等待方式,称之为阻塞式等待。

  • 非阻塞式等待就是不停的检测子进程状态,每一次检测之后,系统调用立即返回,在waitpid中的第三个参数设置为WNOHANG,即为父进程非阻塞式等待

  • 如果等待的子进程状态没有发生变化,则waitpid会返回0值。多次非阻塞等待子进程,直到子进程退出,这样的等待方式又称之为轮询。如果等待的进程不是当前父进程的子进程,则waitpid会调用失败。

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
int main()
{
    pid_t id = fork();
    assert(id!=-1);
    if(id==0)
    {
        // child process
        int cnt=5;
        while(cnt)
        {
            printf("child process running,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt--);
            sleep(3);                                                                                                                                                                                          
        }
        exit(10);
    }
    int status=0;
    while(1)
    {
        // WNOHANG是非阻塞等待,子进程没有退出,父进程检测一次之后,立即返回
        pid_t ret=waitpid(id,&status,WNOHANG);
        if(ret == 0)
        {
            // waitpid调用成功,子进程没有退出
            printf("Wait for success,but the child process is still running\n");
        }
        else if(ret == id)
        {
            // waitpid调用成功,子进程退出
            printf("wait success,exit code:%d,signal number:%d\n",(status>>8)&0xFF,status & 0x7F);
            break;
        }
        else
        {
            // waitpid调用失败,例如等待了一个不属于该父进程的子进程
            printf("The waitpid call failed\n");
            break;
        }
        sleep(1);
    }
	return 0;
}

linux shell &&,Linux,linux,运维,服务器,c

  • 非阻塞等待有一个好处就是,不会像阻塞式等待一样,父进程什么都做不了,而是在轮询期间,父进程还可以做其他的事情。

  • 下面代码中,利用了回调函数的方式,来让父进程轮询等待子进程期间,还可以处理其他任务。

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
void task1()
{
    printf("Process task1\n");
}
void task2()
{
    printf("Process task2\n");
}
void task3()
{
    printf("Process task3\n");
}
typedef void (*func_t)();// 定义一个函数指针类型。

func_t Process_task[10];

void loadtask()
{
    memset(Process_task,0, sizeof(Process_task));
    Process_task[0]=task1;
    Process_task[1]=task2;
    Process_task[2]=task3;
}

int main()
{
    pid_t id = fork();
    assert(id!=-1);
    if(id==0)
    {
        // child process
        int cnt=5;
        while(cnt)
        {               
            printf("child process running,pid:%d,ppid:%d,cnt:%d\n",getpid(),getppid(),cnt--);
            sleep(1);                                                                                                                                                                                          
        }
        exit(10);                                                                               
    }                
    loadtask();// 加载任务到函数指针数组里面。
    int status=0;
    while(1)
    {                                         
        pid_t ret=waitpid(id,&status,WNOHANG);// WNOHANG是非阻塞等待,子进程没有退出,父进程检测一次之后,立即返回
        if(ret == 0) 
        {
            // waitpid调用成功,子进程没有退出
            printf("Wait for success,but the child process is still running\n");
            for(int i=0; Process_task[i]!=NULL; i++)
            {
                Process_task[i]();// 回调函数的方式,让父进程在轮询期间,做其他事情
            }
        }
        else if(ret == id)
        {
            // waitpid调用成功,子进程退出
            printf("wait success,exit code:%d,signal number:%d\n",(status>>8)&0xFF,status & 0x7F);
            break;
        }
        else 
        {
            // waitpid调用失败,例如等待了一个不属于该父进程的子进程
            printf("The waitpid call failed\n");
            break;
        }
        sleep(1);
    }
	return 0;
}

linux shell &&,Linux,linux,运维,服务器,c

四、进程的程序替换

4.1 创建子进程的目的?

  • 创建子进程一般两个目的:
  1. 让子进程执行父进程代码的一部分,也就是执行父进程对应的磁盘上的代码和数据的一部分。

  2. 让子进程加载磁盘上指定的程序到内存中,使其执行新的程序的代码和数据,这就是进程的程序替换。

4.2 进程的程序替换

接下来我们就介绍一些进程的程序的替换函数

4.2.1 单个进程的程序替换
  • 下面函数参数是可变参数列表,可以给C语言函数传递不同个数的参数。
int execl(const char* path,const char* arg,...);  
  • 通过man指令可以查看
man execl

linux shell &&,Linux,linux,运维,服务器,c

  • 要执行一个程序,首先就是找到这个程序,然后在执行这个程序,执行程序的时候,也拥有不同的执行方式,通过执行选项的不同便可以使得程序以多种不同的方式执行。

例如:

#include <stdio.h>
#include <unistd.h>

int main()
{
    // .c --> .exe --> load into memory --> process --> running
    printf("The process is running...\n");
    // 传参以NULL结尾,来表示传参结束                                                        
    execl("/usr/bin/ls","ls","-a","-l","--color=auto",NULL);

    printf("The process finishes running...\n");
    return 0;
}
  • 可以看到只打印了一行run,紧接着是执行后面替换的程序

linux shell &&,Linux,linux,运维,服务器,c


  • exec系列的函数只有在调用失败的时候才有返回值,这个返回值是-1,那为什么exec系列的函数没有调用成功时的返回值呢?

  • 答案:没有必要,因为exec系列函数调用结束之后,代码就全都被替换了,就算给你返回值你也使用不了,因为代码全都替换为指定程序的代码了,所以只要exec系列函数返回,那就一定发生调用错误了。

例如:我随便写一个命令,这个命令是不在这个目录里的

#include <stdio.h>
#include <unistd.h>

int main()
{
    // .c --> .exe --> load into memory --> process --> running
    printf("The process is running...\n");
    // 传参以NULL结尾,来表示传参结束                                                        
    execl("/usr/bin/lsss","ls","-l","--color=auto",NULL);

    printf("The process finishes running...\n");
    return 0;
}

linux shell &&,Linux,linux,运维,服务器,c

4.2.2 父进程派生子进程的程序替换
  • 子进程被替换为ls进程,不会影响父进程,因为进程具有独立性。
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    printf("The process is running...\n");
    pid_t id = fork();
    assert(id != -1);
    if(id==0)
    {
        //child process
        sleep(1);
        execl("/usr/bin/ls","ls","-l",NULL);
        exit(1);// 如果调用失败,直接让子进程退出
    }
    int status = 0;
    pid_t ret = waitpid(id,&status,0);
    if(ret == id)
    {
        printf("wait success, exit code:%d , signal number:%d\n",(status>>8)&0xFF,status&0x7F);
    }
	return 0;
}

linux shell &&,Linux,linux,运维,服务器,c

4.3 进程替换原理

  • 用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并**不创建新进程,**所以调用exec前后该进程的id并未改变。

linux shell &&,Linux,linux,运维,服务器,c

  • 当父进程派生的子进程发生程序替换时,防止父子进程原先共享的代码段和数据段被修改,操作系统会进行写时拷贝,将代码段和数据段重新复制一份给子进程,让子进程程序替换之后,不会影响父进程。这就是进程之间的独立性。

  • 虚拟地址空间和页表可以保证进程之间的独立性,一旦有执行流要改变代码或数据,就会发生写时拷贝。所以不是只有数据可能发生写入,代码也是有可能发生写入的,这两种情况都会发生写时拷贝。

五、替换函数

  • l代表list,指的是将参数一个一个的传入execl函数

int execl(const char *path, const char *arg, …);

int main()
{
  pid_t id = fork();
  if(id == 0){
    // child
    execl("/usr/bin/ls", "ls", "-l", NULL);
    // 如果执行到这里说明替换失败,让子进程退出
    exit(-1);
  }
  // parent
  return 0;
}
  • p是指path,不用传程序的路径,只需要传程序的名字就够了,此函数会自动在PATH环境变量的路径下面去查找对应的程序。
  • execlp中的两个ls是不重复的,一个是告诉操作系统要执行什么程序,一个是告诉操作系统怎么执行程序。

int execlp(const char *file, const char *arg, …);

int main()
{
  pid_t id = fork();
  if(id == 0){
    // child
    execlp("ls", "ls", "-l", "--color=auto", NULL);
    // 如果执行到这里说明替换失败,让子进程退出
    exit(-1);
  }
  // parent
  return 0;
}
  • v是指vector,指的是该函数可以将所有的执行参数放到数组里面,统一进行传参,而不是使用可变参数列表的方式,来一个一个的传执行参数。

int execv(const char *path, char *const argv[]);

int main()
{
  pid_t id = fork();
  if(id == 0){
    // child
    char* const argv[] = {(char*)"ls", (char*)"-l", (char*)"--color=auto", NULL};
    execv("/usr/bin/ls", argv);
    // 如果执行到这里说明替换失败,让子进程退出
    exit(-1);
  }
  // parent
  return 0;
}

PATH和vector,指的是不用传程序路径,默认在环境变量中进行查找并且可以将执行参数放到数组里面,统一进行传参

int execvp(const char *file, char *const argv[]);

int main()
{
  pid_t id = fork();
  if(id == 0){
    // child
    char* const argv[] = {(char*)"ls", (char*)"-l", (char*)"--color=auto", NULL};
    execvp("ls", argv);
    // 如果执行到这里说明替换失败,让子进程退出
    exit(-1);
  }
  // parent
  return 0;
}
  • execle中的e代表自定义环境变量。
  • 下面定义的env指针数组就是自定义环境变量,也就意味着,程序替换的时候,不用系统环境变量,用自己定义的环境变量。

int execle(const char *path, const char *arg,…, char * const envp[]);

int main()
{
  pid_t id = fork();
  if(id == 0){
    // child
    char* const env[] = {(char*)"HELLO=123456789",NULL};
    execle("./mybin","mybin", NULL, env);
    // 如果执行到这里说明替换失败,让子进程退出
    exit(-1);
  }
  // parent
  return 0;
}
  • 也可以不传自定义环境变量,而用系统的环境变量传给子进程替换的程序,只不过替换的程序mybin.c没有打印出来全部的环境变量,而是只打印了PATH和PWD的值。
int main()
{
  pid_t id = fork();
  if(id == 0){
    // child
    extern char** environ;
    execle("./mybin","mybin", NULL, environ);
    // 如果执行到这里说明替换失败,让子进程退出
    exit(-1);
  }
  // parent
  return 0;
}
  • 上面那些函数都不在2号手册

linux shell &&,Linux,linux,运维,服务器,c

int execvpe(const char *file, char *const argv[],char *const envp[]);

  • execvpe其实就是vector+PATH+env,我们需要自己传环境变量,并且不用可变参数列表的方式传执行参数,而是用指针数组的方式来一并将执行参数传递,传程序名时可以不带程序路径,系统会帮我们找。

  • 带e的函数都需要自己组装环境变量,可以选择自己的、或系统的、或系统和自己的环境变量。

linux shell &&,Linux,linux,运维,服务器,c

  • 真正执行程序替换的其实只有execve这一个系统调用接口,其他的6个都是在execve的基础上封装得来的。只有execve在man2号手册,其他都在3号手册。

linux shell &&,Linux,linux,运维,服务器,c

下图exec函数族 一个完整的例子:

linux shell &&,Linux,linux,运维,服务器,c


  • 其中 l 和 v 的区别在于程序运行参数的赋予方式不同l是通过函数参数逐个给与,最终以NULL结尾而v是通过字符指针数组一次性给与
  • 其中有没有 p 的区别在于程序是否需要带路径,也就是是否会默认到path环境变量指定的路径下寻找程序,没有p的需要指定路径,有p的会默认到path环境变量指定路径下寻找
  • 其中有没有 e 的区别在于程序是否需要自定义环境变量没有e则默认使用父进程环境变量,有e则自定义环境变量。

  • 最后在写makefile的时候我们想让两个源文件进行编译,我们可以在makefile中添加一个:
.PHONY:all
all:mybin myprocess

mybin:myexec.c
	gcc -o $@ $^ -std=c99

myprocess:process.c
	gcc -o $@ $^ -std=c99

.PHONY:clean
clean:
	rm -rf myprocess mybin 
  • exec函数族代码示例:
int main()
{
  char *const argv[] = {"ps", "-ef", NULL};
  char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
  execl("/bin/ps", "ps", "-ef", NULL);
  // 带p的,可以使用环境变量PATH,无需写全路径
  execlp("ps", "ps", "-ef", NULL);
  // 带e的,需要自己组装环境变量
  execle("ps", "ps", "-ef", NULL, envp);
  execv("/bin/ps", argv);
  // 带p的,可以使用环境变量PATH,无需写全路径
  execvp("ps", argv);
  // 带e的,需要自己组装环境变量
  execve("/bin/ps", argv, envp);
  exit(0);
}

六、自己实现简易shell

6.1 shell代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define SIZE 512
#define ZERO '\0'
#define SEP " "
#define NUM 32
#define SkipPath(p) do{ p += (strlen(p)-1); while(*p != '/') p--; }while(0)

// 为了方便,我就直接定义了
char cwd[SIZE*2];
char *gArgv[NUM];
int lastcode = 0;

void Die()
{
    exit(1);
}

const char *GetHome()
{
    const char *home = getenv("HOME");
    if(home == NULL) return "/";
    return home;
}

const char *GetUserName()
{
    const char *name = getenv("USER");
    if(name == NULL) return "None";
    return name;
}
const char *GetHostName()
{
    const char *hostname = getenv("HOSTNAME");
    if(hostname == NULL) return "None";
    return hostname;
}
const char *GetCwd()
{
    const char *cwd = getenv("PWD");
    if(cwd == NULL) return "None";
    return cwd;
}

// commandline : output
void MakeCommandLineAndPrint()
{
    char line[SIZE];
    const char *username = GetUserName();
    const char *hostname = GetHostName();
    const char *cwd = GetCwd();

    SkipPath(cwd);
    snprintf(line, sizeof(line), "[%s@%s %s]> ", username, hostname, strlen(cwd) == 1 ? "/" : cwd+1);
    printf("%s", line);
    fflush(stdout);
}

int GetUserCommand(char command[], size_t n)
{
    char *s = fgets(command, n, stdin);
    if(s == NULL) return -1;
    command[strlen(command)-1] = ZERO;
    return strlen(command); 
}


void SplitCommand(char command[], size_t n)
{
    (void)n;
    gArgv[0] = strtok(command, SEP);
    int index = 1;
    while((gArgv[index++] = strtok(NULL, SEP))); 
}

void ExecuteCommand()
{
    pid_t id = fork();
    if(id < 0) Die();
    else if(id == 0)
    {
        // child
        execvp(gArgv[0], gArgv);
        exit(errno);
    }
    else
    {
        // fahter
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if(rid > 0)
        {
            lastcode = WEXITSTATUS(status);
            if(lastcode != 0) printf("%s:%s:%d\n", gArgv[0], strerror(lastcode), lastcode);
        }
    }
}

void Cd()
{
    const char *path = gArgv[1];
    if(path == NULL) path = GetHome();
    // path 一定存在
    chdir(path);

    // 刷新环境变量
    char temp[SIZE*2];
    getcwd(temp, sizeof(temp));
    snprintf(cwd, sizeof(cwd), "PWD=%s", temp);
    putenv(cwd); // OK
}

int CheckBuildin()
{
    int yes = 0;
    const char *enter_cmd = gArgv[0];
    if(strcmp(enter_cmd, "cd") == 0)
    {
        yes = 1;
        Cd();
    }
    else if(strcmp(enter_cmd, "echo") == 0 && strcmp(gArgv[1], "$?") == 0)
    {
        yes = 1;
        printf("%d\n", lastcode);
        lastcode = 0;
    }
    return yes;
}

int main()
{
    int quit = 0;
    while(!quit)
    {
        // 1. 我们需要自己输出一个命令行
        MakeCommandLineAndPrint();

        // 2. 获取用户命令字符串
        char usercommand[SIZE];
        int n = GetUserCommand(usercommand, sizeof(usercommand));
        if(n <= 0) return 1;

        // 3. 命令行字符串分割. 
        SplitCommand(usercommand, sizeof(usercommand));

        // 4. 检测命令是否是内建命令
        n = CheckBuildin();
        if(n) continue;
        // 5. 执行命令
        ExecuteCommand();
    }
    return 0; 
}

6.2 什么是当前路径?(当前进程的工作目录 && cd底层实现用chdir)

  • 查看进程的指令:
ls /proc/进程id

linux shell &&,Linux,linux,运维,服务器,c

  • 可以看到进程有两个路径,一个是cwd一个是exe,exe路径代表当前进程执行的是磁盘上的哪个路径下的程序,可以看到执行的是myproc二进制可执行程序,cwd代表current work directory,代表当前进程的工作目录,所以实际上当前路径就是当前进程的工作目录。

  • 在模拟shell的实现代码中,cd到其他目录,pwd之后的路径实际上是没有变化的,因为pwd实际上pwd的是父进程shell的路径,而父进程的cwd路径始终是未改变的,而执行cd命令的是子进程,所以子进程的cwd路径是会改变的。

  • 系统给我们提供了一个系统调用接口叫做chdir,用于改变当前进程的工作目录cwd路径,实际上cd能够进入指定路径下的目录,底层实现上就是改变了shell(bash)进程的cwd路径,所以pwd时,随时随地打印出来的就是shell进程的工作目录。

  • 所以如果我们模拟实现的shell也想实现cd改变路径的功能,实际上是不可以创建子进程的,因为子进程程序替换执行cd,父进程的工作目录是没有改变的,所以直接将这一种情况单独拿出来进行判断,在这种情况下,直接让父进程执行cd命令,修改父进程的工作目录即可。

6.3 shell内建/内置命令(shell自己执行的命令,而不是派生子进程进行程序替换来执行)

linux shell &&,Linux,linux,运维,服务器,c

  • 像上面的cd命令实际上就是shell的内建命令,因为这样的命令不需要派生子进程来进行程序替换执行,直接让父进程执行就ok,这样的指令就是shell自带的命令,我们称之为内建命令或内置命令。

  • 这也就能解释为什么echo能够打印本地变量了,我们之前将echo理解为一个可执行程序,也就是shell的子进程,但是我们说子进程只能继承父进程的环境变量,而不能继承本地变量,所以当时就陷入echo为什么能够打印出本地变量的疑问当中,因为如果echo是子进程的话,他是没有继承本地变量的。

  • 但现在我们就知道原因了,echo实际上不是shell的子进程,而是shell的内建命令,是shell自己来执行的指令,shell当然拥有本地变量了,当然也就能够打印本地变量。

好了,本文就到这里,感谢大家的收看🌹🌹🌹文章来源地址https://www.toymoban.com/news/detail-854006.html

到了这里,关于Linux之进程控制&&进程终止&&进程等待&&进程的程序替换&&替换函数&&实现简易shell的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux】进程等待和替换——进程等待的原理、wait/waitpid方法、进程程序替换、进程替换原理、替换函数

    1.1进程等待的概念    进程等待指的是父进程等待子进程退出,以获取子进程的退出返回值,并释放子进程占用的资源。    当子进程先于父进程退出,但父进程没有关注子进程的退出状态时, 子进程会为了保存自己的退出状态而保持资源占用, 这种情况被称为“僵尸进

    2024年02月04日
    浏览(39)
  • Linux进程控制【创建、终止、等待】

    ✨个人主页: Yohifo 🎉所属专栏: Linux学习之旅 🎊每篇一句: 图片来源 🎃操作环境: CentOS 7.6 阿里云远程服务器 Good judgment comes from experience, and a lot of that comes from bad judgment. 好的判断力来自经验,其中很多来自糟糕的判断力。 进程 创建后,需要对其进行合理管理,光靠

    2024年02月02日
    浏览(53)
  • 【Linux】进程控制(创建、终止、等待)

    环境:centos7.6,腾讯云服务器 Linux文章都放在了专栏:【 Linux 】欢迎支持订阅 相关文章推荐: 【Linux】冯.诺依曼体系结构与操作系统 【Linux】进程理解与学习Ⅰ-进程概念 【Linux】进程理解与学习Ⅱ-进程状态 【Linux】进程理解与学习Ⅲ-环境变量 【Linux】进程理解与学习Ⅳ

    2023年04月16日
    浏览(56)
  • 零基础Linux_10(进程)进程终止(main函数的返回值)+进程等待

    目录 1. 进程终止 1.1 main函数的返回值 1.2 进程退出码和错误码 1.3 进程终止的常见方法 2. 进程等待 2.1 进程等待的原因 2.2 wait 函数 2.3 waitpid 函数 2.4 int* status参数 2.5 int options非阻塞等待 本篇完。 进程终止指的就是程序执行结束了,进程终止退出的场景有三种: 代码运行

    2024年02月07日
    浏览(42)
  • 【Linux笔记】进程等待与程序替换

    在讲解进程的终止之前,先要普及一下进程的退出码概念。 我们父进程之所以要创建子进程,就是为了让子进程运行不一样的任务,那么对于子进程执行的这个任务执行完毕后的结果是否正确或者是否出差错,我们父进程要对这个结果进行验收。 从而就引出了进程退出码和

    2024年01月21日
    浏览(41)
  • 【Linux】进程控制 — 进程程序替换 + 实现简易shell

    上一节我们讲了进程终止和进程等待等一系列问题,并做了相应的验证,本章将继续对进程控制进行学习,我们将学习进程程序替换,进行相关验证,运用系统进程程序替换接口,自己模拟写一个shell,该shell能够实现执行指令,等一系列命令行操作…… 概念引入: 将可执行

    2024年02月06日
    浏览(50)
  • 【Linux】详解进程终止&&进程等待

             页表中不仅仅只有虚拟地址到物理地址的映射,还包括了很多选项,其中就包括了映射条目的权限。当我们进程的代码和数据加载到内存并和进程地址空间建立映射关系时,如果数据的内容不允许被修改(比如说常量字符串),对应数据在页表中的映射条目的权

    2024年04月14日
    浏览(59)
  • 【Linux初阶】fork进程创建 & 进程终止 & 进程等待

     🌟hello,各位读者大大们你们好呀🌟 🍭🍭系列专栏:【Linux初阶】 ✒️✒️本篇内容:fork进程创建,理解fork返回值和常规用法,进程终止(退出码、退出场景、退出方法、exit),进程等待(wait、waitpid),阻塞等待和非阻塞等待 🚢🚢作者简介:本科在读,计算机海洋

    2024年02月06日
    浏览(47)
  • Linux进程控制【进程程序替换】

    ✨个人主页: Yohifo 🎉所属专栏: Linux学习之旅 🎊每篇一句: 图片来源 🎃操作环境: CentOS 7.6 阿里云远程服务器 Good judgment comes from experience, and a lot of that comes from bad judgment. 好的判断力来自经验,其中很多来自糟糕的判断力。 子进程 在被创建后,共享的是 父进程 的代码

    2024年01月17日
    浏览(59)
  • [Linux 进程控制(二)] 进程程序替换

    首先,我们要认识到,我们之前fork()所创建的子进程,执行的代码,都是父进程的一部分(用if-else分流或者执行同样的代码)! 如果我们想让子进程执行新的程序呢? 执行全新的代码和访问全新的数据,不再和父进程有瓜葛,这种技术就叫做程序替换 ,下面我们就来学习一

    2024年03月14日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包