进程控制块 与 task_struct

http://blog.csdn.net/qq_26768741/article/details/54348586

  1. struct task_struct {
  2. volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
  3. struct thread_info *thread_info;
  4. atomic_t usage;
  5. unsigned long flags;    /* per process flags, defined below */
  6. unsigned long ptrace;
  7. int lock_depth;     /* Lock depth */
  8. int prio, static_prio;
  9. struct list_head run_list;
  10. prio_array_t *array;
  11. unsigned long sleep_avg;
  12. long interactive_credit;
  13. unsigned long long timestamp;
  14. int activated;
  15. unsigned long policy;
  16. cpumask_t cpus_allowed;
  17. unsigned int time_slice, first_time_slice;
  18. struct list_head tasks;
  19. struct list_head ptrace_children;
  20. struct list_head ptrace_list;
  21. struct mm_struct *mm, *active_mm;
  22. /* task state */
  23. struct linux_binfmt *binfmt;
  24. int exit_code, exit_signal;
  25. int pdeath_signal;  /*  The signal sent when the parent dies  */
  26. /* ??? */
  27. unsigned long personality;
  28. int did_exec:1;
  29. pid_t pid;
  30. pid_t __pgrp;       /* Accessed via process_group() */
  31. pid_t tty_old_pgrp;
  32. pid_t session;
  33. pid_t tgid;
  34. /* boolean value for session group leader */
  35. int leader;
  36. /*
  37. * pointers to (original) parent process, youngest child, younger sibling,
  38. * older sibling, respectively.  (p->father can be replaced with
  39. * p->parent->pid)
  40. */
  41. struct task_struct *real_parent; /* real parent process (when being debugged) */
  42. struct task_struct *parent; /* parent process */
  43. struct list_head children;  /* list of my children */
  44. struct list_head sibling;   /* linkage in my parent‘s children list */
  45. struct task_struct *group_leader;   /* threadgroup leader */
  46. /* PID/PID hash table linkage. */
  47. struct pid_link pids[PIDTYPE_MAX];
  48. wait_queue_head_t wait_chldexit;    /* for wait4() */
  49. struct completion *vfork_done;      /* for vfork() */
  50. int __user *set_child_tid;      /* CLONE_CHILD_SETTID */
  51. int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */
  52. unsigned long rt_priority;
  53. unsigned long it_real_value, it_prof_value, it_virt_value;
  54. unsigned long it_real_incr, it_prof_incr, it_virt_incr;
  55. struct timer_list real_timer;
  56. struct list_head posix_timers; /* POSIX.1b Interval Timers */
  57. unsigned long utime, stime, cutime, cstime;
  58. unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw; /* context switch counts */
  59. u64 start_time;
  60. /* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
  61. unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
  62. /* process credentials */
  63. uid_t uid,euid,suid,fsuid;
  64. gid_t gid,egid,sgid,fsgid;
  65. int ngroups;
  66. gid_t   groups[NGROUPS];
  67. kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
  68. int keep_capabilities:1;
  69. struct user_struct *user;
  70. /* limits */
  71. struct rlimit rlim[RLIM_NLIMITS];
  72. unsigned short used_math;
  73. char comm[16];
  74. /* file system info */
  75. int link_count, total_link_count;
  76. struct tty_struct *tty; /* NULL if no tty */
  77. /* ipc stuff */
  78. struct sysv_sem sysvsem;
  79. /* CPU-specific state of this task */
  80. struct thread_struct thread;
  81. /* filesystem information */
  82. struct fs_struct *fs;
  83. /* open file information */
  84. struct files_struct *files;
  85. /* namespace */
  86. struct namespace *namespace;
  87. /* signal handlers */
  88. struct signal_struct *signal;
  89. struct sighand_struct *sighand;
  90. sigset_t blocked, real_blocked;
  91. struct sigpending pending;
  92. unsigned long sas_ss_sp;
  93. size_t sas_ss_size;
  94. int (*notifier)(void *priv);
  95. void *notifier_data;
  96. sigset_t *notifier_mask;
  97. void *security;
  98. /* Thread group tracking */
  99. u32 parent_exec_id;
  100. u32 self_exec_id;
  101. /* Protection of (de-)allocation: mm, files, fs, tty */
  102. spinlock_t alloc_lock;
  103. /* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
  104. spinlock_t proc_lock;
  105. /* context-switch lock */
  106. spinlock_t switch_lock;
  107. /* journalling filesystem info */
  108. void *journal_info;
  109. /* VM state */
  110. struct reclaim_state *reclaim_state;
  111. struct dentry *proc_dentry;
  112. struct backing_dev_info *backing_dev_info;
  113. struct io_context *io_context;
  114. unsigned long ptrace_message;
  115. siginfo_t *last_siginfo; /* For ptrace use.  */
  116. };
时间: 2024-09-30 14:10:52

进程控制块 与 task_struct的相关文章

进程控制块的task_struct结构

>进程控制块 在linux中进程信息存放在叫做进程控制块的数据结构中,每个进程在内核中都有?个进程控制块(PCB)来维护进程相关的信息,Linux内核的 进程控制块是task_struct结构体.在Linux中,这个结构叫做task_struct.      task_struct是Linux内核的一种数据结构,它会被装载到RAM?并且包含着进程的信息. 每个进程都把它的信息放在 task_struct 这个数据结构?, task_struct 包含了这些内容: >>>>&g

进程控制块(PCB)

进程控制块PCB 我们知道,每个进程在内核中都有一个进程控制块(PCB)来维护进程相关的信息,Linux内核的进程控制块是task_struct结构体. /usr/src/linux-headers-3.16.0-30/include/linux/sched.h文件中可以查看struct task_struct 结构体定义.其内部成员有很多,我们重点掌握以下部分即可: * 进程id.系统中每个进程有唯一的id,在C语言中用pid_t类型表示,其实就是一个非负整数. * 进程的状态,有就绪.运行.

Linux下的进程控制块—task_struct

Linux下的进程控制块 进程:程序的执行就是进程.也可以把进程看成一个独立的程序,在内存中有其对应的代码空间和数据空间,一个进程所拥有的数据和代码只属于自己.进程是资源分配的基本单位,也是调度运行的基本单位. 进程控制块(PCB)(系统为了管理进程设置的一个专门的数据结构,用它来记录进程的外部特征,描述进程的运动变化过程.系统利用PCB来控制 和管理进程,所以PCB是系统感知进程存在的唯一标志.进程与PCB是一 一对应的).是进程存在和运行的唯一标志,在Linux中用task_struct这个

PCB(进程控制块)--‘task_struct’

在介绍PCB(进程控制块)前,先实现一个'进度条',然后根据编写的程序,分析PCB的具体实现原理.'进度条'的功能是能够在一行中显示出来,同时进度条中有动态的增长变化,能够知道进度条中的比率,同时也需要能够将 显示的知道程序是否正在执行. ◆下面是编写的程序: ●利用'='来动态的显示进度条的变化,通过使用"|/-\\"来表示程序运行的状态,如果想要将进度条进行动态的增长,输出缓冲区是遇到'\n'时,系统会将缓冲区的内容进行输出,但是在编写缓冲区的程序中,使用'\n'肯定是不行的,因为

linux驱动current,引用当前进程,及task_struct(转)

尽管内核模块不象应用程序一样顺序执行, 内核做的大部分动作是代表一个特定进程的. 内核代码可以引用当前进程, 通过存取全局项 current, 它在 <asm/current.h> 中定义, 它产生一个指针指向结构 task_struct, 在 <Linux/sched.h> 定义. current 指针指向当前在运行的进程. 在一个系统调用执行期间, 例如 open 或者 read, 当前进程是发出调用的进程. 内核代码可以通过使用 current 来使用进程特定的信息, 如果它

进程控制(一)---PCB(进程控制块)

 进程是对程序的动态描述,是操作系统进行资源分配的最小单位(线程是操作系统执行实体的最小单位). 对于多道程序系统来说,其内存中可能存在着很多个进程,为了方便管理这些进程,操作系统内核为每个被创建的进程都建立一个结构体来保存与其相关的信息.这个结构体就是PCB,也就是进程控制块,进程控制块存在于进程的高 1 G空间,也就是内核空间中.在具体linux内核实现中,使用一个名为task_struct的结构体来描述的,在内核/include/linux/sched.h头文件中有具体定义. 操作系统组织

操作系统1_进程控制块PCB

在操作系统中,进程实体是指PCB+程序段+相关的数据段 这里主要总结一下进程控制块 作用: 使一个在多带程序环境下不能独立运行的程序(含数据),成为一个能独立运行的基本单位,一个能与其他进程并发执行的进程 或者,OS是根据PCB来对并发执行的进程进行控制的. PCB常被OS访问,因此其应常驻内存中: 描述方式:linux用task_struct描述,windows用执行体进程块EPROCESS描述 组成成分: 1)进程标示符 (1)内部标示符    OS赋予,唯一的数字标示符 (2)外部标示符 

进程之进程控制块与虚拟地址空间

1.进程概念 在用户层面,进程是一次程序的动态运行实例, 在操作系统层面,进程是操作系统进行资源调度和分配的基本单位,每一个进程都有自己独立的地址空间和运行状态. 操作系统为进程创建了一系列的数据结构来管理进程.操作系统会为每个进程创建一个虚拟地址空间和进程控制块. 2.虚拟地址空间 在32位操作系统下,一个进程最多可以拥有4G的内存空间,在早期的计算机系统中,将程序直接加载到内存,也就是说, 程序所访问到的地址空间就是真实的内存空间,当有多个进程同时执行时,先将一个进程全部加载内存,然后,在剩

进程控制块(PCB)结构

一.进程控制块(PCB)结构 进程控制块(PCB)是系统为了管理进程设置的一个专门的数据结构.系统用它来记录进程的外部特征,描述进程的运动变化过程.同时,系统可以利用PCB来控制和管理进程,所以说,PCB(进程控制块)是系统感知进程存在的唯一标志. Linux系统的PCB包括很多参数,每个PCB约占1KB多的内存空间.用于表示PCB的结构task_struct简要描述如下: include/linux/sched.h struct task_struct { volatile long stat