projects/linux·blob v2.6.26 · refs

1680 lines · 40.4 KiB

1/*
2 * linux/kernel/fork.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7/*
8 * 'fork.c' contains the help-routines for the 'fork' system call
9 * (see also entry.S and others).
10 * Fork is rather simple, once you get the hang of it, but the memory
11 * management can be a bitch. See 'mm/memory.c': 'copy_page_range()'
12 */
13
14#include <linux/slab.h>
15#include <linux/init.h>
16#include <linux/unistd.h>
17#include <linux/module.h>
18#include <linux/vmalloc.h>
19#include <linux/completion.h>
20#include <linux/mnt_namespace.h>
21#include <linux/personality.h>
22#include <linux/mempolicy.h>
23#include <linux/sem.h>
24#include <linux/file.h>
25#include <linux/fdtable.h>
26#include <linux/key.h>
27#include <linux/binfmts.h>
28#include <linux/mman.h>
29#include <linux/fs.h>
30#include <linux/nsproxy.h>
31#include <linux/capability.h>
32#include <linux/cpu.h>
33#include <linux/cgroup.h>
34#include <linux/security.h>
35#include <linux/swap.h>
36#include <linux/syscalls.h>
37#include <linux/jiffies.h>
38#include <linux/futex.h>
39#include <linux/task_io_accounting_ops.h>
40#include <linux/rcupdate.h>
41#include <linux/ptrace.h>
42#include <linux/mount.h>
43#include <linux/audit.h>
44#include <linux/memcontrol.h>
45#include <linux/profile.h>
46#include <linux/rmap.h>
47#include <linux/acct.h>
48#include <linux/tsacct_kern.h>
49#include <linux/cn_proc.h>
50#include <linux/freezer.h>
51#include <linux/delayacct.h>
52#include <linux/taskstats_kern.h>
53#include <linux/random.h>
54#include <linux/tty.h>
55#include <linux/proc_fs.h>
56#include <linux/blkdev.h>
57
58#include <asm/pgtable.h>
59#include <asm/pgalloc.h>
60#include <asm/uaccess.h>
61#include <asm/mmu_context.h>
62#include <asm/cacheflush.h>
63#include <asm/tlbflush.h>
64
65/*
66 * Protected counters by write_lock_irq(&tasklist_lock)
67 */
68unsigned long total_forks; /* Handle normal Linux uptimes. */
69int nr_threads; /* The idle threads do not count.. */
70
71int max_threads; /* tunable limit on nr_threads */
72
73DEFINE_PER_CPU(unsigned long, process_counts) = 0;
74
75__cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */
76
77int nr_processes(void)
78{
79 int cpu;
80 int total = 0;
81
82 for_each_online_cpu(cpu)
83 total += per_cpu(process_counts, cpu);
84
85 return total;
86}
87
88#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
89# define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)
90# define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk))
91static struct kmem_cache *task_struct_cachep;
92#endif
93
94/* SLAB cache for signal_struct structures (tsk->signal) */
95static struct kmem_cache *signal_cachep;
96
97/* SLAB cache for sighand_struct structures (tsk->sighand) */
98struct kmem_cache *sighand_cachep;
99
100/* SLAB cache for files_struct structures (tsk->files) */
101struct kmem_cache *files_cachep;
102
103/* SLAB cache for fs_struct structures (tsk->fs) */
104struct kmem_cache *fs_cachep;
105
106/* SLAB cache for vm_area_struct structures */
107struct kmem_cache *vm_area_cachep;
108
109/* SLAB cache for mm_struct structures (tsk->mm) */
110static struct kmem_cache *mm_cachep;
111
112void free_task(struct task_struct *tsk)
113{
114 prop_local_destroy_single(&tsk->dirties);
115 free_thread_info(tsk->stack);
116 rt_mutex_debug_task_free(tsk);
117 free_task_struct(tsk);
118}
119EXPORT_SYMBOL(free_task);
120
121void __put_task_struct(struct task_struct *tsk)
122{
123 WARN_ON(!tsk->exit_state);
124 WARN_ON(atomic_read(&tsk->usage));
125 WARN_ON(tsk == current);
126
127 security_task_free(tsk);
128 free_uid(tsk->user);
129 put_group_info(tsk->group_info);
130 delayacct_tsk_free(tsk);
131
132 if (!profile_handoff_task(tsk))
133 free_task(tsk);
134}
135
136/*
137 * macro override instead of weak attribute alias, to workaround
138 * gcc 4.1.0 and 4.1.1 bugs with weak attribute and empty functions.
139 */
140#ifndef arch_task_cache_init
141#define arch_task_cache_init()
142#endif
143
144void __init fork_init(unsigned long mempages)
145{
146#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR
147#ifndef ARCH_MIN_TASKALIGN
148#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES
149#endif
150 /* create a slab on which task_structs can be allocated */
151 task_struct_cachep =
152 kmem_cache_create("task_struct", sizeof(struct task_struct),
153 ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);
154#endif
155
156 /* do the arch specific task caches init */
157 arch_task_cache_init();
158
159 /*
160 * The default maximum number of threads is set to a safe
161 * value: the thread structures can take up at most half
162 * of memory.
163 */
164 max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
165
166 /*
167 * we need to allow at least 20 threads to boot a system
168 */
169 if(max_threads < 20)
170 max_threads = 20;
171
172 init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;
173 init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;
174 init_task.signal->rlim[RLIMIT_SIGPENDING] =
175 init_task.signal->rlim[RLIMIT_NPROC];
176}
177
178int __attribute__((weak)) arch_dup_task_struct(struct task_struct *dst,
179 struct task_struct *src)
180{
181 *dst = *src;
182 return 0;
183}
184
185static struct task_struct *dup_task_struct(struct task_struct *orig)
186{
187 struct task_struct *tsk;
188 struct thread_info *ti;
189 int err;
190
191 prepare_to_copy(orig);
192
193 tsk = alloc_task_struct();
194 if (!tsk)
195 return NULL;
196
197 ti = alloc_thread_info(tsk);
198 if (!ti) {
199 free_task_struct(tsk);
200 return NULL;
201 }
202
203 err = arch_dup_task_struct(tsk, orig);
204 if (err)
205 goto out;
206
207 tsk->stack = ti;
208
209 err = prop_local_init_single(&tsk->dirties);
210 if (err)
211 goto out;
212
213 setup_thread_stack(tsk, orig);
214
215#ifdef CONFIG_CC_STACKPROTECTOR
216 tsk->stack_canary = get_random_int();
217#endif
218
219 /* One for us, one for whoever does the "release_task()" (usually parent) */
220 atomic_set(&tsk->usage,2);
221 atomic_set(&tsk->fs_excl, 0);
222#ifdef CONFIG_BLK_DEV_IO_TRACE
223 tsk->btrace_seq = 0;
224#endif
225 tsk->splice_pipe = NULL;
226 return tsk;
227
228out:
229 free_thread_info(ti);
230 free_task_struct(tsk);
231 return NULL;
232}
233
234#ifdef CONFIG_MMU
235static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
236{
237 struct vm_area_struct *mpnt, *tmp, **pprev;
238 struct rb_node **rb_link, *rb_parent;
239 int retval;
240 unsigned long charge;
241 struct mempolicy *pol;
242
243 down_write(&oldmm->mmap_sem);
244 flush_cache_dup_mm(oldmm);
245 /*
246 * Not linked in yet - no deadlock potential:
247 */
248 down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
249
250 mm->locked_vm = 0;
251 mm->mmap = NULL;
252 mm->mmap_cache = NULL;
253 mm->free_area_cache = oldmm->mmap_base;
254 mm->cached_hole_size = ~0UL;
255 mm->map_count = 0;
256 cpus_clear(mm->cpu_vm_mask);
257 mm->mm_rb = RB_ROOT;
258 rb_link = &mm->mm_rb.rb_node;
259 rb_parent = NULL;
260 pprev = &mm->mmap;
261
262 for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
263 struct file *file;
264
265 if (mpnt->vm_flags & VM_DONTCOPY) {
266 long pages = vma_pages(mpnt);
267 mm->total_vm -= pages;
268 vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
269 -pages);
270 continue;
271 }
272 charge = 0;
273 if (mpnt->vm_flags & VM_ACCOUNT) {
274 unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
275 if (security_vm_enough_memory(len))
276 goto fail_nomem;
277 charge = len;
278 }
279 tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
280 if (!tmp)
281 goto fail_nomem;
282 *tmp = *mpnt;
283 pol = mpol_dup(vma_policy(mpnt));
284 retval = PTR_ERR(pol);
285 if (IS_ERR(pol))
286 goto fail_nomem_policy;
287 vma_set_policy(tmp, pol);
288 tmp->vm_flags &= ~VM_LOCKED;
289 tmp->vm_mm = mm;
290 tmp->vm_next = NULL;
291 anon_vma_link(tmp);
292 file = tmp->vm_file;
293 if (file) {
294 struct inode *inode = file->f_path.dentry->d_inode;
295 get_file(file);
296 if (tmp->vm_flags & VM_DENYWRITE)
297 atomic_dec(&inode->i_writecount);
298
299 /* insert tmp into the share list, just after mpnt */
300 spin_lock(&file->f_mapping->i_mmap_lock);
301 tmp->vm_truncate_count = mpnt->vm_truncate_count;
302 flush_dcache_mmap_lock(file->f_mapping);
303 vma_prio_tree_add(tmp, mpnt);
304 flush_dcache_mmap_unlock(file->f_mapping);
305 spin_unlock(&file->f_mapping->i_mmap_lock);
306 }
307
308 /*
309 * Link in the new vma and copy the page table entries.
310 */
311 *pprev = tmp;
312 pprev = &tmp->vm_next;
313
314 __vma_link_rb(mm, tmp, rb_link, rb_parent);
315 rb_link = &tmp->vm_rb.rb_right;
316 rb_parent = &tmp->vm_rb;
317
318 mm->map_count++;
319 retval = copy_page_range(mm, oldmm, mpnt);
320
321 if (tmp->vm_ops && tmp->vm_ops->open)
322 tmp->vm_ops->open(tmp);
323
324 if (retval)
325 goto out;
326 }
327 /* a new mm has just been created */
328 arch_dup_mmap(oldmm, mm);
329 retval = 0;
330out:
331 up_write(&mm->mmap_sem);
332 flush_tlb_mm(oldmm);
333 up_write(&oldmm->mmap_sem);
334 return retval;
335fail_nomem_policy:
336 kmem_cache_free(vm_area_cachep, tmp);
337fail_nomem:
338 retval = -ENOMEM;
339 vm_unacct_memory(charge);
340 goto out;
341}
342
343static inline int mm_alloc_pgd(struct mm_struct * mm)
344{
345 mm->pgd = pgd_alloc(mm);
346 if (unlikely(!mm->pgd))
347 return -ENOMEM;
348 return 0;
349}
350
351static inline void mm_free_pgd(struct mm_struct * mm)
352{
353 pgd_free(mm, mm->pgd);
354}
355#else
356#define dup_mmap(mm, oldmm) (0)
357#define mm_alloc_pgd(mm) (0)
358#define mm_free_pgd(mm)
359#endif /* CONFIG_MMU */
360
361__cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock);
362
363#define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
364#define free_mm(mm) (kmem_cache_free(mm_cachep, (mm)))
365
366#include <linux/init_task.h>
367
368static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)
369{
370 atomic_set(&mm->mm_users, 1);
371 atomic_set(&mm->mm_count, 1);
372 init_rwsem(&mm->mmap_sem);
373 INIT_LIST_HEAD(&mm->mmlist);
374 mm->flags = (current->mm) ? current->mm->flags
375 : MMF_DUMP_FILTER_DEFAULT;
376 mm->core_waiters = 0;
377 mm->nr_ptes = 0;
378 set_mm_counter(mm, file_rss, 0);
379 set_mm_counter(mm, anon_rss, 0);
380 spin_lock_init(&mm->page_table_lock);
381 rwlock_init(&mm->ioctx_list_lock);
382 mm->ioctx_list = NULL;
383 mm->free_area_cache = TASK_UNMAPPED_BASE;
384 mm->cached_hole_size = ~0UL;
385 mm_init_owner(mm, p);
386
387 if (likely(!mm_alloc_pgd(mm))) {
388 mm->def_flags = 0;
389 return mm;
390 }
391
392 free_mm(mm);
393 return NULL;
394}
395
396/*
397 * Allocate and initialize an mm_struct.
398 */
399struct mm_struct * mm_alloc(void)
400{
401 struct mm_struct * mm;
402
403 mm = allocate_mm();
404 if (mm) {
405 memset(mm, 0, sizeof(*mm));
406 mm = mm_init(mm, current);
407 }
408 return mm;
409}
410
411/*
412 * Called when the last reference to the mm
413 * is dropped: either by a lazy thread or by
414 * mmput. Free the page directory and the mm.
415 */
416void __mmdrop(struct mm_struct *mm)
417{
418 BUG_ON(mm == &init_mm);
419 mm_free_pgd(mm);
420 destroy_context(mm);
421 free_mm(mm);
422}
423EXPORT_SYMBOL_GPL(__mmdrop);
424
425/*
426 * Decrement the use count and release all resources for an mm.
427 */
428void mmput(struct mm_struct *mm)
429{
430 might_sleep();
431
432 if (atomic_dec_and_test(&mm->mm_users)) {
433 exit_aio(mm);
434 exit_mmap(mm);
435 set_mm_exe_file(mm, NULL);
436 if (!list_empty(&mm->mmlist)) {
437 spin_lock(&mmlist_lock);
438 list_del(&mm->mmlist);
439 spin_unlock(&mmlist_lock);
440 }
441 put_swap_token(mm);
442 mmdrop(mm);
443 }
444}
445EXPORT_SYMBOL_GPL(mmput);
446
447/**
448 * get_task_mm - acquire a reference to the task's mm
449 *
450 * Returns %NULL if the task has no mm. Checks PF_BORROWED_MM (meaning
451 * this kernel workthread has transiently adopted a user mm with use_mm,
452 * to do its AIO) is not set and if so returns a reference to it, after
453 * bumping up the use count. User must release the mm via mmput()
454 * after use. Typically used by /proc and ptrace.
455 */
456struct mm_struct *get_task_mm(struct task_struct *task)
457{
458 struct mm_struct *mm;
459
460 task_lock(task);
461 mm = task->mm;
462 if (mm) {
463 if (task->flags & PF_BORROWED_MM)
464 mm = NULL;
465 else
466 atomic_inc(&mm->mm_users);
467 }
468 task_unlock(task);
469 return mm;
470}
471EXPORT_SYMBOL_GPL(get_task_mm);
472
473/* Please note the differences between mmput and mm_release.
474 * mmput is called whenever we stop holding onto a mm_struct,
475 * error success whatever.
476 *
477 * mm_release is called after a mm_struct has been removed
478 * from the current process.
479 *
480 * This difference is important for error handling, when we
481 * only half set up a mm_struct for a new process and need to restore
482 * the old one. Because we mmput the new mm_struct before
483 * restoring the old one. . .
484 * Eric Biederman 10 January 1998
485 */
486void mm_release(struct task_struct *tsk, struct mm_struct *mm)
487{
488 struct completion *vfork_done = tsk->vfork_done;
489
490 /* Get rid of any cached register state */
491 deactivate_mm(tsk, mm);
492
493 /* notify parent sleeping on vfork() */
494 if (vfork_done) {
495 tsk->vfork_done = NULL;
496 complete(vfork_done);
497 }
498
499 /*
500 * If we're exiting normally, clear a user-space tid field if
501 * requested. We leave this alone when dying by signal, to leave
502 * the value intact in a core dump, and to save the unnecessary
503 * trouble otherwise. Userland only wants this done for a sys_exit.
504 */
505 if (tsk->clear_child_tid
506 && !(tsk->flags & PF_SIGNALED)
507 && atomic_read(&mm->mm_users) > 1) {
508 u32 __user * tidptr = tsk->clear_child_tid;
509 tsk->clear_child_tid = NULL;
510
511 /*
512 * We don't check the error code - if userspace has
513 * not set up a proper pointer then tough luck.
514 */
515 put_user(0, tidptr);
516 sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
517 }
518}
519
520/*
521 * Allocate a new mm structure and copy contents from the
522 * mm structure of the passed in task structure.
523 */
524struct mm_struct *dup_mm(struct task_struct *tsk)
525{
526 struct mm_struct *mm, *oldmm = current->mm;
527 int err;
528
529 if (!oldmm)
530 return NULL;
531
532 mm = allocate_mm();
533 if (!mm)
534 goto fail_nomem;
535
536 memcpy(mm, oldmm, sizeof(*mm));
537
538 /* Initializing for Swap token stuff */
539 mm->token_priority = 0;
540 mm->last_interval = 0;
541
542 if (!mm_init(mm, tsk))
543 goto fail_nomem;
544
545 if (init_new_context(tsk, mm))
546 goto fail_nocontext;
547
548 dup_mm_exe_file(oldmm, mm);
549
550 err = dup_mmap(mm, oldmm);
551 if (err)
552 goto free_pt;
553
554 mm->hiwater_rss = get_mm_rss(mm);
555 mm->hiwater_vm = mm->total_vm;
556
557 return mm;
558
559free_pt:
560 mmput(mm);
561
562fail_nomem:
563 return NULL;
564
565fail_nocontext:
566 /*
567 * If init_new_context() failed, we cannot use mmput() to free the mm
568 * because it calls destroy_context()
569 */
570 mm_free_pgd(mm);
571 free_mm(mm);
572 return NULL;
573}
574
575static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
576{
577 struct mm_struct * mm, *oldmm;
578 int retval;
579
580 tsk->min_flt = tsk->maj_flt = 0;
581 tsk->nvcsw = tsk->nivcsw = 0;
582
583 tsk->mm = NULL;
584 tsk->active_mm = NULL;
585
586 /*
587 * Are we cloning a kernel thread?
588 *
589 * We need to steal a active VM for that..
590 */
591 oldmm = current->mm;
592 if (!oldmm)
593 return 0;
594
595 if (clone_flags & CLONE_VM) {
596 atomic_inc(&oldmm->mm_users);
597 mm = oldmm;
598 goto good_mm;
599 }
600
601 retval = -ENOMEM;
602 mm = dup_mm(tsk);
603 if (!mm)
604 goto fail_nomem;
605
606good_mm:
607 /* Initializing for Swap token stuff */
608 mm->token_priority = 0;
609 mm->last_interval = 0;
610
611 tsk->mm = mm;
612 tsk->active_mm = mm;
613 return 0;
614
615fail_nomem:
616 return retval;
617}
618
619static struct fs_struct *__copy_fs_struct(struct fs_struct *old)
620{
621 struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
622 /* We don't need to lock fs - think why ;-) */
623 if (fs) {
624 atomic_set(&fs->count, 1);
625 rwlock_init(&fs->lock);
626 fs->umask = old->umask;
627 read_lock(&old->lock);
628 fs->root = old->root;
629 path_get(&old->root);
630 fs->pwd = old->pwd;
631 path_get(&old->pwd);
632 if (old->altroot.dentry) {
633 fs->altroot = old->altroot;
634 path_get(&old->altroot);
635 } else {
636 fs->altroot.mnt = NULL;
637 fs->altroot.dentry = NULL;
638 }
639 read_unlock(&old->lock);
640 }
641 return fs;
642}
643
644struct fs_struct *copy_fs_struct(struct fs_struct *old)
645{
646 return __copy_fs_struct(old);
647}
648
649EXPORT_SYMBOL_GPL(copy_fs_struct);
650
651static int copy_fs(unsigned long clone_flags, struct task_struct *tsk)
652{
653 if (clone_flags & CLONE_FS) {
654 atomic_inc(&current->fs->count);
655 return 0;
656 }
657 tsk->fs = __copy_fs_struct(current->fs);
658 if (!tsk->fs)
659 return -ENOMEM;
660 return 0;
661}
662
663static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
664{
665 struct files_struct *oldf, *newf;
666 int error = 0;
667
668 /*
669 * A background process may not have any files ...
670 */
671 oldf = current->files;
672 if (!oldf)
673 goto out;
674
675 if (clone_flags & CLONE_FILES) {
676 atomic_inc(&oldf->count);
677 goto out;
678 }
679
680 newf = dup_fd(oldf, &error);
681 if (!newf)
682 goto out;
683
684 tsk->files = newf;
685 error = 0;
686out:
687 return error;
688}
689
690static int copy_io(unsigned long clone_flags, struct task_struct *tsk)
691{
692#ifdef CONFIG_BLOCK
693 struct io_context *ioc = current->io_context;
694
695 if (!ioc)
696 return 0;
697 /*
698 * Share io context with parent, if CLONE_IO is set
699 */
700 if (clone_flags & CLONE_IO) {
701 tsk->io_context = ioc_task_link(ioc);
702 if (unlikely(!tsk->io_context))
703 return -ENOMEM;
704 } else if (ioprio_valid(ioc->ioprio)) {
705 tsk->io_context = alloc_io_context(GFP_KERNEL, -1);
706 if (unlikely(!tsk->io_context))
707 return -ENOMEM;
708
709 tsk->io_context->ioprio = ioc->ioprio;
710 }
711#endif
712 return 0;
713}
714
715static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
716{
717 struct sighand_struct *sig;
718
719 if (clone_flags & (CLONE_SIGHAND | CLONE_THREAD)) {
720 atomic_inc(&current->sighand->count);
721 return 0;
722 }
723 sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
724 rcu_assign_pointer(tsk->sighand, sig);
725 if (!sig)
726 return -ENOMEM;
727 atomic_set(&sig->count, 1);
728 memcpy(sig->action, current->sighand->action, sizeof(sig->action));
729 return 0;
730}
731
732void __cleanup_sighand(struct sighand_struct *sighand)
733{
734 if (atomic_dec_and_test(&sighand->count))
735 kmem_cache_free(sighand_cachep, sighand);
736}
737
738static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
739{
740 struct signal_struct *sig;
741 int ret;
742
743 if (clone_flags & CLONE_THREAD) {
744 atomic_inc(&current->signal->count);
745 atomic_inc(&current->signal->live);
746 return 0;
747 }
748 sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL);
749 tsk->signal = sig;
750 if (!sig)
751 return -ENOMEM;
752
753 ret = copy_thread_group_keys(tsk);
754 if (ret < 0) {
755 kmem_cache_free(signal_cachep, sig);
756 return ret;
757 }
758
759 atomic_set(&sig->count, 1);
760 atomic_set(&sig->live, 1);
761 init_waitqueue_head(&sig->wait_chldexit);
762 sig->flags = 0;
763 sig->group_exit_code = 0;
764 sig->group_exit_task = NULL;
765 sig->group_stop_count = 0;
766 sig->curr_target = tsk;
767 init_sigpending(&sig->shared_pending);
768 INIT_LIST_HEAD(&sig->posix_timers);
769
770 hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
771 sig->it_real_incr.tv64 = 0;
772 sig->real_timer.function = it_real_fn;
773
774 sig->it_virt_expires = cputime_zero;
775 sig->it_virt_incr = cputime_zero;
776 sig->it_prof_expires = cputime_zero;
777 sig->it_prof_incr = cputime_zero;
778
779 sig->leader = 0; /* session leadership doesn't inherit */
780 sig->tty_old_pgrp = NULL;
781
782 sig->utime = sig->stime = sig->cutime = sig->cstime = cputime_zero;
783 sig->gtime = cputime_zero;
784 sig->cgtime = cputime_zero;
785 sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0;
786 sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0;
787 sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0;
788 sig->sum_sched_runtime = 0;
789 INIT_LIST_HEAD(&sig->cpu_timers[0]);
790 INIT_LIST_HEAD(&sig->cpu_timers[1]);
791 INIT_LIST_HEAD(&sig->cpu_timers[2]);
792 taskstats_tgid_init(sig);
793
794 task_lock(current->group_leader);
795 memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim);
796 task_unlock(current->group_leader);
797
798 if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
799 /*
800 * New sole thread in the process gets an expiry time
801 * of the whole CPU time limit.
802 */
803 tsk->it_prof_expires =
804 secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
805 }
806 acct_init_pacct(&sig->pacct);
807
808 tty_audit_fork(sig);
809
810 return 0;
811}
812
813void __cleanup_signal(struct signal_struct *sig)
814{
815 exit_thread_group_keys(sig);
816 kmem_cache_free(signal_cachep, sig);
817}
818
819static void cleanup_signal(struct task_struct *tsk)
820{
821 struct signal_struct *sig = tsk->signal;
822
823 atomic_dec(&sig->live);
824
825 if (atomic_dec_and_test(&sig->count))
826 __cleanup_signal(sig);
827}
828
829static void copy_flags(unsigned long clone_flags, struct task_struct *p)
830{
831 unsigned long new_flags = p->flags;
832
833 new_flags &= ~PF_SUPERPRIV;
834 new_flags |= PF_FORKNOEXEC;
835 if (!(clone_flags & CLONE_PTRACE))
836 p->ptrace = 0;
837 p->flags = new_flags;
838 clear_freeze_flag(p);
839}
840
841asmlinkage long sys_set_tid_address(int __user *tidptr)
842{
843 current->clear_child_tid = tidptr;
844
845 return task_pid_vnr(current);
846}
847
848static void rt_mutex_init_task(struct task_struct *p)
849{
850 spin_lock_init(&p->pi_lock);
851#ifdef CONFIG_RT_MUTEXES
852 plist_head_init(&p->pi_waiters, &p->pi_lock);
853 p->pi_blocked_on = NULL;
854#endif
855}
856
857#ifdef CONFIG_MM_OWNER
858void mm_init_owner(struct mm_struct *mm, struct task_struct *p)
859{
860 mm->owner = p;
861}
862#endif /* CONFIG_MM_OWNER */
863
864/*
865 * This creates a new process as a copy of the old one,
866 * but does not actually start it yet.
867 *
868 * It copies the registers, and all the appropriate
869 * parts of the process environment (as per the clone
870 * flags). The actual kick-off is left to the caller.
871 */
872static struct task_struct *copy_process(unsigned long clone_flags,
873 unsigned long stack_start,
874 struct pt_regs *regs,
875 unsigned long stack_size,
876 int __user *child_tidptr,
877 struct pid *pid)
878{
879 int retval;
880 struct task_struct *p;
881 int cgroup_callbacks_done = 0;
882
883 if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
884 return ERR_PTR(-EINVAL);
885
886 /*
887 * Thread groups must share signals as well, and detached threads
888 * can only be started up within the thread group.
889 */
890 if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
891 return ERR_PTR(-EINVAL);
892
893 /*
894 * Shared signal handlers imply shared VM. By way of the above,
895 * thread groups also imply shared VM. Blocking this case allows
896 * for various simplifications in other code.
897 */
898 if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
899 return ERR_PTR(-EINVAL);
900
901 retval = security_task_create(clone_flags);
902 if (retval)
903 goto fork_out;
904
905 retval = -ENOMEM;
906 p = dup_task_struct(current);
907 if (!p)
908 goto fork_out;
909
910 rt_mutex_init_task(p);
911
912#ifdef CONFIG_TRACE_IRQFLAGS
913 DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
914 DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
915#endif
916 retval = -EAGAIN;
917 if (atomic_read(&p->user->processes) >=
918 p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
919 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
920 p->user != current->nsproxy->user_ns->root_user)
921 goto bad_fork_free;
922 }
923
924 atomic_inc(&p->user->__count);
925 atomic_inc(&p->user->processes);
926 get_group_info(p->group_info);
927
928 /*
929 * If multiple threads are within copy_process(), then this check
930 * triggers too late. This doesn't hurt, the check is only there
931 * to stop root fork bombs.
932 */
933 if (nr_threads >= max_threads)
934 goto bad_fork_cleanup_count;
935
936 if (!try_module_get(task_thread_info(p)->exec_domain->module))
937 goto bad_fork_cleanup_count;
938
939 if (p->binfmt && !try_module_get(p->binfmt->module))
940 goto bad_fork_cleanup_put_domain;
941
942 p->did_exec = 0;
943 delayacct_tsk_init(p); /* Must remain after dup_task_struct() */
944 copy_flags(clone_flags, p);
945 INIT_LIST_HEAD(&p->children);
946 INIT_LIST_HEAD(&p->sibling);
947#ifdef CONFIG_PREEMPT_RCU
948 p->rcu_read_lock_nesting = 0;
949 p->rcu_flipctr_idx = 0;
950#endif /* #ifdef CONFIG_PREEMPT_RCU */
951 p->vfork_done = NULL;
952 spin_lock_init(&p->alloc_lock);
953
954 clear_tsk_thread_flag(p, TIF_SIGPENDING);
955 init_sigpending(&p->pending);
956
957 p->utime = cputime_zero;
958 p->stime = cputime_zero;
959 p->gtime = cputime_zero;
960 p->utimescaled = cputime_zero;
961 p->stimescaled = cputime_zero;
962 p->prev_utime = cputime_zero;
963 p->prev_stime = cputime_zero;
964
965#ifdef CONFIG_DETECT_SOFTLOCKUP
966 p->last_switch_count = 0;
967 p->last_switch_timestamp = 0;
968#endif
969
970#ifdef CONFIG_TASK_XACCT
971 p->rchar = 0; /* I/O counter: bytes read */
972 p->wchar = 0; /* I/O counter: bytes written */
973 p->syscr = 0; /* I/O counter: read syscalls */
974 p->syscw = 0; /* I/O counter: write syscalls */
975#endif
976 task_io_accounting_init(p);
977 acct_clear_integrals(p);
978
979 p->it_virt_expires = cputime_zero;
980 p->it_prof_expires = cputime_zero;
981 p->it_sched_expires = 0;
982 INIT_LIST_HEAD(&p->cpu_timers[0]);
983 INIT_LIST_HEAD(&p->cpu_timers[1]);
984 INIT_LIST_HEAD(&p->cpu_timers[2]);
985
986 p->lock_depth = -1; /* -1 = no lock */
987 do_posix_clock_monotonic_gettime(&p->start_time);
988 p->real_start_time = p->start_time;
989 monotonic_to_bootbased(&p->real_start_time);
990#ifdef CONFIG_SECURITY
991 p->security = NULL;
992#endif
993 p->cap_bset = current->cap_bset;
994 p->io_context = NULL;
995 p->audit_context = NULL;
996 cgroup_fork(p);
997#ifdef CONFIG_NUMA
998 p->mempolicy = mpol_dup(p->mempolicy);
999 if (IS_ERR(p->mempolicy)) {
1000 retval = PTR_ERR(p->mempolicy);
1001 p->mempolicy = NULL;
1002 goto bad_fork_cleanup_cgroup;
1003 }
1004 mpol_fix_fork_child_flag(p);
1005#endif
1006#ifdef CONFIG_TRACE_IRQFLAGS
1007 p->irq_events = 0;
1008#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
1009 p->hardirqs_enabled = 1;
1010#else
1011 p->hardirqs_enabled = 0;
1012#endif
1013 p->hardirq_enable_ip = 0;
1014 p->hardirq_enable_event = 0;
1015 p->hardirq_disable_ip = _THIS_IP_;
1016 p->hardirq_disable_event = 0;
1017 p->softirqs_enabled = 1;
1018 p->softirq_enable_ip = _THIS_IP_;
1019 p->softirq_enable_event = 0;
1020 p->softirq_disable_ip = 0;
1021 p->softirq_disable_event = 0;
1022 p->hardirq_context = 0;
1023 p->softirq_context = 0;
1024#endif
1025#ifdef CONFIG_LOCKDEP
1026 p->lockdep_depth = 0; /* no locks held yet */
1027 p->curr_chain_key = 0;
1028 p->lockdep_recursion = 0;
1029#endif
1030
1031#ifdef CONFIG_DEBUG_MUTEXES
1032 p->blocked_on = NULL; /* not blocked yet */
1033#endif
1034
1035 /* Perform scheduler related setup. Assign this task to a CPU. */
1036 sched_fork(p, clone_flags);
1037
1038 if ((retval = security_task_alloc(p)))
1039 goto bad_fork_cleanup_policy;
1040 if ((retval = audit_alloc(p)))
1041 goto bad_fork_cleanup_security;
1042 /* copy all the process information */
1043 if ((retval = copy_semundo(clone_flags, p)))
1044 goto bad_fork_cleanup_audit;
1045 if ((retval = copy_files(clone_flags, p)))
1046 goto bad_fork_cleanup_semundo;
1047 if ((retval = copy_fs(clone_flags, p)))
1048 goto bad_fork_cleanup_files;
1049 if ((retval = copy_sighand(clone_flags, p)))
1050 goto bad_fork_cleanup_fs;
1051 if ((retval = copy_signal(clone_flags, p)))
1052 goto bad_fork_cleanup_sighand;
1053 if ((retval = copy_mm(clone_flags, p)))
1054 goto bad_fork_cleanup_signal;
1055 if ((retval = copy_keys(clone_flags, p)))
1056 goto bad_fork_cleanup_mm;
1057 if ((retval = copy_namespaces(clone_flags, p)))
1058 goto bad_fork_cleanup_keys;
1059 if ((retval = copy_io(clone_flags, p)))
1060 goto bad_fork_cleanup_namespaces;
1061 retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
1062 if (retval)
1063 goto bad_fork_cleanup_io;
1064
1065 if (pid != &init_struct_pid) {
1066 retval = -ENOMEM;
1067 pid = alloc_pid(task_active_pid_ns(p));
1068 if (!pid)
1069 goto bad_fork_cleanup_io;
1070
1071 if (clone_flags & CLONE_NEWPID) {
1072 retval = pid_ns_prepare_proc(task_active_pid_ns(p));
1073 if (retval < 0)
1074 goto bad_fork_free_pid;
1075 }
1076 }
1077
1078 p->pid = pid_nr(pid);
1079 p->tgid = p->pid;
1080 if (clone_flags & CLONE_THREAD)
1081 p->tgid = current->tgid;
1082
1083 p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
1084 /*
1085 * Clear TID on mm_release()?
1086 */
1087 p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
1088#ifdef CONFIG_FUTEX
1089 p->robust_list = NULL;
1090#ifdef CONFIG_COMPAT
1091 p->compat_robust_list = NULL;
1092#endif
1093 INIT_LIST_HEAD(&p->pi_state_list);
1094 p->pi_state_cache = NULL;
1095#endif
1096 /*
1097 * sigaltstack should be cleared when sharing the same VM
1098 */
1099 if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
1100 p->sas_ss_sp = p->sas_ss_size = 0;
1101
1102 /*
1103 * Syscall tracing should be turned off in the child regardless
1104 * of CLONE_PTRACE.
1105 */
1106 clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
1107#ifdef TIF_SYSCALL_EMU
1108 clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
1109#endif
1110 clear_all_latency_tracing(p);
1111
1112 /* Our parent execution domain becomes current domain
1113 These must match for thread signalling to apply */
1114 p->parent_exec_id = p->self_exec_id;
1115
1116 /* ok, now we should be set up.. */
1117 p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
1118 p->pdeath_signal = 0;
1119 p->exit_state = 0;
1120
1121 /*
1122 * Ok, make it visible to the rest of the system.
1123 * We dont wake it up yet.
1124 */
1125 p->group_leader = p;
1126 INIT_LIST_HEAD(&p->thread_group);
1127 INIT_LIST_HEAD(&p->ptrace_children);
1128 INIT_LIST_HEAD(&p->ptrace_list);
1129
1130 /* Now that the task is set up, run cgroup callbacks if
1131 * necessary. We need to run them before the task is visible
1132 * on the tasklist. */
1133 cgroup_fork_callbacks(p);
1134 cgroup_callbacks_done = 1;
1135
1136 /* Need tasklist lock for parent etc handling! */
1137 write_lock_irq(&tasklist_lock);
1138
1139 /*
1140 * The task hasn't been attached yet, so its cpus_allowed mask will
1141 * not be changed, nor will its assigned CPU.
1142 *
1143 * The cpus_allowed mask of the parent may have changed after it was
1144 * copied first time - so re-copy it here, then check the child's CPU
1145 * to ensure it is on a valid CPU (and if not, just force it back to
1146 * parent's CPU). This avoids alot of nasty races.
1147 */
1148 p->cpus_allowed = current->cpus_allowed;
1149 p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed;
1150 if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) ||
1151 !cpu_online(task_cpu(p))))
1152 set_task_cpu(p, smp_processor_id());
1153
1154 /* CLONE_PARENT re-uses the old parent */
1155 if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
1156 p->real_parent = current->real_parent;
1157 else
1158 p->real_parent = current;
1159 p->parent = p->real_parent;
1160
1161 spin_lock(&current->sighand->siglock);
1162
1163 /*
1164 * Process group and session signals need to be delivered to just the
1165 * parent before the fork or both the parent and the child after the
1166 * fork. Restart if a signal comes in before we add the new process to
1167 * it's process group.
1168 * A fatal signal pending means that current will exit, so the new
1169 * thread can't slip out of an OOM kill (or normal SIGKILL).
1170 */
1171 recalc_sigpending();
1172 if (signal_pending(current)) {
1173 spin_unlock(&current->sighand->siglock);
1174 write_unlock_irq(&tasklist_lock);
1175 retval = -ERESTARTNOINTR;
1176 goto bad_fork_free_pid;
1177 }
1178
1179 if (clone_flags & CLONE_THREAD) {
1180 p->group_leader = current->group_leader;
1181 list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
1182
1183 if (!cputime_eq(current->signal->it_virt_expires,
1184 cputime_zero) ||
1185 !cputime_eq(current->signal->it_prof_expires,
1186 cputime_zero) ||
1187 current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY ||
1188 !list_empty(&current->signal->cpu_timers[0]) ||
1189 !list_empty(&current->signal->cpu_timers[1]) ||
1190 !list_empty(&current->signal->cpu_timers[2])) {
1191 /*
1192 * Have child wake up on its first tick to check
1193 * for process CPU timers.
1194 */
1195 p->it_prof_expires = jiffies_to_cputime(1);
1196 }
1197 }
1198
1199 if (likely(p->pid)) {
1200 add_parent(p);
1201 if (unlikely(p->ptrace & PT_PTRACED))
1202 __ptrace_link(p, current->parent);
1203
1204 if (thread_group_leader(p)) {
1205 if (clone_flags & CLONE_NEWPID)
1206 p->nsproxy->pid_ns->child_reaper = p;
1207
1208 p->signal->leader_pid = pid;
1209 p->signal->tty = current->signal->tty;
1210 set_task_pgrp(p, task_pgrp_nr(current));
1211 set_task_session(p, task_session_nr(current));
1212 attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
1213 attach_pid(p, PIDTYPE_SID, task_session(current));
1214 list_add_tail_rcu(&p->tasks, &init_task.tasks);
1215 __get_cpu_var(process_counts)++;
1216 }
1217 attach_pid(p, PIDTYPE_PID, pid);
1218 nr_threads++;
1219 }
1220
1221 total_forks++;
1222 spin_unlock(&current->sighand->siglock);
1223 write_unlock_irq(&tasklist_lock);
1224 proc_fork_connector(p);
1225 cgroup_post_fork(p);
1226 return p;
1227
1228bad_fork_free_pid:
1229 if (pid != &init_struct_pid)
1230 free_pid(pid);
1231bad_fork_cleanup_io:
1232 put_io_context(p->io_context);
1233bad_fork_cleanup_namespaces:
1234 exit_task_namespaces(p);
1235bad_fork_cleanup_keys:
1236 exit_keys(p);
1237bad_fork_cleanup_mm:
1238 if (p->mm)
1239 mmput(p->mm);
1240bad_fork_cleanup_signal:
1241 cleanup_signal(p);
1242bad_fork_cleanup_sighand:
1243 __cleanup_sighand(p->sighand);
1244bad_fork_cleanup_fs:
1245 exit_fs(p); /* blocking */
1246bad_fork_cleanup_files:
1247 exit_files(p); /* blocking */
1248bad_fork_cleanup_semundo:
1249 exit_sem(p);
1250bad_fork_cleanup_audit:
1251 audit_free(p);
1252bad_fork_cleanup_security:
1253 security_task_free(p);
1254bad_fork_cleanup_policy:
1255#ifdef CONFIG_NUMA
1256 mpol_put(p->mempolicy);
1257bad_fork_cleanup_cgroup:
1258#endif
1259 cgroup_exit(p, cgroup_callbacks_done);
1260 delayacct_tsk_free(p);
1261 if (p->binfmt)
1262 module_put(p->binfmt->module);
1263bad_fork_cleanup_put_domain:
1264 module_put(task_thread_info(p)->exec_domain->module);
1265bad_fork_cleanup_count:
1266 put_group_info(p->group_info);
1267 atomic_dec(&p->user->processes);
1268 free_uid(p->user);
1269bad_fork_free:
1270 free_task(p);
1271fork_out:
1272 return ERR_PTR(retval);
1273}
1274
1275noinline struct pt_regs * __cpuinit __attribute__((weak)) idle_regs(struct pt_regs *regs)
1276{
1277 memset(regs, 0, sizeof(struct pt_regs));
1278 return regs;
1279}
1280
1281struct task_struct * __cpuinit fork_idle(int cpu)
1282{
1283 struct task_struct *task;
1284 struct pt_regs regs;
1285
1286 task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL,
1287 &init_struct_pid);
1288 if (!IS_ERR(task))
1289 init_idle(task, cpu);
1290
1291 return task;
1292}
1293
1294static int fork_traceflag(unsigned clone_flags)
1295{
1296 if (clone_flags & CLONE_UNTRACED)
1297 return 0;
1298 else if (clone_flags & CLONE_VFORK) {
1299 if (current->ptrace & PT_TRACE_VFORK)
1300 return PTRACE_EVENT_VFORK;
1301 } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
1302 if (current->ptrace & PT_TRACE_CLONE)
1303 return PTRACE_EVENT_CLONE;
1304 } else if (current->ptrace & PT_TRACE_FORK)
1305 return PTRACE_EVENT_FORK;
1306
1307 return 0;
1308}
1309
1310/*
1311 * Ok, this is the main fork-routine.
1312 *
1313 * It copies the process, and if successful kick-starts
1314 * it and waits for it to finish using the VM if required.
1315 */
1316long do_fork(unsigned long clone_flags,
1317 unsigned long stack_start,
1318 struct pt_regs *regs,
1319 unsigned long stack_size,
1320 int __user *parent_tidptr,
1321 int __user *child_tidptr)
1322{
1323 struct task_struct *p;
1324 int trace = 0;
1325 long nr;
1326
1327 /*
1328 * We hope to recycle these flags after 2.6.26
1329 */
1330 if (unlikely(clone_flags & CLONE_STOPPED)) {
1331 static int __read_mostly count = 100;
1332
1333 if (count > 0 && printk_ratelimit()) {
1334 char comm[TASK_COMM_LEN];
1335
1336 count--;
1337 printk(KERN_INFO "fork(): process `%s' used deprecated "
1338 "clone flags 0x%lx\n",
1339 get_task_comm(comm, current),
1340 clone_flags & CLONE_STOPPED);
1341 }
1342 }
1343
1344 if (unlikely(current->ptrace)) {
1345 trace = fork_traceflag (clone_flags);
1346 if (trace)
1347 clone_flags |= CLONE_PTRACE;
1348 }
1349
1350 p = copy_process(clone_flags, stack_start, regs, stack_size,
1351 child_tidptr, NULL);
1352 /*
1353 * Do this prior waking up the new thread - the thread pointer
1354 * might get invalid after that point, if the thread exits quickly.
1355 */
1356 if (!IS_ERR(p)) {
1357 struct completion vfork;
1358
1359 nr = task_pid_vnr(p);
1360
1361 if (clone_flags & CLONE_PARENT_SETTID)
1362 put_user(nr, parent_tidptr);
1363
1364 if (clone_flags & CLONE_VFORK) {
1365 p->vfork_done = &vfork;
1366 init_completion(&vfork);
1367 }
1368
1369 if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
1370 /*
1371 * We'll start up with an immediate SIGSTOP.
1372 */
1373 sigaddset(&p->pending.signal, SIGSTOP);
1374 set_tsk_thread_flag(p, TIF_SIGPENDING);
1375 }
1376
1377 if (!(clone_flags & CLONE_STOPPED))
1378 wake_up_new_task(p, clone_flags);
1379 else
1380 __set_task_state(p, TASK_STOPPED);
1381
1382 if (unlikely (trace)) {
1383 current->ptrace_message = nr;
1384 ptrace_notify ((trace << 8) | SIGTRAP);
1385 }
1386
1387 if (clone_flags & CLONE_VFORK) {
1388 freezer_do_not_count();
1389 wait_for_completion(&vfork);
1390 freezer_count();
1391 if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
1392 current->ptrace_message = nr;
1393 ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
1394 }
1395 }
1396 } else {
1397 nr = PTR_ERR(p);
1398 }
1399 return nr;
1400}
1401
1402#ifndef ARCH_MIN_MMSTRUCT_ALIGN
1403#define ARCH_MIN_MMSTRUCT_ALIGN 0
1404#endif
1405
1406static void sighand_ctor(struct kmem_cache *cachep, void *data)
1407{
1408 struct sighand_struct *sighand = data;
1409
1410 spin_lock_init(&sighand->siglock);
1411 init_waitqueue_head(&sighand->signalfd_wqh);
1412}
1413
1414void __init proc_caches_init(void)
1415{
1416 sighand_cachep = kmem_cache_create("sighand_cache",
1417 sizeof(struct sighand_struct), 0,
1418 SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,
1419 sighand_ctor);
1420 signal_cachep = kmem_cache_create("signal_cache",
1421 sizeof(struct signal_struct), 0,
1422 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1423 files_cachep = kmem_cache_create("files_cache",
1424 sizeof(struct files_struct), 0,
1425 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1426 fs_cachep = kmem_cache_create("fs_cache",
1427 sizeof(struct fs_struct), 0,
1428 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1429 vm_area_cachep = kmem_cache_create("vm_area_struct",
1430 sizeof(struct vm_area_struct), 0,
1431 SLAB_PANIC, NULL);
1432 mm_cachep = kmem_cache_create("mm_struct",
1433 sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
1434 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1435}
1436
1437/*
1438 * Check constraints on flags passed to the unshare system call and
1439 * force unsharing of additional process context as appropriate.
1440 */
1441static void check_unshare_flags(unsigned long *flags_ptr)
1442{
1443 /*
1444 * If unsharing a thread from a thread group, must also
1445 * unshare vm.
1446 */
1447 if (*flags_ptr & CLONE_THREAD)
1448 *flags_ptr |= CLONE_VM;
1449
1450 /*
1451 * If unsharing vm, must also unshare signal handlers.
1452 */
1453 if (*flags_ptr & CLONE_VM)
1454 *flags_ptr |= CLONE_SIGHAND;
1455
1456 /*
1457 * If unsharing signal handlers and the task was created
1458 * using CLONE_THREAD, then must unshare the thread
1459 */
1460 if ((*flags_ptr & CLONE_SIGHAND) &&
1461 (atomic_read(&current->signal->count) > 1))
1462 *flags_ptr |= CLONE_THREAD;
1463
1464 /*
1465 * If unsharing namespace, must also unshare filesystem information.
1466 */
1467 if (*flags_ptr & CLONE_NEWNS)
1468 *flags_ptr |= CLONE_FS;
1469}
1470
1471/*
1472 * Unsharing of tasks created with CLONE_THREAD is not supported yet
1473 */
1474static int unshare_thread(unsigned long unshare_flags)
1475{
1476 if (unshare_flags & CLONE_THREAD)
1477 return -EINVAL;
1478
1479 return 0;
1480}
1481
1482/*
1483 * Unshare the filesystem structure if it is being shared
1484 */
1485static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp)
1486{
1487 struct fs_struct *fs = current->fs;
1488
1489 if ((unshare_flags & CLONE_FS) &&
1490 (fs && atomic_read(&fs->count) > 1)) {
1491 *new_fsp = __copy_fs_struct(current->fs);
1492 if (!*new_fsp)
1493 return -ENOMEM;
1494 }
1495
1496 return 0;
1497}
1498
1499/*
1500 * Unsharing of sighand is not supported yet
1501 */
1502static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct **new_sighp)
1503{
1504 struct sighand_struct *sigh = current->sighand;
1505
1506 if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1)
1507 return -EINVAL;
1508 else
1509 return 0;
1510}
1511
1512/*
1513 * Unshare vm if it is being shared
1514 */
1515static int unshare_vm(unsigned long unshare_flags, struct mm_struct **new_mmp)
1516{
1517 struct mm_struct *mm = current->mm;
1518
1519 if ((unshare_flags & CLONE_VM) &&
1520 (mm && atomic_read(&mm->mm_users) > 1)) {
1521 return -EINVAL;
1522 }
1523
1524 return 0;
1525}
1526
1527/*
1528 * Unshare file descriptor table if it is being shared
1529 */
1530static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp)
1531{
1532 struct files_struct *fd = current->files;
1533 int error = 0;
1534
1535 if ((unshare_flags & CLONE_FILES) &&
1536 (fd && atomic_read(&fd->count) > 1)) {
1537 *new_fdp = dup_fd(fd, &error);
1538 if (!*new_fdp)
1539 return error;
1540 }
1541
1542 return 0;
1543}
1544
1545/*
1546 * unshare allows a process to 'unshare' part of the process
1547 * context which was originally shared using clone. copy_*
1548 * functions used by do_fork() cannot be used here directly
1549 * because they modify an inactive task_struct that is being
1550 * constructed. Here we are modifying the current, active,
1551 * task_struct.
1552 */
1553asmlinkage long sys_unshare(unsigned long unshare_flags)
1554{
1555 int err = 0;
1556 struct fs_struct *fs, *new_fs = NULL;
1557 struct sighand_struct *new_sigh = NULL;
1558 struct mm_struct *mm, *new_mm = NULL, *active_mm = NULL;
1559 struct files_struct *fd, *new_fd = NULL;
1560 struct nsproxy *new_nsproxy = NULL;
1561 int do_sysvsem = 0;
1562
1563 check_unshare_flags(&unshare_flags);
1564
1565 /* Return -EINVAL for all unsupported flags */
1566 err = -EINVAL;
1567 if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND|
1568 CLONE_VM|CLONE_FILES|CLONE_SYSVSEM|
1569 CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWUSER|
1570 CLONE_NEWNET))
1571 goto bad_unshare_out;
1572
1573 /*
1574 * CLONE_NEWIPC must also detach from the undolist: after switching
1575 * to a new ipc namespace, the semaphore arrays from the old
1576 * namespace are unreachable.
1577 */
1578 if (unshare_flags & (CLONE_NEWIPC|CLONE_SYSVSEM))
1579 do_sysvsem = 1;
1580 if ((err = unshare_thread(unshare_flags)))
1581 goto bad_unshare_out;
1582 if ((err = unshare_fs(unshare_flags, &new_fs)))
1583 goto bad_unshare_cleanup_thread;
1584 if ((err = unshare_sighand(unshare_flags, &new_sigh)))
1585 goto bad_unshare_cleanup_fs;
1586 if ((err = unshare_vm(unshare_flags, &new_mm)))
1587 goto bad_unshare_cleanup_sigh;
1588 if ((err = unshare_fd(unshare_flags, &new_fd)))
1589 goto bad_unshare_cleanup_vm;
1590 if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy,
1591 new_fs)))
1592 goto bad_unshare_cleanup_fd;
1593
1594 if (new_fs || new_mm || new_fd || do_sysvsem || new_nsproxy) {
1595 if (do_sysvsem) {
1596 /*
1597 * CLONE_SYSVSEM is equivalent to sys_exit().
1598 */
1599 exit_sem(current);
1600 }
1601
1602 if (new_nsproxy) {
1603 switch_task_namespaces(current, new_nsproxy);
1604 new_nsproxy = NULL;
1605 }
1606
1607 task_lock(current);
1608
1609 if (new_fs) {
1610 fs = current->fs;
1611 current->fs = new_fs;
1612 new_fs = fs;
1613 }
1614
1615 if (new_mm) {
1616 mm = current->mm;
1617 active_mm = current->active_mm;
1618 current->mm = new_mm;
1619 current->active_mm = new_mm;
1620 activate_mm(active_mm, new_mm);
1621 new_mm = mm;
1622 }
1623
1624 if (new_fd) {
1625 fd = current->files;
1626 current->files = new_fd;
1627 new_fd = fd;
1628 }
1629
1630 task_unlock(current);
1631 }
1632
1633 if (new_nsproxy)
1634 put_nsproxy(new_nsproxy);
1635
1636bad_unshare_cleanup_fd:
1637 if (new_fd)
1638 put_files_struct(new_fd);
1639
1640bad_unshare_cleanup_vm:
1641 if (new_mm)
1642 mmput(new_mm);
1643
1644bad_unshare_cleanup_sigh:
1645 if (new_sigh)
1646 if (atomic_dec_and_test(&new_sigh->count))
1647 kmem_cache_free(sighand_cachep, new_sigh);
1648
1649bad_unshare_cleanup_fs:
1650 if (new_fs)
1651 put_fs_struct(new_fs);
1652
1653bad_unshare_cleanup_thread:
1654bad_unshare_out:
1655 return err;
1656}
1657
1658/*
1659 * Helper to unshare the files of the current task.
1660 * We don't want to expose copy_files internals to
1661 * the exec layer of the kernel.
1662 */
1663
1664int unshare_files(struct files_struct **displaced)
1665{
1666 struct task_struct *task = current;
1667 struct files_struct *copy = NULL;
1668 int error;
1669
1670 error = unshare_fd(CLONE_FILES, &copy);
1671 if (error || !copy) {
1672 *displaced = NULL;
1673 return error;
1674 }
1675 *displaced = task->files;
1676 task_lock(task);
1677 task->files = copy;
1678 task_unlock(task);
1679 return 0;
1680}