精华内容
下载资源
问答
  • 进程控制块
    千次阅读
    2021-01-04 15:40:16

    一、进程控制块

               进程控制块是存放进程的管理和控制信息的数据结构称为进程控制块。它是进程管理和控制的最重要的数据结构,没一个进程都有一个PCB,在创建进程时,建立PCB,伴随进程运行的全过程,直到进程撤销而撤销。

               在不同的操作系统中对进程的管理和控制机制不同,PCB中的信息存在差异,通常PCB包含如下信息。

               1、进程标识符:每个进程都必须有一个唯一的标识符,可以是字符串,也可以是数字,UNIX系统中就是一个整型数,在进程创建时由系统赋予。

               2、进程当前状态:说明进程当前所处的状态,为了管理的方便,系统设计时会将相同状态的进程组成一个队列,如就绪进程队列,等待进程则要根据等待的事件组成多个等待队列,如等待打印机队列、等待磁盘I/O完成队列等等。

               3、进程相应的程序和数据地址:将PCB与其程序和数据联系起来。

               4、进程资源清单:列出除CPU以外的资源记录,如拥有的I/O设备,打开的文件列表等。

               5、进程优先级:进程的优先级反映进程的紧迫程度,通常由用户指定和系统设置。UNIX系统采用用户设置和系统计算相结合的方式确定进程的优先级。

               6、CPU现场保护区:当进程因某种原因不能继续占用CPU时(等待打印机),释放CPU,这时就要将CPU的各种状态信息保护起来,为将来再次得到处理机恢复CPU的各种状态,继续进行。

               7、进程同步与通信机制:用于实现进程间的互斥、同步和通信所需的信号量等。

               8、进程所在队列PCB的链接字:根据进程所处的现行状态,进程相应的PCB参加到不同队列中。PCB链接字指出该进程所在队列中下一个进程PCB的首地址。

               9、与进程相关的其它信息:如进程记账信息,进程占用CPU的时间等。

    二、Liunx进程控制块

               在Liunx中每个进程都由task_struct数据结构来定义。task_struct就是我们通常所说的PCB。          

    struct task_struct
    {
    	volatile long state; //说明了该进程是否可以执行,还是可中断等信息
    	unsigned long flags; // flags 是进程号,在调用fork()时给出
    	int sigpending; // 进程上是否有待处理的信号
     
    	 mm_segment_t addr_limit;  //进程地址空间,区分内核进程与普通进程在内存存放的位置不同  //0-0xBFFFFFFF for user-thead    //0-0xFFFFFFFF for kernel-thread
    	 //调度标志,表示该进程是否需要重新调度,若非0,则当从内核态返回到用户态,会发生调度
    	 volatile long need_resched;
    	 int lock_depth;    //锁深度
    	 long nice;       //进程的基本时间片
     
    	 //进程的调度策略,有三种,实时进程:SCHED_FIFO,SCHED_RR, 分时进程:SCHED_OTHER
    	 unsigned long policy;
    	 struct mm_struct *mm;    //进程内存管理信息
     
    	 int processor;
    	 //若进程不在任何CPU上运行, cpus_runnable 的值是0,否则是1 这个值在运行队列被锁时更新
    	 unsigned long cpus_runnable, cpus_allowed;
    	 struct list_head run_list;   //指向运行队列的指针
    	 unsigned long sleep_time;   //进程的睡眠时间
     
    	 //用于将系统中所有的进程连成一个双向循环链表, 其根是init_task
    	 struct task_struct *next_task, *prev_task;
    	 struct mm_struct *active_mm;
    	 struct list_head local_pages;      //指向本地页面      
    	 unsigned int allocation_order, nr_local_pages;
    	 struct linux_binfmt *binfmt;      //进程所运行的可执行文件的格式
    	 int exit_code, exit_signal;
    	 int pdeath_signal;           //父进程终止时向子进程发送的信号
    	 unsigned long personality;
    	 //Linux可以运行由其他UNIX操作系统生成的符合iBCS2标准的程序
    	 int did_exec:1; 
    	 pid_t pid;          //进程标识符,用来代表一个进程
    	 pid_t pgrp;        //进程组标识,表示进程所属的进程组
    	 pid_t tty_old_pgrp;      //进程控制终端所在的组标识
    	 pid_t session;             //进程的会话标识
    	 pid_t tgid;
    	 int leader;    //表示进程是否为会话主管
    	 struct task_struct *p_opptr,*p_pptr,*p_cptr,*p_ysptr,*p_osptr;
    	 struct list_head thread_group;          //线程链表
    	 struct task_struct *pidhash_next;    //用于将进程链入HASH表
    	 struct task_struct **pidhash_pprev;
    	 wait_queue_head_t wait_chldexit;      //供wait4()使用
    	 struct completion *vfork_done;         //供vfork() 使用
     
     
    	 unsigned long rt_priority;       //实时优先级,用它计算实时进程调度时的weight值
     
     
    	 //it_real_value,it_real_incr用于REAL定时器,单位为jiffies, 系统根据it_real_value
     
    	 //设置定时器的第一个终止时间. 在定时器到期时,向进程发送SIGALRM信号,同时根据
     
    	 //it_real_incr重置终止时间,it_prof_value,it_prof_incr用于Profile定时器,单位为jiffies。
     
    	 //当进程运行时,不管在何种状态下,每个tick都使it_prof_value值减一,当减到0时,向进程发送
     
    	 //信号SIGPROF,并根据it_prof_incr重置时间.
    	 //it_virt_value,it_virt_value用于Virtual定时器,单位为jiffies。当进程运行时,不管在何种
     
    	 //状态下,每个tick都使it_virt_value值减一当减到0时,向进程发送信号SIGVTALRM,根据
     
    	 //it_virt_incr重置初值。
     
    	 unsigned long it_real_value, it_prof_value, it_virt_value;
    	 unsigned long it_real_incr, it_prof_incr, it_virt_value;
    	 struct timer_list real_timer;        //指向实时定时器的指针
    	 struct tms times;                      //记录进程消耗的时间
    	 unsigned long start_time;          //进程创建的时间
     
    	 //记录进程在每个CPU上所消耗的用户态时间和核心态时间
    	 long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS]; 
     
     
    	 //内存缺页和交换信息:
     
    	 //min_flt, maj_flt累计进程的次缺页数(Copy on Write页和匿名页)和主缺页数(从映射文件或交换
     
    	 //设备读入的页面数); nswap记录进程累计换出的页面数,即写到交换设备上的页面数。
    	 //cmin_flt, cmaj_flt, cnswap记录本进程为祖先的所有子孙进程的累计次缺页数,主缺页数和换出页面数。
     
    	 //在父进程回收终止的子进程时,父进程会将子进程的这些信息累计到自己结构的这些域中
    	 unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
    	 int swappable:1; //表示进程的虚拟地址空间是否允许换出
    	 //进程认证信息
    	 //uid,gid为运行该进程的用户的用户标识符和组标识符,通常是进程创建者的uid,gid
     
    	 //euid,egid为有效uid,gid
    	 //fsuid,fsgid为文件系统uid,gid,这两个ID号通常与有效uid,gid相等,在检查对于文件
     
    	 //系统的访问权限时使用他们。
    	 //suid,sgid为备份uid,gid
    	 uid_t uid,euid,suid,fsuid;
    	 gid_t gid,egid,sgid,fsgid;
    	 int ngroups;                  //记录进程在多少个用户组中
    	 gid_t groups[NGROUPS];      //记录进程所在的组
     
    	 //进程的权能,分别是有效位集合,继承位集合,允许位集合
    	 kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
     
    	 int keep_capabilities:1;
    	 struct user_struct *user;
    	 struct rlimit rlim[RLIM_NLIMITS];    //与进程相关的资源限制信息
    	 unsigned short used_math;         //是否使用FPU
    	 char comm[16];                      //进程正在运行的可执行文件名
    	 int link_count, total_link_ count;  //文件系统信息
     
    	 //NULL if no tty 进程所在的控制终端,如果不需要控制终端,则该指针为空
    	 struct tty_struct *tty;
    	 unsigned int locks;
    	 //进程间通信信息
    	 struct sem_undo *semundo;       //进程在信号灯上的所有undo操作
    	 struct sem_queue *semsleeping;   //当进程因为信号灯操作而挂起时,他在该队列中记录等待的操作
    	 //进程的CPU状态,切换时,要保存到停止进程的task_struct中
    	 struct thread_struct thread;
    	 struct fs_struct *fs;           //文件系统信息
    	 struct files_struct *files;    //打开文件信息
    	 spinlock_t sigmask_lock;   //信号处理函数
    	 struct signal_struct *sig;   //信号处理函数
    	 sigset_t blocked;                //进程当前要阻塞的信号,每个信号对应一位
    	 struct sigpending pending;      //进程上是否有待处理的信号
    	 unsigned long sas_ss_sp;
    	 size_t sas_ss_size;
    	 int (*notifier)(void *priv);
    	 void *notifier_data;
    	 sigset_t *notifier_mask;
    	 u32 parent_exec_id;
    	 u32 self_exec_id;
     
    	 spinlock_t alloc_lock;
    	 void *journal_info;
    }

     

    更多相关内容
  • 进程控制块

    千次阅读 2022-04-04 08:39:05
    进程:加载到内存的程序,就叫做进程,系统中会存在大量进程,操作系统要对进程进行管理,操作系统管理进程的方式:先描述再组织,因此任何进程在形成的时候,操作系统要为该进程创建PCB(进程控制块)。 查看进程 ...


    进程:加载到内存的程序,就叫做进程,系统中会存在大量进程,操作系统要对进程进行管理,操作系统管理进程的方式:先描述再组织,因此任何进程在形成的时候,操作系统要为该进程创建PCB(进程控制块)。

    查看进程

    ps axj | head -1 &&  ps axj | grep "test"
    

    该命令可以查看grep关键字的进程状态
    在这里插入图片描述

    PCB内部构成

    标识符

    标示符(pid): 描述本进程的唯一标示符,用来区别其他进程。
    查看标识符函数:getpid,他的返回值类型为pid_t可以认为是整形变量
    使用方法:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    ppid

    ppid:父进程的标识符,获取父进程id函数为getppid()
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    正常在命令行上运行的程序的父进程都是0号进程bash

    状态

    PCB中会存储进程的状态信息,例如:任务状态,退出代码,退出信号等
    其中,程序中main函数的返回值可以被称为退出码,使用该命令可以查看最近执行进程的退出码
    在这里插入图片描述

    优先级

    cpu资源分配的先后顺序,就是指进程的优先权(priority)。 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用,可以改善系统性能。
    还可以把进程运行到指定的CPU上,这样一来,把不重要的进程安排到某个CPU,可以大大改善系统整体性能。

    查看优先级方式

    ps -l
    

    在这里插入图片描述
    其中:
    UID : 代表执行者的身份
    PID : 代表这个进程的代号
    PPID :代表这个进程是由哪个进程发展衍生而来的,亦即父进程的代号
    PRI :代表这个进程可被执行的优先级,其值越小越早被执行
    NI :代表这个进程的nice值

    优先级确定原理

    PRI即进程的优先级,通俗点说就是程序被CPU执行的先后顺序,此值越小,进程的优先级别越高 。NI就是所要说的nice值了,其表示进程可被执行的优先级的修正数值 PRI值越小越快被执行,那么加入nice值后,将会使得PRI变为:PRI(new)=PRI(old)+nice 这样,当nice值为负值的时候,那么该程序将会优先级值将变小,即其优先级会变高,则其越快被执行。所以,调整进程优先级,在Linux下,就是调整进程nice值 。
    nice其取值范围是-20至19,一共40个级别。

    调整优先级

    使用top命令来调整优先级
    进入top后按“r”–>输入进程PID–>输入nice值
    在这里插入图片描述

    nice值范围

    nice其取值范围是-20至19,一共40个级别。为什么要设置一个范围主要是因为优先级再怎么设置,也只能是一种相对的优先级,不能出现绝对的优先级,否则会出现很严重的进程饥饿问题。

    程序计数器

    程序计数器: 程序计数器有点类似与指针的作用,他指向程序中即将被执行的下一条指令的地址。

    内存指针

    内存指针: 包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针

    上下文数据

    上下文数据: 进程执行时处理器的寄存器中的数据。

    时间片

    时间片是指每个进程单次运行的时间。

    上下文数据

    在单CPU情况下,用户可以感受到多个进程在同时进行,本质是通过cpu的快速切换完成的。
    进程在运行期间是有切换的,可能存在大量临时数据,暂时在寄存器中保存,但是cpu只有一套寄存器。
    在进行进程切换的时候,寄存器中的临时数据会被保存到PCB中,再次运行的时候会将上次保存的临时数据再给寄存器,这就是保护上下文数据。
    通过上下文的保护和恢复我们可以感受到进程是被切换的。

    I/O状态信息

    I/O状态信息: 包括显示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表。

    记账信息

    记账信息: 可能包括处理器时间总和,使用的时钟数总和,时间限制,记账号等。
    操作系统中有一个调度模块,用来较为均衡的调度每个进程,更为公平的获得cpu资源。记账信息用来被调度器用来作为分配资源的依据。

    查看进程信息

    ls /proc/进程标识号
    

    查看当前进程的信息
    在这里插入图片描述

    展开全文
  • 进程控制块Task_struct

    千次阅读 2021-11-23 23:45:00
    文章目录进程的定义进程的创建进程的退出Task_struct 结构Task_struct 这里不讲进程的基本原理,重点描述下进程的数据结构(task_struct). 进程的定义 正在执行的程序 正在计算机上执行的程序实例 能分配给处理器并...

    这里不讲进程的基本原理,重点描述下进程的数据结构(task_struct).

    进程的定义

    • 正在执行的程序
    • 正在计算机上执行的程序实例
    • 能分配给处理器并有处理器执行的实体
    • 一组指令序列的执行、一个当前状态个相关的系统自愿集

    在进程执行时,任意给定一个时间,进程都可以唯一地被表征为以下元素:

    • 标识符: 跟这个进程相关的唯一标识符,用来区别其他进程
    • 状态: 进程的几个状态(等待、运行、停止)
    • 优先级: 进程的优先级
    • 程序计数器: 程序中即将被执行的下一条指令的地址。
    • 内存指针:包括程序代码和进程相关数据的指针,还有和其他进程共享的内存块的指针。
    • 上下文数据:进程执行时处理器的寄存器中的数据。
    • I/O状态信息:包括显示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表。
    • 记账信息:可能包括处理器时间总和,使用的时钟数总和,时间限制,记账号等。

    这些所有的信息都存放在一个进程的数据结构中task_struct, 也叫PCB。每个进程在内核中都有一个进程控制块(PCB)来维护进程相关的信息,Linux内核的进程控制块是task_struct结构体. 它在进程的运行时会被加载到RAM中。

    进程的创建

    unix中进程创建是通过内核系统调用fork()实现的,当一个进程产生fork()请求时,操作系统执行以下功能:

    1. 为新进程在进程表中分配一个空项;
    2. 为子进程赋予一个唯一的进程标识符
    3. 给进程分配空间,做一个父进程上下文的逻辑副本,不包括共享内存区;
    4. 初始化进程控制块
    5. 增加父进程拥有的所有文件的计数器
    6. 把子进程置为就绪态
    7. 向父进程返回子进程的进程号;对子进程返回0;
    8. 设置正确的连接,把新进程放置在就绪/挂起链表中。

    传统的UNIX中用于复制进程的系统调用是fork。 但它并不是Linux为此实现的唯一调用,实际上Linux实现了3个。

    1. fork是重量级调用, 因为它建立了父进程的一个完整副本, 然后作为子进程执行。为减少与该调用相关的工作量, Linux使用了写时复制(copy-on-write) 技术。
    2. vfork类似于fork, 但并不创建父进程数据的副本。 相反, 父子进程之间共享数据。这节省了大量CPU时间(如果一个进程操纵共享数据, 则另一个会自动注意到) 。
    3. clone产生线程, 可以对父子进程之间的共享、 复制进行精确控制。

    写时复制: 内核使用了写时复制(Copy-On-Write, COW) 技术, 以防止在fork执行时将父进程的所有数据复制到子进程。 在调用fork时, 内核通常对父进程的每个内存页, 都为子进程创建一个相同的副本。

    执行系统调用 : fork、 vfork和clone系统调用的入口点分别是sys_fork、 sys_vfork和sys_clone函数。 其定义依赖于具体的体系结构, 因为在用户空间和内核空间之间传递参数的方法因体系结构而异。

    do_fork实现 : 所有3个fork机制最终都调用kernel/fork.c中的do_fork(一个体系结构无关的函数) , 其代码流程如图所示 :

    在这里插入图片描述

    进程的退出

    进程必须用exit系统调用终止。 这使得内核有机会将该进程使用的资源释放回系统。 见kernel/exit.c------>do_exit。 简而言之,该函数的实现就是将各个引用计数器减1, 如果引用计数器归0而没有进程再使用对应的结构, 那么将相应的内存区域返还给内存管理模块;

    Task_struct 结构

    Linux内核涉及进程和程序的所有算法都围绕一个名为task_struct的数据结构建立, 该结构定义在include/linux/sched.h中。 这是系统中主要的一个结构:

    1. 进程的状态

      volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
      

      state的可能取值为:

      #define TASK_RUNNING        0//进程要么正在执行,要么准备执行
      #define TASK_INTERRUPTIBLE  1 //可中断的睡眠,可以通过一个信号唤醒
      #define TASK_UNINTERRUPTIBLE    2 //不可中断睡眠,不可以通过信号进行唤醒
      #define __TASK_STOPPED      4 //进程停止执行
      #define __TASK_TRACED       8 //进程被追踪
      /* in tsk->exit_state */ 
      #define EXIT_ZOMBIE     16 //僵尸状态的进程,表示进程被终止,但是父进程还没有获取它的终止信息,比如进程有没有执行完等信息。                     
      #define EXIT_DEAD       32 //进程的最终状态,进程死亡
      /* in tsk->state again */ 
      #define TASK_DEAD       64 //死亡
      #define TASK_WAKEKILL       128 //唤醒并杀死的进程
      #define TASK_WAKING     256 //唤醒进程
      
    2. 进程的唯一标识(pid)

      pid_t pid;//进程的唯一标识
      pid_t tgid;// 线程组的领头线程的pid成员的值
      

      在Linux系统中,一个线程组中的所有线程使用和该线程组的领头线程(该组中的第一个轻量级进程)相同的PID,并被存放在tgid成员中。只有线程组的领头线程的pid成员才会被设置为与tgid相同的值。注意,getpid()系统调用返回的是当前进程的tgid值而不是pid值。(线程是程序运行的最小单位,进程是程序运行的基本单位。)

    3. 进程的标记:

      unsigned int flags; //flags成员的可能取值如下
      
      #define PF_ALIGNWARN    0x00000001    /* Print alignment warning msgs */
                          /* Not implemented yet, only for 486*/
      #define PF_STARTING    0x00000002    /* being created */
      #define PF_EXITING    0x00000004    /* getting shut down */
      #define PF_EXITPIDONE    0x00000008    /* pi exit done on shut down */
      #define PF_VCPU        0x00000010    /* I'm a virtual CPU */
      #define PF_FORKNOEXEC    0x00000040    /* forked but didn't exec */
      #define PF_MCE_PROCESS  0x00000080      /* process policy on mce errors */
      #define PF_SUPERPRIV    0x00000100    /* used super-user privileges */
      #define PF_DUMPCORE    0x00000200    /* dumped core */
      #define PF_SIGNALED    0x00000400    /* killed by a signal */
      #define PF_MEMALLOC    0x00000800    /* Allocating memory */
      #define PF_FLUSHER    0x00001000    /* responsible for disk writeback */
      #define PF_USED_MATH    0x00002000    /* if unset the fpu must be initialized before use */
      #define PF_FREEZING    0x00004000    /* freeze in progress. do not account to load */
      #define PF_NOFREEZE    0x00008000    /* this thread should not be frozen */
      #define PF_FROZEN    0x00010000    /* frozen for system suspend */
      #define PF_FSTRANS    0x00020000    /* inside a filesystem transaction */
      #define PF_KSWAPD    0x00040000    /* I am kswapd */
      #define PF_OOM_ORIGIN    0x00080000    /* Allocating much memory to others */
      #define PF_LESS_THROTTLE 0x00100000    /* Throttle me less: I clean memory */
      #define PF_KTHREAD    0x00200000    /* I am a kernel thread */
      #define PF_RANDOMIZE    0x00400000    /* randomize virtual address space */
      #define PF_SWAPWRITE    0x00800000    /* Allowed to write to swap */
      #define PF_SPREAD_PAGE    0x01000000    /* Spread page cache over cpuset */
      #define PF_SPREAD_SLAB    0x02000000    /* Spread some slab caches over cpuset */
      #define PF_THREAD_BOUND    0x04000000    /* Thread bound to specific cpu */
      #define PF_MCE_EARLY    0x08000000      /* Early kill for mce process policy */
      #define PF_MEMPOLICY    0x10000000    /* Non-default NUMA mempolicy */
      #define PF_MUTEX_TESTER    0x20000000    /* Thread belongs to the rt mutex tester */
      #define PF_FREEZER_SKIP    0x40000000    /* Freezer should not count it as freezeable */
      #define PF_FREEZER_NOSIG 0x80000000    /* Freezer won't send signals to it */
      
    4. 进程之间的亲属关系:

      struct task_struct *real_parent; /* real parent process */
      struct task_struct *parent; /* recipient of SIGCHLD, wait4() reports */
      struct list_head children;    /* list of my children */
      struct list_head sibling;    /* linkage in my parent's children list */
      struct task_struct *group_leader;    /* threadgroup leader */
      

      在Linux系统中,所有进程之间都有着直接或间接地联系,每个进程都有其父进程,也可能有零个或多个子进程。拥有同一父进程的所有进程具有兄弟关系。

      real_parent 指向其父进程,如果创建它的父进程不再存在,则指向PID为1的init进程。
      parent ** 指向其父进程,当它终止时,必须向它的父进程发送信号。它的值通常与real_parent** 相同。

      **children **表示链表的头部,链表中的所有元素都是它的子进程(进程的子进程链表)。
      sibling 用于把当前进程插入到兄弟链表中(进程的兄弟链表)。
      group_leader指向其所在进程组的领头进程。

    5. 进程调度信息:

       int prio, static_prio, normal_prio;
       unsigned int rt_priority;
       const struct sched_class *sched_class;
       struct sched_entity se;
       struct sched_rt_entity rt;
       unsigned int policy;
      

      实时优先级范围是0到MAX_RT_PRIO-1(即99),而普通进程的静态优先级范围是从MAX_RT_PRIO到MAX_PRIO-1(即100到139)。值越大静态优先级越低。

      static_prio 用于保存静态优先级,可以通过nice系统调用来进行修改。
      rt_priority 用于保存实时优先级。
      normal_prio 的值取决于静态优先级和调度策略(进程的调度策略有:先来先服务,短作业优先、时间片轮转、高响应比优先等等的调度算法。
      prio 用于保存动态优先级。
      policy 表示进程的调度策略,目前主要有以下五种:

      #define SCHED_NORMAL        0//按照优先级进行调度(有些地方也说是CFS调度器)
      #define SCHED_FIFO        1//先进先出的调度算法      实时
      #define SCHED_RR        2//时间片轮转的调度算法      实时
      #define SCHED_BATCH        3//用于非交互的处理机消耗型的进程
      #define SCHED_IDLE        5//系统负载很低时的调度算法
      #define SCHED_RESET_ON_FORK     0x40000000
      

      **SCHED_NORMA**L用于普通进程,通过CFS调度器实现;
      **SCHED_BATCH**用于非交互的处理器消耗型进程;
      SCHED_IDLE是在系统负载很低时使用;
      SCHED_FIFO(先入先出调度算法)和
      SCHED_RR
      (轮流调度算法)都是实时调度策略.

    6. ptrace系统调用

      unsigned int ptrace;  
      struct list_head ptraced;  
      struct list_head ptrace_entry;  
      unsigned long ptrace_message;  
      siginfo_t *last_siginfo;      /* For ptrace use.  */  
      ifdef CONFIG_HAVE_HW_BREAKPOINT  
      atomic_t ptrace_bp_refcnt;  
      

      成员**ptrace**被设置为0时表示不需要被跟踪,它的可能取值如下:

      /* linux-4.4.4/include/linux/ptrace.h */  
      
      /*
       * Ptrace flags
       *
       * The owner ship rules for task->ptrace which holds the ptrace
       * flags is simple.  When a task is running it owns it's task->ptrace
       * flags.  When the a task is stopped the ptracer owns task->ptrace.
       */
      
      #define PT_SEIZED	0x00010000	/* SEIZE used, enable new behavior */
      #define PT_PTRACED	0x00000001
      #define PT_DTRACE	0x00000002	/* delayed trace (used on m68k, i386) */
      #define PT_PTRACE_CAP	0x00000004	/* ptracer can follow suid-exec */
      
      #define PT_OPT_FLAG_SHIFT	3
      /* PT_TRACE_* event enable flags */
      #define PT_EVENT_FLAG(event)	(1 << (PT_OPT_FLAG_SHIFT + (event)))
      #define PT_TRACESYSGOOD		PT_EVENT_FLAG(0)
      #define PT_TRACE_FORK		PT_EVENT_FLAG(PTRACE_EVENT_FORK)
      #define PT_TRACE_VFORK		PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
      #define PT_TRACE_CLONE		PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
      #define PT_TRACE_EXEC		PT_EVENT_FLAG(PTRACE_EVENT_EXEC)
      #define PT_TRACE_VFORK_DONE	PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
      #define PT_TRACE_EXIT		PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
      #define PT_TRACE_SECCOMP	PT_EVENT_FLAG(PTRACE_EVENT_SECCOMP)
      
      #define PT_EXITKILL		(PTRACE_O_EXITKILL << PT_OPT_FLAG_SHIFT)
      #define PT_SUSPEND_SECCOMP	(PTRACE_O_SUSPEND_SECCOMP << PT_OPT_FLAG_SHIFT)
      
    7. 时间数据成员

      一个进程从创建到终止叫做该进程的生存期,进程在其生存期内使用CPU时间,内核都需要进行记录,进程耗费的时间分为两部分,一部分是用户模式下耗费的时间,一部分是在系统模式下耗费的时间

      	cputime_t utime, stime, utimescaled, stimescaled;
          cputime_t gtime;
          cputime_t prev_utime, prev_stime;//记录当前的运行时间(用户态和内核态)
          unsigned long nvcsw, nivcsw; //自愿/非自愿上下文切换计数
          struct timespec start_time;  //进程的开始执行时间    
          struct timespec real_start_time;  //进程真正的开始执行时间
          unsigned long min_flt, maj_flt;
          struct task_cputime cputime_expires;//cpu执行的有效时间
          struct list_head cpu_timers[3];//用来统计进程或进程组被处理器追踪的时间
          struct list_head run_list;
          unsigned long timeout;//当前已使用的时间(与开始时间的差值)
          unsigned int time_slice;//进程的时间片的大小
          int nr_cpus_allowed;
      
    8. 信号处理信息

      	struct signal_struct *signal;//指向进程信号描述符
          struct sighand_struct *sighand;//指向进程信号处理程序描述符
          sigset_t blocked, real_blocked;//阻塞信号的掩码
          sigset_t saved_sigmask;    /* restored if set_restore_sigmask() was used */
          struct sigpending pending;//进程上还需要处理的信号
          unsigned long sas_ss_sp;//信号处理程序备用堆栈的地址
          size_t sas_ss_size;//信号处理程序的堆栈的地址
      
    9. 文件系统信息

      /* filesystem information */
          struct fs_struct *fs;//文件系统的信息的指针
      /* open file information */
          struct files_struct *files;//打开文件的信息指针
      

      Task_struct

      /* linux-4.4.4/include/linux/sched.h */  
      struct task_struct {
          //进程的状态 -1:就绪态 0:运行态 >0:停止态
      	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
      	void *stack;     //指向内核栈指针
      	atomic_t usage;  //有几个进程在使用此结构
      	unsigned int flags;	/* per process flags, defined below */
      	unsigned int ptrace;  //ptrace 系统调用,跟踪进程运行
      
      #ifdef CONFIG_SMP      //条件编译多处理器
      	struct llist_node wake_entry;
      	int on_cpu;
      	unsigned int wakee_flips;
      	unsigned long wakee_flip_decay_ts;
      	struct task_struct *last_wakee;
      
      	int wake_cpu;
      #endif
      	int on_rq;       //运行队列和进程调试相关程序
      
      	int prio, static_prio, normal_prio;   
      	unsigned int rt_priority;       // 优先级
      	const struct sched_class *sched_class;
      	struct sched_entity se;
      	struct sched_rt_entity rt;
      #ifdef CONFIG_CGROUP_SCHED   //结构体链表
      	struct task_group *sched_task_group;
      #endif
      	struct sched_dl_entity dl;
      
      #ifdef CONFIG_PREEMPT_NOTIFIERS
      	/* list of struct preempt_notifier: */
      	struct hlist_head preempt_notifiers;
      #endif
      
      #ifdef CONFIG_BLK_DEV_IO_TRACE    //块设备IO的跟踪工具
      	unsigned int btrace_seq;
      #endif
      
      	unsigned int policy;
      	int nr_cpus_allowed;
      	cpumask_t cpus_allowed;
      
      #ifdef CONFIG_PREEMPT_RCU   //RCU同步原语
      	int rcu_read_lock_nesting;
      	union rcu_special rcu_read_unlock_special;
      	struct list_head rcu_node_entry;
      	struct rcu_node *rcu_blocked_node;
      #endif /* #ifdef CONFIG_PREEMPT_RCU */
      #ifdef CONFIG_TASKS_RCU
      	unsigned long rcu_tasks_nvcsw;
      	bool rcu_tasks_holdout;
      	struct list_head rcu_tasks_holdout_list;
      	int rcu_tasks_idle_cpu;
      #endif /* #ifdef CONFIG_TASKS_RCU */
      
      #ifdef CONFIG_SCHED_INFO
      	struct sched_info sched_info;
      #endif
      
      	struct list_head tasks;
      #ifdef CONFIG_SMP
      	struct plist_node pushable_tasks;
      	struct rb_node pushable_dl_tasks;
      #endif
      
      	struct mm_struct *mm, *active_mm;  //管理进程的地址空间,每个进程都有独立的地址空间4G,32位X86
      	/* per-thread vma caching */
      	u32 vmacache_seqnum;
      	struct vm_area_struct *vmacache[VMACACHE_SIZE];
      #if defined(SPLIT_RSS_COUNTING)
      	struct task_rss_stat	rss_stat;
      #endif
      /* task state */   //进程状态参数
      	int exit_state;
      	int exit_code, exit_signal;
      	int pdeath_signal;  /*  The signal sent when the parent dies  */ 
      	unsigned long jobctl;	/* JOBCTL_*, siglock protected */
      
      	/* Used for emulating ABI behavior of previous Linux versions */
      	unsigned int personality;
      
      	/* scheduler bits, serialized by scheduler locks */
      	unsigned sched_reset_on_fork:1;
      	unsigned sched_contributes_to_load:1;
      	unsigned sched_migrated:1;
      	unsigned :0; /* force alignment to the next boundary */
      
      	/* unserialized, strictly 'current' */
      	unsigned in_execve:1; /* bit to tell LSMs we're in execve */
      	unsigned in_iowait:1;
      #ifdef CONFIG_MEMCG
      	unsigned memcg_may_oom:1;
      #endif
      #ifdef CONFIG_MEMCG_KMEM
      	unsigned memcg_kmem_skip_account:1;
      #endif
      #ifdef CONFIG_COMPAT_BRK
      	unsigned brk_randomized:1;
      #endif
      
      	unsigned long atomic_flags; /* Flags needing atomic access. */
      
      	struct restart_block restart_block;
      
      	pid_t pid;
      	pid_t tgid;
      
      #ifdef CONFIG_CC_STACKPROTECTOR  //防止内核堆栈溢出
      	/* Canary value for the -fstack-protector gcc feature */
      	unsigned long stack_canary;
      #endif
      	/*
      	 * pointers to (original) parent process, youngest child, younger sibling,
      	 * older sibling, respectively.  (p->father can be replaced with
      	 * p->real_parent->pid)
      	 */
      	struct task_struct __rcu *real_parent; /* real parent process */
      	struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
      	/*
      	 * children/sibling forms the list of my natural children
      	 */
      	struct list_head children;	/* list of my children */
      	struct list_head sibling;	/* linkage in my parent's children list */
      	struct task_struct *group_leader;	/* threadgroup leader */
      
      	/*
      	 * ptraced is the list of tasks this task is using ptrace on.
      	 * This includes both natural children and PTRACE_ATTACH targets.
      	 * p->ptrace_entry is p's link on the p->parent->ptraced list.
      	 */
      	struct list_head ptraced;
      	struct list_head ptrace_entry;
      
      	/* PID/PID hash table linkage. */
      	struct pid_link pids[PIDTYPE_MAX];
      	struct list_head thread_group;
      	struct list_head thread_node;
      // do_fork()函数
      	struct completion *vfork_done;		/* for vfork() */
      	int __user *set_child_tid;		/* CLONE_CHILD_SETTID */
      	int __user *clear_child_tid;		/* CLONE_CHILD_CLEARTID */
      
      	cputime_t utime, stime, utimescaled, stimescaled; //utime 用户态下的执行时间, stime内核态下的执行时间
      	cputime_t gtime;
      	struct prev_cputime prev_cputime;
      #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
      	seqlock_t vtime_seqlock;
      	unsigned long long vtime_snap;
      	enum {
      		VTIME_SLEEPING = 0,
      		VTIME_USER,
      		VTIME_SYS,
      	} vtime_snap_whence;
      #endif
      	unsigned long nvcsw, nivcsw; /* context switch counts */
      	u64 start_time;		/* monotonic time in nsec */
      	u64 real_start_time;	/* boot based time in nsec */
      /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
      	unsigned long min_flt, maj_flt;
      
      	struct task_cputime cputime_expires;
      	struct list_head cpu_timers[3];
      
      /* process credentials */
      	const struct cred __rcu *real_cred; /* objective and real subjective task
      					 * credentials (COW) */
      	const struct cred __rcu *cred;	/* effective (overridable) subjective task
      					 * credentials (COW) */
      	char comm[TASK_COMM_LEN]; /* executable name excluding path
      				     - access with [gs]et_task_comm (which lock
      				       it with task_lock())
      				     - initialized normally by setup_new_exec */
      /* file system info */
      	struct nameidata *nameidata;
      #ifdef CONFIG_SYSVIPC
      /* ipc stuff */
      	struct sysv_sem sysvsem;
      	struct sysv_shm sysvshm;
      #endif
      #ifdef CONFIG_DETECT_HUNG_TASK
      /* hung task detection */
      	unsigned long last_switch_count;
      #endif
      /* filesystem information */
      	struct fs_struct *fs;
      /* open file information */
      	struct files_struct *files;
      /* namespaces */
      	struct nsproxy *nsproxy;
      /* signal handlers */
      	struct signal_struct *signal;  //信号
      	struct sighand_struct *sighand;
      
      	sigset_t blocked, real_blocked;
      	sigset_t saved_sigmask;	/* restored if set_restore_sigmask() was used */
      	struct sigpending pending;
      
      	unsigned long sas_ss_sp;
      	size_t sas_ss_size;
      
      	struct callback_head *task_works;
      
      	struct audit_context *audit_context;
      #ifdef CONFIG_AUDITSYSCALL
      	kuid_t loginuid;
      	unsigned int sessionid;
      #endif
      	struct seccomp seccomp;
      
      /* Thread group tracking */
         	u32 parent_exec_id;
         	u32 self_exec_id;
      /* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
       * mempolicy */
      	spinlock_t alloc_lock;
      
      	/* Protection of the PI data structures: */
      	raw_spinlock_t pi_lock;
      
      	struct wake_q_node wake_q;
      
      #ifdef CONFIG_RT_MUTEXES
      	/* PI waiters blocked on a rt_mutex held by this task */
      	struct rb_root pi_waiters;
      	struct rb_node *pi_waiters_leftmost;
      	/* Deadlock detection and priority inheritance handling */
      	struct rt_mutex_waiter *pi_blocked_on;
      #endif
      
      #ifdef CONFIG_DEBUG_MUTEXES
      	/* mutex deadlock detection */
      	struct mutex_waiter *blocked_on;
      #endif
      #ifdef CONFIG_TRACE_IRQFLAGS
      	unsigned int irq_events;
      	unsigned long hardirq_enable_ip;
      	unsigned long hardirq_disable_ip;
      	unsigned int hardirq_enable_event;
      	unsigned int hardirq_disable_event;
      	int hardirqs_enabled;
      	int hardirq_context;
      	unsigned long softirq_disable_ip;
      	unsigned long softirq_enable_ip;
      	unsigned int softirq_disable_event;
      	unsigned int softirq_enable_event;
      	int softirqs_enabled;
      	int softirq_context;
      #endif
      #ifdef CONFIG_LOCKDEP
      # define MAX_LOCK_DEPTH 48UL
      	u64 curr_chain_key;
      	int lockdep_depth;
      	unsigned int lockdep_recursion;
      	struct held_lock held_locks[MAX_LOCK_DEPTH];
      	gfp_t lockdep_reclaim_gfp;
      #endif
      
      /* journalling filesystem info */
      	void *journal_info;  //日志文件信息
      
      /* stacked block device info */
      	struct bio_list *bio_list;
      
      #ifdef CONFIG_BLOCK
      /* stack plugging */
      	struct blk_plug *plug;
      #endif
      
      /* VM state */     //虚拟内存状态参数
      	struct reclaim_state *reclaim_state;
      
      	struct backing_dev_info *backing_dev_info;
      
      	struct io_context *io_context;  // io调度器所用的信息
      
      	unsigned long ptrace_message;
      	siginfo_t *last_siginfo; /* For ptrace use.  */
      	struct task_io_accounting ioac;
      #if defined(CONFIG_TASK_XACCT)
      	u64 acct_rss_mem1;	/* accumulated rss usage */
      	u64 acct_vm_mem1;	/* accumulated virtual memory usage */
      	cputime_t acct_timexpd;	/* stime + utime since last update */
      #endif
      #ifdef CONFIG_CPUSETS
      	nodemask_t mems_allowed;	/* Protected by alloc_lock */
      	seqcount_t mems_allowed_seq;	/* Seqence no to catch updates */
      	int cpuset_mem_spread_rotor;
      	int cpuset_slab_spread_rotor;
      #endif
      #ifdef CONFIG_CGROUPS
      	/* Control Group info protected by css_set_lock */
      	struct css_set __rcu *cgroups;
      	/* cg_list protected by css_set_lock and tsk->alloc_lock */
      	struct list_head cg_list;
      #endif
      #ifdef CONFIG_FUTEX   //futex同步机制
      	struct robust_list_head __user *robust_list;
      #ifdef CONFIG_COMPAT
      	struct compat_robust_list_head __user *compat_robust_list;
      #endif
      	struct list_head pi_state_list;
      	struct futex_pi_state *pi_state_cache;
      #endif
      #ifdef CONFIG_PERF_EVENTS
      	struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
      	struct mutex perf_event_mutex;
      	struct list_head perf_event_list;
      #endif
      #ifdef CONFIG_DEBUG_PREEMPT
      	unsigned long preempt_disable_ip;
      #endif
      #ifdef CONFIG_NUMA
      	struct mempolicy *mempolicy;	/* Protected by alloc_lock */
      	short il_next;
      	short pref_node_fork;
      #endif
      #ifdef CONFIG_NUMA_BALANCING
      	int numa_scan_seq;
      	unsigned int numa_scan_period;
      	unsigned int numa_scan_period_max;
      	int numa_preferred_nid;
      	unsigned long numa_migrate_retry;
      	u64 node_stamp;			/* migration stamp  */
      	u64 last_task_numa_placement;
      	u64 last_sum_exec_runtime;
      	struct callback_head numa_work;
      
      	struct list_head numa_entry;
      	struct numa_group *numa_group;
      
      	/*
      	 * numa_faults is an array split into four regions:
      	 * faults_memory, faults_cpu, faults_memory_buffer, faults_cpu_buffer
      	 * in this precise order.
      	 *
      	 * faults_memory: Exponential decaying average of faults on a per-node
      	 * basis. Scheduling placement decisions are made based on these
      	 * counts. The values remain static for the duration of a PTE scan.
      	 * faults_cpu: Track the nodes the process was running on when a NUMA
      	 * hinting fault was incurred.
      	 * faults_memory_buffer and faults_cpu_buffer: Record faults per node
      	 * during the current scan window. When the scan completes, the counts
      	 * in faults_memory and faults_cpu decay and these values are copied.
      	 */
      	unsigned long *numa_faults;
      	unsigned long total_numa_faults;
      
      	/*
      	 * numa_faults_locality tracks if faults recorded during the last
      	 * scan window were remote/local or failed to migrate. The task scan
      	 * period is adapted based on the locality of the faults with different
      	 * weights depending on whether they were shared or private faults
      	 */
      	unsigned long numa_faults_locality[3];
      
      	unsigned long numa_pages_migrated;
      #endif /* CONFIG_NUMA_BALANCING */
      
      #ifdef CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH
      	struct tlbflush_unmap_batch tlb_ubc;
      #endif
      
      	struct rcu_head rcu;       //rcu链表
      
      	/*
      	 * cache last used pipe for splice
      	 */
      	struct pipe_inode_info *splice_pipe;
      
      	struct page_frag task_frag;
      
      #ifdef	CONFIG_TASK_DELAY_ACCT
      	struct task_delay_info *delays;
      #endif
      #ifdef CONFIG_FAULT_INJECTION
      	int make_it_fail;
      #endif
      	/*
      	 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
      	 * balance_dirty_pages() for some dirty throttling pause
      	 */
      	int nr_dirtied;
      	int nr_dirtied_pause;
      	unsigned long dirty_paused_when; /* start of a write-and-pause period */
      
      #ifdef CONFIG_LATENCYTOP
      	int latency_record_count;
      	struct latency_record latency_record[LT_SAVECOUNT];
      #endif
      	/*
      	 * time slack values; these are used to round up poll() and
      	 * select() etc timeout values. These are in nanoseconds.
      	 */
      	unsigned long timer_slack_ns;
      	unsigned long default_timer_slack_ns;
      
      #ifdef CONFIG_KASAN
      	unsigned int kasan_depth;
      #endif
      #ifdef CONFIG_FUNCTION_GRAPH_TRACER
      	/* Index of current stored address in ret_stack */
      	int curr_ret_stack;
      	/* Stack of return addresses for return function tracing */
      	struct ftrace_ret_stack	*ret_stack;
      	/* time stamp for last schedule */
      	unsigned long long ftrace_timestamp;
      	/*
      	 * Number of functions that haven't been traced
      	 * because of depth overrun.
      	 */
      	atomic_t trace_overrun;
      	/* Pause for the tracing */
      	atomic_t tracing_graph_pause;
      #endif
      #ifdef CONFIG_TRACING
      	/* state flags for use by tracers */
      	unsigned long trace;
      	/* bitmask and counter of trace recursion */
      	unsigned long trace_recursion;
      #endif /* CONFIG_TRACING */
      #ifdef CONFIG_MEMCG
      	struct mem_cgroup *memcg_in_oom;
      	gfp_t memcg_oom_gfp_mask;
      	int memcg_oom_order;
      
      	/* number of pages to reclaim on returning to userland */
      	unsigned int memcg_nr_pages_over_high;
      #endif
      #ifdef CONFIG_UPROBES
      	struct uprobe_task *utask;
      #endif
      #if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
      	unsigned int	sequential_io;
      	unsigned int	sequential_io_avg;
      #endif
      #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
      	unsigned long	task_state_change;
      #endif
      	int pagefault_disabled;
      /* CPU-specific state of this task */
      	struct thread_struct thread;
      /*
       * WARNING: on x86, 'thread_struct' contains a variable-sized
       * structure.  It *MUST* be at the end of 'task_struct'.
       *
       * Do not put anything below here!
       */
      };
      
    展开全文
  • 进程控制块PCB

    2021-09-28 21:53:00
    1. 什么是流量控制 2. 操作系统缓冲区和滑动窗口的关系 发送窗口和接收窗口中所存放的字节数,都是存放在操作系统内存缓冲区中的。

    1. 什么是进程控制块PCB

    • 操作系统为了执行进程间的切换,会维护一张表格,这张表就是进程表(process table)。每一个进程都会占用一个进程表项。这个表项就是进程控制块
    • 进程控制块中包含了进程状态的重要信息。包括程序计数器、堆栈指针、内存分配状况、所打开的文件列表、账号与调度信息,以及其他在进程由运行太转换到就绪态或阻塞态时所必须要保存的信息,从而保证了该进程随后能再次启动还能从上次执行的地方继续执行。

    2. 进程控制块中的包含了哪些信息

    • 进程管理相关
      • 进程id
      • 描述虚拟地址空间的信息(页表)
      • 进程调度信息
        • 进程的状态:有就绪,运行,挂起,停止等状态
        • 进程的优先级信息
        • 进程调度所需的其他信息:和相应的进程调度算法有关,如进程等待CPU的时间总和,进程已经执行的时间总和。
      • 进程控制信息
        • 程序和数据的地址:进程程序和数据所在的内存和外存地址,以便调度进程时使用
        • 进程同步和通信机制
        • 资源清单:除了CPU之外进程所需要的全部资源以及已经分配到该进程的资源清单。
        • 链接指针:该进程所在队列的下一个进程的PCB首地址
      • CPU状态信息:进程切换时需要保存和恢复的一些CPU寄存器信息
        • 通用寄存器:可以被用户程序进程访问,用于暂存信息
        • 指令计数器:存放者当前进程要访问的下一条指令地址
        • 程序状态字PSW:含有状态信息
    • 存储管理相关
      • 代码段指针
      • 数据段指针
      • 堆栈段指针
    • 文件管理相关
      • 当前工作目录
      • 文件描述符表,包含多个执行file结构体的指针
      • 用户id和组id

    3. 进程控制块的组织方式

    • 线性表方式:不论进程的状态如何,将所有的PCB连续地存放在内存的系统区。这种方式适用于系统中进程数目不多的情况
    • 索引表方式:该方式时线性表的改进,系统按照进程的状态分别建立就绪索引表,阻塞索引表等
    • 链接表方式:系统按照进程的状态将进程的PCB组成队列,从而形成就绪队列,阻塞队列和运行队列等。

     

     

     

    展开全文
  • 进程概念与PCB详解(新手必看)
  • 进程控制块 PCB1

    2022-08-08 22:47:57
    进程控制块 PCB1
  • 主要讲解进程控制块(pcb)的定义和描述,适合想了解操作系统的PCB
  • 进程和进程控制块(PCB)

    千次阅读 2019-11-14 08:53:11
    进程控制块 进程概念 是程序的一次执行过程,是系统进行资源分配和处理机调度的一个独立单位。 是一个运行中程序的描述,通过描述信息中的内存指针可以找到内存中运行的程序代码及数据,并且通过上下文数据可以...
  • 1.进程实体包括:程序段、数据段、进程控制块PCB; 2.进程控制块是操作系统中最重要的数据结构。 PCB是用来记录进程信息的。比如说当CPU执行某程序的时候,当停止执行一段时间后,重新执行的时候如何让他从断的那里...
  • PCB(进程控制块)讲解

    万次阅读 多人点赞 2019-05-04 22:34:45
    PCB:进程控制块,实际是一个结构体,放在sched.h文件中,Linux下可以通过whereis sched.h命令查看具体路径 该结构体主要包含: 1.进程id 2.进程的状态:就绪、运行、挂起、停止 3.进程切换时需要保存和恢复的一些...
  • 操作系统知识整理 - 进程控制块

    千次阅读 2018-12-29 21:01:08
    进程的静态描述由3部分组成:进程控制块(Process Control Block,PCB),有关程序段和该程序段操作的数据结构集。 PCB是系统感知进程的唯一实体,用于描述进程的当前情况以及管理进程运行的全部信息,是操作系统中...
  • 进程及进程控制块

    千次阅读 2017-04-15 17:19:21
    进程是程序的一个执行实例,是一个正在执行的程序。能分配处理器并由处理器执行的实体。  在一个系统上可以同时运行多个程序。并发运行,一个进程的指令和另一个进程的指令是交错执行的。  进程的两个基本元素是...
  • 为了便于系统控制和描述进程的活动过程,在操作系统核心中定义了一个专门的数据结构,称为进程控制块( Process Control block,PCB)。 操作系统利用PCB来描述进程的基本情况以及进程的运行变化过程。PCB是进程存在的...
  • 操作系统:进程控制块PCB

    千次阅读 2020-12-07 15:27:06
    对于进程控制块PCB的作用、包含的信息以及组织方式进行了相应的介绍!
  • 进程控制块PCB的组织方式.pptx
  • 进程控制块PCB(Process Control Block),它是进程实体的一部分,是操作系统中最重要的记录型数据结构。PCB 中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息。进程控制块的作用是使一个在...
  • 进程模拟和调度,对进程控制块进行初始化,然后进行封装,调度。
  • 操作系统-进程概念与进程控制块

    千次阅读 2018-03-13 15:58:49
    进程 在学习操作系统时,对于进程我们经常能看到如下几个定义: 一个正在执行的程序。 一个正在计算机上执行的程序实例。 能分配给处理器并由处理器执行的实体 由一组执行的指令,一个当前状态和一组相关的系统...
  • 【OS笔记 7】进程控制块PCB详解

    千次阅读 2020-08-16 20:40:12
    PCB是用以记录与进程相关信息的主存区,是进程存在的唯一标志。 二、PCB中的信息 1. 进程标识符 作用: 用于唯一地标识一个进程进程本身:外标识、内部标识 • 家族信息:父进程、子进程信息 2. 处理机状态 ...
  • 进程控制块(PCB)的结构

    千次阅读 2018-04-07 21:46:12
    进程控制块 PCB (Process Control Block): 存放进程的管理和控制信息的数据结构称为进程控制块。它是进程管理和控制的最重要的数据结构,每一个进程均有一个PCB,在创建进程时,建立PCB,伴随进程运行的全过程,...
  • 进程控制块、进程上下文

    千次阅读 2018-08-14 07:58:24
    进程控制块 为了描述和控制进程的运行,系统为每个进程定义了一个数据结构——进程控制块(PCB)。 它是进程重要的组成部分,它记录了操作系统所需的、用于描述进程的当前状态和控制进程的全部信息。 操作系统...
  • 进程控制块及其作用、组织方式

    千次阅读 2018-05-30 16:30:03
    进程控制块中的信息1) 进程标识符(1) 内部标识符 操作系统为每一个进程赋予的唯一数字标识符,系统使用 (2) 外部标识符 有创建者提供,通常有字母与数字组成,往往是由用户(进程)在访问该进程时使用。描述进程的...
  • 进程=程序段+数据段+进程控制块(PCB) PCB(进程控制块): 操作系统根据PCB对并发执行的进程进行控制和管理 通过PCB来感知进程的存在 一个进程仅有一个进程控制块 PCB组成: 标识符:与进程相关的唯一标识符...
  • 为了使程序能够并发执行,并且对程序加以描述及控制,引入了进程的概念。 2. 进程的定义 进程进程实体的运行过程,进程实体由程序段、相关的数据段和PCB三部分构成。在没有引入线程的操作系统中,进程是系统...
  • 在广义上,所有的进程信息被放在一个叫做进程控制块的数据结构中,可以理解为进程属性 的集合。 进程控制块 每个进程在内核中都有一个进程控制块(PCB)来维护进程相关的信息,Linux内核的 进程控制块是task_struct...
  • 进程控制块(PCB)是系统为了管理进程设置的一个专门的数据结构。系统用它来记录进程的外部特征,描述进程的运动变化过程。同时,系统可以利用PCB来控制和管理进程,所以说,PCB(进程控制块)是系统感知进程存在的...
  • 进程控制块 PCB 概述 出现的原因:为了使参与并发执行的每个程序(含数据)都能独立地运行,在操作系统中必须为之配置一个专门的数据结构,称之为进程控制块(PCB)。 作用:PCB是描述进程基本情况和运行状态,控制...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 346,361
精华内容 138,544
关键字:

进程控制块

友情链接: maccms.zip