pid: replace pid bitmap implementation with IDR API
[muen/linux.git] / kernel / pid_namespace.c
1 /*
2  * Pid namespaces
3  *
4  * Authors:
5  *    (C) 2007 Pavel Emelyanov <xemul@openvz.org>, OpenVZ, SWsoft Inc.
6  *    (C) 2007 Sukadev Bhattiprolu <sukadev@us.ibm.com>, IBM
7  *     Many thanks to Oleg Nesterov for comments and help
8  *
9  */
10
11 #include <linux/pid.h>
12 #include <linux/pid_namespace.h>
13 #include <linux/user_namespace.h>
14 #include <linux/syscalls.h>
15 #include <linux/cred.h>
16 #include <linux/err.h>
17 #include <linux/acct.h>
18 #include <linux/slab.h>
19 #include <linux/proc_ns.h>
20 #include <linux/reboot.h>
21 #include <linux/export.h>
22 #include <linux/sched/task.h>
23 #include <linux/sched/signal.h>
24 #include <linux/idr.h>
25
26 struct pid_cache {
27         int nr_ids;
28         char name[16];
29         struct kmem_cache *cachep;
30         struct list_head list;
31 };
32
33 static LIST_HEAD(pid_caches_lh);
34 static DEFINE_MUTEX(pid_caches_mutex);
35 static struct kmem_cache *pid_ns_cachep;
36
37 /*
38  * creates the kmem cache to allocate pids from.
39  * @nr_ids: the number of numerical ids this pid will have to carry
40  */
41
42 static struct kmem_cache *create_pid_cachep(int nr_ids)
43 {
44         struct pid_cache *pcache;
45         struct kmem_cache *cachep;
46
47         mutex_lock(&pid_caches_mutex);
48         list_for_each_entry(pcache, &pid_caches_lh, list)
49                 if (pcache->nr_ids == nr_ids)
50                         goto out;
51
52         pcache = kmalloc(sizeof(struct pid_cache), GFP_KERNEL);
53         if (pcache == NULL)
54                 goto err_alloc;
55
56         snprintf(pcache->name, sizeof(pcache->name), "pid_%d", nr_ids);
57         cachep = kmem_cache_create(pcache->name,
58                         sizeof(struct pid) + (nr_ids - 1) * sizeof(struct upid),
59                         0, SLAB_HWCACHE_ALIGN, NULL);
60         if (cachep == NULL)
61                 goto err_cachep;
62
63         pcache->nr_ids = nr_ids;
64         pcache->cachep = cachep;
65         list_add(&pcache->list, &pid_caches_lh);
66 out:
67         mutex_unlock(&pid_caches_mutex);
68         return pcache->cachep;
69
70 err_cachep:
71         kfree(pcache);
72 err_alloc:
73         mutex_unlock(&pid_caches_mutex);
74         return NULL;
75 }
76
77 static void proc_cleanup_work(struct work_struct *work)
78 {
79         struct pid_namespace *ns = container_of(work, struct pid_namespace, proc_work);
80         pid_ns_release_proc(ns);
81 }
82
83 /* MAX_PID_NS_LEVEL is needed for limiting size of 'struct pid' */
84 #define MAX_PID_NS_LEVEL 32
85
86 static struct ucounts *inc_pid_namespaces(struct user_namespace *ns)
87 {
88         return inc_ucount(ns, current_euid(), UCOUNT_PID_NAMESPACES);
89 }
90
91 static void dec_pid_namespaces(struct ucounts *ucounts)
92 {
93         dec_ucount(ucounts, UCOUNT_PID_NAMESPACES);
94 }
95
96 static struct pid_namespace *create_pid_namespace(struct user_namespace *user_ns,
97         struct pid_namespace *parent_pid_ns)
98 {
99         struct pid_namespace *ns;
100         unsigned int level = parent_pid_ns->level + 1;
101         struct ucounts *ucounts;
102         int err;
103
104         err = -EINVAL;
105         if (!in_userns(parent_pid_ns->user_ns, user_ns))
106                 goto out;
107
108         err = -ENOSPC;
109         if (level > MAX_PID_NS_LEVEL)
110                 goto out;
111         ucounts = inc_pid_namespaces(user_ns);
112         if (!ucounts)
113                 goto out;
114
115         err = -ENOMEM;
116         ns = kmem_cache_zalloc(pid_ns_cachep, GFP_KERNEL);
117         if (ns == NULL)
118                 goto out_dec;
119
120         idr_init(&ns->idr);
121
122         ns->pid_cachep = create_pid_cachep(level + 1);
123         if (ns->pid_cachep == NULL)
124                 goto out_free_idr;
125
126         err = ns_alloc_inum(&ns->ns);
127         if (err)
128                 goto out_free_idr;
129         ns->ns.ops = &pidns_operations;
130
131         kref_init(&ns->kref);
132         ns->level = level;
133         ns->parent = get_pid_ns(parent_pid_ns);
134         ns->user_ns = get_user_ns(user_ns);
135         ns->ucounts = ucounts;
136         ns->nr_hashed = PIDNS_HASH_ADDING;
137         INIT_WORK(&ns->proc_work, proc_cleanup_work);
138
139         return ns;
140
141 out_free_idr:
142         idr_destroy(&ns->idr);
143         kmem_cache_free(pid_ns_cachep, ns);
144 out_dec:
145         dec_pid_namespaces(ucounts);
146 out:
147         return ERR_PTR(err);
148 }
149
150 static void delayed_free_pidns(struct rcu_head *p)
151 {
152         struct pid_namespace *ns = container_of(p, struct pid_namespace, rcu);
153
154         dec_pid_namespaces(ns->ucounts);
155         put_user_ns(ns->user_ns);
156
157         kmem_cache_free(pid_ns_cachep, ns);
158 }
159
160 static void destroy_pid_namespace(struct pid_namespace *ns)
161 {
162         ns_free_inum(&ns->ns);
163
164         idr_destroy(&ns->idr);
165         call_rcu(&ns->rcu, delayed_free_pidns);
166 }
167
168 struct pid_namespace *copy_pid_ns(unsigned long flags,
169         struct user_namespace *user_ns, struct pid_namespace *old_ns)
170 {
171         if (!(flags & CLONE_NEWPID))
172                 return get_pid_ns(old_ns);
173         if (task_active_pid_ns(current) != old_ns)
174                 return ERR_PTR(-EINVAL);
175         return create_pid_namespace(user_ns, old_ns);
176 }
177
178 static void free_pid_ns(struct kref *kref)
179 {
180         struct pid_namespace *ns;
181
182         ns = container_of(kref, struct pid_namespace, kref);
183         destroy_pid_namespace(ns);
184 }
185
186 void put_pid_ns(struct pid_namespace *ns)
187 {
188         struct pid_namespace *parent;
189
190         while (ns != &init_pid_ns) {
191                 parent = ns->parent;
192                 if (!kref_put(&ns->kref, free_pid_ns))
193                         break;
194                 ns = parent;
195         }
196 }
197 EXPORT_SYMBOL_GPL(put_pid_ns);
198
199 void zap_pid_ns_processes(struct pid_namespace *pid_ns)
200 {
201         int nr;
202         int rc;
203         struct task_struct *task, *me = current;
204         int init_pids = thread_group_leader(me) ? 1 : 2;
205         struct pid *pid;
206
207         /* Don't allow any more processes into the pid namespace */
208         disable_pid_allocation(pid_ns);
209
210         /*
211          * Ignore SIGCHLD causing any terminated children to autoreap.
212          * This speeds up the namespace shutdown, plus see the comment
213          * below.
214          */
215         spin_lock_irq(&me->sighand->siglock);
216         me->sighand->action[SIGCHLD - 1].sa.sa_handler = SIG_IGN;
217         spin_unlock_irq(&me->sighand->siglock);
218
219         /*
220          * The last thread in the cgroup-init thread group is terminating.
221          * Find remaining pid_ts in the namespace, signal and wait for them
222          * to exit.
223          *
224          * Note:  This signals each threads in the namespace - even those that
225          *        belong to the same thread group, To avoid this, we would have
226          *        to walk the entire tasklist looking a processes in this
227          *        namespace, but that could be unnecessarily expensive if the
228          *        pid namespace has just a few processes. Or we need to
229          *        maintain a tasklist for each pid namespace.
230          *
231          */
232         rcu_read_lock();
233         read_lock(&tasklist_lock);
234         nr = 2;
235         idr_for_each_entry_continue(&pid_ns->idr, pid, nr) {
236                 task = pid_task(pid, PIDTYPE_PID);
237                 if (task && !__fatal_signal_pending(task))
238                         send_sig_info(SIGKILL, SEND_SIG_FORCED, task);
239         }
240         read_unlock(&tasklist_lock);
241         rcu_read_unlock();
242
243         /*
244          * Reap the EXIT_ZOMBIE children we had before we ignored SIGCHLD.
245          * sys_wait4() will also block until our children traced from the
246          * parent namespace are detached and become EXIT_DEAD.
247          */
248         do {
249                 clear_thread_flag(TIF_SIGPENDING);
250                 rc = sys_wait4(-1, NULL, __WALL, NULL);
251         } while (rc != -ECHILD);
252
253         /*
254          * sys_wait4() above can't reap the EXIT_DEAD children but we do not
255          * really care, we could reparent them to the global init. We could
256          * exit and reap ->child_reaper even if it is not the last thread in
257          * this pid_ns, free_pid(nr_hashed == 0) calls proc_cleanup_work(),
258          * pid_ns can not go away until proc_kill_sb() drops the reference.
259          *
260          * But this ns can also have other tasks injected by setns()+fork().
261          * Again, ignoring the user visible semantics we do not really need
262          * to wait until they are all reaped, but they can be reparented to
263          * us and thus we need to ensure that pid->child_reaper stays valid
264          * until they all go away. See free_pid()->wake_up_process().
265          *
266          * We rely on ignored SIGCHLD, an injected zombie must be autoreaped
267          * if reparented.
268          */
269         for (;;) {
270                 set_current_state(TASK_INTERRUPTIBLE);
271                 if (pid_ns->nr_hashed == init_pids)
272                         break;
273                 schedule();
274         }
275         __set_current_state(TASK_RUNNING);
276
277         if (pid_ns->reboot)
278                 current->signal->group_exit_code = pid_ns->reboot;
279
280         acct_exit_ns(pid_ns);
281         return;
282 }
283
284 #ifdef CONFIG_CHECKPOINT_RESTORE
285 static int pid_ns_ctl_handler(struct ctl_table *table, int write,
286                 void __user *buffer, size_t *lenp, loff_t *ppos)
287 {
288         struct pid_namespace *pid_ns = task_active_pid_ns(current);
289         struct ctl_table tmp = *table;
290         int ret, next;
291
292         if (write && !ns_capable(pid_ns->user_ns, CAP_SYS_ADMIN))
293                 return -EPERM;
294
295         /*
296          * Writing directly to ns' last_pid field is OK, since this field
297          * is volatile in a living namespace anyway and a code writing to
298          * it should synchronize its usage with external means.
299          */
300
301         next = idr_get_cursor(&pid_ns->idr) - 1;
302
303         tmp.data = &next;
304         ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
305         if (!ret && write)
306                 idr_set_cursor(&pid_ns->idr, next + 1);
307
308         return ret;
309 }
310
311 extern int pid_max;
312 static int zero = 0;
313 static struct ctl_table pid_ns_ctl_table[] = {
314         {
315                 .procname = "ns_last_pid",
316                 .maxlen = sizeof(int),
317                 .mode = 0666, /* permissions are checked in the handler */
318                 .proc_handler = pid_ns_ctl_handler,
319                 .extra1 = &zero,
320                 .extra2 = &pid_max,
321         },
322         { }
323 };
324 static struct ctl_path kern_path[] = { { .procname = "kernel", }, { } };
325 #endif  /* CONFIG_CHECKPOINT_RESTORE */
326
327 int reboot_pid_ns(struct pid_namespace *pid_ns, int cmd)
328 {
329         if (pid_ns == &init_pid_ns)
330                 return 0;
331
332         switch (cmd) {
333         case LINUX_REBOOT_CMD_RESTART2:
334         case LINUX_REBOOT_CMD_RESTART:
335                 pid_ns->reboot = SIGHUP;
336                 break;
337
338         case LINUX_REBOOT_CMD_POWER_OFF:
339         case LINUX_REBOOT_CMD_HALT:
340                 pid_ns->reboot = SIGINT;
341                 break;
342         default:
343                 return -EINVAL;
344         }
345
346         read_lock(&tasklist_lock);
347         force_sig(SIGKILL, pid_ns->child_reaper);
348         read_unlock(&tasklist_lock);
349
350         do_exit(0);
351
352         /* Not reached */
353         return 0;
354 }
355
356 static inline struct pid_namespace *to_pid_ns(struct ns_common *ns)
357 {
358         return container_of(ns, struct pid_namespace, ns);
359 }
360
361 static struct ns_common *pidns_get(struct task_struct *task)
362 {
363         struct pid_namespace *ns;
364
365         rcu_read_lock();
366         ns = task_active_pid_ns(task);
367         if (ns)
368                 get_pid_ns(ns);
369         rcu_read_unlock();
370
371         return ns ? &ns->ns : NULL;
372 }
373
374 static struct ns_common *pidns_for_children_get(struct task_struct *task)
375 {
376         struct pid_namespace *ns = NULL;
377
378         task_lock(task);
379         if (task->nsproxy) {
380                 ns = task->nsproxy->pid_ns_for_children;
381                 get_pid_ns(ns);
382         }
383         task_unlock(task);
384
385         if (ns) {
386                 read_lock(&tasklist_lock);
387                 if (!ns->child_reaper) {
388                         put_pid_ns(ns);
389                         ns = NULL;
390                 }
391                 read_unlock(&tasklist_lock);
392         }
393
394         return ns ? &ns->ns : NULL;
395 }
396
397 static void pidns_put(struct ns_common *ns)
398 {
399         put_pid_ns(to_pid_ns(ns));
400 }
401
402 static int pidns_install(struct nsproxy *nsproxy, struct ns_common *ns)
403 {
404         struct pid_namespace *active = task_active_pid_ns(current);
405         struct pid_namespace *ancestor, *new = to_pid_ns(ns);
406
407         if (!ns_capable(new->user_ns, CAP_SYS_ADMIN) ||
408             !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
409                 return -EPERM;
410
411         /*
412          * Only allow entering the current active pid namespace
413          * or a child of the current active pid namespace.
414          *
415          * This is required for fork to return a usable pid value and
416          * this maintains the property that processes and their
417          * children can not escape their current pid namespace.
418          */
419         if (new->level < active->level)
420                 return -EINVAL;
421
422         ancestor = new;
423         while (ancestor->level > active->level)
424                 ancestor = ancestor->parent;
425         if (ancestor != active)
426                 return -EINVAL;
427
428         put_pid_ns(nsproxy->pid_ns_for_children);
429         nsproxy->pid_ns_for_children = get_pid_ns(new);
430         return 0;
431 }
432
433 static struct ns_common *pidns_get_parent(struct ns_common *ns)
434 {
435         struct pid_namespace *active = task_active_pid_ns(current);
436         struct pid_namespace *pid_ns, *p;
437
438         /* See if the parent is in the current namespace */
439         pid_ns = p = to_pid_ns(ns)->parent;
440         for (;;) {
441                 if (!p)
442                         return ERR_PTR(-EPERM);
443                 if (p == active)
444                         break;
445                 p = p->parent;
446         }
447
448         return &get_pid_ns(pid_ns)->ns;
449 }
450
451 static struct user_namespace *pidns_owner(struct ns_common *ns)
452 {
453         return to_pid_ns(ns)->user_ns;
454 }
455
456 const struct proc_ns_operations pidns_operations = {
457         .name           = "pid",
458         .type           = CLONE_NEWPID,
459         .get            = pidns_get,
460         .put            = pidns_put,
461         .install        = pidns_install,
462         .owner          = pidns_owner,
463         .get_parent     = pidns_get_parent,
464 };
465
466 const struct proc_ns_operations pidns_for_children_operations = {
467         .name           = "pid_for_children",
468         .real_ns_name   = "pid",
469         .type           = CLONE_NEWPID,
470         .get            = pidns_for_children_get,
471         .put            = pidns_put,
472         .install        = pidns_install,
473         .owner          = pidns_owner,
474         .get_parent     = pidns_get_parent,
475 };
476
477 static __init int pid_namespaces_init(void)
478 {
479         pid_ns_cachep = KMEM_CACHE(pid_namespace, SLAB_PANIC);
480
481 #ifdef CONFIG_CHECKPOINT_RESTORE
482         register_sysctl_paths(kern_path, pid_ns_ctl_table);
483 #endif
484         return 0;
485 }
486
487 __initcall(pid_namespaces_init);