0. 引言1. Linux进程2. Linux进程的相关标识3. 进程标识编程示例4. 进程标志在Linux内核中的存储和表现形式5. 后记

1. 针对Linux的进程状态，需要监控捕获哪些维度的信息，哪些信息能够更好地为安全人员描绘出黑客的入侵迹象2. 监控很容易造成的现象就是会有短时间内的大量数据产生(杂志数据过滤后)，如何对收集的数据进行聚类，使之表现出一些更高维度的、相对有用的信息3. 要实现数据的聚类，就需要从现在的元数据中找到一些"连结标识"，这些"连结标识"就是我们能够将低纬度的数据聚类扩展到高纬度的技术基础。

http://www.cnblogs.com/LittleHann/p/3865490.html

1. fork生成当前进程的一个相同副本，该副本称之为"子进程"。原进程的所有资源都以适当的方式复制到子进程，因此执行了该系统调用之后，原来的进程就有了2个独立的实例，包括    1) 同一组打开文件    2) 同样的工作目录    3) 内存中同样的数据(2个进程各有一个副本)    ..2. exec从一个可执行的二进制文件来加载另一个应用程序，来"代替"当前运行的进程，即加载了一个新的进程。因为exec并不创建新进程，搜易必须首先使用fork复制一个旧的程序，然后调用exec在系统上创建另一个应用程序//总体来说：fork负责产生空间、exec负责载入实际的需要执行的程序

1. 新进程不是独立于父进程，而是可以和父进程共享某些资源2. 可以指定需要共享和复制的资源种类，例如    1) 父进程的内存数据    2) 打开文件或安装的信号处理程序

http://www.cnblogs.com/LittleHann/p/3853854.html

1. 对于父命名空间来说，全局的ID依然不变，而在子命名空间中，每个子命名空间都有自己的一套ID命名序列2. 虽然子容器(子命名空间)不了解系统中的其他容器，但父容器知道子命名空间的存在，也可以看到其中执行的所有进程3. 在Linux的这种层次结构的命名空间的架构下，一个进程可能拥有多个ID值，至于哪一个是"正确"的，则依赖于具体的上下文

深入linux内核架构(中文版).pdf 第2章

1. 该命名空间中的所有PID对父命名空间都是可见的2. 但子命名空间无法看到父命名空间的PID

1. 全局ID是在内核本身和"初始命名空间"中的唯一ID号，在系统启动期间开始的init进程即属于"初始命名空间"。对每个ID类型，都有一个给定的全局ID，保证在整个系统中是唯一的2. 局部ID属于某个特定的命名空间，不具备全局有效性。对每个ID类型，它们"只能"在所属的命名空间内部有效

1. 对于一个多线程的进程来说，它实际上是一个进程组，每个线程在调用getpid()时获取到的是自己的tgid值，而线程组领头的那个领头线程的pid和tgid是相同的2. 对于独立进程，即没有使用线程的进程来说，它只有唯一一个线程，领头线程，所以它调用getpid()获取到的值就是它的pid

ps -o pid,pgid,ppid,comm | cat

1. 每个会话有1个或多个进程组组成，可能有一个领头进程((session leader))，也可能没有 2. 会话领导进程的PID成为识别会话的SID(session ID) 3. 会话中的每个进程组称为一个工作(job)4. 会话可以有一个进程组成为会话的前台工作(foreground)，而其他的进程组是后台工作(background)5. 每个会话可以连接一个控制终端(control terminal)。当控制终端有输入输出时，都传递给该会话的前台进程组。由终端产生的信号，比如CTRL+Z， CTRL+\，会传递到前台进程组。6. 会话的意义在于将多个job(进程组)囊括在一个终端，并取其中的一个job(进程组)作为前台，来直接接收该终端的输入输出以及终端信号。 其他工作在后台运行

$ping localhost > log &[1] 10141//括号中的1表示工作号，而10141为PGID

1. $kill -SIGTERM -10141//发送给PGID(通过在PGID前面加-来表示是一个PGID而不是PID)2. $kill -SIGTERM %1//发送给工作1(%1) 

$cat > log &$fg %1//当我们运行第一个命令后，由于工作在后台，我们无法对命令进行输入，直到我们将工作带入前台，才能向cat命令输入。在输入完成后，按下CTRL+D来通知shell输入结束

http://www.cnblogs.com/vamei/archive/2012/10/07/2713023.htmlhttp://blog.csdn.net/zmxiangde_88/article/details/8027431

#include <stdio.h>#include <stdlib.h>#include <unistd.h>int main() {    pid_t pid;    /*    计算机程序设计中的分叉函数。返回值，若成功调用一次则返回两个值1    1. 子进程返回0    2. 父进程返回子进程标记    3. 否则，出错返回-1    */    if ((pid = fork())<0)     {//error        printf("fork error!");    }    else if (pid==0)     {//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(0));        printf("The Group ID PGID is %d.\n", getpgid(getpid()));        printf("The Session ID SID is %d.\n", getsid());        exit(0);    }        printf("\n\n\n");    //parent process    sleep(3);    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(0));    printf("The Group ID PGID is %d.\n", getpgid(getpid()));    printf("The Session ID SID is %d.\n", getsid());    return 0;}

1. 组长进程    1) 组长进程标识: 其进程组ID == 其进程ID　　    2) 组长进程可以创建一个进程组，创建该进程组中的进程，然后终止　　    3) 只要进程组中有一个进程存在，进程组就存在，与组长进程是否终止无关　　    4) 进程组生存期: 进程组创建到最后一个进程离开(终止或转移到另一个进程组) 2. 进程组id == 父进程id，即父进程为组长进程

#include <stdio.h>#include <stdlib.h>#include <unistd.h>int main() {    pid_t pid;    if ((pid=fork())<0)     {        printf("fork error!");        exit(1);    }    else if (pid==0)     {//child process        printf("The child process PID is %d.\n",getpid());        printf("The Group ID of child is %d.\n",getpgid(0)); // 返回组id        sleep(5);        printf("The Group ID of child is changed to %d.\n",getpgid(0));        exit(0);    }        sleep(1);    /*    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(5);    printf("\n");    printf("The process PID is %d.\n",getpid());     printf("The Group ID of Process is %d.\n",getpgid(0));     return 0;}

1. 一个进程可以为自己或子进程设置进程组ID2. setpgid()加入一个现有的进程组或创建一个新进程组

#include <stdio.h>#include <stdlib.h>#include <unistd.h>int main() {    pid_t pid;    if ((pid=fork())<0)     {        printf("fork error!");        exit(1);    }    else if (pid==0)     {//child process        printf("The child process PID is %d.\n",getpid());        printf("The Group ID of child is %d.\n",getpgid(0));        printf("The Session ID of child is %d.\n",getsid(0));         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(0));        printf("The Session ID of child is %d.\n",getsid(0));         exit(0);    }    return 0;}

1. 会话: 一个或多个进程组的集合    1) 开始于用户登录    2) 终止与用户退出　　    3) 此期间所有进程都属于这个会话期2. 建立新会话: setsid()函数    1) 该调用进程是组长进程，则出错返回 　　    2) 该调用进程不是组长进程，则创建一个新会话        2.1) 先调用fork父进程终止，子进程调用        2.2) 该进程变成新会话首进程(领头进程)(session header)        2.3) 该进程成为一个新进程组的组长进程。　　　　    2.4) 该进程没有控制终端，如果之前有，则会被中断    3) 组长进程不能成为新会话首进程，新会话首进程必定会成为组长进程 

http://www.cnblogs.com/nysanier/archive/2011/03/10/1979321.htmlhttp://www.cnblogs.com/forstudy/archive/2012/04/03/2427683.html

struct task_struct{    ...    pid_t pid;    pid_t tgid;    struct task_struct *group_leader;    struct pid_link pids[PIDTYPE_MAX];    struct nsproxy *nsproxy;    ...};

1. 内核管理这么多用户进程，现在要快速定位某一个进程，这儿需要查找2. 一个进程的地址空间中有多个虚存区，内核要快速定位进程地址空间的某个虚存区，这儿也需要查找..

1. 基于树的查找: 红黑树2. 基于计算的查找: 哈希查找//两者(基于树、基于计算)的查找的效率高，而且适应内核的情况3. 基于线性表的查找: 二分查找//尽管效率高但不能适应内核里面的情况，现在版本的内核几乎不可能使用数组管理一些数据 

//Hash表的类型   字段名     说明1. PIDTYPE_PID   pid      进程的PID2. PIDTYPE_TGID  tgid     线程组领头进程的PID3. PIDTYPE_PGID  pgrp     进程组领头进程的PID4. PIDTYPE_SID   session  会话领头进程的PID

1. 进程A: PID=12345, PGID=12344, SID=123002. 进程B: PID=12344, PGID=12344, SID=12300，它是进程组12344的组长进程3. 进程C: PID=12346, PGID=12344, SID=123004. 进程D: PID=12347, PGID=12347, SID=12300

1. task_a.pids[PIDTYPE_PGID].pid.tasks[PIDTYPE_PGID]指向有进程A-B-C构成的列表2. task_a.pids[PIDTYPE_SID].pid.tasks[PIDTYPE_SID]指向有进程A-B-C-D构成的列表

#define pid_hashfn(nr, ns)    \    hash_long((unsigned long)nr + (unsigned long)ns, pidhash_shift)

/* 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#endifstatic 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 <<= 18;    hash -= n;    n <<= 33;    hash -= n;    n <<= 3;    hash += n;    n <<= 3;    hash -= n;    n <<= 4;    hash += n;    n <<= 2;    hash += n;    /* High bits are more random, so use them. */    return hash >> (64 - 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 >> (32 - bits);}static inline unsigned long hash_ptr(const void *ptr, unsigned int bits){    return hash_long((unsigned long)ptr, bits);}#endif /* _LINUX_HASH_H */

1. 让key乘以一个大数，于是结果溢出2. 把留在32/64位变量中的值作为hash值33. 由于散列表的索引长度有限，取这hash值的高几位作为索引值，之所以取高几位，是因为高位的数更具有随机性，能够减少所谓"冲突(collision)"，即减少hash碰撞4. 将结果乘以一个大数    1) 32位系统中这个数是0x9e370001UL    2) 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 + 12. 对于64位系统，这个数是0x9e37fffffffc0001UL，同样有2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1*/5. 从程序中可以看到    1) 对于32位系统计算hash值是直接用的乘法，因为gcc在编译时会自动优化算法    2) 对于64位系统，gcc似乎没有类似的优化，所以用的是位移运算和加运算来计算。首先n=hash, 然后n左移18位，hash-=n，这样hash = hash * (1 - 2^18)，下一项是-2^51，而n之前已经左移过18位了，所以只需要再左移33位，于是有n <<= 33，依次类推6. 最终算出了hash值

1. 首先，对于内核中所用的hash算法，不同的PID/TGID/PGRP/SESSION的ID(没做特殊声明前一般用PID作为代表)，有可能会对应到相同的hash表索引，也就是冲突(colliding)2. 于是一个index指向的不是单个进程，而是一个进程的列表，这些进程的PID的hash值都一样3. task_struct中pids表示的四个列表，就是具有同样hash值的进程组成的列表。比如进程A的task_struct中的    1) pids[PIDTYPE_PID]指向了所有PID的hash值都和A的PID的hash值相等的进程的列表    2) pids[PIDTYPE_PGID]指向所有PGID的hash值与A的PGID的hash值相等的进程的列表

http://blog.chinaunix.net/uid-24683784-id-3297992.htmlhttp://blog.chinaunix.net/uid-28728968-id-4189105.htmlhttp://blog.csdn.net/fengtaocat/article/details/7025488http://blog.csdn.net/gaopenghigh/article/details/8831312http://blog.csdn.net/bysun2013/article/details/14053937http://blog.csdn.net/zhanglei4214/article/details/6765913http://blog.csdn.net/gaopenghigh/article/details/8831692http://blog.csdn.net/yanglovefeng/article/details/8036154http://www.oschina.net/question/565065_115167