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