泰晓科技 -- 聚焦 Linux - 追本溯源，见微知著！
网站地址：https://tinylab.org

泰晓Linux实验盘，即刻上手内核与嵌入式开发
请稍侯

IPC Namespace 详解

Peng Weilin 创作于 2021/05/26
打赏

By pwl999 of [TinyLab.org][1] Mar 23, 2021

1 简介

进程间通讯的机制称为 IPC(Inter-Process Communication)。Linux 下有多种 IPC 机制：管道（PIPE）、命名管道（FIFO）、信号（Signal）、消息队列（Message queues）、信号量（Semaphore）、共享内存（Share Memory）、内存映射（Memory Map）、套接字（Socket）。

其中的三种消息队列（Message queues）、信号量（Semaphore）、共享内存（Share Memory）被称为 XSI IPC，他们源自于 UNIX System V IPC。

Linux 的 IPC Namespace 主要就是针对 XSI IPC 的，和其他 IPC 机制无关。

我们用简单操作来熟悉一下 IPC Namespace 的概念：

1、查看普通进程的 IPC namespace ：

  1. pwl@ubuntu:~$ sudo ls -l /proc/$$/ns
  2. [sudo] password for pwl:
  3. total 0
  4. lrwxrwxrwx 1 root root 0 3月  14 10:53 cgroup -> 'cgroup:[4026531835]'
  5. lrwxrwxrwx 1 root root 0 3月  14 10:53 ipc -> 'ipc:[4026531839]'
  6. lrwxrwxrwx 1 root root 0 3月  14 10:53 mnt -> 'mnt:[4026531840]'
  7. lrwxrwxrwx 1 root root 0 3月  14 10:53 net -> 'net:[4026531993]'
  8. lrwxrwxrwx 1 root root 0 3月  14 10:53 pid -> 'pid:[4026531836]'
  9. lrwxrwxrwx 1 root root 0 3月  14 10:53 pid_for_children -> 'pid:[4026531836]'
  10. lrwxrwxrwx 1 root root 0 3月  14 10:53 user -> 'user:[4026531837]'
  11. lrwxrwxrwx 1 root root 0 3月  14 10:53 uts -> 'uts:[4026531838]'
  12. pwl@ubuntu:~$ ipcs
  14. ------ Message Queues --------
  15. key        msqid      owner      perms      used-bytes   messages
  17. ------ Shared Memory Segments --------
  18. key        shmid      owner      perms      bytes      nattch     status
  19. 0x00000000 262144     pwl        600        67108864   2          dest
  20. 0x00000000 360449     pwl        600        524288     2          dest
  22. ------ Semaphore Arrays --------
  23. key        semid      owner      perms      nsems
  25. pwl@ubuntu:~$

2、创建新的 IPC namespace 并查看：

  1. pwl@ubuntu:~$ sudo unshare --ipc
  2. [sudo] password for pwl:
  3. root@ubuntu:~#
  4. root@ubuntu:~# ls -l /proc/$$/ns
  5. total 0
  6. lrwxrwxrwx 1 root root 0 3月  14 10:55 cgroup -> 'cgroup:[4026531835]'
  7. lrwxrwxrwx 1 root root 0 3月  14 10:55 ipc -> 'ipc:[4026532643]'
  8. lrwxrwxrwx 1 root root 0 3月  14 10:55 mnt -> 'mnt:[4026531840]'
  9. lrwxrwxrwx 1 root root 0 3月  14 10:55 net -> 'net:[4026531993]'
  10. lrwxrwxrwx 1 root root 0 3月  14 10:55 pid -> 'pid:[4026531836]'
  11. lrwxrwxrwx 1 root root 0 3月  14 10:55 pid_for_children -> 'pid:[4026531836]'
  12. lrwxrwxrwx 1 root root 0 3月  14 10:55 user -> 'user:[4026531837]'
  13. lrwxrwxrwx 1 root root 0 3月  14 10:55 uts -> 'uts:[4026531838]'
  14. root@ubuntu:~# ipcs
  16. ------ Message Queues --------
  17. key        msqid      owner      perms      used-bytes   messages
  19. ------ Shared Memory Segments --------
  20. key        shmid      owner      perms      bytes      nattch     status
  22. ------ Semaphore Arrays --------
  23. key        semid      owner      perms      nsems
  25. root@ubuntu:~#

2 源码分析

2.1 copy_ipcs()

在进程创建或者 unshare()/setns() 系统调用时，如果设置了 CLONE_NEWIPC 标志会调用 copy_ipcs() 创建一个新的 IPC namespace。其中的核心是创建一个新的 struct ipc_namespace 结构，相当于创建了一个新的 XSI IPC 域：

  1. copy_ipcs() → create_ipc_ns():
  3. static struct ipc_namespace *create_ipc_ns(struct user_namespace *user_ns,
  4. 					   struct ipc_namespace *old_ns)
  5. {
  6. 	struct ipc_namespace *ns;
  7. 	struct ucounts *ucounts;
  8. 	int err;
  10. 	err = -ENOSPC;
  11. 	ucounts = inc_ipc_namespaces(user_ns);
  12. 	if (!ucounts)
  13. 		goto fail;
  15. 	err = -ENOMEM;
  16.     /* (1) 分配新的ipc_namespace数据结构 */
  17. 	ns = kmalloc(sizeof(struct ipc_namespace), GFP_KERNEL);
  18. 	if (ns == NULL)
  19. 		goto fail_dec;
  21. 	err = ns_alloc_inum(&ns->ns);
  22. 	if (err)
  23. 		goto fail_free;
  24. 	ns->ns.ops = &ipcns_operations;
  26. 	refcount_set(&ns->count, 1);
  27. 	ns->user_ns = get_user_ns(user_ns);
  28. 	ns->ucounts = ucounts;
  30.     /* (2) 初始化信号量sem对应的idr池和一些参数 */
  31. 	err = sem_init_ns(ns);
  32. 	if (err)
  33. 		goto fail_put;
  34.     /* (3) 初始化消息msg对应的idr池和一些参数 */
  35. 	err = msg_init_ns(ns);
  36. 	if (err)
  37. 		goto fail_destroy_sem;
  38.     /* (4) 初始化共享内存shm对应的idr池和一些参数 */
  39. 	err = shm_init_ns(ns);
  40. 	if (err)
  41. 		goto fail_destroy_msg;
  42.     /* (5) 初始化消息队列mq对应的一些参数 */
  43. 	err = mq_init_ns(ns);
  44. 	if (err)
  45. 		goto fail_destroy_shm;
  47. 	return ns;
  48. }

2.2 ipcget()

三种 XSI IPC 的实现机制也是非常类似的，IPC namespace 提供了对应的3个 idr 池 ns->ids[3] ，每新建一个 XSI IPC 对象，会从对应的 idr 池中分配一个 key。

以信号量 sem 为例，来分析一下这个过程：

  1. SYSCALL_DEFINE3(semget, key_t, key, int, nsems, int, semflg)
  2. {
  3. 	struct ipc_namespace *ns;
  4.     /* (1) 构造 ipc_ops 参数 */
  5. 	static const struct ipc_ops sem_ops = {
  6. 		.getnew = newary,
  7. 		.associate = sem_security,
  8. 		.more_checks = sem_more_checks,
  9. 	};
  10. 	struct ipc_params sem_params;
  12.     /* (2) 构造 ipc namespace 参数 */
  13. 	ns = current->nsproxy->ipc_ns;
  15. 	if (nsems < 0 || nsems > ns->sc_semmsl)
  16. 		return -EINVAL;
  18.     /* (3) 构造 ipc_params 参数 */
  19. 	sem_params.key = key;
  20. 	sem_params.flg = semflg;
  21. 	sem_params.u.nsems = nsems;
  23.     /* (4) 根据key查询已有的ipcp，或者创建新的ipcp */
  24. 	return ipcget(ns, &sem_ids(ns), &sem_ops, &sem_params);
  25. }
  27. ↓
  29. ipcget() → ipcget_public()
  31. ↓
  33. static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
  34. 		const struct ipc_ops *ops, struct ipc_params *params)
  35. {
  36. 	struct kern_ipc_perm *ipcp;
  37. 	int flg = params->flg;
  38. 	int err;
  40. 	/*
  41. 	 * Take the lock as a writer since we are potentially going to add
  42. 	 * a new entry + read locks are not "upgradable"
  43. 	 */
  44. 	down_write(&ids->rwsem);
  45.     /* (4.1) 根据key在信号量 idr 池 `ns->ids[IPC_SEM_IDS]`中查找对应的ipcp */
  46. 	ipcp = ipc_findkey(ids, params->key);
  47. 	if (ipcp == NULL) {
  48. 		/* key not used */
  49. 		if (!(flg & IPC_CREAT))
  50. 			err = -ENOENT;
  51. 		else
  52.             /* (4.2) 如果key对应的ipcp不存在，且设置了IPC_CREAT标志
  53.                     则根据key创建一个新的ipcp
  54.              */
  55. 			err = ops->getnew(ns, params);
  56. 	} else {
  57. 		/* ipc object has been locked by ipc_findkey() */
  59. 		if (flg & IPC_CREAT && flg & IPC_EXCL)
  60. 			err = -EEXIST;
  61. 		else {
  62. 			err = 0;
  63.             /* (4.3) 如果key对应的ipcp存在，则针对参数进行第一步的检查 */
  64. 			if (ops->more_checks)
  65. 				err = ops->more_checks(ipcp, params);
  66. 			if (!err)
  67. 				/*
  68. 				 * ipc_check_perms returns the IPC id on
  69. 				 * success
  70. 				 */
  71.                 /* (4.4) ipcp存在，针对参数做第二步的权限检查 */
  72. 				err = ipc_check_perms(ns, ipcp, ops, params);
  73. 		}
  74. 		ipc_unlock(ipcp);
  75. 	}
  76. 	up_write(&ids->rwsem);
  78. 	return err;
  79. }
  81. ↓
  83. ops->getnew() → newary()
  85. ↓
  87. static int newary(struct ipc_namespace *ns, struct ipc_params *params)
  88. {
  89. 	int retval;
  90. 	struct sem_array *sma;
  91. 	key_t key = params->key;
  92. 	int nsems = params->u.nsems;
  93. 	int semflg = params->flg;
  94. 	int i;
  96. 	if (!nsems)
  97. 		return -EINVAL;
  98. 	if (ns->used_sems + nsems > ns->sc_semmns)
  99. 		return -ENOSPC;
  101.     /* (4.2.1) 分配nsems个信号量的数据结构sem_array[] */
  102. 	sma = sem_alloc(nsems);
  103. 	if (!sma)
  104. 		return -ENOMEM;
  106.     /* (4.2.2) 初始化其中的ipcp成员，保存UGO模式，保存对应的key */
  107. 	sma->sem_perm.mode = (semflg & S_IRWXUGO);
  108. 	sma->sem_perm.key = key;
  110. 	sma->sem_perm.security = NULL;
  111. 	retval = security_sem_alloc(sma);
  112. 	if (retval) {
  113. 		kvfree(sma);
  114. 		return retval;
  115. 	}
  117. 	for (i = 0; i < nsems; i++) {
  118. 		INIT_LIST_HEAD(&sma->sems[i].pending_alter);
  119. 		INIT_LIST_HEAD(&sma->sems[i].pending_const);
  120. 		spin_lock_init(&sma->sems[i].lock);
  121. 	}
  123. 	sma->complex_count = 0;
  124. 	sma->use_global_lock = USE_GLOBAL_LOCK_HYSTERESIS;
  125. 	INIT_LIST_HEAD(&sma->pending_alter);
  126. 	INIT_LIST_HEAD(&sma->pending_const);
  127. 	INIT_LIST_HEAD(&sma->list_id);
  128. 	sma->sem_nsems = nsems;
  129. 	sma->sem_ctime = ktime_get_real_seconds();
  131. 	/* ipc_addid() locks sma upon success. */
  132.     /* (4.2.3) 赋值 ipcp 中的 uid、gid
  133.             并将新分配的ipcp加入信号量 idr 池 `ns->ids[IPC_SEM_IDS]`中
  134.      */
  135. 	retval = ipc_addid(&sem_ids(ns), &sma->sem_perm, ns->sc_semmni);
  136. 	if (retval < 0) {
  137. 		call_rcu(&sma->sem_perm.rcu, sem_rcu_free);
  138. 		return retval;
  139. 	}
  140. 	ns->used_sems += nsems;
  142. 	sem_unlock(sma, -1);
  143. 	rcu_read_unlock();
  145. 	return sma->sem_perm.id;
  146. }
  148. ↓
  150. int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int limit)
  151. {
  152. 	kuid_t euid;
  153. 	kgid_t egid;
  154. 	int id, err;
  156. 	if (limit > IPCMNI)
  157. 		limit = IPCMNI;
  159. 	if (!ids->tables_initialized || ids->in_use >= limit)
  160. 		return -ENOSPC;
  162. 	idr_preload(GFP_KERNEL);
  164. 	refcount_set(&new->refcount, 1);
  165. 	spin_lock_init(&new->lock);
  166. 	new->deleted = false;
  167. 	rcu_read_lock();
  168. 	spin_lock(&new->lock);
  170.     /* (4.2.3.1) 获取当前进程的uid/gid，赋值给 ipcp 的相关成员，
  171.                 类似文件的 `chown uid:gid ` 操作
  172.      */
  173. 	current_euid_egid(&euid, &egid);
  174. 	new->cuid = new->uid = euid;
  175. 	new->gid = new->cgid = egid;
  177. 	id = ipc_idr_alloc(ids, new);
  178. 	idr_preload_end();
  180.     /* (4.2.3.2) 加入信号量 idr 池 `ns->ids[IPC_SEM_IDS]`中 */
  181. 	if (id >= 0 && new->key != IPC_PRIVATE) {
  182. 		err = rhashtable_insert_fast(&ids->key_ht, &new->khtnode,
  183. 					     ipc_kht_params);
  184. 		if (err < 0) {
  185. 			idr_remove(&ids->ipcs_idr, id);
  186. 			id = err;
  187. 		}
  188. 	}
  189. 	if (id < 0) {
  190. 		spin_unlock(&new->lock);
  191. 		rcu_read_unlock();
  192. 		return id;
  193. 	}
  195. 	ids->in_use++;
  196. 	if (id > ids->max_id)
  197. 		ids->max_id = id;
  199. 	new->id = ipc_buildid(id, ids, new);
  201. 	return id;
  202. }

2.3 ipc_check_perms()

从上一节可以看到 key 被包含在 ipcp 即 struct kern_ipc_perm 结构中：

  1. struct kern_ipc_perm {
  2. 	spinlock_t	lock;
  3. 	bool		deleted;
  4. 	int		id;
  5. 	key_t		key;
  6. 	kuid_t		uid;
  7. 	kgid_t		gid;
  8. 	kuid_t		cuid;
  9. 	kgid_t		cgid;
  10. 	umode_t		mode;
  11. 	unsigned long	seq;
  12. 	void		*security;
  14. 	struct rhash_head khtnode;
  16. 	struct rcu_head rcu;
  17. 	refcount_t refcount;
  18. } ____cacheline_aligned_in_smp __randomize_layout;

在 sem,shm,mq 对象中都有这个成员的存在：

  1. struct sem_array {
  2. 	struct kern_ipc_perm	sem_perm;	/* permissions .. see ipc.h */
  3.     ...
  4. }
  6. struct shmid_kernel /* private to the kernel */
  7. {
  8. 	struct kern_ipc_perm	shm_perm;
  9.     ...
  10. }
  12. struct msg_queue {
  13. 	struct kern_ipc_perm q_perm;
  14.     ...
  15. }

struct kern_ipc_perm 的 ->key 成员保存了key值；->mode 成员保存了 UGO 操作权限，类似文件的 chmod 777 属性；->uid/gid/cuid/cgid 成员保存了属主 uid/gid，类似文件的 chown uid:gid 操作。

在 ipc_check_perms() 函数中，会对被操作的 sem,shm,mq 对象，进行 UGO 权限检查：

  1. ipc_check_perms() → ipcperms()
  3. ↓
  5. int ipcperms(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp, short flag)
  6. {
  7. 	kuid_t euid = current_euid();
  8. 	int requested_mode, granted_mode;
  10. 	audit_ipc_obj(ipcp);
  11.     /* (1) 或 请求的 UGO 操作 */
  12. 	requested_mode = (flag >> 6) | (flag >> 3) | flag;
  14.     /* (2) 获取 ipcp 的 UGO 规则 */
  15. 	granted_mode = ipcp->mode;
  17.     /* (2.1) 如果当前进程 和 ipcp 对象 uid 相等，则取用 U 规则 */
  18. 	if (uid_eq(euid, ipcp->cuid) ||
  19. 	    uid_eq(euid, ipcp->uid))
  20. 		granted_mode >>= 6;
  21.     /* (2.2) 如果当前进程 和 ipcp 对象 gid 相等，则取用 G 规则 */
  22. 	else if (in_group_p(ipcp->cgid) || in_group_p(ipcp->gid))
  23. 		granted_mode >>= 3;
  24.     /* (2.3) 如果当前进程 和 ipcp 对象 uid gid 都不相等，则取用 O 规则 */
  26. 	/* is there some bit set in requested_mode but not in granted_mode? */
  27.     /* (3) 判断请求的操作是否适配对应的规则 */
  28. 	if ((requested_mode & ~granted_mode & 0007) &&
  29. 	    !ns_capable(ns->user_ns, CAP_IPC_OWNER))
  30. 		return -1;
  32. 	return security_ipc_permission(ipcp, flag);
  33. }

2.4 相关系统调用

sem,shm,mq 对象通用部分的解析如上所示，除此以外 XSI IPC 还有其他的操作系统调用，这里就不一一解析：

ModuleSyscallDescript
semsemget()创建信号量
-semctl()初始化信号量
-semop()信号量的PV操作
msgmsgget()创建消息队列
-msgctl()获取和设置消息队列的属性
-msgsnd()将消息写入到消息队列
-msgrcv()从消息队列读取消息
shmshmget()创建共享内存对象
-shmctl()共享内存管理
-shmat()把共享内存区对象映射到调用进程的地址空间
-shmdt()断开共享内存连接

3 参考文档

  1. ipc_namespace
  2. Linux内核命名空间之（2） ipc namespace
  3. linux进程间通信（IPC）机制总结
  4. POSIX:XSI Interprocess Communication

Read Album:

Read Related:

Read Latest: