Linux学习笔记之进程切换

已于 2025-02-24 20:38:17 修改
阅读量922 收藏 22
点赞数 10
分类专栏： linux基础知识 文章标签： 学习 笔记
于 2025-02-19 12:28:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_79964905/article/details/145711300
版权

目录

1.进程退出

        1.1 main函数return

        1.2 exit函数

        1.3 _exit函数

        1.4 异常退出

1.4.1 strerror

        1.4.2 errno

1.4.3 perror

1.5 终止信号

​编辑

2. 进程等待

2.1 wait

2.1.1 函数参数

2.2 waitpid

2.2.1 pid参数

2.2.2 status

2.2.3 options

2.2.4 返回值

3. 进程切换

3.1 execl

3.2 execlp

3.3 execle

3.4 execv

3.5 execvp

3.6 execvpe

        3.7 系统函数execve

        一个进程在被OS从磁盘加载到内存中，就开始了运行，当进程完成他对应的任务时，进程就会退出，此时父进程要想知道子进程的完成情况，是中途出错了，还是正常完成了？就会关注子进程的退出状态。

1.进程退出

        1.1 main函数的return

        常见的进程退出就是程序正常运行，程序退出码为return返回的值。

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>


int main()
{

    printf("我是进程,pid为%d\n",getpid());

    return 100;
}

echo $? 可以在命令行中打印上个进程的退出码。

        1.2 exit函数

        在C语言封装了一个进程退出函数，当进程执行exit时就会结束运行，直接返回错误码。

        将上述代码修改如下，可以发现当进程执行完exit时，就不会继续向下执行代码了，而是直接退出，所以如下运行结果没有打印我是进程。

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

int main()
{

    exit(2);

    printf("我是进程,pid为%d\n",getpid());

    return 100;
}

        进程执行到exit就退出，后面语句没有执行。

        1.3 _exit函数

        _exit函数与exit函数不同， _exit函数是系统提供的函数调用，exit是C语言封装的函数，可以说C语言的exit底层调用了系统接口_exit.

        他们的主要区别在于exit在退出后会刷新缓存区，而_exit不会刷新缓存区，由此可能造成部分内容没有打印。如下代码。

        使用C语言封装函数调用。

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<stdlib.h>
  5 
  6 int main()
  7 {
  8 
  9 
 10 
 11     printf("我是进程,pid为%d",getpid());
 12     exit(2);                                                                                                    
 13 
 14     return 100;
 15 }

        执行结果如下。

        但是换成如下_exit函数，结果如下图。什么都没有打印，即保存在缓存区的数据丢失了。

1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<stdlib.h>
  5 
  6 int main()
  7 {
  8 
  9 
 10 
 11     printf("我是进程,pid为%d",getpid());
 12     _exit(2);                                                                                                    
 13 
 14     return 100;
 15 }

        缓存区是C语言提出的概念，为了减少内存与硬件传输数据消耗的时间，先统一输出到缓存区，等缓存区满了在打印。（这就像家里的垃圾桶一样，我们在家里把垃圾放在了垃圾桶里面，但最终还是会放在楼下大型垃圾桶里面，先放在家里是为了方便，不用每次丢垃圾跑到楼下面。缓存区就是家里的垃圾桶，磁盘显示器就是楼下的大垃圾桶。）但是操作系统不会管C语言的标准，只会按照自己标准退出，不理会C语言的缓存区。

   

        1.4 异常退出

        上述退出都是程序得以按照预设运行下去的结果，退出码就是return返回值或者exit的值，但是程序在计算中可能就带有巨大的错误，例如1/0，计算错误，对野指针赋值等操作。此时操作系统就会给进程发信号，强行停止进程运行，避免产生严重后果。此时退出码就不再是简单的枚举了。

        下面先复习三个C语言错误处理函数

1.4.1 strerror

         进程退出返回的错误码对于机器可以精准识别，但对于人不是太好理解，由于每个数字对于一种错误，该函数就可以将错误码转化为对应信息给人看。

       运行下述代码，可以查看常见错误。（这些错误和环境有关，Linux与Windows有区别）

#include<stdio.h>
#include<string.h>


int main()
{

    int i=0;
    for(i=0; i<200; i++)
    {
        printf("strerr%d:%s\n",i,strerror(i));
    }

    return 0;
}

        如下代码，打印常见的错误信息。

        通过上述方式，可以发现在Linux中大概有133个错误信息。超过133就是未知信息。

        1.4.2 errno

        errno是头文件errno中的全局变量，由C语言维护的，保存退出的错误信息码。当进程错误时，errno就会被设置成对应的错误码。

        运行如下代码，只读权限打开不存在的文件。

#include<string.h>
#include<stdio.h>
#include<errno.h>

int main()
{

    printf("before : errno :%d,strerror:%s\n",errno,strerror(errno));

    FILE* fp=fopen("./bcdc","r");


    printf("after : errno :%d,strerror:%s\n",errno,strerror(errno));

    return 0;
}

        进程发生错误，errno被系统修改为错误数字，就可以借助errno打印错误信息。

1.4.3 perror

         perror也是C语言提供的输出错误的接口，它可以看为是strerror+errno的结合，减少使用麻烦，居家旅行之必备。

        只要使用一个函数就可以达到与上述函数一样的效果。

#include<string.h>
#include<stdio.h>
#include<errno.h>

int main()
{

    perror("");
    FILE* fp=fopen("./bcdc","r");

    perror("");

    return 0;
}

        这个函数极大简便了打印错误。

1.5 终止信号

        编译下述代码，警告错误，忽略警告，运行下述代码

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

int main()
{

   int a=1/0;


    return 0;
}

        按照规定，每个数字对应一个错误信息，但136显然超过了133个枚举的错误信息，这是因为正常结束与程序错误退出码设置不同。

       下标为7的位置作为一个标志位，用于指示进程是否是正常退出。如果最高位为 0，表示进程是正常退出；如果最高位为 1，表示进程是由于接收到信号而异常终止。当程序发生错误时，被操作系统用信号结束，低7位存的就是终止信号。   

        可以简单记为   退出码 = 128 + 信号编号。我们可以通过如下例子证明。手动发送信号。

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


int main()
{

    while(1)
    {
        printf("我是进程，pid为:%d\n",getpid());
        sleep(1);
    }

    return 0;
}

2. 进程等待

        当子进程结束，而父进程什么都不做的时候，子进程就是僵尸状态。但是父进程也可以回收子进程，让子进程进入X（死亡状态）。以下两个函数就可以处理僵尸状态的子进程。

2.1 wait

2.1.1 函数参数

  • 返回值 等待任意子进程结束返回子进程PID，等待失败返回-1
  • 参数 传入整型指针用来保存子进程的退出信息（如果不想获取子进程退出信息可以传入空指针NULL）

         虽然传入参数是32位，但只用到低16位，当程序正常退出时（由 exit() 或 return 语句返回），其中的第8个到第15个比特位（次低8位）存的才是退出码。下标为7的位置作为一个标志位，用于指示进程是否是正常退出（由 exit() 或 return 语句返回）。如果最高位为 0，表示进程是正常退出；如果最高位为 1，表示进程是由于接收到信号而异常终止。当程序发生错误时，被操作系统用信号结束，低7位存的就是终止信号。   

        对于被信号所杀的进程，我们要获得终止信号可以采用位操作。status&0x7f，0x7f转化为2进制就是 0111 1111，c语言也给我们提供了宏可以使用，WTERMSIG(status)。

        对于正常退出进程可以采用位操作， （status>>8）&0xff, 也可以采用宏函数WEXITSTATUS(status)

        wait是阻塞等待子进程，类似于scanf语句，只有当键盘输入时，scanf语句才执行结束，wait只有当子进程结束时，wait语句才执行完。

        如下代码

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

int main()
{

    pid_t id =fork();
    if(id==-1)
    {
        printf("进程申请错误！\n");
        return 1;
    }
    else if(id==0)
    {
        //子进程
        int cnt=5;
        while(cnt)
        {
            printf("我是子进程，pid:%d,cnt:%d\n",getpid(),cnt--);
            sleep(1);
        }
        exit(12);
    }
    else
    {
        //父进程
        int status=0;
        sleep(8);
        pid_t rid=wait(&status);
        
        while(1)
        {
            printf("我是父进程,pid为%d,子进程退出码为:%d\n",getpid(),(status>>8)&0xff);
            sleep(1);
        }


    }

    return 0;
}

        打开新的命令行，输入下述指令，每秒打印proc进程信息。

while true; do ps ajx | head -1 && ps ajx | grep proc sleep 1 done

        当父进程wait后，子进程僵尸状态结束，转变为瞬时的X状态。

        程序是正常运行便可以得到他的退出码与我们设置的12返回值相吻合。

        除了上述正常退出外，还可以使用kill 结束子进程或者在子进程设置错误，父进程得到子进程的退出信号。

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

int main()
{

    pid_t id =fork();
    if(id==-1)
    {
        printf("进程申请错误！\n");
        return 1;
    }
    else if(id==0)
    {

        //子进程
        int cnt=5;
        while(cnt)
        {
            printf("我是子进程，pid:%d,cnt:%d\n",getpid(),cnt--);
            sleep(1);
        }

        int a=1/0;//人为设置错误

        exit(12);
    }
    else
    {
        //父进程
        int status=0;
        sleep(8);
        pid_t rid=wait(&status);
        
        while(1)
        {
            printf("我是父进程,pid为%d,子进程错误信号为:%d\n",getpid(),status&0x7f);//0x7f为 0111 1111
            sleep(1);
        }


    }


    return 0;
}

2.2 waitpid

        

    2.2.1 pid参数

            

            如果pid大于0，表示等待指定子进程。如果pid值等于-1表示等待任意子进程，如果pid=0，表示等待进程组 ID 与调用进程的进程组 ID 相同的任何子进程，如果pid=-1，表示等待任何进程组 ID 等于pid绝对值的子进程。

    2.2.2 status

            与wait函数参数一样.使用低16位存储信息。

    2.2.3 options

            第三个参数options表示是否阻塞，如果为0，表示阻塞等待，效果与第一个函数一样；如果为WNOHANG，表示非阻塞等待，即便没有子进程结束，程序运行到函数时立刻返回。

    2.2.4 返回值

            非阻塞状态下，程序在运行到waitpid函数时判断子进程是否结束，没结束不会等待，此时返回值为0；如果子进程结束返回值为子进程pid，如果等待失败返回负数。

            阻塞状态下，与wait函数一样，子进程退出返回子进程的pid，等待失败返回负数

          将参数设置如下，下面两个函数就是一样的了。

    wait(&status) == waitpid(-1,&status,0)

    3. 进程切换

            进程切换就像是借躯重生一样，新进程借用旧进程的地盘，加载自己的数据。C语言中有如下函数可以切换进程。

    3.1 execl

            第一个参数path就是你要切换到的进程的地址，后面是可变参数列表代表的是你要给这个进程怎么使用。第一个参数解决是谁的问题，后面的参数解决怎么用的问题，在命令行中怎么用后面的就怎么写，以空指针结尾。

            下面看个简单例子。

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

int main()
{
    execl("/usr/bin/ls","ls","-a","-l",NULL);

    return 0;
}

            上述代码核心就是下面两部分，也就是说我们自己写的程序编译之后也可以切换

            之前目录下且编译通过一个Hello.c文件,代码如下。

    #include<stdio.h>

int main()
{

    printf("hello execl!\n");

    return 100;
}

            将原来的参数修改之后即可，

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

int main()
{
    execl("./myhello","myhello",NULL);

    return 0;
}

            通过打印进程的退出码，我们发现结果是100说明进程切换后，执行的语句就不再是原来的文件了，而是切换后的文件了。

            

            当发生进程切换时，操作系统将进程的申请的空间进行释放回收，然后利用当前的task_struct建立进程，一些进程通用的保留下来，跟旧程序内存相关的释放重新申请，进程还是那个进程但是里面的数据变了.

            我们可以通过竞争切换前后打印进程的pid来验证。

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

int main()
{

    printf("hello execl!我的pid为%d\n",getpid());

    return 100;
}
    #include<string.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>

int main()
{
    printf("切换前pid为%d\n",getpid());//这里一定要加上\n刷新缓存区，否则进程切换后缓存区的数据也没有了
    execl("./myhello","myhello",NULL);

    return 0;
}

            操作系统这么做也很简单，当前进程被切换后没有用了没有必要再重新开辟一块内存，继续用之前的内存也减少了开辟内存的操作，提升了效率。

            通常我们会创建一个子进程让子进程切换，而不是直接让父进程切换。如下代码，我们就可以用父进程接收子进程的状态.

            

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
        execl("./myhello","myhello",NULL);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

    3.2 execlp

            它的第一个参数只需要传进程的名字就可以，后面的参数和execl一样传该程序如何使用。

            例如如下代码。

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
       execlp("ls","ls","-a","-l",NULL);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

            如果把进程切换为我们自己写的程序会怎么样呢？如下图

            

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
       execlp("myhello","myhello",NULL);
       exit(100);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

            我们会发现程序并没有按照预期执行说明execlp执行失败，最终子进程执行 exit(100);退出。其实这里之所以也可以只写程序的名字是因为环境变量中保存了地址，程序会从环境变量的地址中搜索这个程序，如果有就切换如果没有就不切换，我们自己写的程序不在环境变量中的地址所以无法执行。

    3.3 execle

            在程序进行切换的时候，保留了一些有用的数据，将堆区栈区一些资源释放出来，其中就保留了环境变量，execle相较于execl，多传递了环境变量。其余一样。

            hello.c文件

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

extern char ** environ;
int main()
{

    for(int i=0 ; environ[i]; i++)
    {
        printf("env[%d]:%s\n",i,environ[i]);
    }

    return 100;
}

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
        char * const env[]=
        {
            "HELLO=ECECL",
            "PATH=./",
            NULL
        };
        
       execle("./myhello","myhello",NULL,env);
       exit(123);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

            上述代码运行如下。此时子进程的环境变量就是我们输入的环境变量

    3.4 execv

            这个与ecexl函数基本一样，唯一的区别是l是列表意思，v是数组意思，把原来列表形式的传入改为数组形式传入，实际上就是之前讲的命令行参数。

            

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
         char * const argv[]=
        {
            "ls",
            "-a",
            "-l",
            NULL
        };
        execv("/usr/bin/ls",argv);
       exit(123);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

    3.5 execvp

            这实际上与execv变化在于带了默认环境变量，其余一样

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
         char * const argv[]=
        {
            "ls",
            "-a",
            "-l",
            NULL
        };
        execvp("ls",argv);
       exit(123);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

            结果如上图。

    3.6 execvpe

            这个函数就相当于加了第三个环境变量数组参数，可以向子进程传递环境变量。

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

int main()
{
    pid_t id=fork();
    
    if(id==0)
    {
        char * const env[]=
        {
            "HELLO=ECECL",
            "PATH=./",
            NULL
        };
         char * const argv[]=
        {
            "ls",
            "-a",
            "-l",
            NULL
        };
        execvpe("ls",argv，env);
       exit(123);
    }
    else
    {
        int status=0;
        pid_t rid=wait(&status);
        while(1)
        {
            sleep(1);
             printf("子进程退出码为%d\n",WEXITSTATUS(status));
        }
    }

    return 0;
}

            3.7 系统函数execve

            上述的函数都是C语言封装的函数，这个是操作系统提供的进程切换函数，与execvpe使用一样。仅依靠系统提供的这个无法满足丰富的调用，C语言就提供了多个进程切换函数。

    《深入理解Linux内核3rd》学习笔记——进程切换（上）：相关知识
    weixin_30906185的博客
    05-25 382
    　　进程切换（process switch），作为抢占式多任务OS中重要的一个功能，其实质就是OS内核挂起正在运行的进程A，然后将先前被挂起的另一个进程B恢复运行。 硬件上下文 　　每个进程都有自己的地址空间，但是所有进程在物理上共享着CPU的寄存器，因此，当恢复一个进程执行前，OS内核必须要将挂起该进程时寄存器的值装入CPU寄存器。进程恢复执行前必须装入寄存器的一组数据就叫做“硬件上...
    Linux中的进程切换分析
    qq_38213564的博客
    04-25 686
    call指令压栈RIP寄存器到进程切换前的prev进程内核堆栈，而ret指令出栈存入RIP寄存器的是进程切换之后的next进程的内核堆栈栈顶数据，所以 ret 恢复的就是 next 进程内核堆栈中的 rip 值，即实现了 rip 值的保存与修改。当进程在运行过程中遇到中断或触发系统调用，首先会进行中断上下文的切换，之后进行ISR中断服务，之后调用_schedule()函数进行进程的切换，schedule()将当前进程的标识符记为prev进程。然后再通过调度算法确定下一个要被换上的进程，记为next进程。
    进程切换（linux）
    chen_ever的博客
    11-01 850
    进程切换，并行，并发，调度算法，寄存器，调度队列，活动队列，过期队列
    (linux操作系统)进程的切换与调度
    最新发布
    2302_80245587的博客
    03-28 6047
    说到进程的切换与调度，我们先来看一个东西，这个东西叫做进程的优先级。
    Linux进程的切换
    w8848w的博客
    10-20 2074
    1、代码不会执行了——首先可以立刻释放的就是进程对应的程序信息数据退出2、进程退出，要有退出信息（进程的退出码）保存在自己的task_struct内部3、管理结构task_struct必须被OS维护起来，方便用户未来进行获取进程退出的信息task_struct->是进程的PCB进程=内核数据结构+代码和数据结构体->成员属性->退出信息（int code,其他信息）
    【Linux】进程切换
    Hello，My Friends~
    05-24 1177
    操作系统为了控制进程的执行，必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行，这种行为被称为进程切换，任务切换或上下文切换 或者说，进行进程切换就是从正在运行的进程中收回处理器，然后再使待运行进程来占用处理器。 这里所说的从某个进程收回处理器，实质上就是把进程存放在处理器的寄存器中的中间数据找个地方存起来，从而把处理器的寄存器腾出来让其他进程使用。那么被中止运行进程的中间数据存在何处好呢？当然这个地方应该是进程的私有堆栈。 让进程来占用处理器，实质上是把某个进程存放在私有堆栈中寄存器的数
    linux 进程切换
    inquisiter
    04-07 499
    内核中栈的管理情况如上，tack->pt_regs指向保存的用户态栈信息。thread保存的是内核栈的信息。 x86本身设计了自带的tss任务切换方式，管理特权进程的切换。但linux系统采用了新的软件机制。摒弃了大部分tss的用途，设计出了以cpu为基准的tss特权切换方式。每个cpu实现一个tss，当特权切换发生时，大部分寄存器采用软件实现的方式保存和调用。 ...
    Linux学习笔记（强悍总结值得一看）_linux_linux学习笔记_
    09-29
    这份"Linux学习笔记（强悍总结值得一看）"是Linux初学者的宝贵资源，也适合有经验的用户作为参考手册。以下是对笔记内容的详细概述： 1. **Linux常用命令**： Linux命令行是其强大的工具，掌握常用命令是Linux学习...
    Linux学习笔记-超全总结值得一看（带标签目录）- 154页.pdf
    01-06
    【Linux学习笔记】这篇超全总结涵盖了Linux操作系统的基础知识，特别是关于命令行的使用和快捷键，以及一些桌面环境下的快捷操作。以下是笔记中的主要内容： 1. **LINUX常用操作命令**： - `clear`：清空终端屏幕...
    linux学习笔记，linux命令整理
    10-22
    在Linux操作系统的学习中，掌握命令行的使用是至关重要的。...总的来说，Linux学习笔记是一个全面了解和掌握Linux系统操作的基础教程，涵盖了从基本命令到高级管理的诸多方面，对提升Linux技能有很大帮助。
    Linux学习笔记-学习笔记自用
    09-13
    Linux系统作为全球最受欢迎的开源操作系统之一，具有高度的可定制性和强大的...随着技能的提升，用户可以进一步探索Linux系统的高级功能，如网络配置、进程管理、Shell脚本编写等，从而更深入地利用Linux的强大功能。
    Linux学习笔记（强悍总结值得一看）
    06-20
    这些只是Linux学习笔记中的一部分内容，完整的学习资料会详细解释每个命令的选项、参数以及实际应用场景。通过深入学习和实践，你将能够熟练掌握Linux，无论你是开发人员还是系统管理员，都能在工作中游刃有余。记住...
    Linux深入理解进程切换
    qq_43541346的博客
    05-23 847
    从现在起，内核在新进程的内核态栈上操作，所以，这条指令才是执行旧进程切换到新进程的开始。其中，content_switch 函数有三个参数：rq、prev、next，rq即使上面我们说的running queue（就绪队列），prev 指向切换前进程的进程描述符，next 指向切换后进程的进程描述符。switch_to 调用3个参数，prev、next和last，prev和next分别指向新旧进程的描述符地址，last，是一个输出参数，用来记录是从哪个进程切换来的。将新进程的栈指针加载到esp寄存器中。
    linux 进程满,linux进程切换
    weixin_39616379的博客
    04-28 120
    Linux切换并没有使用X86CPU的切换方法，Linux切换的实质就是cr3切换(内存空间切换，在switch_mm函数中)+ 寄存器切换(包括EIP，ESP等，均在switch_to函数中)。这里我们讲述下switch_to主流程：1、 在switch_mm函数中将new_task->pgd设置到cr3寄存器中，实现页表切换，由于每个进程3-4G的页表映射机制完全一样(从内核页表中直接复...
    Linux2.6进程切换
    weixin_30901729的博客
    05-22 135
    1.进程切换是指：保存prev进程的上下文，用next的上下文替代。 其中上下文包括：页全局目录、内核态堆栈、硬件上下文。 2.80x86为进程切换提供的硬件支持： 第一种：通过任务门 第二种：通过JMP和CALL指令：把硬件上下文存在TSS中，执行这条指令时，通过硬件自动切换TSS，完成硬件上下文的过程 TSS是任务状态段，只能存放在GDT中，不能存放在LDT中 ...
    Linux中进程调度与进程切换
    zbh24的专栏
    04-26 1216
    这几天比较忙，马上补上。
    Linux进程切换
    飞的博客
    04-17 517
    这篇文章也是阅读《Linux内核情景分析》的读书笔记。这篇文章仅涉及进程切换的一部分内容，具体来说就是switch_to()函数的分析，觉得这个函数确实值得花点心思，而且它确实也是进程切换的一个核心操作。看了一下最新的内核代码，这一函数的内容已经发生了很大变化，但是这里还是以书中的2.4内核为背景分析。 首先列出这个函数的内容 #define switch_to(prev,next,last)
    linux进程切换
    yejing's utopia
    01-29 695
    为了控制task（进程）的执行，kernel必须有能力挂起正在cpu上运行的task，并恢复之前被挂起的某个进程，这种行为就是task切换（又称上下文（context）切换）。 尽快在现代操作系统引入虚拟内存之后，每个进程都有自己的地址空间，但是硬件（CPU）只有一个（当然，可以由多核心），我们都知道cpu的计算单元直接使用的数据并不是内存，而是寄存器，每个核心都有一套匹配的寄存器，这个核心为所
    Linux系统学习笔记精要
    Linux学习笔记详细知识点 Linux操作系统作为一款免费、开源的Unix类操作系统，其应用范围极为广泛，从嵌入式系统到超级计算机，从桌面操作系统到服务器领域，都有Linux的身影。Linux以其稳定、高效、安全的特性赢得...
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

    当前余额3.43元 前往充值 >
    需支付：10.00元
    成就一亿技术人!
    领取后你会自动成为博主和红包主的粉丝 规则
    hope_wisdom
    发出的红包
    实付元
    使用余额支付
    点击重新获取
    扫码支付
    钱包余额 0

    抵扣说明：

    1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
    2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

    余额充值