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/syscalls.h> 14 #include <linux/err.h> 15 #include <linux/acct.h> 16 #include <linux/slab.h> 17 18 #define BITS_PER_PAGE (PAGE_SIZE*8) 19 20 struct pid_cache { 21 int nr_ids; 22 char name[16]; 23 struct kmem_cache *cachep; 24 struct list_head list; 25 }; 26 27 static LIST_HEAD(pid_caches_lh); 28 static DEFINE_MUTEX(pid_caches_mutex); 29 static struct kmem_cache *pid_ns_cachep; 30 31 /* 32 * creates the kmem cache to allocate pids from. 33 * @nr_ids: the number of numerical ids this pid will have to carry 34 */ 35 36 static struct kmem_cache *create_pid_cachep(int nr_ids) 37 { 38 struct pid_cache *pcache; 39 struct kmem_cache *cachep; 40 41 mutex_lock(&pid_caches_mutex); 42 list_for_each_entry(pcache, &pid_caches_lh, list) 43 if (pcache->nr_ids == nr_ids) 44 goto out; 45 46 pcache = kmalloc(sizeof(struct pid_cache), GFP_KERNEL); 47 if (pcache == NULL) 48 goto err_alloc; 49 50 snprintf(pcache->name, sizeof(pcache->name), "pid_%d", nr_ids); 51 cachep = kmem_cache_create(pcache->name, 52 sizeof(struct pid) + (nr_ids - 1) * sizeof(struct upid), 53 0, SLAB_HWCACHE_ALIGN, NULL); 54 if (cachep == NULL) 55 goto err_cachep; 56 57 pcache->nr_ids = nr_ids; 58 pcache->cachep = cachep; 59 list_add(&pcache->list, &pid_caches_lh); 60 out: 61 mutex_unlock(&pid_caches_mutex); 62 return pcache->cachep; 63 64 err_cachep: 65 kfree(pcache); 66 err_alloc: 67 mutex_unlock(&pid_caches_mutex); 68 return NULL; 69 } 70 71 static struct pid_namespace *create_pid_namespace(struct pid_namespace *parent_pid_ns) 72 { 73 struct pid_namespace *ns; 74 unsigned int level = parent_pid_ns->level + 1; 75 int i; 76 77 ns = kmem_cache_zalloc(pid_ns_cachep, GFP_KERNEL); 78 if (ns == NULL) 79 goto out; 80 81 ns->pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL); 82 if (!ns->pidmap[0].page) 83 goto out_free; 84 85 ns->pid_cachep = create_pid_cachep(level + 1); 86 if (ns->pid_cachep == NULL) 87 goto out_free_map; 88 89 kref_init(&ns->kref); 90 ns->level = level; 91 ns->parent = get_pid_ns(parent_pid_ns); 92 93 set_bit(0, ns->pidmap[0].page); 94 atomic_set(&ns->pidmap[0].nr_free, BITS_PER_PAGE - 1); 95 96 for (i = 1; i < PIDMAP_ENTRIES; i++) 97 atomic_set(&ns->pidmap[i].nr_free, BITS_PER_PAGE); 98 99 return ns; 100 101 out_free_map: 102 kfree(ns->pidmap[0].page); 103 out_free: 104 kmem_cache_free(pid_ns_cachep, ns); 105 out: 106 return ERR_PTR(-ENOMEM); 107 } 108 109 static void destroy_pid_namespace(struct pid_namespace *ns) 110 { 111 int i; 112 113 for (i = 0; i < PIDMAP_ENTRIES; i++) 114 kfree(ns->pidmap[i].page); 115 kmem_cache_free(pid_ns_cachep, ns); 116 } 117 118 struct pid_namespace *copy_pid_ns(unsigned long flags, struct pid_namespace *old_ns) 119 { 120 if (!(flags & CLONE_NEWPID)) 121 return get_pid_ns(old_ns); 122 if (flags & (CLONE_THREAD|CLONE_PARENT)) 123 return ERR_PTR(-EINVAL); 124 return create_pid_namespace(old_ns); 125 } 126 127 void free_pid_ns(struct kref *kref) 128 { 129 struct pid_namespace *ns, *parent; 130 131 ns = container_of(kref, struct pid_namespace, kref); 132 133 parent = ns->parent; 134 destroy_pid_namespace(ns); 135 136 if (parent != NULL) 137 put_pid_ns(parent); 138 } 139 140 void zap_pid_ns_processes(struct pid_namespace *pid_ns) 141 { 142 int nr; 143 int rc; 144 struct task_struct *task; 145 146 /* 147 * The last thread in the cgroup-init thread group is terminating. 148 * Find remaining pid_ts in the namespace, signal and wait for them 149 * to exit. 150 * 151 * Note: This signals each threads in the namespace - even those that 152 * belong to the same thread group, To avoid this, we would have 153 * to walk the entire tasklist looking a processes in this 154 * namespace, but that could be unnecessarily expensive if the 155 * pid namespace has just a few processes. Or we need to 156 * maintain a tasklist for each pid namespace. 157 * 158 */ 159 read_lock(&tasklist_lock); 160 nr = next_pidmap(pid_ns, 1); 161 while (nr > 0) { 162 rcu_read_lock(); 163 164 /* 165 * Any nested-container's init processes won't ignore the 166 * SEND_SIG_NOINFO signal, see send_signal()->si_fromuser(). 167 */ 168 task = pid_task(find_vpid(nr), PIDTYPE_PID); 169 if (task) 170 send_sig_info(SIGKILL, SEND_SIG_NOINFO, task); 171 172 rcu_read_unlock(); 173 174 nr = next_pidmap(pid_ns, nr); 175 } 176 read_unlock(&tasklist_lock); 177 178 do { 179 clear_thread_flag(TIF_SIGPENDING); 180 rc = sys_wait4(-1, NULL, __WALL, NULL); 181 } while (rc != -ECHILD); 182 183 acct_exit_ns(pid_ns); 184 return; 185 } 186 187 static __init int pid_namespaces_init(void) 188 { 189 pid_ns_cachep = KMEM_CACHE(pid_namespace, SLAB_PANIC); 190 return 0; 191 } 192 193 __initcall(pid_namespaces_init); 194