在進程創建的時候，Linux系統會分配一個號碼給當前這個進程，這個號碼在進程所在的命名空間中是唯一的，但在其它的兄弟進程中，這個號碼就不是唯一的了，也就是對于全局的命名空間來說，這個號不是全局唯一。這個號碼就是進程的ID號，簡稱為PID。
一，進程號數據結構表示
這個PID被保存在進程的結構表示task_struct中。
struct task_struct{
....
pid_t pid;
pid_t tgid;
.....
};
這兩個結構都是pid_t，這個結構是是體系結構相關的，在X86下它的定義是int，也就是可以同時使用的最大的ID數為int的取值范圍。tgid是線程組ID，因為在Linux中線程也是進程，線程組的ID其實就是主線程的PID。
typedef int __kernel_pid_t;
typedef __kernel_pid_t pid_t;
二，管理進程ID
因為這些都是和具體的PID命名空間相關的，先了解一下PID的命名空間結構。
struct pid_namespace {
struct kref kref;
struct pidmap pidmap[PIDMAP_ENTRIES];
int last_pid;
struct task_struct *child_reaper;
struct kmem_cache *pid_cachep;
int level;
struct pid_namespace *parent;
#ifdef CONFIG_PROC_FS
struct vfsmount *proc_mnt;
#endif
};
這個結構用于實現很多的功能，如保證分配唯一的PID，在這里只關心這幾個成員：
- child_reaper。每個PID命名空間都有一個和全局空間中init進程一樣的進程，該進程實現了對命名空間中的孤兒進程進行wait4操作。child_reaper保存了該進程的指針。
- parent。指向父命名空間的指針。
- level。表示當前的命名空間在命名空間層次結構中的深度，第一個命名空間，就是全局的命名空間level值為0。level較高的命名空間對于level較低的命名空間是可見的，其實命名空間是采用在低level命名空間中給高level命名空間中的PID建立映射，所以對其是可見的。
為了實現命名空間可見性，建立兩個數據結構：struct pid用于內核對PID的內部表示，而struct upid表示特定的命名空間中可見的信息。定義如下：
struct upid {
/* Try to keep pid_chain in the same cacheline as nr for find_pid */
int nr; //表示ID的數值，這個就是命名空間內所可見的PID數值。
struct pid_namespace *ns; // 該ID的命名空間指針。
struct hlist_node pid_chain; // 將所有的upid實例都保存在一散列溢出鏈表上。
};
struct pid
{
atomic_t count; // 引用計數
/* lists of tasks that use this pid */ //
struct hlist_head tasks[PIDTYPE_MAX]; // 每個數組項都是一個散列表頭。
struct rcu_head rcu; //
int level;
struct upid numbers[1];
};
PIDTYPE_MAX表示進程ID的類型，如下：
enum pid_type
{
PIDTYPE_PID,進程ID
PIDTYPE_PGID,進程組ID
PIDTYPE_SID,會話組ID
PIDTYPE_MAX
};
在網上找的一張圖片，說明這些數據結構的關系：
這個圖也不是那么容易看明白，圖中一共有三個部分，說明如下：
-
struct pid是進程ID在內核結構的一個表示。但有可能會出現多個task_struct實例共享同一個進程ID，這就需要將所有共享進程ID的task_struct都以一種方式和struct pid關聯起來，這里就是struct pid結構中的tasks數組，對應多個散列鏈表的頭部，那是不是struct task_struct結構中應該提供鏈表接點呢，就是這樣的。
struct task_struct{ ...... struct pid_link pids[PIDTYPE_MAX]; ...... }; struct pid_link{ //定義于pid.h文件中。 struct hlist_node node; struct pid *pid; }這個結構中，pid指向進程所屬的pid結構，而node用作散列表接點元素。上文中的圖中的mode，應為node。這樣的話，圖的右上角部分就容易理解了。再往下 - struct pid結構中有一個level域，表示當前命名空間的層次，這個值可以表示當前可以看到該進程的命名空間的數目，比如當前只有一個命名空間，則表示進程對一個命名空間是可見的，如果這個命名空間有一個子命名空間，那么子命名空間的level值應該是1，這個時候表示子命名空間的進程對2個命名空間可見：自身和父命名空間。struct pid為了實現這個，在結構中定義了numbers域，定義只有一個，因為大多數情況是這樣的。但如果有更多的話，也沒事，為什么呢？因為這個numbers域在結構的末尾，所以只要添加，就可以根據level的值讀出來。只要分配空間了，就不會有數組溢出了。所以數組的每一個元素都是對應于在某一層次的命名空間中的struct upid表示，這正是PID在特定命名空間中可見的信息。
-
現在說到右下角了，這是在指定的命名空間中查找對應于指定PID的struct pid結構實例。因為我們在某一命名空間對PID可見的信息是struct upid,那么要根據這個struct upid找到struct pid。
為了實現這個，內核使用散列表，在pid.c文件中定義：
static struct hlist_head *pid_hash;這是一個數組，數組的大小取決于當前計算機的內存大小，調用pidhash_init函數計算合適的容量并分配內存
void __init pidhash_init(void) { int i, pidhash_size; unsigned long megabytes = nr_kernel_pages >> (20 - PAGE_SHIFT); pidhash_shift = max(4, fls(megabytes * 4)); pidhash_shift = min(12, pidhash_shift); pidhash_size = 1 << pidhash_shift; printk("PID hash table entries: %d (order: %d, %Zd bytes)\n", pidhash_size, pidhash_shift, pidhash_size * sizeof(struct hlist_head)); pid_hash = alloc_bootmem(pidhash_size * sizeof(*(pid_hash))); if (!pid_hash) panic("Could not alloc pidhash!\n"); for (i = 0; i < pidhash_size; i++) INIT_HLIST_HEAD(&pid_hash[i]); }這個函數在內核啟動的時候，也就是start_kernel中，就會被調用。
在這之后，可以根據struct upid中nr的值和命名空間的地址進行散列。
int fastcall attach_pid(struct task_struct *task, enum pid_type type,
struct pid *pid)
{
struct pid_link *link;
link = &task->pids[type];
link->pid = pid;
hlist_add_head_rcu(&link->node, &pid->tasks[type]);
return 0;
}
這個比較好理解，就是將struct pid附加到struct task_struct上去。這樣就建立了一個雙向的連接：task_struct可以通過task_struct->pids[type]->pid訪問struct pid實例。而從struct pid實例開始的話，可以遍歷tasks[type]散列表找到task_struct實例。
四，實現
在管理這些結構時，主要是對下面幾個問題比較著重：
- 根據一個局部的進程ID和對應的命名空間，查找所對應的task_struct實例。
- 如果已知task_struct和進程類型，命名空間，如何找到命名空間里的進程ID，就是struct upid結構的nr值。
對于第一個問題，先根據局部的進程ID和對應的命名空間找到struct pid實例，然后再確定task_struct實例。
struct pid * fastcall 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;
}
EXPORT_SYMBOL_GPL(find_pid_ns);
通過前文說的pid_hash散列數組，對于container_of的實現，可以參看博文【Li
nux內核的Container_of機制
】。在找到struct pid之后，再確定struct task_struct就容易了。
內核封裝了一個函數，用于一步完成這個操作：
struct task_struct *find_task_by_pid_type_ns(int type, int nr,
struct pid_namespace *ns)
{
return pid_task(find_pid_ns(nr, ns), type);
}
pid_task用于根據struct pid和type，找到具體的struct task_struct，這里也用到了Container_of機制。
struct task_struct * fastcall pid_task(struct pid *pid, enum pid_type type)
{
struct task_struct *result = NULL;
if (pid) {
struct hlist_node *first;
first = rcu_dereference(pid->tasks[type].first);
if (first)
result = hlist_entry(first, struct task_struct, pids[(type)].node);
}
return result;
}
再回到第二個問題，第二個問題就比較容易了，根據struct task_struct和type，可以很容易的找到struct pid，只需要
struct pid* _pid = task->pids[type].pid;
就可以了，然后再直接遍歷_pid->numbers就可以得到匹配的命名空間所在struct upid結構，進而獲取nr的值。
五，生成唯一的進程ID
上面討論的是內核如果對進程的ID進行管理，內核肯定還會負責生成一些PID，并且保證這些PID都是全局唯一的。
為了知道哪些ID已經分配，內核使用了一個大位圖，位圖中的每個比特表示一個PID，這樣就很明白了，PID的值和比特位的位置是唯一對應的。這樣一來，分配一個沒有使用的PID，就相當于在位圖中尋找第一個為0的比特，然后將其置1。
static int alloc_pidmap(struct pid_namespace *pid_ns)
{
int i, offset, max_scan, pid, last = pid_ns->last_pid;
struct pidmap *map;
pid = last + 1;
if (pid >= pid_max)
pid = RESERVED_PIDS;
offset = pid & BITS_PER_PAGE_MASK;
map = &pid_ns->pidmap[pid/BITS_PER_PAGE];
max_scan = (pid_max + BITS_PER_PAGE - 1)/BITS_PER_PAGE - !offset;
for (i = 0; i <= max_scan; ++i) {
if (unlikely(!map->page)) {
void *page = kzalloc(PAGE_SIZE, GFP_KERNEL);
/*
* Free the page if someone raced with us
* installing it:
*/
spin_lock_irq(&pidmap_lock);
if (map->page)
kfree(page);
else
map->page = page;
spin_unlock_irq(&pidmap_lock);
if (unlikely(!map->page))
break;
}
if (likely(atomic_read(&map->nr_free))) {
do {
if (!test_and_set_bit(offset, map->page)) {
atomic_dec(&map->nr_free);
pid_ns->last_pid = pid;
return pid;
}
offset = find_next_offset(map, offset);
pid = mk_pid(pid_ns, map, offset);
/*
* find_next_offset() found a bit, the pid from it
* is in-bounds, and if we fell back to the last
* bitmap block and the final block was the same
* as the starting point, pid is before last_pid.
*/
} while (offset < BITS_PER_PAGE && pid < pid_max &&
(i != max_scan || pid < last ||
!((last+1) & BITS_PER_PAGE_MASK)));
}
if (map < &pid_ns->pidmap[(pid_max-1)/BITS_PER_PAGE]) {
++map;
offset = 0;
} else {
map = &pid_ns->pidmap[0];
offset = RESERVED_PIDS;
if (unlikely(last == offset))
break;
}
pid = mk_pid(pid_ns, map, offset);
}
return -1;
}
釋放一個PID操作
static fastcall void free_pidmap(struct pid_namespace *pid_ns, int pid)
{
struct pidmap *map = pid_ns->pidmap + pid / BITS_PER_PAGE;
int offset = pid & BITS_PER_PAGE_MASK;
clear_bit(offset, map->page);
atomic_inc(&map->nr_free);
}
另外，上面討論知道，在建立一個新的進程時，進程需要在多個命名空間中是可見的，對于每個對其可見的命名空間，都需要生成一個局部的PID，這個過程處理如下：
struct pid *alloc_pid(struct pid_namespace *ns)
{
struct pid *pid;
enum pid_type type;
int i, nr;
struct pid_namespace *tmp;
struct upid *upid;
pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL);
if (!pid)
goto out;
tmp = ns;
for (i = ns->level; i >= 0; i--) {//這里將對其可見的所有的命名空間都生成一個局部的ID
nr = alloc_pidmap(tmp);
if (nr < 0)
goto out_free;
pid->numbers[i].nr = nr;
pid->numbers[i].ns = tmp;
tmp = tmp->parent;
}
get_pid_ns(ns);
pid->level = ns->level;
atomic_set(&pid->count, 1);
for (type = 0; type < PIDTYPE_MAX; ++type)
INIT_HLIST_HEAD(&pid->tasks[type]);
spin_lock_irq(&pidmap_lock);
for (i = ns->level; i >= 0; i--) {//更新struct pid,對每個struct upid，都將其置于散列表上。
upid = &pid->numbers[i];
hlist_add_head_rcu(&upid->pid_chain,
&pid_hash[pid_hashfn(upid->nr, upid->ns)]);
}
spin_unlock_irq(&pidmap_lock);
out:
return pid;
out_free:
for (i++; i <= ns->level; i++)
free_pidmap(pid->numbers[i].ns, pid->numbers[i].nr);
kmem_cache_free(ns->pid_cachep, pid);
pid = NULL;
goto out;
}
這個函數很簡單，處理的功能也比較單一。
六，小結
再回過來看內核進程，這里一個進程類型，其實在內核中進程不是只有一個PID這個特征的，還有其它的ID，像上文涉及的tgid就是其中一個，可能有以下幾種類型：
-
線程組ID，就是TGID。在一個進程沒有使用線程之前，TGID和PID是相等的。線程組的主進程，就是第一個創建線程的進程。每個”線程“都包含組長的task_struct實例
struct task_struct{ ....... struct task_struct *group_leader; /* threadgroup leader */ ....... }; - 由獨立進程合并的進程組。每個task_struct結構都包含進程組長的PID信息，這個數據存儲于task_struct->signal->__pgrp中。
- 幾個進程組可以合并成一個會話，會話中的所有進程都有同樣的會話ID。
- 全局PID。
-
局部PID。這是由于引進命名空間導致的，因為命名空間中的所有PID對父命名空間都是可見的，但子命名空間無法看到父命名空間的PID。這就要求，某些進程可能有多個PID，因為可以看到該進程的命名空間都為為其分配一個PID。
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
