0
点赞
收藏
分享

微信扫一扫

Linux之进程控制详解

罗蓁蓁 2022-02-09 阅读 83
linux运维服务器
加载失败

进程控制

文章目录

进程创建

进程创建的最常见的两种场景：

1、命令行启动命令(程序、指令等)

2、通过程序自身fork出来子进程

fork函数初识

在linux中fork函数时非常重要的函数，fork创建子进程是以父进程为"模板"的，很多数据代码继承父进程，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()
{
    cout<<"I am a process: "<<getpid()<<endl;
    pid_t id = fork();
    if(id < 0)
    {
        cerr<<"fork error"<<endl;
        return 1;
    }
    else if(id == 0)
    {
        //child
        cout<<"I am son ："<<getpid()<<endl;
        sleep(5);
    }
    else
    {
        //parent
        cout<<"I am father"<<getpid()<<" My son pid："<<id<<endl;
        sleep(5);
    }
    return 0;
}

为什么是这样呢？任何孩子都有唯一的父亲，一个父亲可能有多个孩子，父亲需要标识孩子。所以子进程中返回0，父进程返回子进程id

进程调用fork，当控制转移到内核中的fork代码后，内核做：

  • 分配新的内存块和内核数据结构给子进程
  • 将父进程部分数据结构内容拷贝至子进程
  • 添加子进程到系统进程列表当中
  • fork返回，开始调度器调度

fork函数返回值

为什么会有两个返回值呢？

fork之后会进入内核，fork函数的实现进行申请内存构建数据结构PCB，虚拟内存，页表，最后将当前新进程设置为R状态，放置进调度列表中，此时进程已经创建成功了，父子进程共享代码，fork函数的最后一个代码是返回一个值，return ret这个代码父子进程都会执行一次，所以会有两个返回值

在返回时，将函数的返回值返回给变量，发生了写时拷贝，一个变量名但是内容是不同的，本质父子页表映射数据到了不同的内存区域

写时拷贝

在不写入的情况下，父子进程共享代码和数据：

#include<stdio.h>
#include<unistd.h>
int main()
{
    const char *str = "hello world";
    fork();
    while(1)
    {
        printf("ppid:%d,pid: %d,str: %s\n",getppid(),getpid(),str);
        sleep(1);
    }
    return 0;
}

image-20220114164853461

其中，默认情况下，父子进程共享代码，但是数据是各自私有一份的

代码共享：所有代码共享，因为程序计数器的原因，一般都是从fork之后开始执行，那么为什么代码要共享呢？因为代码是不可以被修改的，所以各自私有浪费空间。为什么数据要私有一份呢？因为进程之间具有独立性，如果父进程正在执行，子进程将父进程的数据改了，那就影响到了父进程。

为什么要有写时拷贝？

所以通常，**父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。**写时拷贝的识别，操作，是由OS完成

image-20220110154416663

数据10M，写入的时候是1M，发生写时拷贝，是拷贝10M还是1M？答案是拷贝1M

fork常规用法

fork调用失败的原因

总结：如何理解子进程创建？如何理解fork？

本质是系统多了一个进程，子进程要以父进程为模板(并不是将所有东西都拷贝给子进程，比如PID是不需要拷贝的)

进程终止

进程退出场景

上面的退出场景已经包括了所有的场景，情况1和情况2是用退出码进行标识的，情况3是发生了异常，会有退出原因

进程常见退出方法

main函数返回

main函数退出的时候，return的那个数字叫做进程的退出码，怎么查看进程的退出码呢？

image-20220114215635001

echo $?

image-20220114215707435

为什么main函数的return一般写成0呢？0在函数设计中，一般代表正确，非零代表出错。这里的return是给系统看，确认进程的执行结果是否正确，退出码可以人为的定义，也可以使用系统的错误码list，那么非零到底是什么意思呢？当程序运行失败的时候，我们最关心的是为什么失败？失败原因，计算机不擅长处理，擅长处理整数类型的数据，所以退出码都是整数类型的，但是我们人又擅长字符串的描述，所以就有错误码和字符串的映射：

#include<stdio.h>
#include<string.h>
int main()
{
    for(int i = 0;i<200;i++)
    {
        printf("%d:%s\n",i,strerror(i));
    }
    return 0;
}

image-20220114232824701

进程非正常结束：野指针，除0，越界…，退出码无意义

exit

exit和return有什么区别呢？

#include<stdlib.h>
int main()
{
    exit(1);
}

exit的参数就是进程的退出码

#include<stdlib.h>
int exe()
{
    exit(12);
}
int main()
{
    exe();
    cout<<"haha"<<endl;
}

进入exe函数，调用exit函数，此时直接就将进程终止了，并不会再去执行下面的语句了。

_exit

exit和_exit几乎一模一样，区别在于exit是库函数，_exit是系统调用，exit在退出程序时会刷新缓冲区，而_exit在退出时不会刷新缓冲区。

int main()
{
    cout<<"haha";//写入缓冲区
    exit();
}

int main()
{
    cout<<"haha";//写入缓冲区
    _exit();
}

image-20220114173440679

站在OS角度，如何理解进程终止？

进程终止的核心思想就是归还资源：

1、"释放"曾经为了管理进程所维护的所有的数据结构对象。

2、释放程序代码和数据占用的内存空间。

3、取消曾经该进程的链接关系(比如和它和它的父进程之间的链接关系)

上面提到了两个释放，所谓第一个释放不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个"数据结构的池"

第二个释放不是代码和数据清空，而是把内存设置为无效就可以了

实际上我们每次申请空间是比较耗时的，由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。 内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。而数据结构池就是，当一个进程创建时有task_struct，mm_struct等各种数据结构变量，而我们在申请这些内存时，每次都要将这块内存强转为(task_struct*)，(mm_struct*)，这样时间效率肯定不好，所以就有一个数据结构池，这里面是一些无效的pcb以及mm_struct，他们处于一个废弃队列当中，当创建进程需要内存时，就将这里的内存提取出去。

进程等待

我们首先将子进程创建出来：

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        while(1)
        {
            sleep(1);
            cout<<"child..."<<endl;
        }
        exit(0);//终止
    }
    else
    {
        while(1)
        {
            sleep(1);
            cout<<"father..."<<endl;
        }
    }
    cout<<"hello world"<<endl;
}

子进程被创建出来，谁先运行，是由调度器说了算的，那么谁先退出呢？一般而言，我们通常要让子进程先退出，为什么呢？因为父进程可以很容易对子进程进行管理(垃圾回收)，如果父进程退出，子进程就成孤儿进程了，由操作系统领养，创建子进程出来是为了处理业务的，需要让父进程拿到子进程执行的结果

一般子进程是需要被父进程等待的，父进程等待的意义就是垃圾回收以及拿到子进程执行的结果

为什么要等待？

进程等待的方法

wait方法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);

返回值：

参数：

int main()
{
     pid_t id = fork();
     if(id < 0)
     {
         perror("fork");
         return 1;
     }
     else if(id == 0)
     {
         //child
         int count = 5;
         while(count)
         {
             printf("child is runing: %d\n,ppid:%d,pid: %d\n",count--,getppid(),getpid());
             sleep(1);
         }
         exit(0);
     }
     else
     {
         //father
         printf("father is waiting...\n");
         pid_t ret = wait(NULL);
         printf("father is wait done,ret: %d\n",ret);
     }
    	return 0;
 }

image-20220115151350308

可以看到父进程等待成功了

我们来演示一下子进程变成僵尸进程后被父进程回收的过程：

我们首先让子进程五秒后退出，父进程先睡眠不进行处理，查看子进程被回收的过程：

int main()
{
     pid_t id = fork();
     if(id < 0)
     {
         perror("fork");
         return 1;
     }
     else if(id == 0)
     {
         //child
         int count = 5;
         while(count)
         {
             printf("child is runing: %d\n,ppid:%d,pid: %d\n",count--,getppid(),getpid());
             sleep(1);
         }
         exit(0);
     }
     else
     {
         //father
         printf("father is waiting...\n");
         sleep(8);
         pid_t ret = wait(NULL);
         sleep(3);
         printf("father is wait done,ret: %d\n",ret);
     }
    	return 0;
 }

我们用一个脚本来监视进程的状态：

while :; do echo "####################"; ps ajx | head -1 && ps ajx | grep mytest | grep -v grep; echo "####################"; sleep 1; done

image-20220116223124471

上面只是为了演示，但是实际中我们这样写就行：

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int count = 0;
        while(1)
        {
            sleep(1);
            cout<<"child..."<<count<<endl;
            if(count>=15)
            {
                break;
            }
            count++;
        }
        exit(0);//终止
    }
    else
    {
        cout<<"father before..."<<endl;
        wait(NULL);//阻塞等待，等待子进程退出
        cout<<"father after..."<<endl;
    }
}

image-20220116225445794

子进程退出父进程回收后继续做自己的事情就可以了。下面看另外一种方法：

waitpid方法

pid_ t waitpid(pid_t pid, int *status, int options);

参数：

返回值：

WNOHANG是什么我们后面说，下面看这样一个程序：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0)//等待成功
    {
        printf("wait success!\n");
    }
    else
    {
        printf("wait failed!\n");
    }
    printf("father wait after!\n"); 
}

image-20220116231227680

当我们waitpid这样传参时其实这里的waitpid和wait的作用一样的，不一样的就是参数不同，我们来看看waitpid的第二个参数status：

pid_ t waitpid(pid_t pid, int *status, int options);

status：是一个整形指针，其实在传参的时候，该参数是一个输出型参数

int st = 0;
waitpid(pid,&st,0);//开始等待，子进程退出，操作系统就会从进程PCB中读取退出信息，保存在status指向的变量中

返回之后，st中就保存的是进程退出的信息，int是32bit，而这个int当中就要保存这些信息：是否正常退出，退出码是多少，退出信号是多少，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特
位）：

image-20220111103710036

那么为什么需要用status让父进程知道子进程的退出信息呢？是否可以通过设置全局变量，子进程如果退出将该全局变量改了，以这样的方式告知父进程子进程的退出码？这样绝对是不行的，因为写时拷贝，子进程在修改全局变量时，会发生写时拷贝，父进程和子进程指向的变量不是同一块内容。

在waitpid中拿到的status的值，是从哪里拿到的呢？答案是从子进程的task_struct中拿到的

一般进程提前终止，本质是该进程收到了OS的信号，进程先关心的是信号的内容，status指向的变量的低7位表示的是终止信号，正常终止的话，没有收到任何退出信号，此时才去关心结果对还是不对(退出码)

完整的等待过程：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    int st = 0;
    pid_t ret = waitpid(id,&st,0);
    if(ret > 0)
    {
        printf("wait success!\n");
        printf("st:%d\n",st);
        printf("child exit signal:%d\n",st&0x7F);//获取低7位
        printf("child exit code:%d\n",(st>>8)&0xff);//获取高八位退出码
        if(st & 0x7F)//如果终止信号不为0 
        {
        	printf("child run error!\n");   
        }
        else
        {
            //终止信号为0，进程正常退出
            int code = ((st>>8)&0xff);//退出码
            if(code)//如果退出码不为0
            {
                printf("child run success,but result is not right!:code ：%d",code);
            }
            else
            {
                printf("child run success,result is right!:code ：%d",code);
            }
        }
    }
    else
    {
        printf("wait failed!\n");
    }
    printf("father wait after!\n");
    
}

上面的代码就是进程完整等待的过程。

但是这样拿到退出码和信号比较麻烦，实际上系统上提供了这么两个宏可以帮我们干上面的检测：

  • WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）

这个检测的相当于是!(status & 0x7F)

  • WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

这个检测的相当于是(st>>8) & 0xff。

所以我们可以将上面的代码换成下面这种：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    int st = 0;
    pid_t ret = waitpid(id,&st,0);
    if(ret > 0)
    {
    	if(WIFEXITED(st))
        {
            printf("exit code : %d\n",WEXITSTATUS(st));//退出码
        }
        else
        {
            printf("child exit error\n");
        }
    }
}

第一个参数pid：

第三个参数options：

将WNOHANG作为第三个参数传给waitpid时称为非阻塞式等待，如果传0则为阻塞式等待。

什么意思呢？举个例子：

在这个例子当中你每次打电话询问你同学的状态，通过多次打电话(非阻塞轮询方案)检测它的进度，每次打电话就相当于一次waitpid函数调用，这叫非阻塞式等待，如果你刚开始打通电话不挂断，一直等到见到你同学才挂断，这种情景叫做阻塞式等待。我们在C语言，C++中所调用的函数，全部都是阻塞函数：调用->执行->返回->结束，因为都是单执行流，简单一些，这种方式调用方都在等，什么事情都没有做。

而非阻塞等待是一种基于非阻塞接口的轮询方案：

image-20220118122126337

在非阻塞等待当中，wait失败有两种说法：

非阻塞等待的三种状态：

1.失败：子进程还没有退出，下次在检测

2.成功：子进程退出，已经返回

3.失败：真正的等待失败

非阻塞式等待：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error!\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        int count = 0;
        while(count<10)
        {
            printf("child [%d] is running...\n",getpid());
            sleep(1);
            count++;
        }
        exit(0);
    }
    printf("father wait before!\n");
    int status = 0;
    while(1)
    {
        pid_t ret = waitpid(id,&status,WNOHANG);
        if(ret == 0)//id指定的子进程没有结束
        {
            printf("wait next!\n");
            printf("father do other things\n");
        }
        else if(ret > 0)
        {
            printf("wait success,ret:%d,code:%d\n",ret,WEXITSTATUS(status));
        }
        else
        {
            printf("wait failed!\n");
            break;
        }
    }
}

如何理解阻塞等待？

总结：

  • 进程等待是什么？
  • 为什么要进程等待？
  • 怎么进行进程等待？

进程程序替换

替换原理

fork创建子进程无非两个作用：

1、想让子进程执行父进程代码的一部分(富二代子承父业)

2、想让子进程执行和父进程完全不同的事情(富二代创业)

前面我们说的都是第一种，那么当我们想要进行第二种时，就需要进程替换，在进程替换时，代码也要发生写时拷贝，不进行进程替换时父子代码是共享的

进程替换有没有创建新的进程呢？

进程替换是将磁盘上的程序替换给子进程，怎么替换呢？本质上用该程序的代码和数据替换，修改页表的映射。完成进程替换的过程并不是我们自己做的，而是操作系统做的，操作系统提供了下面的接口，下面是替换函数：

替换函数

其实有六种以exec开头的函数,统称exec函数：

#include <unistd.h>
int execl(const char *path, const char *arg, ...);//...是可变参数
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

命名理解

void myfun(char *arg1,char *arg2,char *arg3);//列表式传参
myfun(a1,a2,a3);//list
void myfun(char *arg[]);//非列表式的传参
char *arg[] = {a1,a2,a3};
myfun(arg);

参数命名中有l的需要一个一个进行传参，有v的需要将参数放入数组，通过数组传参

有p的第一个参数是file，而不带p的第一个参数是path，有p自动去环境变量PATH中搜索：传参时可以直接传想要使用的命令，不需要传路径，会自动搜索，只需要告诉执行的命令是谁

没有p的需要传路径

execl

#include<stdio.h>
#include<unistd.h>
int main()
{
    execl("/usr/bin/ps","ps","-e","-l","-f",NULL);
    return 0;
}

可以看到通过我们自己写的程序运行了ps命令：

image-20220118124029627

函数的第一个参数代表你要执行谁，第二个参数是你在命令行怎么调用执行，在后面的参数中你就怎么传递。

接下来看下面的程序：

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execl("/usr/bin/ps","ls","-a","-l","-i",NULL);
    printf("hello world\n");
    return 0;
}

image-20220118124502981

exec_cmd是自己写的可执行程序，./exec_cmd变成了进程，代码执行到execl，进行程序替换，用ls进程的代码和数据替换exec_cmd进程的代码和数据，执行ls进程

ls：系统的可执行程序

上面的代码输出结果是什么呢？

注意：

举个例子，我们故意把程序替换写错：

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execl("/usr/bi/ps","ls","-a","-l","-i",NULL);
    printf("hello world\n");
    return 0;
}

image-20220118124840654

此时就会返回去打印后面的语句了。

我们当然也可以让子进程去干程序替换这件事情：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
    //execl("/usr/bin/ls", "ls",_"-a","-l"，"-i"，NULL);
	//execl("/usr/bin/top" , "top" ,NULL);
    pid_t id = fork();
    if(id<0)
    {
        perror("fork");
        return 1;
    }
    else if(id == 0)
    {
        //child
        printf("i am a child , pid:%d, ppid: %d\n",getpid(),getppid());
        execl("usr/bin/ps","ps",NULL);
        exit(1);
    }
    //father
    int status = 0;
    pid_t ret = waitpid(id,&status,0);//阻塞式等待
    if(ret > 0)
    {
        printf("wait success!\n");
        printf("exit code: %d,exit status: %d\n",(status>>8)&0xFF,status & 0x7F);
    }
    else{
        printf("wait failed!\n");
    }
    return 0;    
}

image-20220122084200553

exec系列函数的理解

execv

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    char *arg[] = {"ls","-a","-l","-i",NULL};
    execv("/usr/bin/ls",arg);
    printf("you should running here\n");
    return 0;
}

image-20220123131153282

execvp

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    char *arg[] = {"ls","-a","-l","-i",NULL};
    execvp("ls",arg);
    printf("you should running here\n");
    return 0;
}

image-20220123131559949

execlp

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execlp("ls","ls","-a","-l","-i",NULL);
    printf("you should running here\n");
    return 0;
}

image-20220123131706927

elecle

在说明elecle函数之前，我们先想一个问题：

exec系列函数能调用系统程序，那么他能调用自己的程序吗？答案是可以的

我们首先自己写一个程序：

#include<stdio.h>
int main()
{
    int i = 0;
    int sum = 0;
    for(;i<=100;i++)
    {
        sum+=i;
    }
    printf("result[1~100] sum is:%d\n",sum);
    return 0;
}

Makefile的编写：

makefile默认只生成一个可执行程序，默认是自顶向下扫描makefile文件遇到的第一个目标

输入make bin命令 ，默认就生成bin

.PHONY:all
all:mytest mycmd
mytest:Test.c
    gcc -o $@ $^  
mycmd:mycmd.c
    gcc -o $@ $^
.PHONY:clean
clean:
    rm mytest mycmd

我们在Test.c中使用程序替换execl函数去执行我们写的程序：

#include<stdio.h>
#include<unistd.h>
int main()
{
    printf("begin............................\n");
    execl("./mycmd","./mycmd",NULL);
    return 0;
}

image-20220123133449837

可以看到我们成功的通过exec系列函数调用自己写的程序：

image-20220123133131317

上面说的都是为了说明execle系统调用所做的铺垫，下面我们再来看execle：

我们在mycmd.c中获取一个环境变量myenv，而这个程序它本身是没有myenv这个环境变量的，所以我们就可以通过execle函数给我们写的程序将环境变量传过去：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
    char *env[] = {"myenv = you_can_see_me!",NULL};//自定义环境变量
    printf("begin............................\n");
    execle("./mycmd","./mycmd",NULL,env);//调用该函数并将自定义的环境变量数据传给目标程序
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
int main()
{
    int i = 0;
    int sum = 0;
    for(;i<=100;i++)
    {
        sum+=i;
    }
    printf("result[1~100] sum is:%d\n",sum);
    printf("myenv: %s\n",getenv("myenv"));
    return 0;
}

image-20220123135600079

我们man查看exec系列函数：

image-20220123135833252

image-20220123135905832

我们发现execve是和上面的函数分开的，本质上是因为，execve是最底层的系统调用，其他都是去调用它去完成的：

image-20220123140304951

实际中，我们可以fork出子进程，让子进程去进行程序替换，替父进程完成事情：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
    pid_t id = fork();
    if(id<0)
    {
        perror("fork error\n");
        return 1;
    }
    if(id == 0)
    {
        //child
        execl("usr/bin/ls","ls","-a","-l","-i",NULL);
        //如果返回则替换失败
        exit(-1);
    }
    
    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0)
    {
        printf("wait success,cmd exit\n");
    }
    return 0;
}

image-20220123141119545

总结：

1、什么是程序替换?

2、为什么要程序替换?

3、如何程序替换？

注意：exec系列函数只要返回了，就说明出错了

shell小程序的简单实现

讲解完程序替换，其实我们就可以实现一个简单的shell了，我们首先来说一下shell的运行原理：

shell运行原理：用户执行命令->shell解释器->fork()->子进程去执行命令(利用exec系列函数，OS做的)->shell->用户

我们发现shell运行原理就是用户执行命令，shell解释器创建子进程去执行命令，子进程将执行结构告诉shell，最后再反馈给用户，其实就是给上面的程序套了一层循环去创建子进程去执行命令：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
    while(1)
    {
        pid_t id = fork();
        if(id<0)
        {
            perror("fork error\n");
            return 1;
        }
        if(id == 0)
        {
            //child
            execl("usr/bin/ls","ls","-a","-l","-i",NULL);
            //如果返回则替换失败
            exit(-1);
        }

        pid_t ret = waitpid(id,NULL,0);
        if(ret > 0)
        {
            printf("wait success,cmd exit\n");
        }
    }
    return 0;
}

下面我们来实现我们的myshell.c，首先我们登录主机后，会打印命令提示符(用户名@主机名 当前目录)提示符：

image-20220123142545051

所以我们首先要干的就是打印这个命令提示符，然后我们需要获取用户输入的文本(需要我们解析) 比如：ls -a -l，然后父进程fork(子进程去执行)，然后父进程wait，我们需要重复的去做这些动作，需要用循环。

实际上获取主机名等信息都是有函数的：

int main()
{
    char name[32];
    gethostname(name,32);//获得主机名
    get_current_dir_name();
}

image-20220123143217418

这里我们为了简单，就直接打印一个主机名：

const char* cmd_line = "[temp@VM-0-3-centos ~]#";

然后我们需要做的就是数据读取，C语言有一个fgets函数，我们可以这样读取数据：

image-20220123145701165

fgets(cmd,SIZE,stdin);

cmd是保存输入命令的一个数组，大小自己决定即可，size是读取的字符个数，stream是从哪里读，这里需要注意的是，我们读取结束后最后一个字符是\n，所以需要将它置为\0

cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0

接下来就要进行字符串数据分析，怎么分析呢？我们首先要把输入的字符串以空格为标志进行分割，然后放进一个字符指针数组，不了解strtok函数的可以去了解一下：

//字符串(命令行数据分析)
char* args[NUM];
args[0] = strtok(cmd," ");//字符串分割
int i = 1;
do{
     rgs[i] = strtok(NULL," ");
     if(args[i] == NULL)
     {
           break;
     }
     ++i;
}while(1);

然后就是创建子进程进行执行命令，子进程通过调用程序替换函数去执行命令，那么我们想一下我们用哪个函数呢？我们的命令是用数组存起来的，所以需要带v，那么就用execvp，并且不用传路径，传命令名就好，会自动去环境变量PATH里找：

pid_t id = fork();
if(id < 0)
{
     perror("fork error!\n");
     continue;
}
 //4.执行非内置命令
if(id == 0)
{
     //child
     execvp(args[0],args);
     exit(1);//替换失败了就直接退出
}
int status = 0;
pid_t ret = waitpid(id,&status,0);
if(ret>0)
{
    printf("status code :%d\n",(status>>8)&0xff);
}

总体的代码如下：

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#define SIZE 256
#define NUM 16
int main()
{
    char cmd[SIZE];//保存命令
    const char* cmd_line = "[temp@VM-0-3-centos ~]#";
    while(1)
    {
        cmd[0] = 0;//清空数据
        //memset(cmd,'\0',sizeof(cmd));
        printf("%s",cmd_line);
        //数据读取
        fgets(cmd,SIZE,stdin);
        //printf("%s",cmd);
        cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0
        
        //字符串(命令行数据分析)
        char* args[NUM];
        args[0] = strtok(cmd," ");//字符串分割
        int i = 1;
        do{
            args[i] = strtok(NULL," ");
            if(args[i] == NULL)
            {
                break;
            }
            ++i;
        }while(1);
		//shell内的函数调用，内置命令
        pid_t id = fork();
        if(id < 0)
        {
            perror("fork error!\n");
            continue;
        }
        //4.执行非内置命令
        if(id == 0)
        {
            //child
            execvp(args[0],args);
            exit(1);//替换失败了就直接退出
        }
        int status = 0;
        pid_t ret = waitpid(id,&status,0);
        if(ret>0)
        {
            printf("status code :%d\n",(status>>8)&0xff);
        }
    }
    return 0;
}

上面的代码只是支持非内置命令，内置命令不可以，比如cd：

cd .. //回到上一路径

有一个系统接口chdir是修改路径的：

image-20220123152315681

如果想要支持cd命令，就需要在创建子进程前判断命令：

if(strcmp( args[0]，"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
{
    continue;
}

这样就成功执行cd命令了

image-20220123152636311

支持cd命令的shell：

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#define SIZE 256
#define NUM 16
int main()
{
    char cmd[SIZE];//保存命令
    const char* cmd_line = "[temp@VM-0-3-centos ~]#";
    while(1)
    {
        cmd[0] = 0;//清空数据
        //memset(cmd,'\0',sizeof(cmd));
        printf("%s",cmd_line);
        //数据读取
        fgets(cmd,SIZE,stdin);
        //printf("%s",cmd);
        cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0
        
        //字符串(命令行数据分析)
        char* args[NUM];
        args[0] = strtok(cmd," ");//字符串分割
        int i = 1;
        do{
            args[i] = strtok(NULL," ");
            if(args[i] == NULL)
            {
                break;
            }
            ++i;
        }while(1);
        //3.判断命令
        if(strcmp( args[0],"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
        {
            continue;
        }
		//shell内的函数调用，内置命令
        pid_t id = fork();
        if(id < 0)
        {
            perror("fork error!\n");
            continue;
        }
        //4.执行非内置命令
        if(id == 0)
        {
            //child
            execvp(args[0],args);
            exit(1);//替换失败了就直接退出
        }
        int status = 0;
        pid_t ret = waitpid(id,&status,0);
        if(ret>0)
        {
            printf("status code :%d\n",(status>>8)&0xff);
        }
    }
    return 0;
}
举报

相关推荐

Linux进程控制（详解）

linux

linux之进程控制

linux运维服务器

进程控制详解

后端c++开发语言

进程控制(详解)

决策树分类sklearn

【Linux】进程周边007之进程控制

linux服务器运维c++开发语言算法

[Linux]进程控制

数据结构leetcode算法前缀树

进程控制（Linux）

jenkinswindows前端

[ Linux ] 进程控制

进程控制进程等待进程替换Linux系统/运维yyds干货盘点

【Linux】进程控制

linux运维服务器

Linux——进程控制

golang学习
0 条评论
加载失败