linux fork.c

[cpp]  view plain copy

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