目录
. 引言
. Linux进程
. Linux命名空间
. Linux进程的相关标识
. 进程标识编程示例
. 进程标志在Linux内核中的存储和表现形式
. 后记
0. 引言
在进行Linux主机的系统状态安全监控的过程中,我们常常会涉及到对系统进程信息的收集、聚类、分析等技术,因此,研究Linux进程原理能帮助我们更好的明确以下几个问题
. 针对Linux的进程状态,需要监控捕获哪些维度的信息,哪些信息能够更好地为安全人员描绘出黑客的入侵迹象
. 监控很容易造成的现象就是会有短时间内的大量数据产生(杂志数据过滤后),如何对收集的数据进行聚类,使之表现出一些更高维度的、相对有用的信息
. 要实现数据的聚类,就需要从现在的元数据中找到一些"连结标识",这些"连结标识"就是我们能够将低纬度的数据聚类扩展到高纬度的技术基础。
本文的技术研究会围绕这几点进行Linux操作系统进程的基本原理研究
1. Linux进程
0x1: 进程的表示
进程属于操作系统的资源,因此进程相关的元数据都保存在内核态RING0中,Linux内核涉及进程和程序的所有算法都围绕task_struct数据结构建立,该结构定义在include/sched.h中,这是操作系统中主要的一个结构,task_struct包含很多成员,将进程与各个内核子系统联系起来,关于task_struct结构体的相关知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3865490.html
0x2: 进程的产生方式
Linux下新进程是使用fork和exec系统调用产生的
. fork
生成当前进程的一个相同副本,该副本称之为"子进程"。原进程的所有资源都以适当的方式复制到子进程,因此执行了该系统调用之后,原来的进程就有了2个独立的实例,包括
) 同一组打开文件
) 同样的工作目录
) 内存中同样的数据(2个进程各有一个副本)
..
. exec
从一个可执行的二进制文件来加载另一个应用程序,来"代替"当前运行的进程,即加载了一个新的进程。因为exec并不创建新进程,搜易必须首先使用fork复制一个旧的程序,然后调用exec在系统上创建另一个应用程序
//总体来说:fork负责产生空间、exec负责载入实际的需要执行的程序
除此之外,Linux还提供了clone系统调用,clone的工作原理基本上和fork相同,所区别的是
. 新进程不是独立于父进程,而是可以和父进程共享某些资源
. 可以指定需要共享和复制的资源种类,例如
) 父进程的内存数据
) 打开文件或安装的信号处理程序
关于Linux下进程创建的相关知识,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3853854.html
2. Linux命名空间
0x1: Linux namespace基本概念
命名空间提供了虚拟化的一种轻量级形式,使得我们可以从不同的方面来查看运行系统的全局属性,该机制类似于Solaris中的zone、或FreeBSD中的jail
首先要明白的是,Linux命名空间是一个总的概念,它体现的是一个资源虚拟隔离的思想,在这个思想下,Linux的内核实现了很多的命名空间虚拟化机制,命名空间的一个总体目标是支持轻量级虚拟化工具container的实现,container机制本身对外提供一组进程,这组进程自己会认为它们就是系统唯一存在的进程,目前Linux实现了六种类型的namespace,每一个namespace是包装了一些全局系统资源的抽象集合,这一抽象集合使得在进程的命名空间中可以看到全局系统资源
. mount命名空间(CLONE_NEWS)
用于隔离一组进程看到的文件系统挂载点集合,即处于不同mount命名空间的进程看到的文件系统层次很可能是不一样的。mount()和umount()系统调用的影响不再是全局的而只影响其调用进程指向的命名空间
mount命名空间的一个应用类似chroot,然而和chroot()系统调用相比,mount命名空间在安全性和扩展性上更好。其它一些更复杂的应用如: 不同的mount命名空间可以建立主从关系,这样可以让一个命名空间的事件自动传递到另一个命名空间
mount命名空间是Linux内核最早实现的命名空间 . UTS命名空间(CLONE_NEWUTS)
隔离了两个系统变量
) 系统节点名: uname()系统调用返回UTS
) 域名: 域名使用setnodename()和setdomainname()系统调用设置
从容器的上下文看,UTS赋予了每个容器各自的主机名和网络信息服务名(NIS)(Network Information Service),这使得初始化和配置脚本能够根据不同的名字进行裁剪。UTS源于传递给uname()系统调用的参数:struct utsname。该结构体的名字源于"UNIX Time-sharing System" . IPC namespaces(CLONE_NEWIPC)
隔离进程间通信资源,具体来说就是System V IPC objects and (since Linux2.6.30) POSIX message queues。每一个IPC命名空间拥有自己的System V IPC标识符和POSIX消息队列文件系统 . PID namespaces(CLONE_NEWPID)
隔离进程ID号命名空间,话句话说就是位于不同进程命名空间的进程可以有相同的进程ID号,PID命名空间的最大的好处是在主机之间移植container时,可以保留container内的ID号,PID命名空间允许每个container拥有自己的init进程(PID=),init进程是所有进程的祖先,负责系统启动时的初始化和作为孤儿进程的父进程
从特殊的角度来看PID命名空间,就是一个进程有两个ID,一个ID号属于PID命名空间,一个ID号属于PID命名空间之外的主机系统,此外,PID命名空间能够被嵌套。 . Network namespaces(CLONE_NEWNET)
用于隔离和网络有关的资源,这就使得每个网络命名空间有其自己的网络设备、IP地址、IP路由表、/proc/net目录、端口号等等
从网络命名空间的角度看,每个container拥有其自己的网络设备(虚拟的)和用于绑定自己网络端口号的应用程序。主机上合适的路由规则可以将网络数据包和特定container相关的网络设备关联。例如,可以有多个web服务器,分别存在不同的container中,这就使得这些web服务器可以在其命名空间中绑定80端口号 . User namespaces(CLONE_NEWUSER)
隔离用户和组ID空间,换句话说,一个进程的用户和组ID在用户命名空间之外可以不同于命名空间之内的ID,最有趣的是一个用户ID在命名空间之外非特权,而在命名空间内却可以是具有特权的。这就意味着在命名空间内拥有全部的特权权限,在命名空间之外则不是这样
我们重点学习一下"PID namespace"的相关概念
0x2: Linux PID namespace
传统上,在Linux及其其他衍生的Unix变体中,进程PID是全局管理的,系统中的所有进程都是通过PID标识的,这意味着内核必须管理一个全局的PID列表,全局ID使得内核可以有选择地允许或拒绝某些特权,即针对ID值进行权限划分,但是在有些业务场景下,例如提供Web主机的供应商需要向用户提供Linux计算机的全部访问权限(包括root权限在内)。可以想到的解决方案有
. 为每个用户都准备一台计算机,但是代价太高
. 使用KVM、VMWare提供的虚拟化环境,但是资源分配做的不是很好,计算机的各个用户都需要提供一个独立的内核、以及一份完全安装好的配套的用户层应用
命名空间提供了一种较好的解决方案,并且所需资源较少,命名空间只使用一个内核在一台物理计算机上运行,所有的全局资源都通过命名空间抽象起来,这使得可以将一组进程放置到容器中,各个容器彼此隔离,隔离可以使容器的成员与其他容器毫无关系。但也可以通过允许容器进行一定的共享,来降低容器之间的分隔。例如,容器可以设置为使用自身的PID集合,但仍然与其他容器共享部分文件系统(这就是Docker的流行做法)
本质上,命名空间建立了系统的不同视图。未使用命名空间之前的每一项全局资源都必须包装到容器数据结构中,只有资源和包含资源的命名空间构成的二元组仍然是全局唯一的,即
. 对于子命名空间来说: 本空间中的全局资源是本空间全局唯一的,但是在父空间及兄弟空间中不唯一
. 对于父空间来说,本空间和子空间的所有全局资源都是唯一的
aaarticlea/png;base64,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*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" alt="" />
从图中可以看到:
. 命名空间可以组织为层次,图中一个命名空间为父空间,衍生了两个子命名空间
) 父命名空间: 宿主物理机
) 子命名空间: 虚拟机容器
. 对于每个虚拟机容器自身来说,它们看起来完全和单独的一台Linux计算机一样,有自身的init进程,PID为0,其他进程的PID以递增次序分配
. 对于父命名空间来说,全局的ID依然不变,而在子命名空间中,每个子命名空间都有自己的一套ID命名序列
. 虽然子容器(子命名空间)不了解系统中的其他容器,但父容器知道子命名空间的存在,也可以看到其中执行的所有进程
. 在Linux的这种层次结构的命名空间的架构下,一个进程可能拥有多个ID值,至于哪一个是"正确"的,则依赖于具体的上下文
命名空间可以使用以下两种方法创建
. 在用fork或clone系统调用创建新进程时,传入特定的选项
) 与父进程共享命名空间
) 建立新的命名空间 . unshare系统调用将进程的某些部分从父进程分离,包括命名空间
/*
在进程使用上述两种机制之一从父进程命名空间分离后,从该进程的角度来看,改变子进程命名空间的全局属性不会传播到父进程命名空间,而父进程的修改也不会传播到子进程。但是,对于文件系统来说,这里存在特例,在这种主机型虚拟机架构下文件系统常常伴随着大量的共享
*/
命名空间的实现需要两个部分
. 每个子系统的命名空间结构,用于将传统的所有全局资源包装到命名空间中
. 将给定进程关联到所属各个命名空间的机制
aaarticlea/png;base64,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" alt="" />
从图中可以看到,每个进程通过"struct nsproxy"的转接,可以使用位于不同的命名空间类别中,因为使用了指针,多个进程可以共享一组子命名空间,因此,修改给定的命名空间,对所有属于该命名空间的进程都是可见的
每个进程都通过struct task_struct关联到自身的命名空间视图
struct task_struct
{
..
struct nsproxy *nsproxy;
..
}
子系统此前的全局属性现在都封装到命名空间中,每个进程关联到一个选定的命名空间中,每个可以感知命名空间的内核子系统都必须提供一个数据结构,将所有通过命名空间形式提供的对象集中起来,struct nsproxy用于汇集指向特定于子系统的命名空间包装器的指针
/source/include/linux/nsproxy.h
/*
A structure to contain pointers to all per-process namespaces
1. fs (mount)
2. uts
3. network
4. sysvipc
5. etc
'count' is the number of tasks holding a reference. The count for each namespace, then, will be the number of nsproxies pointing to it, not the number of tasks.
The nsproxy is shared by tasks which share all namespaces. As soon as a single namespace is cloned or unshared, the nsproxy is copied.
*/
struct nsproxy
{
atomic_t count; /*
1. UTS(UNIX Timesharing System)命名空间包含了运行内核的名称、版本、底层体系结构类型等信息
*/
struct uts_namespace *uts_ns; /*
2. 保存在struct ipc_namespace中的所有与进程间通信(IPC)有关的信息
*/
struct ipc_namespace *ipc_ns; /*
3. 已经装载的文件系统的视图,在struct mnt_namespace中给出
*/
struct mnt_namespace *mnt_ns; /*
4. 有关进程ID的信息,由struct pid_namespace提供
*/
struct pid_namespace *pid_ns; /*
5. struct net包含所有网络相关的命名空间参数
*/
struct net *net_ns;
};
extern struct nsproxy init_nsproxy;
由于在创建新进程时可以使用fork建立一个新的命名空间,因此必须提供控制该行为的适当的标志,每个命名空间都有一个对应的标志
/source/include/linux/sched.h
..
#define CLONE_NEWUTS 0x04000000 /* New utsname group? */
#define CLONE_NEWIPC 0x08000000 /* New ipcs */
#define CLONE_NEWUSER 0x10000000 /* New user namespace */
#define CLONE_NEWPID 0x20000000 /* New pid namespace */
#define CLONE_NEWNET 0x40000000 /* New network namespace */
..
需要注意的是,对命名空间的支持必须在编译时启用,而且必须逐一指定需要支持的命名空间。这样,每个进程都会关联到一个默认命名空间,这样可以感知命名空间的代码总是可以使用。但是如果内核编译时没有指定对具体命名空间的支持,默认命名空间的作用则类似不启用命名空间,所有的属性都相当于全局的
init_nsproxy定义了初始的全局命名空间,其中维护了指向各子系统的命名空间对象的指针
\linux-2.6.32.63\kernel\nsproxy.c
struct nsproxy init_nsproxy = INIT_NSPROXY(init_nsproxy);
\linux-2.6.32.63\include\linux\init_task.h
#define INIT_NSPROXY(nsproxy) { \
.pid_ns = &init_pid_ns, \
.count = ATOMIC_INIT(), \
.uts_ns = &init_uts_ns, \
.mnt_ns = NULL, \
INIT_NET_NS(net_ns) \
INIT_IPC_NS(ipc_ns) \
}
0x3: 在命名空间模式下的进程ID号
Linux进程总是会分配一个PID用于在其命名空间中唯一地标识它们,用fork或clone产生的每个进程都由内核自动的分配了一个新的唯一的PID值。但是命名空间增加了PID管理的复杂性,PID命名空间按层次组织。在建立一个新的命名空间时,该命名空间中的所有PID对父命名空间都是可见的,但子命名空间无法看到父命名空间的PID。这意味着某些进程具有多个PID,凡是可以看到该进程的命名空间,都会为其分配一个PID,这必须反应在数据结构中,即我们必须区*部ID、全局ID
. 全局ID
是在内核本身和初始命名空间中的唯一ID号,在系统启动期间开始的init进程即属于初始命名空间。对每个ID类型,都有一个给定的全局ID,保证在整个系统中是唯一的
) 全局PID、TGID直接保存在task_struct中
struct task_struct
{
..
pid_t pid;
pid_t tgid;
..
}
) 会话和进程组ID不是直接保存在task_struct本身中,而是保存在用于信号处理的结构中
全局SID: task_struct->group_leader->pids[PIDTYPE_SID].pid; -> pid_vnr(task_session(current));
全局PGID: task_struct->group_leader->pids[PIDTYPE_PGID].pid; -> pid_vnr(task_pgrp(current));
辅助含数据set_task_session、set_task_pgrp可用于修改这些值 . 局部ID
属于某个特定的命名空间,不具备全局有效性。对每个ID类型,它们在所属的命名空间内部有效,但类型相同、值也相同的ID可能出现在不同的命名空间中
0x4: 管理PID
除了内核态支持的数据结构之外,内核还需要找一个办法来管理所有命名空间内部的局部ID。这需要几个相互连接的数据结构、以及许多辅助函数互相配合
1. 数据结构
一个小型的子系统称之为PID分配器(pid allocator)用于加速新ID的分配。此外,内核需要提供辅助函数,以实现通过ID及其类型查找进程的task_struct的功能、以及将ID的内核表示形式和用户空间可见的数值进行转换的功能,关于命名空间下PID的相关数据结构及其之间的关系,请参阅另一篇文章
http://www.cnblogs.com/LittleHann/p/3865490.html
//搜索:10. 命名空间(namespace)相关数据结构
2. 操作函数
内核提供了一些辅助函数,用于操作命名空间下和PID相关的数据结构,本质上内核必须完成下面2件事
. 给出局部数字ID和对应的命名空间,查找此二元组描述的task_struct对应的PID实例(即在虚拟机沙箱中看到的局部PID)
) 为确定pid实例(这是PID的内核表示),内核必须采用标准的散列方案,首先根据PID和命名空间指针计算在pid_hash数组中的索引,然后遍历散列表直至找到所需要的元素,这是通过辅助函数find_pid_ns处理的
struct pid *find_pid_ns(int nr, struct pid_namespace *ns)
{
struct hlist_node *elem;
struct upid *pnr; hlist_for_each_entry_rcu(pnr, elem,
&pid_hash[pid_hashfn(nr, ns)], pid_chain)
if (pnr->nr == nr && pnr->ns == ns)
return container_of(pnr, struct pid,
numbers[ns->level]); return NULL;
} ) pid_task取出pid->tasks[type]散列表中的第一个task_struct实例,这两个步骤可以通过辅助函数find_task_by_pid_type_ns完成
/*
一些简单一点的辅助函数基于最一般性的find_task_by_pid_type_ns
struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns): 根据给出的数字PID和进程的命名空间拉力查找task_struct实例
struct task_struct *find_task_by_vpid(pid_t vnr): 通过局部数字PID查找进程
struct task_struct *find_task_by_pid(pid_t vnr): 通过全局数组PID查找进程
内核中许多地方都需要find_task_by_pid,因为很多特定于进程的操作(例如 kill发送一个信号)都通过PID标识目标进程
*/ . 给出task_struct、ID类型、命名空间,取得命名空间局部的数字ID
) 获得与task_struct关联的pid实例
static inline struct pid *task_pid(struct task_struct *task)
{
return task->pids[PIDTYPE_PID].pid;
} ) 获得pid实例之后,从struct pid的numbers数组中的uid信息,即可获得数字ID
pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns)
{
struct upid *upid;
pid_t nr = ; /*
因为父命名空间可以看到子命名空间中的PID,反过来却不行,内核必须确保当前命名空间的level小于或等于产生局部PID的命名空间的level,即当前一定是父命名空间在读子命名空间
*/
if (pid && ns->level <= pid->level)
{
upid = &pid->numbers[ns->level];
if (upid->ns == ns)
nr = upid->nr;
}
return nr;
}
/*
内核使用了几个辅助函数,合并了前述的步骤
pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
*/
3. 生成唯一的PID
除了管理PID之外,内核还负责提供机制来生成唯一的PID(尚未分配),为了跟踪已经分配和仍然可用的PID,内核使用一个大的位图,其中每个PID由一个bit标识,PID的值可通过对应bit位在位图中的位置计算而来
因此,分配一个空闲的PID,本质上就等同于寻找位图中第一个值为0的bit,接下来将该bit设置为1.反之,释放一个PID可通过将对应的bit从1设置为0即可
. static int alloc_pidmap(struct pid_namespace *pid_ns)
. static void free_pidmap(struct upid *upid)
在建立一个新的进程时,进程可能在多个命名空间中是可见的,对每个这样的命名空间,都需要生成一个局部PID,这是在alloc_pid中处理的。起始于建立进程的命名空间,一直到初始的全局命名空间,内核会为此间的每个命名空间都分别创建一个局部PID,包含在strcut pid中的所有upid都用重新生成的PID更新其数据,每个upid实例都必须置于PID散列表中
Relevant Link:
深入linux内核架构(中文版).pdf 第2章
http://guojing.me/linux-kernel-architecture/posts/process-type-and-namespace/
http://blog.csdn.net/linuxkerneltravel/article/details/5303863
http://bbs.chinaunix.net/thread-4165157-1-1.html
http://blog.csdn.net/dog250/article/details/9325017
http://blog.csdn.net/shichaog/article/details/41378145
http://linux.cn/article-5019-weibo.html
2. Linux进程的相关标识
以下是Linux和进程相关的标识ID值,我们先学习它们的基本概念,在下一节我们会学习到这些ID值间的关系、以及Linux是如何保存和组织它们的。需要明白的是,Linux采取了向下兼容、统一视角的设计思想
. Linux所有的进程都被广义地看成一个组的概念,差别在于
) 对于进程来说,进程自身就是唯一的组员,它自己代表自己,也代表这个组
) 对于线程来说,线程由进程创建,线程属于领头进程所属的组中
. Linux的标识采取逐级聚类的思想,不断扩大组范围
0x1: PID(Process ID 进程 ID号)
Linux系统中总是会分配一个号码用于在其命名空间中唯一地标识它们,即进程ID号(PID),用fork或者clone产生的每个进程都由内核自动地分配一个新的唯一的PID值: current->pid
值得注意的是,命名空间增加了PID管理的复杂性,PID命名空间按照层次组织,在建立一个新的命名空间时
. 该命名空间中的所有PID对父命名空间都是可见的
. 但子命名空间无法看到父命名空间的PID
这也就是意味着在"多层次命名空间"的状态下,进行具有多个PID,凡是可能看到该进程的的命名空间,都会为其分配一个PID,这种特征反映在了Linux的数据结构中,即局部ID、和全局ID
. 全局ID
是在内核本身和"初始命名空间"中的唯一ID号,在系统启动期间开始的init进程即属于"初始命名空间"。对每个ID类型,都有一个给定的全局ID,保证在整个系统中是唯一的 . 局部ID
属于某个特定的命名空间,不具备全局有效性。对每个ID类型,它们"只能"在所属的命名空间内部有效
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKQAAABKCAIAAAC6mWjkAAAFcElEQVR4nO2cW5KdNhCGtR5tRW8pT83YY1eqkvE4bbvKuTmJ/a4VeAX9Mptgc3kApG5dEHA4iIP6q3kAHSF69KMLajXq3efvakQDvvx4QdCqCqDUD6Wgzs2LaFBdN/7ZLQpU+KJeUO1Y24HY3cCOiqNS3fiHe920HvSZ6XZ+tKnYwskRsRtCxG4IEbshROyGCMTWgNVevYRrQ8U2tnNYU9Go9Rg78dZobNd1eNQX+R3wYhvrFCaHJ8NYEVsppQFjgQG7rkMAm1xsIWswiBdUoi+n9IxN2ONWhMKWTZaKrJkltiHF02EttLMvGdGOZQ8/5dKX18zGvPvkuvHeqLCuAImhGnA8pqO7seu7R0ByS2OL5eTscQn8H6D9+qxu3Fhe/Hh52k4N2GcfLxvaTC69Lm8/8dn42A6cZUF1EqMXDfE0M28c/FJjCxPEvD3DKbs+KE5DqQfKNP2cna7AceTzYifT6+LEZtVCToLaSxs9o0WmWSP2lD0i9hRvP37rD3jT84b1PZnyp8NPrFYvmNFxdcpjas6enlQ37jOEw42xca/E5/O+U0/beVtiP378j57GNgGitX5mQlp8+uFYjGYlFQvK2JMZJoJfrKXD9jCGRx0JNcjbE9vpUqxxZengYp5eWe9HKIt9qFWWDe1hc64WCMQOoA7u3UyaYEt7opn8+XmEf2ubIOyFiN0QInZDiNgNIWI3xPRsXDgVq8XmiyqBtyFa29BB9lnvPNT7RBcAaDpJCBa+nN8pTgdmJnmLowV5kxHW2X84LmjZbCUyXrIO1ytodupaypfOvU/DWZhOvE9k0QwRiRcyTidWBsvnLA9dS19o/xHZSuyCQyLMXtr/lFtKjjwZQ6ka0BpwAheP6U242sYigPUdUlLsG92/Vadlx6dR2cmqTBaLoAfdjEXQfcFU4ET6YPPYWbCeHEFHTq2l9h+Ty8ROjNk9dcQm2xOY2HE6N4D30ERmEXtk6t/doBvP+ZXz3bhSShkzemC5ZzFIz00kyWOmAS1INz5widjldpHzK2cnaLy8UOwgPXKck4cgs41pof1HZItXr2A2O+fVa1ZVpf3K8asXfUnSiXsV0n15iKygcK/Zzb97yaJKQ4jYDSFiN4SI3RAidkOI2A0hYjeEiN0QVGzmwSX4dL6UkE4Pt8kP5PzfSXLb95dyiK35x8GJTUNj2GInieMKVwyT6RnvZOBbLCq51drzIeJuDkKyG+fhuKTSWQxnOn1O7c6pf0AEAxh3BGyPieaXuB98vPjgz7jlVc7N4GKPFRn5dweI0ymXnuvGPfPa2hB3r12Z7ikzdGigz1gyXpzGWN+kq2pDki2bR7AvFDsoKNJ1Zr+ajcPOBgKm48XZ7YoBwecmMxv3HsDceDxnnE6G4M4cQzNx2MzzOXFb2rJF7AEnNm1JbD+dBku6RypwMp2GRiZi52bPl1gctisoGi/IfdPx4iK2h8Rnp3fXKjrxCTcClNKjZj1T6/7Vi8RhJz6U4zL0BSbjxWkENZmQtKp3EIwvnBkRuyFkubQh3khgXzu8/u2f2iYIe/Hw4e/aJgh7cf/8Z20ThL24e/9HbROEvbh7+t0dr/dnz8uf8mEJO/Lq6Ut/sNSfvSI//Rph277GSrz69UucOMeffWH+abH3+c55c7iWrZRa5M9eld9nKRp27e+ctwgdsx1z/Nkr83NX1QQbfedcINy9T756lf3ZK/LTTSNFrvud8za5f/6rP1jqz16af2mXe+3vnLfIw4ev4+FSf/aS/Mvjm6/+nfMGeQ0HXRtvfG/gVTim1+to3zk/CeLPbggRuyHkq8QN8UY2L7TDw/PXcibhHNw/yeaFZrj7JeH1Es7JTz9/rm2CsBP/A0JTOJ/2dI3HAAAAAElFTkSuQmCC" alt="" />
//the system call getpid() is defined to return an integer that is the current process's PID.
asmlinkage long sys_getpid(void)
{
return current->tgid;
}
0x2: TGID(Thread Group ID 线程组 ID号)
处于某个线程组(在一个进程中,通过标志CLONE_THREAD来调用clone建立的该进程的不同的执行上下文)中的所有进程都有统一的线程组ID(TGID)
. 如果进程没有使用线程,则它的PID和TGID相同
线程组中的"主线程"(Linux中线程也是进程)被称作"组长(group leader)",通过clone创建的所有线程的task_struct的group_leader成员,都会指向组长的task_struct。
. 在Linux系统中,一个线程组中的所有线程使用和该线程组的领头线程(该组中的第一个轻量级进程)相同的PID(本质是tgid),并被存放在tgid成员中。只有线程组的领头线程的pid成员才会被设置为与tgid相同的值
梳理一下这段概念,我们可以这么理解
. 对于一个多线程的进程来说,它实际上是一个进程组,每个线程在调用getpid()时获取到的是自己的tgid值,而线程组领头的那个领头线程的pid和tgid是相同的
. 对于独立进程,即没有使用线程的进程来说,它只有唯一一个线程,领头线程,所以它调用getpid()获取到的值就是它的pid
0x3: TID
#define gettid() syscall(__NR_gettid) /* Thread ID - the internal kernel "pid" */
asmlinkage long sys_gettid(void)
{
return current->pid;
}
对于进程来说,取TID、PID、TGID都是一样的,取到的值都是相同的,但是对于线程来说
. tid: 线程ID
. pid: 线程所属进程的ID
. tgid: 等同于pid,也就是线程组id,即线程组领头进程的id
为了更好地阐述这个概念,我们可以运行下列这个程序
#include <stdio.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/syscall.h> struct message
{
int i;
int j;
}; void *hello(struct message *str)
{
printf("child, the tid(pthread_self())=%lu, tid(SYS_gettid)=%d\n",pthread_self(),syscall(SYS_gettid));
//printf("the arg.i is %d, arg.j is %d\n",str->i,str->j);
printf("child, getpid()=%d\n",getpid());
while();
} int main(int argc, char *argv[])
{
struct message test;
pthread_t thread_id;
test.i=;
test.j=;
pthread_create(&thread_id,NULL,hello,&test);
printf("parent, the tid(pthread_self())=%lu, tid(SYS_gettid)=%d\n",pthread_self(),syscall(SYS_gettid));
printf("parent, getpid()=%d\n",getpid());
pthread_join(thread_id,NULL);
return ;
}
aaarticlea/png;base64,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" alt="" />
Relevant Link:
http://www.cnblogs.com/lakeone/p/3789117.html
http://blog.csdn.net/pppjob/article/details/3864020
0x3: PGID(Process Group ID 进程组 ID号)
了解了进行ID、线程组(就是单线程下的进程)ID之后,我们继续学习"进程组ID",可以看出,Linux就是在将做原子的因素不断组合成更大的集合。
每个进程都会属于一个进程组(process group),每个进程组中可以包含多个进程。进程组会有一个进程组领导进程 (process group leader),领导进程的PID成为进程组的ID (process group ID, PGID),以识别进程组。
图中箭头表示父进程通过fork和exec机制产生子进程。ps和cat都是bash的子进程。进程组的领导进程的PID成为进程组ID。领导进程可以先终结。此时进程组依然存在,并持有相同的PGID,直到进程组中最后一个进程终结
进程组简化了向组内的所有成员发送信号的操作,进程组中的所有进程都会收到该信号,例如,用管道连接的进程包含在同一个进程组中(管道的原理就是在创建2个子进程)
aaarticlea/png;base64,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" alt="" />
或者输入pgrp也可以,pgrp和pgid是等价的
aaarticlea/png;base64,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" alt="" />
0x4: PPID(Parent process ID 父进程 ID号)
PPID是当前进程的父进程的PID
ps -o pid,pgid,ppid,comm | cat
aaarticlea/png;base64,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" alt="" />
因为ps、cat都是由bash启动的,所以它们的ppid都等于bash进程的pid
0x5: SID(Session ID 会话ID)
更进一步,在shell支持工作控制(job control)的前提下,多个进程组还可以构成一个会话 (session)。bash(Bourne-Again shell)支持工作控制,而sh(Bourne shell)并不支持
. 每个会话有1个或多个进程组组成,可能有一个领头进程((session leader)),也可能没有
. 会话领导进程的PID成为识别会话的SID(session ID)
. 会话中的每个进程组称为一个工作(job)
. 会话可以有一个进程组成为会话的前台工作(foreground),而其他的进程组是后台工作(background)
. 每个会话可以连接一个控制终端(control terminal)。当控制终端有输入输出时,都传递给该会话的前台进程组。由终端产生的信号,比如CTRL+Z, CTRL+\,会传递到前台进程组。
. 会话的意义在于将多个job(进程组)囊括在一个终端,并取其中的一个job(进程组)作为前台,来直接接收该终端的输入输出以及终端信号。 其他工作在后台运行
一个命令可以通过在末尾加上&方式让它在后台运行:
$ping localhost > log &
[]
//括号中的1表示工作号,而10141为PGID
信号可以通过kill的方式来发送给工作组
. $kill -SIGTERM -
//发送给PGID(通过在PGID前面加-来表示是一个PGID而不是PID) . $kill -SIGTERM %
//发送给工作1(%1)
一个工作可以通过$fg从后台工作变为前台工作:
$cat > log &
$fg %
//当我们运行第一个命令后,由于工作在后台,我们无法对命令进行输入,直到我们将工作带入前台,才能向cat命令输入。在输入完成后,按下CTRL+D来通知shell输入结束
进程组(工作)的概念较为简单易懂。而会话主要是针对一个终端建立的。当我们打开多个终端窗口时,实际上就创建了多个终端会话。每个会话都会有自己的前台工作和后台工作。这样,我们就为进程增加了管理和运行的层次
aaarticlea/png;base64,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" alt="" />
Relevant Link:
http://www.cnblogs.com/vamei/archive/2012/10/07/2713023.html
http://blog.csdn.net/zmxiangde_88/article/details/8027431
3. 进程标识编程示例
了解了进程标识的基本概念之后,接下来我们通过API编程方式来直观地了解下
0x1: 父子进程、组长进程和组员进程的关系
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> int main()
{
pid_t pid; /*
计算机程序设计中的分叉函数。返回值,若成功调用一次则返回两个值1
1. 子进程返回0
2. 父进程返回子进程标记
3. 否则,出错返回-1
*/
if ((pid = fork())<)
{//error
printf("fork error!");
}
else if (pid==)
{//child process
printf("The Child Process PID is %d.\n", getpid());
printf("The Parent Process PPID is %d.\n", getppid());
printf("The Group ID PGID is %d.\n", getpgrp());
printf("The Group ID PGID is %d.\n", getpgid());
printf("The Group ID PGID is %d.\n", getpgid(getpid()));
printf("The Session ID SID is %d.\n", getsid());
exit();
} printf("\n\n\n"); //parent process
sleep();
printf("The Parent Process PID is %d.\n", getpid());
printf("The Group ID PGID is %d.\n", getpgrp());
printf("The Group ID PGID is %d.\n", getpgid());
printf("The Group ID PGID is %d.\n", getpgid(getpid()));
printf("The Session ID SID is %d.\n", getsid()); return ;
}
aaarticlea/png;base64,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" alt="" />
从运行结果来看,我们可以得出几个结论
. 组长进程
) 组长进程标识: 其进程组ID == 其进程ID
) 组长进程可以创建一个进程组,创建该进程组中的进程,然后终止
) 只要进程组中有一个进程存在,进程组就存在,与组长进程是否终止无关
) 进程组生存期: 进程组创建到最后一个进程离开(终止或转移到另一个进程组) . 进程组id == 父进程id,即父进程为组长进程
0x2: 进程组更改
我们继续拿fork()产生父子进程的这个code example作为示例,因为正常情况下,父子进程具有相同的PGID,这个代码场景能帮助我们更好地去了解PGID的相关知识
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> int main()
{
pid_t pid; if ((pid=fork())<)
{
printf("fork error!");
exit();
}
else if (pid==)
{//child process
printf("The child process PID is %d.\n",getpid());
printf("The Group ID of child is %d.\n",getpgid()); // 返回组id
sleep();
printf("The Group ID of child is changed to %d.\n",getpgid());
exit();
} sleep();
/*
1. parent process:
will first execute the code blow
对于父进程来说,它的PID就是进程组ID: PGID,所以setpgid对父进程来说没有变化 2. child process
will also execute the code blow after 5 seconds
对于子进程来说,setpgid将改变子进程所属的进程组ID
*/
// 改变子进程的组id为子进程本身
setpgid(pid, pid); sleep();
printf("\n");
printf("The process PID is %d.\n",getpid());
printf("The Group ID of Process is %d.\n",getpgid()); return ;
}
aaarticlea/png;base64,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" alt="" />
从程序的运行结果可以看出
. 一个进程可以为自己或子进程设置进程组ID
. setpgid()加入一个现有的进程组或创建一个新进程组
0x3: 会话ID Session ID
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> int main()
{
pid_t pid; if ((pid=fork())<)
{
printf("fork error!");
exit();
}
else if (pid==)
{//child process
printf("The child process PID is %d.\n",getpid());
printf("The Group ID of child is %d.\n",getpgid());
printf("The Session ID of child is %d.\n",getsid());
setsid();
/*
子进程非组长进程
1. 故其成为新会话首进程(sessson leader)
2. 且成为组长进程(group leader)
所以
1. pgid = pid_child
2. sid = pid_child
*/
printf("Changed:\n");
printf("The child process PID is %d.\n",getpid());
printf("The Group ID of child is %d.\n",getpgid());
printf("The Session ID of child is %d.\n",getsid());
exit();
} return ;
}
aaarticlea/png;base64,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" alt="" />
从程序的运行结果可以得到如下结论
. 会话: 一个或多个进程组的集合
) 开始于用户登录
) 终止与用户退出
) 此期间所有进程都属于这个会话期 . 建立新会话: setsid()函数
) 该调用进程是组长进程,则出错返回
) 该调用进程不是组长进程,则创建一个新会话
2.1) 先调用fork父进程终止,子进程调用
2.2) 该进程变成新会话首进程(领头进程)(session header)
2.3) 该进程成为一个新进程组的组长进程。
2.4) 该进程没有控制终端,如果之前有,则会被中断
) 组长进程不能成为新会话首进程,新会话首进程必定会成为组长进程
下面这张图对整个PID、PGID、SID的关系做了一个梳理
Relevant Link:
http://www.cnblogs.com/nysanier/archive/2011/03/10/1979321.html
http://www.cnblogs.com/forstudy/archive/2012/04/03/2427683.html
4. 进程标志在Linux内核中的存储和表现形式
了解了Linux中进程标识的基本概念和API编程方式后,我们接下来继续研究一下Linux在内核中是如何去存储、组织、表现这些标识的
在task_struct中,和进程标识ID相关的域有
struct task_struct
{
...
pid_t pid;
pid_t tgid;
struct task_struct *group_leader;
struct pid_link pids[PIDTYPE_MAX];
struct nsproxy *nsproxy;
...
};
aaarticlea/png;base64,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" alt="" />
如果显示不完整,请另存到本地看
0x1: Linux内核Hash表
要谈Linux内核中进程标识的存储和组织,我们首先要了解Linux内核的Hash表机制,在内核中,查找是必不可少的,例如
. 内核管理这么多用户进程,现在要快速定位某一个进程,这儿需要查找
. 一个进程的地址空间中有多个虚存区,内核要快速定位进程地址空间的某个虚存区,这儿也需要查找
..
查找技术属于数据结构算法的范畴,常用的查找算法有如下几种
. 基于树的查找: 红黑树
. 基于计算的查找: 哈希查找
//两者(基于树、基于计算)的查找的效率高,而且适应内核的情况 . 基于线性表的查找: 二分查找
//尽管效率高但不能适应内核里面的情况,现在版本的内核几乎不可能使用数组管理一些数据
本文主要学习的进程标识的存储和查找就是基于计算的HASH表查找方式
0x2: Linux pid_hash散列表
在内核中,经常需要通过进程PID来获取进程描述符,例如
kill命令: 最简单的方法可以通过遍历task_struct链表并对比pid的值来获取,但这样效率太低,尤其当系统中运行很多个进程的时候
linux内核通过PIDS散列表来解决这一问题,能快速的通过进程PID获取到进程描述符
PID散列表包含4个表,因为进程描述符包含了表示不同类型PID的字段,每种类型的PID需要自己的散列表
//Hash表的类型 字段名 说明
. PIDTYPE_PID pid 进程的PID
. PIDTYPE_TGID tgid 线程组领头进程的PID
. PIDTYPE_PGID pgrp 进程组领头进程的PID
. PIDTYPE_SID session 会话领头进程的PID
0x3: 进程标识在内核中的存储
一个PID只对应着一个进程,但是一个PGID,TGID和SID可能对应着多个进程,所以在pid结构体中,把拥有同样PID(广义的PID)的进程放进名为tasks的成员表示的数组中,当然,不同类型的ID放在相应的数组元素中。
考虑下面四个进程:
. 进程A: PID=, PGID=, SID=
. 进程B: PID=, PGID=, SID=,它是进程组12344的组长进程
. 进程C: PID=, PGID=, SID= . 进程D: PID=, PGID=, SID=
分别用task_a, task_b, task_c和task_d表示它们的task_struct,则它们之间的联系是:
. task_a.pids[PIDTYPE_PGID].pid.tasks[PIDTYPE_PGID]指向有进程A-B-C构成的列表
. task_a.pids[PIDTYPE_SID].pid.tasks[PIDTYPE_SID]指向有进程A-B-C-D构成的列表
内核初始化期间动态地为4个散列表分配空间,并把它们的地址存入pid_hash数组(就是struct->pids[PIDTYPE_MAX]中)
0x4: 进程标识ID在内核中的表示和使用
内核用pid_hashfn宏把PID转换为表索引
kernel/pid.c
#define pid_hashfn(nr, ns) \
hash_long((unsigned long)nr + (unsigned long)ns, pidhash_shift)
这个宏就负责把一个PID转换为一个index,我们继续跟进hash_long这个函数
\include\linux\hash.h
/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */
#define GOLDEN_RATIO_PRIME_32 0x9e370001UL
/* 2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */
#define GOLDEN_RATIO_PRIME_64 0x9e37fffffffc0001UL #if BITS_PER_LONG == 32
#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_PRIME_32
#define hash_long(val, bits) hash_32(val, bits)
#elif BITS_PER_LONG == 64
#define hash_long(val, bits) hash_64(val, bits)
#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_PRIME_64
#else
#error Wordsize not 32 or 64
#endif static inline u64 hash_64(u64 val, unsigned int bits)
{
u64 hash = val; /* Sigh, gcc can't optimise this alone like it does for 32 bits. */
u64 n = hash;
n <<= ;
hash -= n;
n <<= ;
hash -= n;
n <<= ;
hash += n;
n <<= ;
hash -= n;
n <<= ;
hash += n;
n <<= ;
hash += n; /* High bits are more random, so use them. */
return hash >> ( - bits);
} static inline u32 hash_32(u32 val, unsigned int bits)
{
/* On some cpus multiply is faster, on others gcc will do shifts */
u32 hash = val * GOLDEN_RATIO_PRIME_32; /* High bits are more random, so use them. */
return hash >> ( - bits);
} static inline unsigned long hash_ptr(const void *ptr, unsigned int bits)
{
return hash_long((unsigned long)ptr, bits);
}
#endif /* _LINUX_HASH_H */
对这个算法的简单理解如下
. 让key乘以一个大数,于是结果溢出
. 把留在32/64位变量中的值作为hash值3
. 由于散列表的索引长度有限,取这hash值的高几位作为索引值,之所以取高几位,是因为高位的数更具有随机性,能够减少所谓"冲突(collision)",即减少hash碰撞
. 将结果乘以一个大数
) 32位系统中这个数是0x9e370001UL
) 64位系统中这个数是0x9e37fffffffc0001UL
/*
取这个数字的数学意义
Knuth建议,要得到满意的结果
1. 对于32位机器,2^32做黄金分割,这个大树是最接近黄金分割点的素数,0x9e370001UL就是接近 2^32*(sqrt(5)-1)/2 的一个素数,且这个数可以很方便地通过加运算和位移运算得到,因为它等于2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1
2. 对于64位系统,这个数是0x9e37fffffffc0001UL,同样有2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1
*/
. 从程序中可以看到
) 对于32位系统计算hash值是直接用的乘法,因为gcc在编译时会自动优化算法
) 对于64位系统,gcc似乎没有类似的优化,所以用的是位移运算和加运算来计算。首先n=hash, 然后n左移18位,hash-=n,这样hash = hash * ( - ^),下一项是-^,而n之前已经左移过18位了,所以只需要再左移33位,于是有n <<= ,依次类推
. 最终算出了hash值
现在我们已经可以通过pid_hashfn把PID转换为一个index了,接下来我们再来想一想其中的问题
. 首先,对于内核中所用的hash算法,不同的PID/TGID/PGRP/SESSION的ID(没做特殊声明前一般用PID作为代表),有可能会对应到相同的hash表索引,也就是冲突(colliding)
. 于是一个index指向的不是单个进程,而是一个进程的列表,这些进程的PID的hash值都一样
. task_struct中pids表示的四个列表,就是具有同样hash值的进程组成的列表。比如进程A的task_struct中的
) pids[PIDTYPE_PID]指向了所有PID的hash值都和A的PID的hash值相等的进程的列表
) pids[PIDTYPE_PGID]指向所有PGID的hash值与A的PGID的hash值相等的进程的列表
需要注意的是,与A同组的进程,他们具有同样的PGID,更具上面所解释的,这些进程构成的链表是存放在A的pids[PIDTYPE_PGID].pid.tasks指向的列表中
下面的图片说明了hash和进程链表的关系,图中TGID=4351和TGID=246具有同样的hash值。(图中的字段名称比较老,但大意是一样的,只要把pid_chain看做是pid_link结构中的node,把pid_list看做是pid结构中的tasks即可)
Relevant Link:
http://blog.chinaunix.net/uid-24683784-id-3297992.html
http://blog.chinaunix.net/uid-28728968-id-4189105.html
http://blog.csdn.net/fengtaocat/article/details/7025488
http://blog.csdn.net/gaopenghigh/article/details/8831312
http://blog.csdn.net/bysun2013/article/details/14053937
http://blog.csdn.net/zhanglei4214/article/details/6765913
http://blog.csdn.net/gaopenghigh/article/details/8831692
http://blog.csdn.net/yanglovefeng/article/details/8036154
http://www.oschina.net/question/565065_115167
5. 后记
在Linux的进程的标识符中有很多"组"的概念,Linux从最原始的PID开始,进行了逐层的封装,不断嵌套成更大的组,这也意味着,Linux中的进程序列之间并不是完全独立的关系,而是包含着很多的组合关系的,我们可以充分利用Linux操作系统本身提供的特性,来对指令序列进行聚合,从而从低维的序列信息中发现更高伟的行为模式
Copyright (c) 2014 LittleHann All rights reserved