Linux进程pid分配法

一. 概述

Android系统创建进程，最终的实现还是调用linux fork方法，对于linux系统每个进程都有唯一的进程ID(值大于0)，也有pid上限，默认为32768。 pid可重复利用，当进程被杀后会回收该pid，以供后续的进程pid分配。

上一篇文章Linux进程管理详细地介绍了进程fork过程，在copy_process()过程，执行完父进行文件、内存等信息的拷贝，紧接着便是执行alloc_pid()方法去分配pid.

二. 分配法

2.1 copy_process

static struct task_struct *copy_process(unsigned long clone_flags,
          unsigned long stack_start,
          unsigned long stack_size,
          int __user *child_tidptr,
          struct pid *pid,
          int trace,
          unsigned long tls)
{
  ...
  struct task_struct *p;
  if (pid != &init_struct_pid) {
    //分配pid[见小节2.2]
    pid = alloc_pid(p->nsproxy->pid_ns_for_children);
  }
  p->pid = pid_nr(pid); //设置pid[见小节2.4]
  ...
}

2.2 alloc_pid

[-> kernel/kernel/pid.c]

struct pid *alloc_pid(struct pid_namespace *ns)
{
  struct pid *pid; //[见小节2.2.1]
  enum pid_type type;
  int i, nr;
  struct pid_namespace *tmp; //[见小节2.2.4]
  struct upid *upid;
  int retval = -ENOMEM;
  //分配pid结构体的内存
  pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL);
  ...

  tmp = ns;
  pid->level = ns->level;
  for (i = ns->level; i >= 0; i--) {
    nr = alloc_pidmap(tmp); //分配pid【见小节2.3】
    ...
    pid->numbers[i].nr = nr; //nr保存到pid结构体
    pid->numbers[i].ns = tmp;
    tmp = tmp->parent;
  }
  ...

  get_pid_ns(ns);
  atomic_set(&pid->count, 1);
  for (type = 0; type < PIDTYPE_MAX; ++type)
    INIT_HLIST_HEAD(&pid->tasks[type]); //初始化pid的hlist结构体

  upid = pid->numbers + ns->level;
  spin_lock_irq(&pidmap_lock);
  if (!(ns->nr_hashed & PIDNS_HASH_ADDING))
    goto out_unlock;
    
  for ( ; upid >= pid->numbers; --upid) {
    //建立pid_hash的关联关系
    hlist_add_head_rcu(&upid->pid_chain,
        &pid_hash[pid_hashfn(upid->nr, upid->ns)]);
    upid->ns->nr_hashed++;
  }
  spin_unlock_irq(&pidmap_lock);
  return pid;
  ...
}

2.2.1 pid结构体

[-> kernel/include/linux/pid.h]

struct pid
{
  atomic_t count;
  unsigned int level;

  struct hlist_head tasks[PIDTYPE_MAX]; //见enum pid_type
  struct rcu_head rcu;
  struct upid numbers[1]; //见结构体upid
};

2.2.2 upid结构体

[-> pid.h]

struct upid 
{
  int nr; 
  struct pid_namespace *ns;
  struct hlist_node pid_chain;
};

2.2.3 pid_type

[-> pid.h]

enum pid_type
{
  PIDTYPE_PID, //进程ID
  PIDTYPE_PGID, //进程组ID
  PIDTYPE_SID, //会话组ID
  PIDTYPE_MAX,
  __PIDTYPE_TGID //仅用于__task_pid_nr_ns()
};

2.2.4 pid_namespace结构体

[-> kernel/include/linux/pid_namespace.h]

struct pid_namespace {
  struct kref kref;
  struct pidmap pidmap[PIDMAP_ENTRIES];
  struct rcu_head rcu;
  int last_pid; 
  unsigned int nr_hashed;
  struct task_struct *child_reaper;
  struct kmem_cache *pid_cachep;
  unsigned int level;
  struct pid_namespace *parent;
  ...
  struct user_namespace *user_ns;
  struct work_struct proc_work;
  kgid_t pid_gid;
  int hide_pid;
  int reboot; 
  struct ns_common ns;
};

PID命名空间，这是为系统提供虚拟化做支撑的功能。

2.3 alloc_pidmap

[-> kernel/kernel/pid.c]

static int alloc_pidmap(struct pid_namespace *pid_ns)
{
  //last_pid为上次分配出去的pid
  int i, offset, max_scan, pid, last = pid_ns->last_pid;
  struct pidmap *map;

  pid = last + 1;
  if (pid >= pid_max)
    pid = RESERVED_PIDS; //默认为300
    
  offset = pid & BITS_PER_PAGE_MASK; //最高位值置0，其余位不变
  map = &pid_ns->pidmap[pid/BITS_PER_PAGE]; //找到目标pidmap

  //当offset =0，则扫描一次;
  //当offset!=0，则扫描两次
  max_scan = DIV_ROUND_UP(pid_max, BITS_PER_PAGE) - !offset;
  for (i = 0; i <= max_scan; ++i) {
    if (unlikely(!map->page)) {
      void *page = kzalloc(PAGE_SIZE, GFP_KERNEL);
      spin_lock_irq(&pidmap_lock);
      if (!map->page) {
        map->page = page;
        page = NULL;
      }
      spin_unlock_irq(&pidmap_lock);
      kfree(page);
      if (unlikely(!map->page))
        break;
    }
    
    //当pidmap还有可用pid时
    if (likely(atomic_read(&map->nr_free))) {
      do {
        //当offset位空闲时返回该pid
        if (!test_and_set_bit(offset, map->page)) {
          atomic_dec(&map->nr_free); //可用pid减一
          set_last_pid(pid_ns, last, pid); //设置last_pid
          return pid;
        }
        //否则，查询下一个非0的offset值
        offset = find_next_offset(map, offset);
        根据offset转换成相应的pid
        pid = mk_pid(pid_ns, map, offset);
      } while (offset < BITS_PER_PAGE && pid < pid_max);
    }
    
    //当上述pid分配失败，则再次查找offset
    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允许分配的最大值为32767，当pid分配轮过一圈之后则允许分配的最小值为300，也就是说前300个pid是不可再分配的。

2.3.1 pidmap结构体

[-> kernel/include/linux/pid_namespace.h]

struct pidmap {
       atomic_t nr_free; //可用pid的个数
       void *page; //用于存放位图
};

pidmap->page的大小为4KB，每一个bit位代表一个进程pid的分配情况，那么4KB*8=32768，这正好是pid可分配的上限，用nr_free代表该namespace下还有多少可用pid。

2.3.2 find_next_offset

[-> pid.c]

#define find_next_offset(map, off)					\
    find_next_zero_bit((map)->page, BITS_PER_PAGE, off)

static inline int mk_pid(struct pid_namespace *pid_ns,
    struct pidmap *map, int off)
{
  return (map - pid_ns->pidmap)*BITS_PER_PAGE + off;
}

2.4 pid_nr