进程ID号

转载 2012年03月25日 21:59:58

关于进程ID号,在深入理解linux内核架构中已经讲得很清楚了。下面是主要的部分。

UNIX进程总是会分配一个号码用于在其命名空间中唯一地标识它们。该号码被称作进程ID号,简称PID。用forkclone产生的每个进程都由内核自动地分配了一个新的唯一的PID值。

1. 进程ID

但每个进程除了PID这个特征值之外,还有其他的ID。有下列几种可能的类型。

处于某个线程组(在一个进程中,以标志CLONE_THREAD来调用clone建立的该进程的不同的执行上下文,我们在后文会看到)中的所有进程都有统一的线程组IDTGID)。如果进程没有使用线程,则其PIDTGID相同。

线程组中的主进程被称作组长(group leader)。通过clone创建的所有线程的task_structgroup_leader成员,会指向组长的task_struct实例。

另外,独立进程可以合并成进程组(使用setpgrp系统调用)。进程组成员的task_structpgrp属性值都是相同的,即进程组组长的PID。进程组简化了向组的所有成员发送信号的操作,这对于各种系统程序设计应用(参见系统程序设计方面的文献,例如[SR05])是有用的。请注意,用管道连接的进程包含在同一个进程组中。

几个进程组可以合并成一个会话。会话中的所有进程都有同样的会话ID,保存在task_structsession成员中。SID可以使用setsid系统调用设置。它可以用于终端程序设计,但和我们这里的讨论不相干。

命名空间增加了PID管理的复杂性。回想一下,PID命名空间按层次组织。在建立一个新的命名空间时,该命名空间中的所有PID对父命名空间都是可见的,但子命名空间无法看到父命名空间的PID。但这意味着某些进程具有多个PID,凡可以看到该进程的命名空间,都会为其分配一个PID。 这必须反映在数据结构中。我们必须区分局部ID和全局ID

全局ID是在内核本身和初始命名空间中的唯一ID号,在系统启动期间开始的init进程即属于初始命名空间。对每个ID类型,都有一个给定的全局ID,保证在整个系统中是唯一的。

局部ID属于某个特定的命名空间,不具备全局有效性。对每个ID类型,它们在所属的命名空间内部有效,但类型相同、值也相同的ID可能出现在不同的命名空间中。

全局PIDTGID直接保存在task_struct中,分别是task_structpidtgid成员:

1 <sched.h> 

2 struct task_struct {  

3 ...  

4         pid_t pid;  

5         pid_t tgid;  

6 ...  

7 } 

这两项都是pid_t类型,该类型定义为__kernel_pid_t,后者由各个体系结构分别定义。通常定义为int,即可以同时使用232个不同的ID

会话和进程组ID不是直接包含在task_struct本身中,但保存在用于信号处理的结构中。task_ struct->signal->__session表示全局SID,而全局PGID则保存在task_struct->signal->__pgrp。辅助函数set_task_sessionset_task_pgrp可用于修改这些值。

2. 管理PID

除了这两个字段之外,内核还需要找一个办法来管理所有命名空间内部的局部量,以及其他ID(如TIDSID)。这需要几个相互连接的数据结构,以及许多辅助函数,并将在下文讨论。

数据结构

下文我将使用ID指代提到的任何进程ID。在必要的情况下,我会明确地说明ID类型(例如,TGID,即线程组ID)。

一个小型的子系统称之为PID分配器(pid allocator)用于加速新ID的分配。此外,内核需要提供辅助函数,以实现通过ID及其类型查找进程的task_struct的功能,以及将ID的内核表示形式和用户空间可见的数值进行转换的功能。

在介绍表示ID本身所需的数据结构之前,我需要讨论PID命名空间的表示方式。我们所需查看的代码如下所示:

8 <pid_namespace.h> 

9 struct pid_namespace {  

10 ...  

11         struct task_struct *child_reaper;  

12 ...  

13         int level;  

14         struct pid_namespace *parent;  

15 }; 

实际上PID分配器也需要依靠该结构的某些部分来连续生成唯一ID,但我们目前对此无需关注。我们上述代码中给出的下列成员更感兴趣。

每个PID命名空间都具有一个进程,其发挥的作用相当于全局的init进程。init的一个目的是对孤儿进程调用wait4,命名空间局部的init变体也必须完成该工作。child_reaper保存了指向该进程的task_struct的指针。

parent是指向父命名空间的指针,层次表示当前命名空间在命名空间层次结构中的深度。初始命名空间的level0,该命名空间的子空间level1,下一层的子空间level2,依次递推。level的计算比较重要,因为level较高的命名空间中的ID,对level较低的命名空间来说是可见的。从给定的level设置,内核即可推断进程会关联到多少个ID

回想图2-3的内容,命名空间是按层次关联的。这有助于理解上述的定义。

PID的管理围绕两个数据结构展开:struct pid是内核对PID的内部表示,而struct upid则表示特定的命名空间中可见的信息。两个结构的定义如下:

16 <pid.h> 

17 struct upid {  

18         int nr;  

19         struct pid_namespace *ns;  

20         struct hlist_node pid_chain;  

21 };  

22  

23 struct pid  

24 {  

25         atomic_t count;  

26         /* 使用该pid的进程的列表 */  

27         struct hlist_head tasks[PIDTYPE_MAX];  

28         int level;  

29         struct upid numbers[1];  

30 }; 

由于这两个结构与其他一些数据结构存在广泛的联系,在分别讨论相关结构之前,图2-5对此进行了概述。

对于struct upidnr表示ID的数值,ns是指向该ID所属的命名空间的指针。所有的upid实例都保存在一个散列表中,稍后我们会看到该结构。pid_chain用内核的标准方法实现了散列溢出链表。

struct pid的定义首先是一个引用计数器counttasks是一个数组,每个数组项都是一个散列表头,对应于一个ID类型。这样做是必要的,因为一个ID可能用于几个进程。所有共享同一给定IDtask_struct实例,都通过该列表连接起来。PIDTYPE_MAX表示ID类型的数目:

1 <pid.h> 

2 enum pid_type  

3 {  

4         PIDTYPE_PID,  

5         PIDTYPE_PGID,  

6         PIDTYPE_SID,  

7         PIDTYPE_MAX  

8 }; 


2.3.3 进程ID号(2

请注意,枚举类型中定义的ID类型不包括线程组ID!这是因为线程组ID无非是线程组组长的PID而已,因此再单独定义一项是不必要的。

一个进程可能在多个命名空间中可见,而其在各个命名空间中的局部ID各不相同。level表示可以看到该进程的命名空间的数目(换言之,即包含该进程的命名空间在命名空间层次结构中的深度),而numbers是一个upid实例的数组,每个数组项都对应于一个命名空间。注意该数组形式上只有一个数组项,如果一个进程只包含在全局命名空间中,那么确实如此。由于该数组位于结构的末尾,因此只要分配更多的内存空间,即可向数组添加附加的项。

由于所有共享同一IDtask_struct实例都按进程存储在一个散列表中,因此需要在struct task_struct中增加一个散列表元素:

1 <sched.h> 

2 struct task_struct {  

3 ...  

4         /* PIDPID散列表的联系。 */  

5         struct pid_link pids[PIDTYPE_MAX];  

6 ...  

7 }; 

辅助数据结构pid_link可以将task_struct连接到表头在struct pid中的散列表上:

8 <pid.h> 

9 struct pid_link  

10 {  

11         struct hlist_node node;  

12         struct pid *pid;  

13 }; 

pid指向进程所属的pid结构实例,node用作散列表元素。

为在给定的命名空间中查找对应于指定PID数值的pid结构实例,使用了一个散列表:

14 kernel/pid.c  

15 static struct hlist_head *pid_hash; 

hlist_head是一个内核的标准数据结构,用于建立双链散列表(附录C描述了该散列表的结构,并介绍了用于处理该数据结构的几个辅助函数)。

pid_hash用作一个hlist_head数组。数组的元素数目取决于计算机的内存配置,大约在24=16212=4096之间。pidhash_init用于计算恰当的容量并分配所需的内存。

假如已经分配了struct pid的一个新实例,并设置用于给定的ID类型。它会如下附加到task_struct

16 kernel/pid.c  

17 int fastcall attach_pid(struct task_struct *task, enum pid_type type,  

18                 struct pid *pid)  

19 {  

20         struct pid_link *link;  

21  

22         link = &task->pids[type];  

23         link->pidpid = pid;  

24         hlist_add_head_rcu(&link->node, &pid->tasks[type]);  

25  

26         return 0;  

27 } 

这里建立了双向连接:task_struct可以通过task_struct->pids[type]->pid访问pid实例。而从pid实例开始,可以遍历tasks[type]散列表找到task_structhlist_add_head_rcu是遍历散列表的标准函数,此外还确保了遵守RCU机制(参见第5章)。因为,在其他内核组件并发地操作散列表时,可防止竞态条件(race condition)出现。

函数

内核提供了若干辅助函数,用于操作和扫描上面描述的数据结构。本质上内核必须完成下面两个不同的任务。

(1) 给出局部数字ID和对应的命名空间,查找此二元组描述的task_struct

(2) 给出task_structID类型、命名空间,取得命名空间局部的数字ID

我们首先专注于如何将task_struct实例变为数字ID。这个过程包含下面两个步骤。

(1) 获得与task_struct关联的pid实例。辅助函数task_pidtask_tgidtask_pgrptask_session分别用于取得不同类型的ID。获取PID的实现很简单:

28 <sched.h> 

29 static inline struct pid *task_pid(struct task_struct *task)  

30 {  

31         return task->pids[PIDTYPE_PID].pid;  

32 } 

获取TGID的做法类似,因为TGID不过是线程组组长的PID而已。只要将上述实现替换为task-> group_leader->pids[PIDTYPE_PID].pid即可。

找出进程组ID则需要使用PIDTYPE_PGID作为数组索引,但该ID仍然需要从线程组组长的task_ struct实例获取:

33 <sched.h> 

34 static inline struct pid *task_pgrp(struct task_struct *task)  

35 {  

36         return task->group_leader->pids[PIDTYPE_PGID].pid;  

37 } 

(2) 在获得pid实例之后,从struct pidnumbers数组中的uid信息,即可获得数字ID

38 kernel/pid.c  

39 pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns)  

40 {  

41         struct upid *upid;  

42         pid_t nr = 0;  

43  

44         if (pid && ns->level <= pid->level) {  

45                 upid = &pid->numbers[ns->level];  

46                 if (upid->ns == ns)  

47                         nr = upid->nr;  

48         }  

49         return nr;  

50 } 

因为父命名空间可以看到子命名空间中的PID,反过来却不行,内核必须确保当前命名空间的level小于或等于产生局部PID的命名空间的level

同样重要的是要注意到,内核只需要关注产生全局PID。因为全局命名空间中所有其他ID类型都会映射到PID,因此不必生成诸如全局TGIDSID

除了在第2步使用的pid_nr_ns之外,内核还可以使用下列辅助函数:

pid_vnr返回该ID所属的命名空间所看到的局部PID

pid_nr则获取从init进程看到的全局PID

这两个函数都依赖于pid_nr_ns,并自动选择适当的level0用于获取全局PID,而pid->level则用于获取局部PID

内核提供了几个辅助函数,合并了前述步骤:

51 kernel/pid.c  

52 pid_t task_pid_nr_ns(struct task_struct 
*tsk, struct pid_namespace *ns)  

53 pid_t task_tgid_nr_ns(struct task_struct 
*tsk, struct pid_namespace *ns)  

54 pid_t task_pgrp_nr_ns(struct task_struct 
*tsk, struct pid_namespace *ns)  

55 pid_t task_session_nr_ns(struct task_struct 
*tsk, struct pid_namespace *ns) 

从函数名可以明显推断其语义,因此我们不再赘述。

2.3.3 进程ID号(3

现在我们把注意力转向内核如何将数字PID和命名空间转换为pid实例。同样需要下面两个步骤。

(1) 给出进程的局部数字PID和关联的命名空间(这是PID的用户空间表示),为确定pid实例(这是PID的内核表示),内核必须采用标准的散列方案。首先,根据PID和命名空间指针计算在pid_hash数组中的索引, 然后遍历散列表直至找到所要的元素。这是通过辅助函数find_pid_ns处理的:

1 kernel/pid.c  

2 struct pid * fastcall find_pid_ns(int nr,
struct pid_namespace *ns) 

struct upid的实例保存在散列表中,由于这些实例直接包含在struct pid中,内核可以使用container_of机制(参见附录C)推断出所要的信息。

(2) pid_task取出pid->tasks[type]散列表中的第一个task_struct实例。

这两个步骤可以通过辅助函数find_task_by_pid_type_ns完成:

3 kernel/pid.c  

4 struct task_struct *find_task_by_pid_type_ns(int type, int nr,  

5                 struct pid_namespace *ns)  

6 {  

7         return pid_task(find_pid_ns(nr, ns), type);  

8 } 

一些简单一点的辅助函数基于最一般性的find_task_by_pid_type_ns

find_task_by_pid_ns(pid_t nr, struct pid_namespace * ns)根据给出的数字PID和进程的命名空间来查找task_struct实例。

find_task_by_vpid(pid_t vnr)通过局部数字PID查找进程。

find_task_by_pid(pid_t nr)通过全局数字PID查找进程。

内核源代码中许多地方都需要find_task_by_pid,因为很多特定于进程的操作(例如,使用kill发送一个信号)都通过PID标识目标进程。

3. 生成唯一的PID

除了管理PID之外,内核还负责提供机制来生成唯一的PID(尚未分配)。在这种情况下,可以忽略各种不同类型的PID之间的差别,因为按一般的UNIX观念,只需要为PID生成唯一的数值即可。所有其他的ID都可以派生自PID,在下文讨论forkclone时会看到这一点。在随后的几节中,名词PID还是指一般的UNIX进程IDPIDTYPE_PID)。

为跟踪已经分配和仍然可用的PID,内核使用一个大的位图,其中每个PID由一个比特标识。PID的值可通过对应比特在位图中的位置计算而来。

因此,分配一个空闲的PID,本质上就等同于寻找位图中第一个值为0的比特,接下来将该比特设置为1。反之,释放一个PID可通过将对应的比特从1切换为0来实现。这些操作使用下述两个函数实现:

9 kernel/pid.c  

10 static int alloc_pidmap(struct pid_namespace *pid_ns) 

用于分配一个PID,而

11 kernel/pid.c  

12 static fastcall void free_pidmap(struct 
pid_namespace *pid_ns, int pid) 

用于释放一个PID。我们这里不关注具体的实现方式,但它们必须能够在命名空间下工作。

在建立一个新进程时,进程可能在多个命名空间中是可见的。对每个这样的命名空间,都需要生成一个局部PID。这是在alloc_pid中处理的:

13 kernel/pid.c  

14 struct pid *alloc_pid(struct pid_namespace *ns)  

15 {  

16         struct pid *pid;  

17         enum pid_type type;  

18         int i, nr;  

19         struct pid_namespace *tmp;  

20         struct upid *upid;  

21 ...  

22         tmp = ns;  

23         for (i = ns->level; i >= 0; i--) {  

24                 nr = alloc_pidmap(tmp);  

25 ...  

26                 pid->numbers[i].nr = nr;  

27                 pid->numbers[i].ns = tmp;  

28                 tmptmp = tmp->parent;  

29         }  

30         pid->level = ns->level;  

31 ... 

起始于建立进程的命名空间,一直到初始的全局命名空间,内核会为此间的每个命名空间分别创建一个局部PID。包含在struct pid中的所有upid都用重新生成的PID更新其数据。每个upid实例都必须置于PID散列表中:

32 

  1. kernel/pid.c    
  2. 33         for (i = ns->level; i >= 0; i--) {    
  3. 34                 upid = &pid->numbers[i];    
  4. 35                 hlist_add_head_rcu(&upid->pid_chain,    
  5. 36                                 &pid_hash[pid_  
  6. hashfn(upid->nr, upid->ns)]);    
  7. 37         }    
  8. 38 ...    
  9. 39         return pid;    
  10. 40 }   
  11. struct task_struct {  
  12. ...  
  13. pid_t pid;/*全局进程id*/  
  14. pid_t tgid;/*全局线程组id,如果没有使用线程和pid相同*/  
  15. ...  
  16. /* PID/PID hash table linkage. */  
  17. struct pid_link pids[PIDTYPE_MAX];  
  18. ...  
  19. };  
  20. enum pid_type  
  21. {  
  22. PIDTYPE_PID,  
  23. PIDTYPE_PGID,  
  24. PIDTYPE_SID,  
  25. PIDTYPE_MAX  
  26. };  
  27. struct pid_link  
  28. {  
  29. struct hlist_node node;  
  30. struct pid *pid;  
  31. };  
  32. /*核对PID的内部表示*/  
  33. struct pid  
  34. {  
  35. atomic_t count;  
  36. unsigned int level;  
  37. /* lists of tasks that use this pid */  
  38. struct hlist_head tasks[PIDTYPE_MAX];  
  39. struct rcu_head rcu;  
  40. struct upid numbers[1];  
  41. };  
  42. /* 
  43.  * struct upid is used to get the id of the struct pid, as it is 
  44.  * seen in particular namespace. Later the struct pid is found with 
  45.  * find_pid_ns() using the int nr and struct pid_namespace *ns. 
  46.  */  
  47. /*特定的命名空间中可见的信息*/  
  48. struct upid {  
  49. /* Try to keep pid_chain in the same cacheline as nr for find_vpid */  
  50. int nr;  
  51. struct pid_namespace *ns;  
  52. struct hlist_node pid_chain;  
  53. };  
  54. struct pid_namespace {  
  55. struct kref kref;  
  56. struct pidmap pidmap[PIDMAP_ENTRIES];  
  57. int last_pid;  
  58. /*每个PID命名空间都具有一个进程,其发挥的作用相当于全局的init进程。init的一    个目的是对孤儿进程调用wait4,命名空间局部的init变体也必须完成该工作。 child_reaper保存了指向该进程的task_struct的指针。*/  
  59. struct task_struct *child_reaper;  
  60. struct kmem_cache *pid_cachep;  
  61. /*层次表示当前命名空间在命名空间层次结构中的深度。初始命名空间的level为0,该  命名空间的子空间level为1,下一层的子空间level为2,依次递推.level的计算比较重 要,因为level较高的命名空间中的ID,对level较低的命名空间来说是可见的。从给 定的level设置,内核即可推断进程会关联到多少个ID*/  
  62. unsigned int level;  
  63. /*指向父命名空间的指针*/  
  64. struct pid_namespace *parent;  
  65. #ifdef CONFIG_PROC_FS  
  66. struct vfsmount *proc_mnt;  
  67. #endif  
  68. #ifdef CONFIG_BSD_PROCESS_ACCT  
  69. struct bsd_acct_struct *bacct;  
  70. #endif  
  71. };  
  72. struct pidmap {  
  73.        atomic_t nr_free;  
  74.        void *page;  
  75. };  
总结:关于进程ID号,主要是确定上面5个结构体中字段的意义和结构体之间的关系,在内核中参看具体的函数可以进一步理解他们之间的关系。

相关文章推荐

得到进程ID号

  • 2002年04月04日 00:00
  • 6KB
  • 下载

进程ID号

关于进程ID号,在深入理解linux内核架构中已经讲得很清楚了。下面是主要的部分。 UNIX进程总是会分配一个号码用于在其命名空间中唯一地标识它们。该号码被称作进程ID号,简称PID。用fork或c...
  • bullbat
  • bullbat
  • 2011年12月19日 20:24
  • 4806

通过进程号ID获得窗口的句柄

2012年-09月-05日 通过进程号的ID获得窗口的句柄     最近几天,工作的需要,打算实现将别人编译好的exe程序,通过自己的程序去调用,然后根据程序中得到的ID号,去得到此进程运行创建的...

Linux进程ID号--Linux进程的管理与调度(三)

日期 内核版本 架构 作者 GitHub CSDN 2016-05-12 Linux-4.5 X86 & arm gatieme LinuxDeviceDrive...
  • gatieme
  • gatieme
  • 2016年05月12日 13:31
  • 9815

关于IIS报的确进程在与 World Wide Web Publishing 服务通信时遇到致命错误。进程 ID 为 '4528'。数据字段包含错误号 的解决办法

今日,更新了webservices程序后,一分钟内,突然发现网站不能访问了,当时给急得真是。。。。 发现是服务器的问题,逐重启了IIS服务,网站好了,可过了一分钟,又挂了。 立马把程序文件全部还原...
  • hui717
  • hui717
  • 2012年06月04日 14:16
  • 9837

获取进程ID

  • 2017年08月20日 15:45
  • 4.34MB
  • 下载

登陆oracle11g 报错 ORA-01034 ORA-27101 进程 ID: 0 会话 ID: 0 序列号:

登陆oracle11g 报错 ORA-01034 ORA-27101 进程 ID: 0 会话 ID: 0 序列号: 0 不知道什么情况,重启了下电脑,oracle登陆不上去。服务已启动,用PLSQL连...
  • xp_lx1
  • xp_lx1
  • 2016年12月12日 09:23
  • 212

获取指定进程ID

  • 2016年08月21日 13:30
  • 335B
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:进程ID号
举报原因:
原因补充:

(最多只允许输入30个字)