Merge tag 'mm-stable-2022-10-13' of git://git.kernel.org/pub/scm/linux/kernel/git...
[platform/kernel/linux-starfive.git] / ipc / namespace.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/ipc/namespace.c
4  * Copyright (C) 2006 Pavel Emelyanov <xemul@openvz.org> OpenVZ, SWsoft Inc.
5  */
6
7 #include <linux/ipc.h>
8 #include <linux/msg.h>
9 #include <linux/ipc_namespace.h>
10 #include <linux/rcupdate.h>
11 #include <linux/nsproxy.h>
12 #include <linux/slab.h>
13 #include <linux/cred.h>
14 #include <linux/fs.h>
15 #include <linux/mount.h>
16 #include <linux/user_namespace.h>
17 #include <linux/proc_ns.h>
18 #include <linux/sched/task.h>
19
20 #include "util.h"
21
22 static struct ucounts *inc_ipc_namespaces(struct user_namespace *ns)
23 {
24         return inc_ucount(ns, current_euid(), UCOUNT_IPC_NAMESPACES);
25 }
26
27 static void dec_ipc_namespaces(struct ucounts *ucounts)
28 {
29         dec_ucount(ucounts, UCOUNT_IPC_NAMESPACES);
30 }
31
32 static struct ipc_namespace *create_ipc_ns(struct user_namespace *user_ns,
33                                            struct ipc_namespace *old_ns)
34 {
35         struct ipc_namespace *ns;
36         struct ucounts *ucounts;
37         int err;
38
39         err = -ENOSPC;
40         ucounts = inc_ipc_namespaces(user_ns);
41         if (!ucounts)
42                 goto fail;
43
44         err = -ENOMEM;
45         ns = kzalloc(sizeof(struct ipc_namespace), GFP_KERNEL_ACCOUNT);
46         if (ns == NULL)
47                 goto fail_dec;
48
49         err = ns_alloc_inum(&ns->ns);
50         if (err)
51                 goto fail_free;
52         ns->ns.ops = &ipcns_operations;
53
54         refcount_set(&ns->ns.count, 1);
55         ns->user_ns = get_user_ns(user_ns);
56         ns->ucounts = ucounts;
57
58         err = mq_init_ns(ns);
59         if (err)
60                 goto fail_put;
61
62         err = -ENOMEM;
63         if (!setup_mq_sysctls(ns))
64                 goto fail_put;
65
66         if (!setup_ipc_sysctls(ns))
67                 goto fail_mq;
68
69         err = msg_init_ns(ns);
70         if (err)
71                 goto fail_put;
72
73         sem_init_ns(ns);
74         shm_init_ns(ns);
75
76         return ns;
77
78 fail_mq:
79         retire_mq_sysctls(ns);
80
81 fail_put:
82         put_user_ns(ns->user_ns);
83         ns_free_inum(&ns->ns);
84 fail_free:
85         kfree(ns);
86 fail_dec:
87         dec_ipc_namespaces(ucounts);
88 fail:
89         return ERR_PTR(err);
90 }
91
92 struct ipc_namespace *copy_ipcs(unsigned long flags,
93         struct user_namespace *user_ns, struct ipc_namespace *ns)
94 {
95         if (!(flags & CLONE_NEWIPC))
96                 return get_ipc_ns(ns);
97         return create_ipc_ns(user_ns, ns);
98 }
99
100 /*
101  * free_ipcs - free all ipcs of one type
102  * @ns:   the namespace to remove the ipcs from
103  * @ids:  the table of ipcs to free
104  * @free: the function called to free each individual ipc
105  *
106  * Called for each kind of ipc when an ipc_namespace exits.
107  */
108 void free_ipcs(struct ipc_namespace *ns, struct ipc_ids *ids,
109                void (*free)(struct ipc_namespace *, struct kern_ipc_perm *))
110 {
111         struct kern_ipc_perm *perm;
112         int next_id;
113         int total, in_use;
114
115         down_write(&ids->rwsem);
116
117         in_use = ids->in_use;
118
119         for (total = 0, next_id = 0; total < in_use; next_id++) {
120                 perm = idr_find(&ids->ipcs_idr, next_id);
121                 if (perm == NULL)
122                         continue;
123                 rcu_read_lock();
124                 ipc_lock_object(perm);
125                 free(ns, perm);
126                 total++;
127         }
128         up_write(&ids->rwsem);
129 }
130
131 static void free_ipc_ns(struct ipc_namespace *ns)
132 {
133         /* mq_put_mnt() waits for a grace period as kern_unmount()
134          * uses synchronize_rcu().
135          */
136         mq_put_mnt(ns);
137         sem_exit_ns(ns);
138         msg_exit_ns(ns);
139         shm_exit_ns(ns);
140
141         retire_mq_sysctls(ns);
142         retire_ipc_sysctls(ns);
143
144         dec_ipc_namespaces(ns->ucounts);
145         put_user_ns(ns->user_ns);
146         ns_free_inum(&ns->ns);
147         kfree(ns);
148 }
149
150 static LLIST_HEAD(free_ipc_list);
151 static void free_ipc(struct work_struct *unused)
152 {
153         struct llist_node *node = llist_del_all(&free_ipc_list);
154         struct ipc_namespace *n, *t;
155
156         llist_for_each_entry_safe(n, t, node, mnt_llist)
157                 free_ipc_ns(n);
158 }
159
160 /*
161  * The work queue is used to avoid the cost of synchronize_rcu in kern_unmount.
162  */
163 static DECLARE_WORK(free_ipc_work, free_ipc);
164
165 /*
166  * put_ipc_ns - drop a reference to an ipc namespace.
167  * @ns: the namespace to put
168  *
169  * If this is the last task in the namespace exiting, and
170  * it is dropping the refcount to 0, then it can race with
171  * a task in another ipc namespace but in a mounts namespace
172  * which has this ipcns's mqueuefs mounted, doing some action
173  * with one of the mqueuefs files.  That can raise the refcount.
174  * So dropping the refcount, and raising the refcount when
175  * accessing it through the VFS, are protected with mq_lock.
176  *
177  * (Clearly, a task raising the refcount on its own ipc_ns
178  * needn't take mq_lock since it can't race with the last task
179  * in the ipcns exiting).
180  */
181 void put_ipc_ns(struct ipc_namespace *ns)
182 {
183         if (refcount_dec_and_lock(&ns->ns.count, &mq_lock)) {
184                 mq_clear_sbinfo(ns);
185                 spin_unlock(&mq_lock);
186
187                 if (llist_add(&ns->mnt_llist, &free_ipc_list))
188                         schedule_work(&free_ipc_work);
189         }
190 }
191
192 static inline struct ipc_namespace *to_ipc_ns(struct ns_common *ns)
193 {
194         return container_of(ns, struct ipc_namespace, ns);
195 }
196
197 static struct ns_common *ipcns_get(struct task_struct *task)
198 {
199         struct ipc_namespace *ns = NULL;
200         struct nsproxy *nsproxy;
201
202         task_lock(task);
203         nsproxy = task->nsproxy;
204         if (nsproxy)
205                 ns = get_ipc_ns(nsproxy->ipc_ns);
206         task_unlock(task);
207
208         return ns ? &ns->ns : NULL;
209 }
210
211 static void ipcns_put(struct ns_common *ns)
212 {
213         return put_ipc_ns(to_ipc_ns(ns));
214 }
215
216 static int ipcns_install(struct nsset *nsset, struct ns_common *new)
217 {
218         struct nsproxy *nsproxy = nsset->nsproxy;
219         struct ipc_namespace *ns = to_ipc_ns(new);
220         if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN) ||
221             !ns_capable(nsset->cred->user_ns, CAP_SYS_ADMIN))
222                 return -EPERM;
223
224         put_ipc_ns(nsproxy->ipc_ns);
225         nsproxy->ipc_ns = get_ipc_ns(ns);
226         return 0;
227 }
228
229 static struct user_namespace *ipcns_owner(struct ns_common *ns)
230 {
231         return to_ipc_ns(ns)->user_ns;
232 }
233
234 const struct proc_ns_operations ipcns_operations = {
235         .name           = "ipc",
236         .type           = CLONE_NEWIPC,
237         .get            = ipcns_get,
238         .put            = ipcns_put,
239         .install        = ipcns_install,
240         .owner          = ipcns_owner,
241 };