diff options
Diffstat (limited to 'kernel/pid.c')
-rw-r--r-- | kernel/pid.c | 353 |
1 files changed, 318 insertions, 35 deletions
diff --git a/kernel/pid.c b/kernel/pid.c index c6e3f9ffff87..d1db36b94674 100644 --- a/kernel/pid.c +++ b/kernel/pid.c | |||
@@ -18,6 +18,12 @@ | |||
18 | * allocation scenario when all but one out of 1 million PIDs possible are | 18 | * allocation scenario when all but one out of 1 million PIDs possible are |
19 | * allocated already: the scanning of 32 list entries and at most PAGE_SIZE | 19 | * allocated already: the scanning of 32 list entries and at most PAGE_SIZE |
20 | * bytes. The typical fastpath is a single successful setbit. Freeing is O(1). | 20 | * bytes. The typical fastpath is a single successful setbit. Freeing is O(1). |
21 | * | ||
22 | * Pid namespaces: | ||
23 | * (C) 2007 Pavel Emelyanov <xemul@openvz.org>, OpenVZ, SWsoft Inc. | ||
24 | * (C) 2007 Sukadev Bhattiprolu <sukadev@us.ibm.com>, IBM | ||
25 | * Many thanks to Oleg Nesterov for comments and help | ||
26 | * | ||
21 | */ | 27 | */ |
22 | 28 | ||
23 | #include <linux/mm.h> | 29 | #include <linux/mm.h> |
@@ -28,12 +34,14 @@ | |||
28 | #include <linux/hash.h> | 34 | #include <linux/hash.h> |
29 | #include <linux/pid_namespace.h> | 35 | #include <linux/pid_namespace.h> |
30 | #include <linux/init_task.h> | 36 | #include <linux/init_task.h> |
37 | #include <linux/syscalls.h> | ||
31 | 38 | ||
32 | #define pid_hashfn(nr) hash_long((unsigned long)nr, pidhash_shift) | 39 | #define pid_hashfn(nr, ns) \ |
40 | hash_long((unsigned long)nr + (unsigned long)ns, pidhash_shift) | ||
33 | static struct hlist_head *pid_hash; | 41 | static struct hlist_head *pid_hash; |
34 | static int pidhash_shift; | 42 | static int pidhash_shift; |
35 | static struct kmem_cache *pid_cachep; | ||
36 | struct pid init_struct_pid = INIT_STRUCT_PID; | 43 | struct pid init_struct_pid = INIT_STRUCT_PID; |
44 | static struct kmem_cache *pid_ns_cachep; | ||
37 | 45 | ||
38 | int pid_max = PID_MAX_DEFAULT; | 46 | int pid_max = PID_MAX_DEFAULT; |
39 | 47 | ||
@@ -68,8 +76,25 @@ struct pid_namespace init_pid_ns = { | |||
68 | [ 0 ... PIDMAP_ENTRIES-1] = { ATOMIC_INIT(BITS_PER_PAGE), NULL } | 76 | [ 0 ... PIDMAP_ENTRIES-1] = { ATOMIC_INIT(BITS_PER_PAGE), NULL } |
69 | }, | 77 | }, |
70 | .last_pid = 0, | 78 | .last_pid = 0, |
71 | .child_reaper = &init_task | 79 | .level = 0, |
80 | .child_reaper = &init_task, | ||
72 | }; | 81 | }; |
82 | EXPORT_SYMBOL_GPL(init_pid_ns); | ||
83 | |||
84 | int is_container_init(struct task_struct *tsk) | ||
85 | { | ||
86 | int ret = 0; | ||
87 | struct pid *pid; | ||
88 | |||
89 | rcu_read_lock(); | ||
90 | pid = task_pid(tsk); | ||
91 | if (pid != NULL && pid->numbers[pid->level].nr == 1) | ||
92 | ret = 1; | ||
93 | rcu_read_unlock(); | ||
94 | |||
95 | return ret; | ||
96 | } | ||
97 | EXPORT_SYMBOL(is_container_init); | ||
73 | 98 | ||
74 | /* | 99 | /* |
75 | * Note: disable interrupts while the pidmap_lock is held as an | 100 | * Note: disable interrupts while the pidmap_lock is held as an |
@@ -176,11 +201,17 @@ static int next_pidmap(struct pid_namespace *pid_ns, int last) | |||
176 | 201 | ||
177 | fastcall void put_pid(struct pid *pid) | 202 | fastcall void put_pid(struct pid *pid) |
178 | { | 203 | { |
204 | struct pid_namespace *ns; | ||
205 | |||
179 | if (!pid) | 206 | if (!pid) |
180 | return; | 207 | return; |
208 | |||
209 | ns = pid->numbers[pid->level].ns; | ||
181 | if ((atomic_read(&pid->count) == 1) || | 210 | if ((atomic_read(&pid->count) == 1) || |
182 | atomic_dec_and_test(&pid->count)) | 211 | atomic_dec_and_test(&pid->count)) { |
183 | kmem_cache_free(pid_cachep, pid); | 212 | kmem_cache_free(ns->pid_cachep, pid); |
213 | put_pid_ns(ns); | ||
214 | } | ||
184 | } | 215 | } |
185 | EXPORT_SYMBOL_GPL(put_pid); | 216 | EXPORT_SYMBOL_GPL(put_pid); |
186 | 217 | ||
@@ -193,60 +224,94 @@ static void delayed_put_pid(struct rcu_head *rhp) | |||
193 | fastcall void free_pid(struct pid *pid) | 224 | fastcall void free_pid(struct pid *pid) |
194 | { | 225 | { |
195 | /* We can be called with write_lock_irq(&tasklist_lock) held */ | 226 | /* We can be called with write_lock_irq(&tasklist_lock) held */ |
227 | int i; | ||
196 | unsigned long flags; | 228 | unsigned long flags; |
197 | 229 | ||
198 | spin_lock_irqsave(&pidmap_lock, flags); | 230 | spin_lock_irqsave(&pidmap_lock, flags); |
199 | hlist_del_rcu(&pid->pid_chain); | 231 | for (i = 0; i <= pid->level; i++) |
232 | hlist_del_rcu(&pid->numbers[i].pid_chain); | ||
200 | spin_unlock_irqrestore(&pidmap_lock, flags); | 233 | spin_unlock_irqrestore(&pidmap_lock, flags); |
201 | 234 | ||
202 | free_pidmap(&init_pid_ns, pid->nr); | 235 | for (i = 0; i <= pid->level; i++) |
236 | free_pidmap(pid->numbers[i].ns, pid->numbers[i].nr); | ||
237 | |||
203 | call_rcu(&pid->rcu, delayed_put_pid); | 238 | call_rcu(&pid->rcu, delayed_put_pid); |
204 | } | 239 | } |
205 | 240 | ||
206 | struct pid *alloc_pid(void) | 241 | struct pid *alloc_pid(struct pid_namespace *ns) |
207 | { | 242 | { |
208 | struct pid *pid; | 243 | struct pid *pid; |
209 | enum pid_type type; | 244 | enum pid_type type; |
210 | int nr = -1; | 245 | int i, nr; |
246 | struct pid_namespace *tmp; | ||
247 | struct upid *upid; | ||
211 | 248 | ||
212 | pid = kmem_cache_alloc(pid_cachep, GFP_KERNEL); | 249 | pid = kmem_cache_alloc(ns->pid_cachep, GFP_KERNEL); |
213 | if (!pid) | 250 | if (!pid) |
214 | goto out; | 251 | goto out; |
215 | 252 | ||
216 | nr = alloc_pidmap(current->nsproxy->pid_ns); | 253 | tmp = ns; |
217 | if (nr < 0) | 254 | for (i = ns->level; i >= 0; i--) { |
218 | goto out_free; | 255 | nr = alloc_pidmap(tmp); |
256 | if (nr < 0) | ||
257 | goto out_free; | ||
258 | |||
259 | pid->numbers[i].nr = nr; | ||
260 | pid->numbers[i].ns = tmp; | ||
261 | tmp = tmp->parent; | ||
262 | } | ||
219 | 263 | ||
264 | get_pid_ns(ns); | ||
265 | pid->level = ns->level; | ||
220 | atomic_set(&pid->count, 1); | 266 | atomic_set(&pid->count, 1); |
221 | pid->nr = nr; | ||
222 | for (type = 0; type < PIDTYPE_MAX; ++type) | 267 | for (type = 0; type < PIDTYPE_MAX; ++type) |
223 | INIT_HLIST_HEAD(&pid->tasks[type]); | 268 | INIT_HLIST_HEAD(&pid->tasks[type]); |
224 | 269 | ||
225 | spin_lock_irq(&pidmap_lock); | 270 | spin_lock_irq(&pidmap_lock); |
226 | hlist_add_head_rcu(&pid->pid_chain, &pid_hash[pid_hashfn(pid->nr)]); | 271 | for (i = ns->level; i >= 0; i--) { |
272 | upid = &pid->numbers[i]; | ||
273 | hlist_add_head_rcu(&upid->pid_chain, | ||
274 | &pid_hash[pid_hashfn(upid->nr, upid->ns)]); | ||
275 | } | ||
227 | spin_unlock_irq(&pidmap_lock); | 276 | spin_unlock_irq(&pidmap_lock); |
228 | 277 | ||
229 | out: | 278 | out: |
230 | return pid; | 279 | return pid; |
231 | 280 | ||
232 | out_free: | 281 | out_free: |
233 | kmem_cache_free(pid_cachep, pid); | 282 | for (i++; i <= ns->level; i++) |
283 | free_pidmap(pid->numbers[i].ns, pid->numbers[i].nr); | ||
284 | |||
285 | kmem_cache_free(ns->pid_cachep, pid); | ||
234 | pid = NULL; | 286 | pid = NULL; |
235 | goto out; | 287 | goto out; |
236 | } | 288 | } |
237 | 289 | ||
238 | struct pid * fastcall find_pid(int nr) | 290 | struct pid * fastcall find_pid_ns(int nr, struct pid_namespace *ns) |
239 | { | 291 | { |
240 | struct hlist_node *elem; | 292 | struct hlist_node *elem; |
241 | struct pid *pid; | 293 | struct upid *pnr; |
294 | |||
295 | hlist_for_each_entry_rcu(pnr, elem, | ||
296 | &pid_hash[pid_hashfn(nr, ns)], pid_chain) | ||
297 | if (pnr->nr == nr && pnr->ns == ns) | ||
298 | return container_of(pnr, struct pid, | ||
299 | numbers[ns->level]); | ||
242 | 300 | ||
243 | hlist_for_each_entry_rcu(pid, elem, | ||
244 | &pid_hash[pid_hashfn(nr)], pid_chain) { | ||
245 | if (pid->nr == nr) | ||
246 | return pid; | ||
247 | } | ||
248 | return NULL; | 301 | return NULL; |
249 | } | 302 | } |
303 | EXPORT_SYMBOL_GPL(find_pid_ns); | ||
304 | |||
305 | struct pid *find_vpid(int nr) | ||
306 | { | ||
307 | return find_pid_ns(nr, current->nsproxy->pid_ns); | ||
308 | } | ||
309 | EXPORT_SYMBOL_GPL(find_vpid); | ||
310 | |||
311 | struct pid *find_pid(int nr) | ||
312 | { | ||
313 | return find_pid_ns(nr, &init_pid_ns); | ||
314 | } | ||
250 | EXPORT_SYMBOL_GPL(find_pid); | 315 | EXPORT_SYMBOL_GPL(find_pid); |
251 | 316 | ||
252 | /* | 317 | /* |
@@ -307,12 +372,32 @@ struct task_struct * fastcall pid_task(struct pid *pid, enum pid_type type) | |||
307 | /* | 372 | /* |
308 | * Must be called under rcu_read_lock() or with tasklist_lock read-held. | 373 | * Must be called under rcu_read_lock() or with tasklist_lock read-held. |
309 | */ | 374 | */ |
310 | struct task_struct *find_task_by_pid_type(int type, int nr) | 375 | struct task_struct *find_task_by_pid_type_ns(int type, int nr, |
376 | struct pid_namespace *ns) | ||
311 | { | 377 | { |
312 | return pid_task(find_pid(nr), type); | 378 | return pid_task(find_pid_ns(nr, ns), type); |
313 | } | 379 | } |
314 | 380 | ||
315 | EXPORT_SYMBOL(find_task_by_pid_type); | 381 | EXPORT_SYMBOL(find_task_by_pid_type_ns); |
382 | |||
383 | struct task_struct *find_task_by_pid(pid_t nr) | ||
384 | { | ||
385 | return find_task_by_pid_type_ns(PIDTYPE_PID, nr, &init_pid_ns); | ||
386 | } | ||
387 | EXPORT_SYMBOL(find_task_by_pid); | ||
388 | |||
389 | struct task_struct *find_task_by_vpid(pid_t vnr) | ||
390 | { | ||
391 | return find_task_by_pid_type_ns(PIDTYPE_PID, vnr, | ||
392 | current->nsproxy->pid_ns); | ||
393 | } | ||
394 | EXPORT_SYMBOL(find_task_by_vpid); | ||
395 | |||
396 | struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns) | ||
397 | { | ||
398 | return find_task_by_pid_type_ns(PIDTYPE_PID, nr, ns); | ||
399 | } | ||
400 | EXPORT_SYMBOL(find_task_by_pid_ns); | ||
316 | 401 | ||
317 | struct pid *get_task_pid(struct task_struct *task, enum pid_type type) | 402 | struct pid *get_task_pid(struct task_struct *task, enum pid_type type) |
318 | { | 403 | { |
@@ -339,45 +424,239 @@ struct pid *find_get_pid(pid_t nr) | |||
339 | struct pid *pid; | 424 | struct pid *pid; |
340 | 425 | ||
341 | rcu_read_lock(); | 426 | rcu_read_lock(); |
342 | pid = get_pid(find_pid(nr)); | 427 | pid = get_pid(find_vpid(nr)); |
343 | rcu_read_unlock(); | 428 | rcu_read_unlock(); |
344 | 429 | ||
345 | return pid; | 430 | return pid; |
346 | } | 431 | } |
347 | 432 | ||
433 | pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns) | ||
434 | { | ||
435 | struct upid *upid; | ||
436 | pid_t nr = 0; | ||
437 | |||
438 | if (pid && ns->level <= pid->level) { | ||
439 | upid = &pid->numbers[ns->level]; | ||
440 | if (upid->ns == ns) | ||
441 | nr = upid->nr; | ||
442 | } | ||
443 | return nr; | ||
444 | } | ||
445 | |||
446 | pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns) | ||
447 | { | ||
448 | return pid_nr_ns(task_pid(tsk), ns); | ||
449 | } | ||
450 | EXPORT_SYMBOL(task_pid_nr_ns); | ||
451 | |||
452 | pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns) | ||
453 | { | ||
454 | return pid_nr_ns(task_tgid(tsk), ns); | ||
455 | } | ||
456 | EXPORT_SYMBOL(task_tgid_nr_ns); | ||
457 | |||
458 | pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns) | ||
459 | { | ||
460 | return pid_nr_ns(task_pgrp(tsk), ns); | ||
461 | } | ||
462 | EXPORT_SYMBOL(task_pgrp_nr_ns); | ||
463 | |||
464 | pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns) | ||
465 | { | ||
466 | return pid_nr_ns(task_session(tsk), ns); | ||
467 | } | ||
468 | EXPORT_SYMBOL(task_session_nr_ns); | ||
469 | |||
348 | /* | 470 | /* |
349 | * Used by proc to find the first pid that is greater then or equal to nr. | 471 | * Used by proc to find the first pid that is greater then or equal to nr. |
350 | * | 472 | * |
351 | * If there is a pid at nr this function is exactly the same as find_pid. | 473 | * If there is a pid at nr this function is exactly the same as find_pid. |
352 | */ | 474 | */ |
353 | struct pid *find_ge_pid(int nr) | 475 | struct pid *find_ge_pid(int nr, struct pid_namespace *ns) |
354 | { | 476 | { |
355 | struct pid *pid; | 477 | struct pid *pid; |
356 | 478 | ||
357 | do { | 479 | do { |
358 | pid = find_pid(nr); | 480 | pid = find_pid_ns(nr, ns); |
359 | if (pid) | 481 | if (pid) |
360 | break; | 482 | break; |
361 | nr = next_pidmap(current->nsproxy->pid_ns, nr); | 483 | nr = next_pidmap(ns, nr); |
362 | } while (nr > 0); | 484 | } while (nr > 0); |
363 | 485 | ||
364 | return pid; | 486 | return pid; |
365 | } | 487 | } |
366 | EXPORT_SYMBOL_GPL(find_get_pid); | 488 | EXPORT_SYMBOL_GPL(find_get_pid); |
367 | 489 | ||
490 | struct pid_cache { | ||
491 | int nr_ids; | ||
492 | char name[16]; | ||
493 | struct kmem_cache *cachep; | ||
494 | struct list_head list; | ||
495 | }; | ||
496 | |||
497 | static LIST_HEAD(pid_caches_lh); | ||
498 | static DEFINE_MUTEX(pid_caches_mutex); | ||
499 | |||
500 | /* | ||
501 | * creates the kmem cache to allocate pids from. | ||
502 | * @nr_ids: the number of numerical ids this pid will have to carry | ||
503 | */ | ||
504 | |||
505 | static struct kmem_cache *create_pid_cachep(int nr_ids) | ||
506 | { | ||
507 | struct pid_cache *pcache; | ||
508 | struct kmem_cache *cachep; | ||
509 | |||
510 | mutex_lock(&pid_caches_mutex); | ||
511 | list_for_each_entry (pcache, &pid_caches_lh, list) | ||
512 | if (pcache->nr_ids == nr_ids) | ||
513 | goto out; | ||
514 | |||
515 | pcache = kmalloc(sizeof(struct pid_cache), GFP_KERNEL); | ||
516 | if (pcache == NULL) | ||
517 | goto err_alloc; | ||
518 | |||
519 | snprintf(pcache->name, sizeof(pcache->name), "pid_%d", nr_ids); | ||
520 | cachep = kmem_cache_create(pcache->name, | ||
521 | sizeof(struct pid) + (nr_ids - 1) * sizeof(struct upid), | ||
522 | 0, SLAB_HWCACHE_ALIGN, NULL); | ||
523 | if (cachep == NULL) | ||
524 | goto err_cachep; | ||
525 | |||
526 | pcache->nr_ids = nr_ids; | ||
527 | pcache->cachep = cachep; | ||
528 | list_add(&pcache->list, &pid_caches_lh); | ||
529 | out: | ||
530 | mutex_unlock(&pid_caches_mutex); | ||
531 | return pcache->cachep; | ||
532 | |||
533 | err_cachep: | ||
534 | kfree(pcache); | ||
535 | err_alloc: | ||
536 | mutex_unlock(&pid_caches_mutex); | ||
537 | return NULL; | ||
538 | } | ||
539 | |||
540 | static struct pid_namespace *create_pid_namespace(int level) | ||
541 | { | ||
542 | struct pid_namespace *ns; | ||
543 | int i; | ||
544 | |||
545 | ns = kmem_cache_alloc(pid_ns_cachep, GFP_KERNEL); | ||
546 | if (ns == NULL) | ||
547 | goto out; | ||
548 | |||
549 | ns->pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL); | ||
550 | if (!ns->pidmap[0].page) | ||
551 | goto out_free; | ||
552 | |||
553 | ns->pid_cachep = create_pid_cachep(level + 1); | ||
554 | if (ns->pid_cachep == NULL) | ||
555 | goto out_free_map; | ||
556 | |||
557 | kref_init(&ns->kref); | ||
558 | ns->last_pid = 0; | ||
559 | ns->child_reaper = NULL; | ||
560 | ns->level = level; | ||
561 | |||
562 | set_bit(0, ns->pidmap[0].page); | ||
563 | atomic_set(&ns->pidmap[0].nr_free, BITS_PER_PAGE - 1); | ||
564 | |||
565 | for (i = 1; i < PIDMAP_ENTRIES; i++) { | ||
566 | ns->pidmap[i].page = 0; | ||
567 | atomic_set(&ns->pidmap[i].nr_free, BITS_PER_PAGE); | ||
568 | } | ||
569 | |||
570 | return ns; | ||
571 | |||
572 | out_free_map: | ||
573 | kfree(ns->pidmap[0].page); | ||
574 | out_free: | ||
575 | kmem_cache_free(pid_ns_cachep, ns); | ||
576 | out: | ||
577 | return ERR_PTR(-ENOMEM); | ||
578 | } | ||
579 | |||
580 | static void destroy_pid_namespace(struct pid_namespace *ns) | ||
581 | { | ||
582 | int i; | ||
583 | |||
584 | for (i = 0; i < PIDMAP_ENTRIES; i++) | ||
585 | kfree(ns->pidmap[i].page); | ||
586 | kmem_cache_free(pid_ns_cachep, ns); | ||
587 | } | ||
588 | |||
368 | struct pid_namespace *copy_pid_ns(unsigned long flags, struct pid_namespace *old_ns) | 589 | struct pid_namespace *copy_pid_ns(unsigned long flags, struct pid_namespace *old_ns) |
369 | { | 590 | { |
591 | struct pid_namespace *new_ns; | ||
592 | |||
370 | BUG_ON(!old_ns); | 593 | BUG_ON(!old_ns); |
371 | get_pid_ns(old_ns); | 594 | new_ns = get_pid_ns(old_ns); |
372 | return old_ns; | 595 | if (!(flags & CLONE_NEWPID)) |
596 | goto out; | ||
597 | |||
598 | new_ns = ERR_PTR(-EINVAL); | ||
599 | if (flags & CLONE_THREAD) | ||
600 | goto out_put; | ||
601 | |||
602 | new_ns = create_pid_namespace(old_ns->level + 1); | ||
603 | if (!IS_ERR(new_ns)) | ||
604 | new_ns->parent = get_pid_ns(old_ns); | ||
605 | |||
606 | out_put: | ||
607 | put_pid_ns(old_ns); | ||
608 | out: | ||
609 | return new_ns; | ||
373 | } | 610 | } |
374 | 611 | ||
375 | void free_pid_ns(struct kref *kref) | 612 | void free_pid_ns(struct kref *kref) |
376 | { | 613 | { |
377 | struct pid_namespace *ns; | 614 | struct pid_namespace *ns, *parent; |
378 | 615 | ||
379 | ns = container_of(kref, struct pid_namespace, kref); | 616 | ns = container_of(kref, struct pid_namespace, kref); |
380 | kfree(ns); | 617 | |
618 | parent = ns->parent; | ||
619 | destroy_pid_namespace(ns); | ||
620 | |||
621 | if (parent != NULL) | ||
622 | put_pid_ns(parent); | ||
623 | } | ||
624 | |||
625 | void zap_pid_ns_processes(struct pid_namespace *pid_ns) | ||
626 | { | ||
627 | int nr; | ||
628 | int rc; | ||
629 | |||
630 | /* | ||
631 | * The last thread in the cgroup-init thread group is terminating. | ||
632 | * Find remaining pid_ts in the namespace, signal and wait for them | ||
633 | * to exit. | ||
634 | * | ||
635 | * Note: This signals each threads in the namespace - even those that | ||
636 | * belong to the same thread group, To avoid this, we would have | ||
637 | * to walk the entire tasklist looking a processes in this | ||
638 | * namespace, but that could be unnecessarily expensive if the | ||
639 | * pid namespace has just a few processes. Or we need to | ||
640 | * maintain a tasklist for each pid namespace. | ||
641 | * | ||
642 | */ | ||
643 | read_lock(&tasklist_lock); | ||
644 | nr = next_pidmap(pid_ns, 1); | ||
645 | while (nr > 0) { | ||
646 | kill_proc_info(SIGKILL, SEND_SIG_PRIV, nr); | ||
647 | nr = next_pidmap(pid_ns, nr); | ||
648 | } | ||
649 | read_unlock(&tasklist_lock); | ||
650 | |||
651 | do { | ||
652 | clear_thread_flag(TIF_SIGPENDING); | ||
653 | rc = sys_wait4(-1, NULL, __WALL, NULL); | ||
654 | } while (rc != -ECHILD); | ||
655 | |||
656 | |||
657 | /* Child reaper for the pid namespace is going away */ | ||
658 | pid_ns->child_reaper = NULL; | ||
659 | return; | ||
381 | } | 660 | } |
382 | 661 | ||
383 | /* | 662 | /* |
@@ -412,5 +691,9 @@ void __init pidmap_init(void) | |||
412 | set_bit(0, init_pid_ns.pidmap[0].page); | 691 | set_bit(0, init_pid_ns.pidmap[0].page); |
413 | atomic_dec(&init_pid_ns.pidmap[0].nr_free); | 692 | atomic_dec(&init_pid_ns.pidmap[0].nr_free); |
414 | 693 | ||
415 | pid_cachep = KMEM_CACHE(pid, SLAB_PANIC); | 694 | init_pid_ns.pid_cachep = create_pid_cachep(1); |
695 | if (init_pid_ns.pid_cachep == NULL) | ||
696 | panic("Can't create pid_1 cachep\n"); | ||
697 | |||
698 | pid_ns_cachep = KMEM_CACHE(pid_namespace, SLAB_PANIC); | ||
416 | } | 699 | } |