Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/slab.h> |
| 15 | #include <linux/init.h> |
| 16 | #include <linux/unistd.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include <linux/module.h> |
| 18 | #include <linux/vmalloc.h> |
| 19 | #include <linux/completion.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/personality.h> |
| 21 | #include <linux/mempolicy.h> |
| 22 | #include <linux/sem.h> |
| 23 | #include <linux/file.h> |
Al Viro | 9f3acc3 | 2008-04-24 07:44:08 -0400 | [diff] [blame] | 24 | #include <linux/fdtable.h> |
Jens Axboe | da9cbc8 | 2008-06-30 20:42:08 +0200 | [diff] [blame] | 25 | #include <linux/iocontext.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include <linux/key.h> |
| 27 | #include <linux/binfmts.h> |
| 28 | #include <linux/mman.h> |
Andrea Arcangeli | cddb8a5 | 2008-07-28 15:46:29 -0700 | [diff] [blame] | 29 | #include <linux/mmu_notifier.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | #include <linux/fs.h> |
Serge E. Hallyn | ab51601 | 2006-10-02 02:18:06 -0700 | [diff] [blame] | 31 | #include <linux/nsproxy.h> |
Randy.Dunlap | c59ede7 | 2006-01-11 12:17:46 -0800 | [diff] [blame] | 32 | #include <linux/capability.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | #include <linux/cpu.h> |
Paul Menage | b4f48b6 | 2007-10-18 23:39:33 -0700 | [diff] [blame] | 34 | #include <linux/cgroup.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | #include <linux/security.h> |
Mel Gorman | a1e7877 | 2008-07-23 21:27:23 -0700 | [diff] [blame] | 36 | #include <linux/hugetlb.h> |
Will Drewry | e2cfabdf | 2012-04-12 16:47:57 -0500 | [diff] [blame] | 37 | #include <linux/seccomp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | #include <linux/swap.h> |
| 39 | #include <linux/syscalls.h> |
| 40 | #include <linux/jiffies.h> |
| 41 | #include <linux/futex.h> |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 42 | #include <linux/compat.h> |
Eric Dumazet | 207205a | 2011-03-22 16:30:44 -0700 | [diff] [blame] | 43 | #include <linux/kthread.h> |
Andrew Morton | 7c3ab73 | 2006-12-10 02:19:19 -0800 | [diff] [blame] | 44 | #include <linux/task_io_accounting_ops.h> |
Dipankar Sarma | ab2af1f | 2005-09-09 13:04:13 -0700 | [diff] [blame] | 45 | #include <linux/rcupdate.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | #include <linux/ptrace.h> |
| 47 | #include <linux/mount.h> |
| 48 | #include <linux/audit.h> |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 49 | #include <linux/memcontrol.h> |
Frederic Weisbecker | f201ae2 | 2008-11-23 06:22:56 +0100 | [diff] [blame] | 50 | #include <linux/ftrace.h> |
Mike Galbraith | 5e2bf01 | 2012-05-10 13:01:45 -0700 | [diff] [blame] | 51 | #include <linux/proc_fs.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | #include <linux/profile.h> |
| 53 | #include <linux/rmap.h> |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 54 | #include <linux/ksm.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | #include <linux/acct.h> |
Jay Lan | 8f0ab51 | 2006-09-30 23:28:59 -0700 | [diff] [blame] | 56 | #include <linux/tsacct_kern.h> |
Matt Helsley | 9f46080 | 2005-11-07 00:59:16 -0800 | [diff] [blame] | 57 | #include <linux/cn_proc.h> |
Rafael J. Wysocki | ba96a0c | 2007-05-23 13:57:25 -0700 | [diff] [blame] | 58 | #include <linux/freezer.h> |
Shailabh Nagar | ca74e92 | 2006-07-14 00:24:36 -0700 | [diff] [blame] | 59 | #include <linux/delayacct.h> |
Shailabh Nagar | ad4ecbc | 2006-07-14 00:24:44 -0700 | [diff] [blame] | 60 | #include <linux/taskstats_kern.h> |
Arjan van de Ven | 0a42540 | 2006-09-26 10:52:38 +0200 | [diff] [blame] | 61 | #include <linux/random.h> |
Miloslav Trmac | 522ed77 | 2007-07-15 23:40:56 -0700 | [diff] [blame] | 62 | #include <linux/tty.h> |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 63 | #include <linux/blkdev.h> |
Al Viro | 5ad4e53 | 2009-03-29 19:50:06 -0400 | [diff] [blame] | 64 | #include <linux/fs_struct.h> |
Eric Sandeen | 7c9f886 | 2008-04-22 16:38:23 -0500 | [diff] [blame] | 65 | #include <linux/magic.h> |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 66 | #include <linux/perf_event.h> |
Stanislaw Gruszka | 42c4ab4 | 2009-07-29 12:15:26 +0200 | [diff] [blame] | 67 | #include <linux/posix-timers.h> |
Avi Kivity | 8e7cac7 | 2009-11-29 16:34:48 +0200 | [diff] [blame] | 68 | #include <linux/user-return-notifier.h> |
Ying Han | 3d5992d | 2010-10-26 14:21:23 -0700 | [diff] [blame] | 69 | #include <linux/oom.h> |
Andrea Arcangeli | ba76149 | 2011-01-13 15:46:58 -0800 | [diff] [blame] | 70 | #include <linux/khugepaged.h> |
Oleg Nesterov | d80e731 | 2012-02-24 20:07:11 +0100 | [diff] [blame] | 71 | #include <linux/signalfd.h> |
Srikar Dronamraju | 0326f5a | 2012-03-13 23:30:11 +0530 | [diff] [blame] | 72 | #include <linux/uprobes.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | |
| 74 | #include <asm/pgtable.h> |
| 75 | #include <asm/pgalloc.h> |
| 76 | #include <asm/uaccess.h> |
| 77 | #include <asm/mmu_context.h> |
| 78 | #include <asm/cacheflush.h> |
| 79 | #include <asm/tlbflush.h> |
| 80 | |
Steven Rostedt | ad8d75f | 2009-04-14 19:39:12 -0400 | [diff] [blame] | 81 | #include <trace/events/sched.h> |
| 82 | |
KAMEZAWA Hiroyuki | 43d2b11 | 2012-01-10 15:08:09 -0800 | [diff] [blame] | 83 | #define CREATE_TRACE_POINTS |
| 84 | #include <trace/events/task.h> |
| 85 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | /* |
| 87 | * Protected counters by write_lock_irq(&tasklist_lock) |
| 88 | */ |
| 89 | unsigned long total_forks; /* Handle normal Linux uptimes. */ |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 90 | int nr_threads; /* The idle threads do not count.. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | |
| 92 | int max_threads; /* tunable limit on nr_threads */ |
| 93 | |
| 94 | DEFINE_PER_CPU(unsigned long, process_counts) = 0; |
| 95 | |
Christoph Hellwig | c59923a | 2006-07-10 04:45:40 -0700 | [diff] [blame] | 96 | __cacheline_aligned DEFINE_RWLOCK(tasklist_lock); /* outer */ |
Paul E. McKenney | db1466b | 2010-03-03 07:46:56 -0800 | [diff] [blame] | 97 | |
| 98 | #ifdef CONFIG_PROVE_RCU |
| 99 | int lockdep_tasklist_lock_is_held(void) |
| 100 | { |
| 101 | return lockdep_is_held(&tasklist_lock); |
| 102 | } |
| 103 | EXPORT_SYMBOL_GPL(lockdep_tasklist_lock_is_held); |
| 104 | #endif /* #ifdef CONFIG_PROVE_RCU */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | |
| 106 | int nr_processes(void) |
| 107 | { |
| 108 | int cpu; |
| 109 | int total = 0; |
| 110 | |
Ian Campbell | 1d51075 | 2009-11-03 10:11:14 +0000 | [diff] [blame] | 111 | for_each_possible_cpu(cpu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | total += per_cpu(process_counts, cpu); |
| 113 | |
| 114 | return total; |
| 115 | } |
| 116 | |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 117 | void __weak arch_release_task_struct(struct task_struct *tsk) |
| 118 | { |
| 119 | } |
| 120 | |
Thomas Gleixner | f5e1028 | 2012-05-05 15:05:48 +0000 | [diff] [blame] | 121 | #ifndef CONFIG_ARCH_TASK_STRUCT_ALLOCATOR |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 122 | static struct kmem_cache *task_struct_cachep; |
Thomas Gleixner | 4110180 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 123 | |
| 124 | static inline struct task_struct *alloc_task_struct_node(int node) |
| 125 | { |
| 126 | return kmem_cache_alloc_node(task_struct_cachep, GFP_KERNEL, node); |
| 127 | } |
| 128 | |
Thomas Gleixner | 4110180 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 129 | static inline void free_task_struct(struct task_struct *tsk) |
| 130 | { |
Thomas Gleixner | 4110180 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 131 | kmem_cache_free(task_struct_cachep, tsk); |
| 132 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | #endif |
| 134 | |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 135 | void __weak arch_release_thread_info(struct thread_info *ti) |
| 136 | { |
| 137 | } |
| 138 | |
Thomas Gleixner | f5e1028 | 2012-05-05 15:05:48 +0000 | [diff] [blame] | 139 | #ifndef CONFIG_ARCH_THREAD_INFO_ALLOCATOR |
Thomas Gleixner | 4110180 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 140 | |
Thomas Gleixner | 0d15d74 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 141 | /* |
| 142 | * Allocate pages if THREAD_SIZE is >= PAGE_SIZE, otherwise use a |
| 143 | * kmemcache based allocator. |
| 144 | */ |
| 145 | # if THREAD_SIZE >= PAGE_SIZE |
Eric Dumazet | b6a8401 | 2011-03-22 16:30:42 -0700 | [diff] [blame] | 146 | static struct thread_info *alloc_thread_info_node(struct task_struct *tsk, |
| 147 | int node) |
FUJITA Tomonori | b69c49b | 2008-07-25 01:45:40 -0700 | [diff] [blame] | 148 | { |
Glauber Costa | 2ad306b | 2012-12-18 14:22:18 -0800 | [diff] [blame] | 149 | struct page *page = alloc_pages_node(node, THREADINFO_GFP_ACCOUNTED, |
Thomas Gleixner | 2889f60 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 150 | THREAD_SIZE_ORDER); |
Eric Dumazet | b6a8401 | 2011-03-22 16:30:42 -0700 | [diff] [blame] | 151 | |
| 152 | return page ? page_address(page) : NULL; |
FUJITA Tomonori | b69c49b | 2008-07-25 01:45:40 -0700 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | static inline void free_thread_info(struct thread_info *ti) |
| 156 | { |
Glauber Costa | 2ad306b | 2012-12-18 14:22:18 -0800 | [diff] [blame] | 157 | free_memcg_kmem_pages((unsigned long)ti, THREAD_SIZE_ORDER); |
FUJITA Tomonori | b69c49b | 2008-07-25 01:45:40 -0700 | [diff] [blame] | 158 | } |
Thomas Gleixner | 0d15d74 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 159 | # else |
| 160 | static struct kmem_cache *thread_info_cache; |
| 161 | |
| 162 | static struct thread_info *alloc_thread_info_node(struct task_struct *tsk, |
| 163 | int node) |
| 164 | { |
| 165 | return kmem_cache_alloc_node(thread_info_cache, THREADINFO_GFP, node); |
| 166 | } |
| 167 | |
| 168 | static void free_thread_info(struct thread_info *ti) |
| 169 | { |
Thomas Gleixner | 0d15d74 | 2012-05-05 15:05:41 +0000 | [diff] [blame] | 170 | kmem_cache_free(thread_info_cache, ti); |
| 171 | } |
| 172 | |
| 173 | void thread_info_cache_init(void) |
| 174 | { |
| 175 | thread_info_cache = kmem_cache_create("thread_info", THREAD_SIZE, |
| 176 | THREAD_SIZE, 0, NULL); |
| 177 | BUG_ON(thread_info_cache == NULL); |
| 178 | } |
| 179 | # endif |
FUJITA Tomonori | b69c49b | 2008-07-25 01:45:40 -0700 | [diff] [blame] | 180 | #endif |
| 181 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | /* SLAB cache for signal_struct structures (tsk->signal) */ |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 183 | static struct kmem_cache *signal_cachep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | |
| 185 | /* SLAB cache for sighand_struct structures (tsk->sighand) */ |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 186 | struct kmem_cache *sighand_cachep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | |
| 188 | /* SLAB cache for files_struct structures (tsk->files) */ |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 189 | struct kmem_cache *files_cachep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | |
| 191 | /* SLAB cache for fs_struct structures (tsk->fs) */ |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 192 | struct kmem_cache *fs_cachep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | |
| 194 | /* SLAB cache for vm_area_struct structures */ |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 195 | struct kmem_cache *vm_area_cachep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | |
| 197 | /* SLAB cache for mm_struct structures (tsk->mm) */ |
Christoph Lameter | e18b890 | 2006-12-06 20:33:20 -0800 | [diff] [blame] | 198 | static struct kmem_cache *mm_cachep; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | |
KOSAKI Motohiro | c6a7f57 | 2009-09-21 17:01:32 -0700 | [diff] [blame] | 200 | static void account_kernel_stack(struct thread_info *ti, int account) |
| 201 | { |
| 202 | struct zone *zone = page_zone(virt_to_page(ti)); |
| 203 | |
| 204 | mod_zone_page_state(zone, NR_KERNEL_STACK, account); |
| 205 | } |
| 206 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | void free_task(struct task_struct *tsk) |
| 208 | { |
KOSAKI Motohiro | c6a7f57 | 2009-09-21 17:01:32 -0700 | [diff] [blame] | 209 | account_kernel_stack(tsk->stack, -1); |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 210 | arch_release_thread_info(tsk->stack); |
Roman Zippel | f7e4217 | 2007-05-09 02:35:17 -0700 | [diff] [blame] | 211 | free_thread_info(tsk->stack); |
Ingo Molnar | 23f78d4a | 2006-06-27 02:54:53 -0700 | [diff] [blame] | 212 | rt_mutex_debug_task_free(tsk); |
Frederic Weisbecker | fb52607 | 2008-11-25 21:07:04 +0100 | [diff] [blame] | 213 | ftrace_graph_exit_task(tsk); |
Will Drewry | e2cfabdf | 2012-04-12 16:47:57 -0500 | [diff] [blame] | 214 | put_seccomp_filter(tsk); |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 215 | arch_release_task_struct(tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | free_task_struct(tsk); |
| 217 | } |
| 218 | EXPORT_SYMBOL(free_task); |
| 219 | |
Oleg Nesterov | ea6d290 | 2010-05-26 14:43:16 -0700 | [diff] [blame] | 220 | static inline void free_signal_struct(struct signal_struct *sig) |
| 221 | { |
Oleg Nesterov | 97101eb | 2010-05-26 14:43:20 -0700 | [diff] [blame] | 222 | taskstats_tgid_free(sig); |
Mike Galbraith | 1c5354d | 2011-01-05 11:16:04 +0100 | [diff] [blame] | 223 | sched_autogroup_exit(sig); |
Oleg Nesterov | ea6d290 | 2010-05-26 14:43:16 -0700 | [diff] [blame] | 224 | kmem_cache_free(signal_cachep, sig); |
| 225 | } |
| 226 | |
| 227 | static inline void put_signal_struct(struct signal_struct *sig) |
| 228 | { |
Mike Galbraith | 1c5354d | 2011-01-05 11:16:04 +0100 | [diff] [blame] | 229 | if (atomic_dec_and_test(&sig->sigcnt)) |
Oleg Nesterov | ea6d290 | 2010-05-26 14:43:16 -0700 | [diff] [blame] | 230 | free_signal_struct(sig); |
| 231 | } |
| 232 | |
Andrew Morton | 158d9eb | 2006-03-31 02:31:34 -0800 | [diff] [blame] | 233 | void __put_task_struct(struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | { |
Eugene Teo | 270f722 | 2007-10-18 23:40:38 -0700 | [diff] [blame] | 235 | WARN_ON(!tsk->exit_state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | WARN_ON(atomic_read(&tsk->usage)); |
| 237 | WARN_ON(tsk == current); |
| 238 | |
Kees Cook | 1a2a4d0 | 2011-12-21 12:17:03 -0800 | [diff] [blame] | 239 | security_task_free(tsk); |
David Howells | e0e8173 | 2009-09-02 09:13:40 +0100 | [diff] [blame] | 240 | exit_creds(tsk); |
Shailabh Nagar | 35df17c | 2006-08-31 21:27:38 -0700 | [diff] [blame] | 241 | delayacct_tsk_free(tsk); |
Oleg Nesterov | ea6d290 | 2010-05-26 14:43:16 -0700 | [diff] [blame] | 242 | put_signal_struct(tsk->signal); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | |
| 244 | if (!profile_handoff_task(tsk)) |
| 245 | free_task(tsk); |
| 246 | } |
Rik van Riel | 77c100c | 2011-02-01 09:51:46 -0500 | [diff] [blame] | 247 | EXPORT_SYMBOL_GPL(__put_task_struct); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | |
Thomas Gleixner | 6c0a9fa | 2012-05-05 15:05:40 +0000 | [diff] [blame] | 249 | void __init __weak arch_task_cache_init(void) { } |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 250 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | void __init fork_init(unsigned long mempages) |
| 252 | { |
Thomas Gleixner | f5e1028 | 2012-05-05 15:05:48 +0000 | [diff] [blame] | 253 | #ifndef CONFIG_ARCH_TASK_STRUCT_ALLOCATOR |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | #ifndef ARCH_MIN_TASKALIGN |
| 255 | #define ARCH_MIN_TASKALIGN L1_CACHE_BYTES |
| 256 | #endif |
| 257 | /* create a slab on which task_structs can be allocated */ |
| 258 | task_struct_cachep = |
| 259 | kmem_cache_create("task_struct", sizeof(struct task_struct), |
Vegard Nossum | 2dff440 | 2008-05-31 15:56:17 +0200 | [diff] [blame] | 260 | ARCH_MIN_TASKALIGN, SLAB_PANIC | SLAB_NOTRACK, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | #endif |
| 262 | |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 263 | /* do the arch specific task caches init */ |
| 264 | arch_task_cache_init(); |
| 265 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | /* |
| 267 | * The default maximum number of threads is set to a safe |
| 268 | * value: the thread structures can take up at most half |
| 269 | * of memory. |
| 270 | */ |
| 271 | max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE); |
| 272 | |
| 273 | /* |
| 274 | * we need to allow at least 20 threads to boot a system |
| 275 | */ |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 276 | if (max_threads < 20) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | max_threads = 20; |
| 278 | |
| 279 | init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2; |
| 280 | init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2; |
| 281 | init_task.signal->rlim[RLIMIT_SIGPENDING] = |
| 282 | init_task.signal->rlim[RLIMIT_NPROC]; |
| 283 | } |
| 284 | |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 285 | int __attribute__((weak)) arch_dup_task_struct(struct task_struct *dst, |
| 286 | struct task_struct *src) |
| 287 | { |
| 288 | *dst = *src; |
| 289 | return 0; |
| 290 | } |
| 291 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | static struct task_struct *dup_task_struct(struct task_struct *orig) |
| 293 | { |
| 294 | struct task_struct *tsk; |
| 295 | struct thread_info *ti; |
Eric Sandeen | 7c9f886 | 2008-04-22 16:38:23 -0500 | [diff] [blame] | 296 | unsigned long *stackend; |
Eric Dumazet | 207205a | 2011-03-22 16:30:44 -0700 | [diff] [blame] | 297 | int node = tsk_fork_get_node(orig); |
Peter Zijlstra | 3e26c14 | 2007-10-16 23:25:50 -0700 | [diff] [blame] | 298 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | |
Eric Dumazet | 504f52b | 2011-03-22 16:30:41 -0700 | [diff] [blame] | 300 | tsk = alloc_task_struct_node(node); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | if (!tsk) |
| 302 | return NULL; |
| 303 | |
Eric Dumazet | b6a8401 | 2011-03-22 16:30:42 -0700 | [diff] [blame] | 304 | ti = alloc_thread_info_node(tsk, node); |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 305 | if (!ti) |
| 306 | goto free_tsk; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 308 | err = arch_dup_task_struct(tsk, orig); |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 309 | if (err) |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 310 | goto free_ti; |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 311 | |
Andrew Morton | 87bec58 | 2012-07-30 14:42:31 -0700 | [diff] [blame] | 312 | tsk->stack = ti; |
| 313 | |
| 314 | setup_thread_stack(tsk, orig); |
Avi Kivity | 8e7cac7 | 2009-11-29 16:34:48 +0200 | [diff] [blame] | 315 | clear_user_return_notifier(tsk); |
Mike Galbraith | f26f9af | 2010-12-08 11:05:42 +0100 | [diff] [blame] | 316 | clear_tsk_need_resched(tsk); |
Eric Sandeen | 7c9f886 | 2008-04-22 16:38:23 -0500 | [diff] [blame] | 317 | stackend = end_of_stack(tsk); |
| 318 | *stackend = STACK_END_MAGIC; /* for overflow detection */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | |
Arjan van de Ven | 0a42540 | 2006-09-26 10:52:38 +0200 | [diff] [blame] | 320 | #ifdef CONFIG_CC_STACKPROTECTOR |
| 321 | tsk->stack_canary = get_random_int(); |
| 322 | #endif |
| 323 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 324 | /* |
| 325 | * One for us, one for whoever does the "release_task()" (usually |
| 326 | * parent) |
| 327 | */ |
| 328 | atomic_set(&tsk->usage, 2); |
Alexey Dobriyan | 6c5c934 | 2006-09-29 01:59:40 -0700 | [diff] [blame] | 329 | #ifdef CONFIG_BLK_DEV_IO_TRACE |
Jens Axboe | 2056a78 | 2006-03-23 20:00:26 +0100 | [diff] [blame] | 330 | tsk->btrace_seq = 0; |
Alexey Dobriyan | 6c5c934 | 2006-09-29 01:59:40 -0700 | [diff] [blame] | 331 | #endif |
Jens Axboe | a0aa7f6 | 2006-04-20 13:05:33 +0200 | [diff] [blame] | 332 | tsk->splice_pipe = NULL; |
Eric Dumazet | 5640f76 | 2012-09-23 23:04:42 +0000 | [diff] [blame] | 333 | tsk->task_frag.page = NULL; |
KOSAKI Motohiro | c6a7f57 | 2009-09-21 17:01:32 -0700 | [diff] [blame] | 334 | |
| 335 | account_kernel_stack(ti, 1); |
| 336 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | return tsk; |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 338 | |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 339 | free_ti: |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 340 | free_thread_info(ti); |
Akinobu Mita | f19b9f7 | 2012-07-30 14:42:33 -0700 | [diff] [blame] | 341 | free_tsk: |
Suresh Siddha | 61c4628 | 2008-03-10 15:28:04 -0700 | [diff] [blame] | 342 | free_task_struct(tsk); |
| 343 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | #ifdef CONFIG_MMU |
Alexey Dobriyan | a39bc51 | 2007-10-18 23:41:10 -0700 | [diff] [blame] | 347 | static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | { |
Linus Torvalds | 297c5ee | 2010-08-20 16:24:55 -0700 | [diff] [blame] | 349 | struct vm_area_struct *mpnt, *tmp, *prev, **pprev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | struct rb_node **rb_link, *rb_parent; |
| 351 | int retval; |
| 352 | unsigned long charge; |
| 353 | struct mempolicy *pol; |
| 354 | |
Oleg Nesterov | 32cdba1 | 2012-11-14 19:03:42 +0100 | [diff] [blame] | 355 | uprobe_start_dup_mmap(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | down_write(&oldmm->mmap_sem); |
Ralf Baechle | ec8c044 | 2006-12-12 17:14:57 +0000 | [diff] [blame] | 357 | flush_cache_dup_mm(oldmm); |
Oleg Nesterov | f8ac4ec | 2012-08-08 17:11:42 +0200 | [diff] [blame] | 358 | uprobe_dup_mmap(oldmm, mm); |
Ingo Molnar | ad33945 | 2006-07-03 00:25:15 -0700 | [diff] [blame] | 359 | /* |
| 360 | * Not linked in yet - no deadlock potential: |
| 361 | */ |
| 362 | down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING); |
Hugh Dickins | 7ee7823 | 2005-10-29 18:16:08 -0700 | [diff] [blame] | 363 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | mm->locked_vm = 0; |
| 365 | mm->mmap = NULL; |
| 366 | mm->mmap_cache = NULL; |
| 367 | mm->free_area_cache = oldmm->mmap_base; |
Wolfgang Wander | 1363c3c | 2005-06-21 17:14:49 -0700 | [diff] [blame] | 368 | mm->cached_hole_size = ~0UL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 369 | mm->map_count = 0; |
Rusty Russell | 9489424 | 2009-03-30 22:05:12 -0600 | [diff] [blame] | 370 | cpumask_clear(mm_cpumask(mm)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | mm->mm_rb = RB_ROOT; |
| 372 | rb_link = &mm->mm_rb.rb_node; |
| 373 | rb_parent = NULL; |
| 374 | pprev = &mm->mmap; |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 375 | retval = ksm_fork(mm, oldmm); |
| 376 | if (retval) |
| 377 | goto out; |
Andrea Arcangeli | ba76149 | 2011-01-13 15:46:58 -0800 | [diff] [blame] | 378 | retval = khugepaged_fork(mm, oldmm); |
| 379 | if (retval) |
| 380 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 381 | |
Linus Torvalds | 297c5ee | 2010-08-20 16:24:55 -0700 | [diff] [blame] | 382 | prev = NULL; |
Hugh Dickins | fd3e42f | 2005-10-29 18:16:06 -0700 | [diff] [blame] | 383 | for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | struct file *file; |
| 385 | |
| 386 | if (mpnt->vm_flags & VM_DONTCOPY) { |
Hugh Dickins | ab50b8e | 2005-10-29 18:15:56 -0700 | [diff] [blame] | 387 | vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file, |
Huang Shijie | 44de9d0 | 2012-07-31 16:41:49 -0700 | [diff] [blame] | 388 | -vma_pages(mpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | continue; |
| 390 | } |
| 391 | charge = 0; |
| 392 | if (mpnt->vm_flags & VM_ACCOUNT) { |
Huang Shijie | b2412b7 | 2012-07-30 14:42:30 -0700 | [diff] [blame] | 393 | unsigned long len = vma_pages(mpnt); |
| 394 | |
Al Viro | 191c542 | 2012-02-13 03:58:52 +0000 | [diff] [blame] | 395 | if (security_vm_enough_memory_mm(oldmm, len)) /* sic */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | goto fail_nomem; |
| 397 | charge = len; |
| 398 | } |
Christoph Lameter | e94b176 | 2006-12-06 20:33:17 -0800 | [diff] [blame] | 399 | tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | if (!tmp) |
| 401 | goto fail_nomem; |
| 402 | *tmp = *mpnt; |
Rik van Riel | 5beb493 | 2010-03-05 13:42:07 -0800 | [diff] [blame] | 403 | INIT_LIST_HEAD(&tmp->anon_vma_chain); |
Lee Schermerhorn | 846a16b | 2008-04-28 02:13:09 -0700 | [diff] [blame] | 404 | pol = mpol_dup(vma_policy(mpnt)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 405 | retval = PTR_ERR(pol); |
| 406 | if (IS_ERR(pol)) |
| 407 | goto fail_nomem_policy; |
| 408 | vma_set_policy(tmp, pol); |
Andrea Arcangeli | a247c3a | 2010-09-22 13:05:12 -0700 | [diff] [blame] | 409 | tmp->vm_mm = mm; |
Rik van Riel | 5beb493 | 2010-03-05 13:42:07 -0800 | [diff] [blame] | 410 | if (anon_vma_fork(tmp, mpnt)) |
| 411 | goto fail_nomem_anon_vma_fork; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | tmp->vm_flags &= ~VM_LOCKED; |
Linus Torvalds | 297c5ee | 2010-08-20 16:24:55 -0700 | [diff] [blame] | 413 | tmp->vm_next = tmp->vm_prev = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | file = tmp->vm_file; |
| 415 | if (file) { |
Josef "Jeff" Sipek | f3a43f3 | 2006-12-08 02:36:43 -0800 | [diff] [blame] | 416 | struct inode *inode = file->f_path.dentry->d_inode; |
Hugh Dickins | b88ed20 | 2008-12-10 20:48:52 +0000 | [diff] [blame] | 417 | struct address_space *mapping = file->f_mapping; |
| 418 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | get_file(file); |
| 420 | if (tmp->vm_flags & VM_DENYWRITE) |
| 421 | atomic_dec(&inode->i_writecount); |
Peter Zijlstra | 3d48ae4 | 2011-05-24 17:12:06 -0700 | [diff] [blame] | 422 | mutex_lock(&mapping->i_mmap_mutex); |
Hugh Dickins | b88ed20 | 2008-12-10 20:48:52 +0000 | [diff] [blame] | 423 | if (tmp->vm_flags & VM_SHARED) |
| 424 | mapping->i_mmap_writable++; |
Hugh Dickins | b88ed20 | 2008-12-10 20:48:52 +0000 | [diff] [blame] | 425 | flush_dcache_mmap_lock(mapping); |
| 426 | /* insert tmp into the share list, just after mpnt */ |
Michel Lespinasse | 9826a51 | 2012-10-08 16:31:35 -0700 | [diff] [blame] | 427 | if (unlikely(tmp->vm_flags & VM_NONLINEAR)) |
| 428 | vma_nonlinear_insert(tmp, |
| 429 | &mapping->i_mmap_nonlinear); |
| 430 | else |
| 431 | vma_interval_tree_insert_after(tmp, mpnt, |
| 432 | &mapping->i_mmap); |
Hugh Dickins | b88ed20 | 2008-12-10 20:48:52 +0000 | [diff] [blame] | 433 | flush_dcache_mmap_unlock(mapping); |
Peter Zijlstra | 3d48ae4 | 2011-05-24 17:12:06 -0700 | [diff] [blame] | 434 | mutex_unlock(&mapping->i_mmap_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | /* |
Mel Gorman | a1e7877 | 2008-07-23 21:27:23 -0700 | [diff] [blame] | 438 | * Clear hugetlb-related page reserves for children. This only |
| 439 | * affects MAP_PRIVATE mappings. Faults generated by the child |
| 440 | * are not guaranteed to succeed, even if read-only |
| 441 | */ |
| 442 | if (is_vm_hugetlb_page(tmp)) |
| 443 | reset_vma_resv_huge_pages(tmp); |
| 444 | |
| 445 | /* |
Hugh Dickins | 7ee7823 | 2005-10-29 18:16:08 -0700 | [diff] [blame] | 446 | * Link in the new vma and copy the page table entries. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 447 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | *pprev = tmp; |
| 449 | pprev = &tmp->vm_next; |
Linus Torvalds | 297c5ee | 2010-08-20 16:24:55 -0700 | [diff] [blame] | 450 | tmp->vm_prev = prev; |
| 451 | prev = tmp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 452 | |
| 453 | __vma_link_rb(mm, tmp, rb_link, rb_parent); |
| 454 | rb_link = &tmp->vm_rb.rb_right; |
| 455 | rb_parent = &tmp->vm_rb; |
| 456 | |
| 457 | mm->map_count++; |
Hugh Dickins | 0b0db14 | 2005-11-21 21:32:20 -0800 | [diff] [blame] | 458 | retval = copy_page_range(mm, oldmm, mpnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 459 | |
| 460 | if (tmp->vm_ops && tmp->vm_ops->open) |
| 461 | tmp->vm_ops->open(tmp); |
| 462 | |
| 463 | if (retval) |
| 464 | goto out; |
| 465 | } |
Jeremy Fitzhardinge | d6dd61c | 2007-05-02 19:27:14 +0200 | [diff] [blame] | 466 | /* a new mm has just been created */ |
| 467 | arch_dup_mmap(oldmm, mm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | retval = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 469 | out: |
Hugh Dickins | 7ee7823 | 2005-10-29 18:16:08 -0700 | [diff] [blame] | 470 | up_write(&mm->mmap_sem); |
Hugh Dickins | fd3e42f | 2005-10-29 18:16:06 -0700 | [diff] [blame] | 471 | flush_tlb_mm(oldmm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 472 | up_write(&oldmm->mmap_sem); |
Oleg Nesterov | 32cdba1 | 2012-11-14 19:03:42 +0100 | [diff] [blame] | 473 | uprobe_end_dup_mmap(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 474 | return retval; |
Rik van Riel | 5beb493 | 2010-03-05 13:42:07 -0800 | [diff] [blame] | 475 | fail_nomem_anon_vma_fork: |
| 476 | mpol_put(pol); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | fail_nomem_policy: |
| 478 | kmem_cache_free(vm_area_cachep, tmp); |
| 479 | fail_nomem: |
| 480 | retval = -ENOMEM; |
| 481 | vm_unacct_memory(charge); |
| 482 | goto out; |
| 483 | } |
| 484 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 485 | static inline int mm_alloc_pgd(struct mm_struct *mm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | { |
| 487 | mm->pgd = pgd_alloc(mm); |
| 488 | if (unlikely(!mm->pgd)) |
| 489 | return -ENOMEM; |
| 490 | return 0; |
| 491 | } |
| 492 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 493 | static inline void mm_free_pgd(struct mm_struct *mm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 494 | { |
Benjamin Herrenschmidt | 5e54197 | 2008-02-04 22:29:14 -0800 | [diff] [blame] | 495 | pgd_free(mm, mm->pgd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 496 | } |
| 497 | #else |
| 498 | #define dup_mmap(mm, oldmm) (0) |
| 499 | #define mm_alloc_pgd(mm) (0) |
| 500 | #define mm_free_pgd(mm) |
| 501 | #endif /* CONFIG_MMU */ |
| 502 | |
Daniel Walker | 23ff444 | 2007-10-18 03:06:07 -0700 | [diff] [blame] | 503 | __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 504 | |
Christoph Lameter | e94b176 | 2006-12-06 20:33:17 -0800 | [diff] [blame] | 505 | #define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 506 | #define free_mm(mm) (kmem_cache_free(mm_cachep, (mm))) |
| 507 | |
Hidehiro Kawai | 4cb0e11 | 2009-01-06 14:42:47 -0800 | [diff] [blame] | 508 | static unsigned long default_dump_filter = MMF_DUMP_FILTER_DEFAULT; |
| 509 | |
| 510 | static int __init coredump_filter_setup(char *s) |
| 511 | { |
| 512 | default_dump_filter = |
| 513 | (simple_strtoul(s, NULL, 0) << MMF_DUMP_FILTER_SHIFT) & |
| 514 | MMF_DUMP_FILTER_MASK; |
| 515 | return 1; |
| 516 | } |
| 517 | |
| 518 | __setup("coredump_filter=", coredump_filter_setup); |
| 519 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | #include <linux/init_task.h> |
| 521 | |
Alexey Dobriyan | 858f099 | 2009-09-23 15:57:32 -0700 | [diff] [blame] | 522 | static void mm_init_aio(struct mm_struct *mm) |
| 523 | { |
| 524 | #ifdef CONFIG_AIO |
| 525 | spin_lock_init(&mm->ioctx_lock); |
| 526 | INIT_HLIST_HEAD(&mm->ioctx_list); |
| 527 | #endif |
| 528 | } |
| 529 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 530 | static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 531 | { |
| 532 | atomic_set(&mm->mm_users, 1); |
| 533 | atomic_set(&mm->mm_count, 1); |
| 534 | init_rwsem(&mm->mmap_sem); |
| 535 | INIT_LIST_HEAD(&mm->mmlist); |
Hugh Dickins | f8af4da | 2009-09-21 17:01:57 -0700 | [diff] [blame] | 536 | mm->flags = (current->mm) ? |
| 537 | (current->mm->flags & MMF_INIT_MASK) : default_dump_filter; |
Oleg Nesterov | 999d9fc | 2008-07-25 01:47:41 -0700 | [diff] [blame] | 538 | mm->core_state = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 539 | mm->nr_ptes = 0; |
KAMEZAWA Hiroyuki | d559db0 | 2010-03-05 13:41:39 -0800 | [diff] [blame] | 540 | memset(&mm->rss_stat, 0, sizeof(mm->rss_stat)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | spin_lock_init(&mm->page_table_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 542 | mm->free_area_cache = TASK_UNMAPPED_BASE; |
Wolfgang Wander | 1363c3c | 2005-06-21 17:14:49 -0700 | [diff] [blame] | 543 | mm->cached_hole_size = ~0UL; |
Alexey Dobriyan | 858f099 | 2009-09-23 15:57:32 -0700 | [diff] [blame] | 544 | mm_init_aio(mm); |
Balbir Singh | cf475ad | 2008-04-29 01:00:16 -0700 | [diff] [blame] | 545 | mm_init_owner(mm, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 546 | |
| 547 | if (likely(!mm_alloc_pgd(mm))) { |
| 548 | mm->def_flags = 0; |
Andrea Arcangeli | cddb8a5 | 2008-07-28 15:46:29 -0700 | [diff] [blame] | 549 | mmu_notifier_mm_init(mm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 550 | return mm; |
| 551 | } |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 552 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | free_mm(mm); |
| 554 | return NULL; |
| 555 | } |
| 556 | |
Konstantin Khlebnikov | c3f0327 | 2012-03-21 16:33:48 -0700 | [diff] [blame] | 557 | static void check_mm(struct mm_struct *mm) |
| 558 | { |
| 559 | int i; |
| 560 | |
| 561 | for (i = 0; i < NR_MM_COUNTERS; i++) { |
| 562 | long x = atomic_long_read(&mm->rss_stat.count[i]); |
| 563 | |
| 564 | if (unlikely(x)) |
| 565 | printk(KERN_ALERT "BUG: Bad rss-counter state " |
| 566 | "mm:%p idx:%d val:%ld\n", mm, i, x); |
| 567 | } |
| 568 | |
| 569 | #ifdef CONFIG_TRANSPARENT_HUGEPAGE |
| 570 | VM_BUG_ON(mm->pmd_huge_pte); |
| 571 | #endif |
| 572 | } |
| 573 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | /* |
| 575 | * Allocate and initialize an mm_struct. |
| 576 | */ |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 577 | struct mm_struct *mm_alloc(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 578 | { |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 579 | struct mm_struct *mm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 580 | |
| 581 | mm = allocate_mm(); |
KOSAKI Motohiro | de03c72 | 2011-05-24 17:12:15 -0700 | [diff] [blame] | 582 | if (!mm) |
| 583 | return NULL; |
| 584 | |
| 585 | memset(mm, 0, sizeof(*mm)); |
Linus Torvalds | 6345d24 | 2011-05-29 11:32:28 -0700 | [diff] [blame] | 586 | mm_init_cpumask(mm); |
| 587 | return mm_init(mm, current); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 588 | } |
| 589 | |
| 590 | /* |
| 591 | * Called when the last reference to the mm |
| 592 | * is dropped: either by a lazy thread or by |
| 593 | * mmput. Free the page directory and the mm. |
| 594 | */ |
Harvey Harrison | 7ad5b3a | 2008-02-08 04:19:53 -0800 | [diff] [blame] | 595 | void __mmdrop(struct mm_struct *mm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 596 | { |
| 597 | BUG_ON(mm == &init_mm); |
| 598 | mm_free_pgd(mm); |
| 599 | destroy_context(mm); |
Andrea Arcangeli | cddb8a5 | 2008-07-28 15:46:29 -0700 | [diff] [blame] | 600 | mmu_notifier_mm_destroy(mm); |
Konstantin Khlebnikov | c3f0327 | 2012-03-21 16:33:48 -0700 | [diff] [blame] | 601 | check_mm(mm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 602 | free_mm(mm); |
| 603 | } |
Avi Kivity | 6d4e4c4 | 2007-11-21 16:41:05 +0200 | [diff] [blame] | 604 | EXPORT_SYMBOL_GPL(__mmdrop); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 605 | |
| 606 | /* |
| 607 | * Decrement the use count and release all resources for an mm. |
| 608 | */ |
| 609 | void mmput(struct mm_struct *mm) |
| 610 | { |
Andrew Morton | 0ae26f1 | 2006-06-23 02:05:15 -0700 | [diff] [blame] | 611 | might_sleep(); |
| 612 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 613 | if (atomic_dec_and_test(&mm->mm_users)) { |
Srikar Dronamraju | d4b3b63 | 2012-03-30 23:56:31 +0530 | [diff] [blame] | 614 | uprobe_clear_state(mm); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | exit_aio(mm); |
Andrea Arcangeli | 1c2fb7a | 2009-09-21 17:02:22 -0700 | [diff] [blame] | 616 | ksm_exit(mm); |
Andrea Arcangeli | ba76149 | 2011-01-13 15:46:58 -0800 | [diff] [blame] | 617 | khugepaged_exit(mm); /* must run before exit_mmap */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 618 | exit_mmap(mm); |
Matt Helsley | 925d1c4 | 2008-04-29 01:01:36 -0700 | [diff] [blame] | 619 | set_mm_exe_file(mm, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 620 | if (!list_empty(&mm->mmlist)) { |
| 621 | spin_lock(&mmlist_lock); |
| 622 | list_del(&mm->mmlist); |
| 623 | spin_unlock(&mmlist_lock); |
| 624 | } |
Hiroshi Shimamoto | 801460d | 2009-09-23 15:57:41 -0700 | [diff] [blame] | 625 | if (mm->binfmt) |
| 626 | module_put(mm->binfmt->module); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 627 | mmdrop(mm); |
| 628 | } |
| 629 | } |
| 630 | EXPORT_SYMBOL_GPL(mmput); |
| 631 | |
Jiri Slaby | 3864601 | 2011-05-26 16:25:46 -0700 | [diff] [blame] | 632 | void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file) |
| 633 | { |
| 634 | if (new_exe_file) |
| 635 | get_file(new_exe_file); |
| 636 | if (mm->exe_file) |
| 637 | fput(mm->exe_file); |
| 638 | mm->exe_file = new_exe_file; |
Jiri Slaby | 3864601 | 2011-05-26 16:25:46 -0700 | [diff] [blame] | 639 | } |
| 640 | |
| 641 | struct file *get_mm_exe_file(struct mm_struct *mm) |
| 642 | { |
| 643 | struct file *exe_file; |
| 644 | |
Konstantin Khlebnikov | 2dd8ad8 | 2012-10-08 16:28:51 -0700 | [diff] [blame] | 645 | /* We need mmap_sem to protect against races with removal of exe_file */ |
Jiri Slaby | 3864601 | 2011-05-26 16:25:46 -0700 | [diff] [blame] | 646 | down_read(&mm->mmap_sem); |
| 647 | exe_file = mm->exe_file; |
| 648 | if (exe_file) |
| 649 | get_file(exe_file); |
| 650 | up_read(&mm->mmap_sem); |
| 651 | return exe_file; |
| 652 | } |
| 653 | |
| 654 | static void dup_mm_exe_file(struct mm_struct *oldmm, struct mm_struct *newmm) |
| 655 | { |
| 656 | /* It's safe to write the exe_file pointer without exe_file_lock because |
| 657 | * this is called during fork when the task is not yet in /proc */ |
| 658 | newmm->exe_file = get_mm_exe_file(oldmm); |
| 659 | } |
| 660 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 661 | /** |
| 662 | * get_task_mm - acquire a reference to the task's mm |
| 663 | * |
Oleg Nesterov | 246bb0b | 2008-07-25 01:47:38 -0700 | [diff] [blame] | 664 | * Returns %NULL if the task has no mm. Checks PF_KTHREAD (meaning |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 665 | * this kernel workthread has transiently adopted a user mm with use_mm, |
| 666 | * to do its AIO) is not set and if so returns a reference to it, after |
| 667 | * bumping up the use count. User must release the mm via mmput() |
| 668 | * after use. Typically used by /proc and ptrace. |
| 669 | */ |
| 670 | struct mm_struct *get_task_mm(struct task_struct *task) |
| 671 | { |
| 672 | struct mm_struct *mm; |
| 673 | |
| 674 | task_lock(task); |
| 675 | mm = task->mm; |
| 676 | if (mm) { |
Oleg Nesterov | 246bb0b | 2008-07-25 01:47:38 -0700 | [diff] [blame] | 677 | if (task->flags & PF_KTHREAD) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 678 | mm = NULL; |
| 679 | else |
| 680 | atomic_inc(&mm->mm_users); |
| 681 | } |
| 682 | task_unlock(task); |
| 683 | return mm; |
| 684 | } |
| 685 | EXPORT_SYMBOL_GPL(get_task_mm); |
| 686 | |
Christopher Yeoh | 8cdb878 | 2012-02-02 11:34:09 +1030 | [diff] [blame] | 687 | struct mm_struct *mm_access(struct task_struct *task, unsigned int mode) |
| 688 | { |
| 689 | struct mm_struct *mm; |
| 690 | int err; |
| 691 | |
| 692 | err = mutex_lock_killable(&task->signal->cred_guard_mutex); |
| 693 | if (err) |
| 694 | return ERR_PTR(err); |
| 695 | |
| 696 | mm = get_task_mm(task); |
| 697 | if (mm && mm != current->mm && |
| 698 | !ptrace_may_access(task, mode)) { |
| 699 | mmput(mm); |
| 700 | mm = ERR_PTR(-EACCES); |
| 701 | } |
| 702 | mutex_unlock(&task->signal->cred_guard_mutex); |
| 703 | |
| 704 | return mm; |
| 705 | } |
| 706 | |
Oleg Nesterov | 57b59c4 | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 707 | static void complete_vfork_done(struct task_struct *tsk) |
Oleg Nesterov | c415c3b | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 708 | { |
Oleg Nesterov | d68b46f | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 709 | struct completion *vfork; |
Oleg Nesterov | c415c3b | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 710 | |
Oleg Nesterov | d68b46f | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 711 | task_lock(tsk); |
| 712 | vfork = tsk->vfork_done; |
| 713 | if (likely(vfork)) { |
| 714 | tsk->vfork_done = NULL; |
| 715 | complete(vfork); |
| 716 | } |
| 717 | task_unlock(tsk); |
| 718 | } |
| 719 | |
| 720 | static int wait_for_vfork_done(struct task_struct *child, |
| 721 | struct completion *vfork) |
| 722 | { |
| 723 | int killed; |
| 724 | |
| 725 | freezer_do_not_count(); |
| 726 | killed = wait_for_completion_killable(vfork); |
| 727 | freezer_count(); |
| 728 | |
| 729 | if (killed) { |
| 730 | task_lock(child); |
| 731 | child->vfork_done = NULL; |
| 732 | task_unlock(child); |
| 733 | } |
| 734 | |
| 735 | put_task_struct(child); |
| 736 | return killed; |
Oleg Nesterov | c415c3b | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 737 | } |
| 738 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 739 | /* Please note the differences between mmput and mm_release. |
| 740 | * mmput is called whenever we stop holding onto a mm_struct, |
| 741 | * error success whatever. |
| 742 | * |
| 743 | * mm_release is called after a mm_struct has been removed |
| 744 | * from the current process. |
| 745 | * |
| 746 | * This difference is important for error handling, when we |
| 747 | * only half set up a mm_struct for a new process and need to restore |
| 748 | * the old one. Because we mmput the new mm_struct before |
| 749 | * restoring the old one. . . |
| 750 | * Eric Biederman 10 January 1998 |
| 751 | */ |
| 752 | void mm_release(struct task_struct *tsk, struct mm_struct *mm) |
| 753 | { |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 754 | /* Get rid of any futexes when releasing the mm */ |
| 755 | #ifdef CONFIG_FUTEX |
Peter Zijlstra | fc6b177 | 2009-10-05 18:17:32 +0200 | [diff] [blame] | 756 | if (unlikely(tsk->robust_list)) { |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 757 | exit_robust_list(tsk); |
Peter Zijlstra | fc6b177 | 2009-10-05 18:17:32 +0200 | [diff] [blame] | 758 | tsk->robust_list = NULL; |
| 759 | } |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 760 | #ifdef CONFIG_COMPAT |
Peter Zijlstra | fc6b177 | 2009-10-05 18:17:32 +0200 | [diff] [blame] | 761 | if (unlikely(tsk->compat_robust_list)) { |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 762 | compat_exit_robust_list(tsk); |
Peter Zijlstra | fc6b177 | 2009-10-05 18:17:32 +0200 | [diff] [blame] | 763 | tsk->compat_robust_list = NULL; |
| 764 | } |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 765 | #endif |
Thomas Gleixner | 322a2c1 | 2009-10-05 18:18:03 +0200 | [diff] [blame] | 766 | if (unlikely(!list_empty(&tsk->pi_state_list))) |
| 767 | exit_pi_state_list(tsk); |
Linus Torvalds | 8141c7f | 2008-11-15 10:20:36 -0800 | [diff] [blame] | 768 | #endif |
| 769 | |
Srikar Dronamraju | 0326f5a | 2012-03-13 23:30:11 +0530 | [diff] [blame] | 770 | uprobe_free_utask(tsk); |
| 771 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 772 | /* Get rid of any cached register state */ |
| 773 | deactivate_mm(tsk, mm); |
| 774 | |
Roland McGrath | fec1d01 | 2006-12-06 20:36:34 -0800 | [diff] [blame] | 775 | /* |
| 776 | * If we're exiting normally, clear a user-space tid field if |
| 777 | * requested. We leave this alone when dying by signal, to leave |
| 778 | * the value intact in a core dump, and to save the unnecessary |
Oleg Nesterov | d68b46f | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 779 | * trouble, say, a killed vfork parent shouldn't touch this mm. |
| 780 | * Userland only wants this done for a sys_exit. |
Roland McGrath | fec1d01 | 2006-12-06 20:36:34 -0800 | [diff] [blame] | 781 | */ |
Eric Dumazet | 9c8a822 | 2009-08-06 15:09:28 -0700 | [diff] [blame] | 782 | if (tsk->clear_child_tid) { |
| 783 | if (!(tsk->flags & PF_SIGNALED) && |
| 784 | atomic_read(&mm->mm_users) > 1) { |
| 785 | /* |
| 786 | * We don't check the error code - if userspace has |
| 787 | * not set up a proper pointer then tough luck. |
| 788 | */ |
| 789 | put_user(0, tsk->clear_child_tid); |
| 790 | sys_futex(tsk->clear_child_tid, FUTEX_WAKE, |
| 791 | 1, NULL, NULL, 0); |
| 792 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 793 | tsk->clear_child_tid = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 794 | } |
Konstantin Khlebnikov | f7505d64 | 2012-05-31 16:26:21 -0700 | [diff] [blame] | 795 | |
| 796 | /* |
| 797 | * All done, finally we can wake up parent and return this mm to him. |
| 798 | * Also kthread_stop() uses this completion for synchronization. |
| 799 | */ |
| 800 | if (tsk->vfork_done) |
| 801 | complete_vfork_done(tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 802 | } |
| 803 | |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 804 | /* |
| 805 | * Allocate a new mm structure and copy contents from the |
| 806 | * mm structure of the passed in task structure. |
| 807 | */ |
Carsten Otte | 402b086 | 2008-03-25 18:47:10 +0100 | [diff] [blame] | 808 | struct mm_struct *dup_mm(struct task_struct *tsk) |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 809 | { |
| 810 | struct mm_struct *mm, *oldmm = current->mm; |
| 811 | int err; |
| 812 | |
| 813 | if (!oldmm) |
| 814 | return NULL; |
| 815 | |
| 816 | mm = allocate_mm(); |
| 817 | if (!mm) |
| 818 | goto fail_nomem; |
| 819 | |
| 820 | memcpy(mm, oldmm, sizeof(*mm)); |
Linus Torvalds | 6345d24 | 2011-05-29 11:32:28 -0700 | [diff] [blame] | 821 | mm_init_cpumask(mm); |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 822 | |
Andrea Arcangeli | e7a00c4 | 2011-01-13 15:46:45 -0800 | [diff] [blame] | 823 | #ifdef CONFIG_TRANSPARENT_HUGEPAGE |
| 824 | mm->pmd_huge_pte = NULL; |
| 825 | #endif |
Mel Gorman | 5bca230 | 2012-11-22 14:40:03 +0000 | [diff] [blame] | 826 | #ifdef CONFIG_NUMA_BALANCING |
| 827 | mm->first_nid = NUMA_PTE_SCAN_INIT; |
| 828 | #endif |
Pavel Emelianov | 78fb746 | 2008-02-07 00:13:51 -0800 | [diff] [blame] | 829 | if (!mm_init(mm, tsk)) |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 830 | goto fail_nomem; |
| 831 | |
| 832 | if (init_new_context(tsk, mm)) |
| 833 | goto fail_nocontext; |
| 834 | |
Matt Helsley | 925d1c4 | 2008-04-29 01:01:36 -0700 | [diff] [blame] | 835 | dup_mm_exe_file(oldmm, mm); |
| 836 | |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 837 | err = dup_mmap(mm, oldmm); |
| 838 | if (err) |
| 839 | goto free_pt; |
| 840 | |
| 841 | mm->hiwater_rss = get_mm_rss(mm); |
| 842 | mm->hiwater_vm = mm->total_vm; |
| 843 | |
Hiroshi Shimamoto | 801460d | 2009-09-23 15:57:41 -0700 | [diff] [blame] | 844 | if (mm->binfmt && !try_module_get(mm->binfmt->module)) |
| 845 | goto free_pt; |
| 846 | |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 847 | return mm; |
| 848 | |
| 849 | free_pt: |
Hiroshi Shimamoto | 801460d | 2009-09-23 15:57:41 -0700 | [diff] [blame] | 850 | /* don't put binfmt in mmput, we haven't got module yet */ |
| 851 | mm->binfmt = NULL; |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 852 | mmput(mm); |
| 853 | |
| 854 | fail_nomem: |
| 855 | return NULL; |
| 856 | |
| 857 | fail_nocontext: |
| 858 | /* |
| 859 | * If init_new_context() failed, we cannot use mmput() to free the mm |
| 860 | * because it calls destroy_context() |
| 861 | */ |
| 862 | mm_free_pgd(mm); |
| 863 | free_mm(mm); |
| 864 | return NULL; |
| 865 | } |
| 866 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 867 | static int copy_mm(unsigned long clone_flags, struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 868 | { |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 869 | struct mm_struct *mm, *oldmm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 870 | int retval; |
| 871 | |
| 872 | tsk->min_flt = tsk->maj_flt = 0; |
| 873 | tsk->nvcsw = tsk->nivcsw = 0; |
Mandeep Singh Baines | 17406b8 | 2009-02-06 15:37:47 -0800 | [diff] [blame] | 874 | #ifdef CONFIG_DETECT_HUNG_TASK |
| 875 | tsk->last_switch_count = tsk->nvcsw + tsk->nivcsw; |
| 876 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 877 | |
| 878 | tsk->mm = NULL; |
| 879 | tsk->active_mm = NULL; |
| 880 | |
| 881 | /* |
| 882 | * Are we cloning a kernel thread? |
| 883 | * |
| 884 | * We need to steal a active VM for that.. |
| 885 | */ |
| 886 | oldmm = current->mm; |
| 887 | if (!oldmm) |
| 888 | return 0; |
| 889 | |
| 890 | if (clone_flags & CLONE_VM) { |
| 891 | atomic_inc(&oldmm->mm_users); |
| 892 | mm = oldmm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 893 | goto good_mm; |
| 894 | } |
| 895 | |
| 896 | retval = -ENOMEM; |
JANAK DESAI | a0a7ec3 | 2006-02-07 12:59:01 -0800 | [diff] [blame] | 897 | mm = dup_mm(tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 898 | if (!mm) |
| 899 | goto fail_nomem; |
| 900 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 901 | good_mm: |
| 902 | tsk->mm = mm; |
| 903 | tsk->active_mm = mm; |
| 904 | return 0; |
| 905 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 906 | fail_nomem: |
| 907 | return retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 908 | } |
| 909 | |
Alexey Dobriyan | a39bc51 | 2007-10-18 23:41:10 -0700 | [diff] [blame] | 910 | static int copy_fs(unsigned long clone_flags, struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 911 | { |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 912 | struct fs_struct *fs = current->fs; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 913 | if (clone_flags & CLONE_FS) { |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 914 | /* tsk->fs is already what we want */ |
Nick Piggin | 2a4419b | 2010-08-18 04:37:33 +1000 | [diff] [blame] | 915 | spin_lock(&fs->lock); |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 916 | if (fs->in_exec) { |
Nick Piggin | 2a4419b | 2010-08-18 04:37:33 +1000 | [diff] [blame] | 917 | spin_unlock(&fs->lock); |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 918 | return -EAGAIN; |
| 919 | } |
| 920 | fs->users++; |
Nick Piggin | 2a4419b | 2010-08-18 04:37:33 +1000 | [diff] [blame] | 921 | spin_unlock(&fs->lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 922 | return 0; |
| 923 | } |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 924 | tsk->fs = copy_fs_struct(fs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 925 | if (!tsk->fs) |
| 926 | return -ENOMEM; |
| 927 | return 0; |
| 928 | } |
| 929 | |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 930 | static int copy_files(unsigned long clone_flags, struct task_struct *tsk) |
JANAK DESAI | a016f33 | 2006-02-07 12:59:02 -0800 | [diff] [blame] | 931 | { |
| 932 | struct files_struct *oldf, *newf; |
| 933 | int error = 0; |
| 934 | |
| 935 | /* |
| 936 | * A background process may not have any files ... |
| 937 | */ |
| 938 | oldf = current->files; |
| 939 | if (!oldf) |
| 940 | goto out; |
| 941 | |
| 942 | if (clone_flags & CLONE_FILES) { |
| 943 | atomic_inc(&oldf->count); |
| 944 | goto out; |
| 945 | } |
| 946 | |
JANAK DESAI | a016f33 | 2006-02-07 12:59:02 -0800 | [diff] [blame] | 947 | newf = dup_fd(oldf, &error); |
| 948 | if (!newf) |
| 949 | goto out; |
| 950 | |
| 951 | tsk->files = newf; |
| 952 | error = 0; |
| 953 | out: |
| 954 | return error; |
| 955 | } |
| 956 | |
Jens Axboe | fadad878 | 2008-01-24 08:54:47 +0100 | [diff] [blame] | 957 | static int copy_io(unsigned long clone_flags, struct task_struct *tsk) |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 958 | { |
| 959 | #ifdef CONFIG_BLOCK |
| 960 | struct io_context *ioc = current->io_context; |
Tejun Heo | 6e736be | 2011-12-14 00:33:38 +0100 | [diff] [blame] | 961 | struct io_context *new_ioc; |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 962 | |
| 963 | if (!ioc) |
| 964 | return 0; |
Jens Axboe | fadad878 | 2008-01-24 08:54:47 +0100 | [diff] [blame] | 965 | /* |
| 966 | * Share io context with parent, if CLONE_IO is set |
| 967 | */ |
| 968 | if (clone_flags & CLONE_IO) { |
Tejun Heo | 3d48749 | 2012-03-05 13:15:25 -0800 | [diff] [blame] | 969 | ioc_task_link(ioc); |
| 970 | tsk->io_context = ioc; |
Jens Axboe | fadad878 | 2008-01-24 08:54:47 +0100 | [diff] [blame] | 971 | } else if (ioprio_valid(ioc->ioprio)) { |
Tejun Heo | 6e736be | 2011-12-14 00:33:38 +0100 | [diff] [blame] | 972 | new_ioc = get_task_io_context(tsk, GFP_KERNEL, NUMA_NO_NODE); |
| 973 | if (unlikely(!new_ioc)) |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 974 | return -ENOMEM; |
| 975 | |
Tejun Heo | 6e736be | 2011-12-14 00:33:38 +0100 | [diff] [blame] | 976 | new_ioc->ioprio = ioc->ioprio; |
Tejun Heo | 11a3122 | 2012-02-07 07:51:30 +0100 | [diff] [blame] | 977 | put_io_context(new_ioc); |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 978 | } |
| 979 | #endif |
| 980 | return 0; |
| 981 | } |
| 982 | |
Alexey Dobriyan | a39bc51 | 2007-10-18 23:41:10 -0700 | [diff] [blame] | 983 | static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 984 | { |
| 985 | struct sighand_struct *sig; |
| 986 | |
Zhaolei | 6034880 | 2009-01-06 14:40:46 -0800 | [diff] [blame] | 987 | if (clone_flags & CLONE_SIGHAND) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 988 | atomic_inc(¤t->sighand->count); |
| 989 | return 0; |
| 990 | } |
| 991 | sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL); |
Ingo Molnar | e56d090 | 2006-01-08 01:01:37 -0800 | [diff] [blame] | 992 | rcu_assign_pointer(tsk->sighand, sig); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 993 | if (!sig) |
| 994 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 995 | atomic_set(&sig->count, 1); |
| 996 | memcpy(sig->action, current->sighand->action, sizeof(sig->action)); |
| 997 | return 0; |
| 998 | } |
| 999 | |
Oleg Nesterov | a7e5328 | 2006-03-28 16:11:27 -0800 | [diff] [blame] | 1000 | void __cleanup_sighand(struct sighand_struct *sighand) |
Oleg Nesterov | c81addc | 2006-03-28 16:11:17 -0800 | [diff] [blame] | 1001 | { |
Oleg Nesterov | d80e731 | 2012-02-24 20:07:11 +0100 | [diff] [blame] | 1002 | if (atomic_dec_and_test(&sighand->count)) { |
| 1003 | signalfd_cleanup(sighand); |
Oleg Nesterov | c81addc | 2006-03-28 16:11:17 -0800 | [diff] [blame] | 1004 | kmem_cache_free(sighand_cachep, sighand); |
Oleg Nesterov | d80e731 | 2012-02-24 20:07:11 +0100 | [diff] [blame] | 1005 | } |
Oleg Nesterov | c81addc | 2006-03-28 16:11:17 -0800 | [diff] [blame] | 1006 | } |
| 1007 | |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1008 | |
| 1009 | /* |
| 1010 | * Initialize POSIX timer handling for a thread group. |
| 1011 | */ |
| 1012 | static void posix_cpu_timers_init_group(struct signal_struct *sig) |
| 1013 | { |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 1014 | unsigned long cpu_limit; |
| 1015 | |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1016 | /* Thread group counters. */ |
| 1017 | thread_group_cputime_init(sig); |
| 1018 | |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 1019 | cpu_limit = ACCESS_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); |
| 1020 | if (cpu_limit != RLIM_INFINITY) { |
| 1021 | sig->cputime_expires.prof_exp = secs_to_cputime(cpu_limit); |
Oleg Nesterov | 6279a751 | 2009-03-27 01:06:07 +0100 | [diff] [blame] | 1022 | sig->cputimer.running = 1; |
| 1023 | } |
| 1024 | |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1025 | /* The timer lists. */ |
| 1026 | INIT_LIST_HEAD(&sig->cpu_timers[0]); |
| 1027 | INIT_LIST_HEAD(&sig->cpu_timers[1]); |
| 1028 | INIT_LIST_HEAD(&sig->cpu_timers[2]); |
| 1029 | } |
| 1030 | |
Alexey Dobriyan | a39bc51 | 2007-10-18 23:41:10 -0700 | [diff] [blame] | 1031 | static int copy_signal(unsigned long clone_flags, struct task_struct *tsk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1032 | { |
| 1033 | struct signal_struct *sig; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1034 | |
Oleg Nesterov | 4ab6c08 | 2009-08-26 14:29:24 -0700 | [diff] [blame] | 1035 | if (clone_flags & CLONE_THREAD) |
Peter Zijlstra | 490dea4 | 2008-11-24 17:06:57 +0100 | [diff] [blame] | 1036 | return 0; |
Oleg Nesterov | 6279a751 | 2009-03-27 01:06:07 +0100 | [diff] [blame] | 1037 | |
Veaceslav Falico | a56704e | 2010-03-10 15:23:01 -0800 | [diff] [blame] | 1038 | sig = kmem_cache_zalloc(signal_cachep, GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1039 | tsk->signal = sig; |
| 1040 | if (!sig) |
| 1041 | return -ENOMEM; |
| 1042 | |
Oleg Nesterov | b3ac022 | 2010-05-26 14:43:24 -0700 | [diff] [blame] | 1043 | sig->nr_threads = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1044 | atomic_set(&sig->live, 1); |
Oleg Nesterov | b3ac022 | 2010-05-26 14:43:24 -0700 | [diff] [blame] | 1045 | atomic_set(&sig->sigcnt, 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1046 | init_waitqueue_head(&sig->wait_chldexit); |
Oleg Nesterov | db51aec | 2008-04-30 00:52:52 -0700 | [diff] [blame] | 1047 | sig->curr_target = tsk; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1048 | init_sigpending(&sig->shared_pending); |
| 1049 | INIT_LIST_HEAD(&sig->posix_timers); |
| 1050 | |
Thomas Gleixner | c9cb2e3 | 2007-02-16 01:27:49 -0800 | [diff] [blame] | 1051 | hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1052 | sig->real_timer.function = it_real_fn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1053 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1054 | task_lock(current->group_leader); |
| 1055 | memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim); |
| 1056 | task_unlock(current->group_leader); |
| 1057 | |
Oleg Nesterov | 6279a751 | 2009-03-27 01:06:07 +0100 | [diff] [blame] | 1058 | posix_cpu_timers_init_group(sig); |
| 1059 | |
Miloslav Trmac | 522ed77 | 2007-07-15 23:40:56 -0700 | [diff] [blame] | 1060 | tty_audit_fork(sig); |
Mike Galbraith | 5091faa | 2010-11-30 14:18:03 +0100 | [diff] [blame] | 1061 | sched_autogroup_fork(sig); |
Miloslav Trmac | 522ed77 | 2007-07-15 23:40:56 -0700 | [diff] [blame] | 1062 | |
Ben Blum | 4714d1d | 2011-05-26 16:25:18 -0700 | [diff] [blame] | 1063 | #ifdef CONFIG_CGROUPS |
Tejun Heo | 257058a | 2011-12-12 18:12:21 -0800 | [diff] [blame] | 1064 | init_rwsem(&sig->group_rwsem); |
Ben Blum | 4714d1d | 2011-05-26 16:25:18 -0700 | [diff] [blame] | 1065 | #endif |
| 1066 | |
David Rientjes | a63d83f | 2010-08-09 17:19:46 -0700 | [diff] [blame] | 1067 | sig->oom_score_adj = current->signal->oom_score_adj; |
Mandeep Singh Baines | dabb16f | 2011-01-13 15:46:05 -0800 | [diff] [blame] | 1068 | sig->oom_score_adj_min = current->signal->oom_score_adj_min; |
KOSAKI Motohiro | 28b83c5 | 2009-09-21 17:03:13 -0700 | [diff] [blame] | 1069 | |
Lennart Poettering | ebec18a | 2012-03-23 15:01:54 -0700 | [diff] [blame] | 1070 | sig->has_child_subreaper = current->signal->has_child_subreaper || |
| 1071 | current->signal->is_child_subreaper; |
| 1072 | |
KOSAKI Motohiro | 9b1bf12 | 2010-10-27 15:34:08 -0700 | [diff] [blame] | 1073 | mutex_init(&sig->cred_guard_mutex); |
| 1074 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1075 | return 0; |
| 1076 | } |
| 1077 | |
Alexey Dobriyan | a39bc51 | 2007-10-18 23:41:10 -0700 | [diff] [blame] | 1078 | static void copy_flags(unsigned long clone_flags, struct task_struct *p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1079 | { |
| 1080 | unsigned long new_flags = p->flags; |
| 1081 | |
Tejun Heo | 21aa9af | 2010-06-08 21:40:37 +0200 | [diff] [blame] | 1082 | new_flags &= ~(PF_SUPERPRIV | PF_WQ_WORKER); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1083 | new_flags |= PF_FORKNOEXEC; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1084 | p->flags = new_flags; |
| 1085 | } |
| 1086 | |
Heiko Carstens | 17da2bd | 2009-01-14 14:14:10 +0100 | [diff] [blame] | 1087 | SYSCALL_DEFINE1(set_tid_address, int __user *, tidptr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1088 | { |
| 1089 | current->clear_child_tid = tidptr; |
| 1090 | |
Pavel Emelyanov | b488893 | 2007-10-18 23:40:14 -0700 | [diff] [blame] | 1091 | return task_pid_vnr(current); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1092 | } |
| 1093 | |
Alexey Dobriyan | a39bc51 | 2007-10-18 23:41:10 -0700 | [diff] [blame] | 1094 | static void rt_mutex_init_task(struct task_struct *p) |
Ingo Molnar | 23f78d4a | 2006-06-27 02:54:53 -0700 | [diff] [blame] | 1095 | { |
Thomas Gleixner | 1d61548 | 2009-11-17 14:54:03 +0100 | [diff] [blame] | 1096 | raw_spin_lock_init(&p->pi_lock); |
Zilvinas Valinskas | e29e175 | 2007-03-16 13:38:34 -0800 | [diff] [blame] | 1097 | #ifdef CONFIG_RT_MUTEXES |
Dima Zavin | 732375c | 2011-07-07 17:27:59 -0700 | [diff] [blame] | 1098 | plist_head_init(&p->pi_waiters); |
Ingo Molnar | 23f78d4a | 2006-06-27 02:54:53 -0700 | [diff] [blame] | 1099 | p->pi_blocked_on = NULL; |
Ingo Molnar | 23f78d4a | 2006-06-27 02:54:53 -0700 | [diff] [blame] | 1100 | #endif |
| 1101 | } |
| 1102 | |
Balbir Singh | cf475ad | 2008-04-29 01:00:16 -0700 | [diff] [blame] | 1103 | #ifdef CONFIG_MM_OWNER |
| 1104 | void mm_init_owner(struct mm_struct *mm, struct task_struct *p) |
| 1105 | { |
| 1106 | mm->owner = p; |
| 1107 | } |
| 1108 | #endif /* CONFIG_MM_OWNER */ |
| 1109 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1110 | /* |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1111 | * Initialize POSIX timer handling for a single task. |
| 1112 | */ |
| 1113 | static void posix_cpu_timers_init(struct task_struct *tsk) |
| 1114 | { |
Martin Schwidefsky | 6486163 | 2011-12-15 14:56:09 +0100 | [diff] [blame] | 1115 | tsk->cputime_expires.prof_exp = 0; |
| 1116 | tsk->cputime_expires.virt_exp = 0; |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1117 | tsk->cputime_expires.sched_exp = 0; |
| 1118 | INIT_LIST_HEAD(&tsk->cpu_timers[0]); |
| 1119 | INIT_LIST_HEAD(&tsk->cpu_timers[1]); |
| 1120 | INIT_LIST_HEAD(&tsk->cpu_timers[2]); |
| 1121 | } |
| 1122 | |
| 1123 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1124 | * This creates a new process as a copy of the old one, |
| 1125 | * but does not actually start it yet. |
| 1126 | * |
| 1127 | * It copies the registers, and all the appropriate |
| 1128 | * parts of the process environment (as per the clone |
| 1129 | * flags). The actual kick-off is left to the caller. |
| 1130 | */ |
Ingo Molnar | 36c8b58 | 2006-07-03 00:25:41 -0700 | [diff] [blame] | 1131 | static struct task_struct *copy_process(unsigned long clone_flags, |
| 1132 | unsigned long stack_start, |
Ingo Molnar | 36c8b58 | 2006-07-03 00:25:41 -0700 | [diff] [blame] | 1133 | unsigned long stack_size, |
Ingo Molnar | 36c8b58 | 2006-07-03 00:25:41 -0700 | [diff] [blame] | 1134 | int __user *child_tidptr, |
Roland McGrath | 09a0539 | 2008-07-25 19:45:47 -0700 | [diff] [blame] | 1135 | struct pid *pid, |
| 1136 | int trace) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1137 | { |
| 1138 | int retval; |
Mariusz Kozlowski | a24efe6 | 2007-10-18 23:41:09 -0700 | [diff] [blame] | 1139 | struct task_struct *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1140 | |
| 1141 | if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS)) |
| 1142 | return ERR_PTR(-EINVAL); |
| 1143 | |
| 1144 | /* |
| 1145 | * Thread groups must share signals as well, and detached threads |
| 1146 | * can only be started up within the thread group. |
| 1147 | */ |
| 1148 | if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND)) |
| 1149 | return ERR_PTR(-EINVAL); |
| 1150 | |
| 1151 | /* |
| 1152 | * Shared signal handlers imply shared VM. By way of the above, |
| 1153 | * thread groups also imply shared VM. Blocking this case allows |
| 1154 | * for various simplifications in other code. |
| 1155 | */ |
| 1156 | if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM)) |
| 1157 | return ERR_PTR(-EINVAL); |
| 1158 | |
Sukadev Bhattiprolu | 123be07 | 2009-09-23 15:57:20 -0700 | [diff] [blame] | 1159 | /* |
| 1160 | * Siblings of global init remain as zombies on exit since they are |
| 1161 | * not reaped by their parent (swapper). To solve this and to avoid |
| 1162 | * multi-rooted process trees, prevent global and container-inits |
| 1163 | * from creating siblings. |
| 1164 | */ |
| 1165 | if ((clone_flags & CLONE_PARENT) && |
| 1166 | current->signal->flags & SIGNAL_UNKILLABLE) |
| 1167 | return ERR_PTR(-EINVAL); |
| 1168 | |
Eric W. Biederman | 8382fca | 2012-12-20 19:26:06 -0800 | [diff] [blame] | 1169 | /* |
| 1170 | * If the new process will be in a different pid namespace |
| 1171 | * don't allow the creation of threads. |
| 1172 | */ |
| 1173 | if ((clone_flags & (CLONE_VM|CLONE_NEWPID)) && |
| 1174 | (task_active_pid_ns(current) != current->nsproxy->pid_ns)) |
| 1175 | return ERR_PTR(-EINVAL); |
| 1176 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1177 | retval = security_task_create(clone_flags); |
| 1178 | if (retval) |
| 1179 | goto fork_out; |
| 1180 | |
| 1181 | retval = -ENOMEM; |
| 1182 | p = dup_task_struct(current); |
| 1183 | if (!p) |
| 1184 | goto fork_out; |
| 1185 | |
Steven Rostedt | f7e8b61 | 2009-06-02 16:39:48 -0400 | [diff] [blame] | 1186 | ftrace_graph_init_task(p); |
Will Drewry | e2cfabdf | 2012-04-12 16:47:57 -0500 | [diff] [blame] | 1187 | get_seccomp_filter(p); |
Steven Rostedt | f7e8b61 | 2009-06-02 16:39:48 -0400 | [diff] [blame] | 1188 | |
Peter Zijlstra | bea493a | 2006-10-17 00:10:33 -0700 | [diff] [blame] | 1189 | rt_mutex_init_task(p); |
| 1190 | |
Ingo Molnar | d12c1a3 | 2008-07-14 12:09:28 +0200 | [diff] [blame] | 1191 | #ifdef CONFIG_PROVE_LOCKING |
Ingo Molnar | de30a2b | 2006-07-03 00:24:42 -0700 | [diff] [blame] | 1192 | DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled); |
| 1193 | DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled); |
| 1194 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1195 | retval = -EAGAIN; |
David Howells | 3b11a1d | 2008-11-14 10:39:26 +1100 | [diff] [blame] | 1196 | if (atomic_read(&p->real_cred->user->processes) >= |
Jiri Slaby | 78d7d40 | 2010-03-05 13:42:54 -0800 | [diff] [blame] | 1197 | task_rlimit(p, RLIMIT_NPROC)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1198 | if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) && |
Serge Hallyn | 18b6e04 | 2008-10-15 16:38:45 -0500 | [diff] [blame] | 1199 | p->real_cred->user != INIT_USER) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1200 | goto bad_fork_free; |
| 1201 | } |
Vasiliy Kulikov | 72fa599 | 2011-08-08 19:02:04 +0400 | [diff] [blame] | 1202 | current->flags &= ~PF_NPROC_EXCEEDED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1203 | |
David Howells | f1752ee | 2008-11-14 10:39:17 +1100 | [diff] [blame] | 1204 | retval = copy_creds(p, clone_flags); |
| 1205 | if (retval < 0) |
| 1206 | goto bad_fork_free; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1207 | |
| 1208 | /* |
| 1209 | * If multiple threads are within copy_process(), then this check |
| 1210 | * triggers too late. This doesn't hurt, the check is only there |
| 1211 | * to stop root fork bombs. |
| 1212 | */ |
Li Zefan | 04ec93f | 2009-02-06 08:17:19 +0000 | [diff] [blame] | 1213 | retval = -EAGAIN; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1214 | if (nr_threads >= max_threads) |
| 1215 | goto bad_fork_cleanup_count; |
| 1216 | |
Al Viro | a1261f5 | 2005-11-13 16:06:55 -0800 | [diff] [blame] | 1217 | if (!try_module_get(task_thread_info(p)->exec_domain->module)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1218 | goto bad_fork_cleanup_count; |
| 1219 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1220 | p->did_exec = 0; |
Shailabh Nagar | ca74e92 | 2006-07-14 00:24:36 -0700 | [diff] [blame] | 1221 | delayacct_tsk_init(p); /* Must remain after dup_task_struct() */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1222 | copy_flags(clone_flags, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1223 | INIT_LIST_HEAD(&p->children); |
| 1224 | INIT_LIST_HEAD(&p->sibling); |
Paul E. McKenney | f41d911 | 2009-08-22 13:56:52 -0700 | [diff] [blame] | 1225 | rcu_copy_process(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1226 | p->vfork_done = NULL; |
| 1227 | spin_lock_init(&p->alloc_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1228 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1229 | init_sigpending(&p->pending); |
| 1230 | |
Martin Schwidefsky | 6486163 | 2011-12-15 14:56:09 +0100 | [diff] [blame] | 1231 | p->utime = p->stime = p->gtime = 0; |
| 1232 | p->utimescaled = p->stimescaled = 0; |
Hidetoshi Seto | d99ca3b | 2009-12-02 17:26:47 +0900 | [diff] [blame] | 1233 | #ifndef CONFIG_VIRT_CPU_ACCOUNTING |
Frederic Weisbecker | d37f761d | 2012-11-22 00:58:35 +0100 | [diff] [blame] | 1234 | p->prev_cputime.utime = p->prev_cputime.stime = 0; |
Hidetoshi Seto | d99ca3b | 2009-12-02 17:26:47 +0900 | [diff] [blame] | 1235 | #endif |
KAMEZAWA Hiroyuki | a3a2e76 | 2010-04-06 14:34:42 -0700 | [diff] [blame] | 1236 | #if defined(SPLIT_RSS_COUNTING) |
| 1237 | memset(&p->rss_stat, 0, sizeof(p->rss_stat)); |
| 1238 | #endif |
Balbir Singh | 172ba84 | 2007-07-09 18:52:00 +0200 | [diff] [blame] | 1239 | |
Arjan van de Ven | 6976675 | 2008-09-01 15:52:40 -0700 | [diff] [blame] | 1240 | p->default_timer_slack_ns = current->timer_slack_ns; |
| 1241 | |
Andrea Righi | 5995477 | 2008-07-27 17:29:15 +0200 | [diff] [blame] | 1242 | task_io_accounting_init(&p->ioac); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1243 | acct_clear_integrals(p); |
| 1244 | |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 1245 | posix_cpu_timers_init(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1246 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1247 | do_posix_clock_monotonic_gettime(&p->start_time); |
Tomas Janousek | 924b42d | 2007-07-15 23:39:42 -0700 | [diff] [blame] | 1248 | p->real_start_time = p->start_time; |
| 1249 | monotonic_to_bootbased(&p->real_start_time); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1250 | p->io_context = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1251 | p->audit_context = NULL; |
Ben Blum | 4714d1d | 2011-05-26 16:25:18 -0700 | [diff] [blame] | 1252 | if (clone_flags & CLONE_THREAD) |
Tejun Heo | 257058a | 2011-12-12 18:12:21 -0800 | [diff] [blame] | 1253 | threadgroup_change_begin(current); |
Paul Menage | b4f48b6 | 2007-10-18 23:39:33 -0700 | [diff] [blame] | 1254 | cgroup_fork(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1255 | #ifdef CONFIG_NUMA |
Lee Schermerhorn | 846a16b | 2008-04-28 02:13:09 -0700 | [diff] [blame] | 1256 | p->mempolicy = mpol_dup(p->mempolicy); |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1257 | if (IS_ERR(p->mempolicy)) { |
| 1258 | retval = PTR_ERR(p->mempolicy); |
| 1259 | p->mempolicy = NULL; |
| 1260 | goto bad_fork_cleanup_cgroup; |
| 1261 | } |
Paul Jackson | c61afb1 | 2006-03-24 03:16:08 -0800 | [diff] [blame] | 1262 | mpol_fix_fork_child_flag(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1263 | #endif |
Michal Hocko | 778d3b0 | 2011-07-26 16:08:30 -0700 | [diff] [blame] | 1264 | #ifdef CONFIG_CPUSETS |
| 1265 | p->cpuset_mem_spread_rotor = NUMA_NO_NODE; |
| 1266 | p->cpuset_slab_spread_rotor = NUMA_NO_NODE; |
Mel Gorman | cc9a6c8 | 2012-03-21 16:34:11 -0700 | [diff] [blame] | 1267 | seqcount_init(&p->mems_allowed_seq); |
Michal Hocko | 778d3b0 | 2011-07-26 16:08:30 -0700 | [diff] [blame] | 1268 | #endif |
Ingo Molnar | de30a2b | 2006-07-03 00:24:42 -0700 | [diff] [blame] | 1269 | #ifdef CONFIG_TRACE_IRQFLAGS |
| 1270 | p->irq_events = 0; |
| 1271 | p->hardirqs_enabled = 0; |
| 1272 | p->hardirq_enable_ip = 0; |
| 1273 | p->hardirq_enable_event = 0; |
| 1274 | p->hardirq_disable_ip = _THIS_IP_; |
| 1275 | p->hardirq_disable_event = 0; |
| 1276 | p->softirqs_enabled = 1; |
| 1277 | p->softirq_enable_ip = _THIS_IP_; |
| 1278 | p->softirq_enable_event = 0; |
| 1279 | p->softirq_disable_ip = 0; |
| 1280 | p->softirq_disable_event = 0; |
| 1281 | p->hardirq_context = 0; |
| 1282 | p->softirq_context = 0; |
| 1283 | #endif |
Ingo Molnar | fbb9ce95 | 2006-07-03 00:24:50 -0700 | [diff] [blame] | 1284 | #ifdef CONFIG_LOCKDEP |
| 1285 | p->lockdep_depth = 0; /* no locks held yet */ |
| 1286 | p->curr_chain_key = 0; |
| 1287 | p->lockdep_recursion = 0; |
| 1288 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1289 | |
Ingo Molnar | 408894e | 2006-01-09 15:59:20 -0800 | [diff] [blame] | 1290 | #ifdef CONFIG_DEBUG_MUTEXES |
| 1291 | p->blocked_on = NULL; /* not blocked yet */ |
| 1292 | #endif |
Andrew Morton | c255a45 | 2012-07-31 16:43:02 -0700 | [diff] [blame] | 1293 | #ifdef CONFIG_MEMCG |
KAMEZAWA Hiroyuki | 569b846 | 2009-12-15 16:47:03 -0800 | [diff] [blame] | 1294 | p->memcg_batch.do_batch = 0; |
| 1295 | p->memcg_batch.memcg = NULL; |
| 1296 | #endif |
Markus Metzger | 0f48140 | 2009-04-03 16:43:48 +0200 | [diff] [blame] | 1297 | |
Srivatsa Vaddagiri | 3c90e6e | 2007-11-09 22:39:39 +0100 | [diff] [blame] | 1298 | /* Perform scheduler related setup. Assign this task to a CPU. */ |
Samir Bellabes | 3e51e3e | 2011-05-11 18:18:05 +0200 | [diff] [blame] | 1299 | sched_fork(p); |
Peter Zijlstra | 6ab423e | 2009-05-25 14:45:27 +0200 | [diff] [blame] | 1300 | |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 1301 | retval = perf_event_init_task(p); |
Peter Zijlstra | 6ab423e | 2009-05-25 14:45:27 +0200 | [diff] [blame] | 1302 | if (retval) |
| 1303 | goto bad_fork_cleanup_policy; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1304 | retval = audit_alloc(p); |
| 1305 | if (retval) |
David Howells | f1752ee | 2008-11-14 10:39:17 +1100 | [diff] [blame] | 1306 | goto bad_fork_cleanup_policy; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1307 | /* copy all the process information */ |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1308 | retval = copy_semundo(clone_flags, p); |
| 1309 | if (retval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1310 | goto bad_fork_cleanup_audit; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1311 | retval = copy_files(clone_flags, p); |
| 1312 | if (retval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1313 | goto bad_fork_cleanup_semundo; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1314 | retval = copy_fs(clone_flags, p); |
| 1315 | if (retval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1316 | goto bad_fork_cleanup_files; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1317 | retval = copy_sighand(clone_flags, p); |
| 1318 | if (retval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1319 | goto bad_fork_cleanup_fs; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1320 | retval = copy_signal(clone_flags, p); |
| 1321 | if (retval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1322 | goto bad_fork_cleanup_sighand; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1323 | retval = copy_mm(clone_flags, p); |
| 1324 | if (retval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1325 | goto bad_fork_cleanup_signal; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1326 | retval = copy_namespaces(clone_flags, p); |
| 1327 | if (retval) |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 1328 | goto bad_fork_cleanup_mm; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1329 | retval = copy_io(clone_flags, p); |
| 1330 | if (retval) |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 1331 | goto bad_fork_cleanup_namespaces; |
Al Viro | afa86fc | 2012-10-22 22:51:14 -0400 | [diff] [blame] | 1332 | retval = copy_thread(clone_flags, stack_start, stack_size, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1333 | if (retval) |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 1334 | goto bad_fork_cleanup_io; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1335 | |
Pavel Emelyanov | 425fb2b | 2007-10-18 23:40:07 -0700 | [diff] [blame] | 1336 | if (pid != &init_struct_pid) { |
| 1337 | retval = -ENOMEM; |
Eric W. Biederman | 61bce0f | 2009-01-07 18:08:49 -0800 | [diff] [blame] | 1338 | pid = alloc_pid(p->nsproxy->pid_ns); |
Pavel Emelyanov | 425fb2b | 2007-10-18 23:40:07 -0700 | [diff] [blame] | 1339 | if (!pid) |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 1340 | goto bad_fork_cleanup_io; |
Pavel Emelyanov | 425fb2b | 2007-10-18 23:40:07 -0700 | [diff] [blame] | 1341 | } |
| 1342 | |
| 1343 | p->pid = pid_nr(pid); |
| 1344 | p->tgid = p->pid; |
| 1345 | if (clone_flags & CLONE_THREAD) |
| 1346 | p->tgid = current->tgid; |
| 1347 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1348 | p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL; |
| 1349 | /* |
| 1350 | * Clear TID on mm_release()? |
| 1351 | */ |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1352 | p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr : NULL; |
Jens Axboe | 73c1010 | 2011-03-08 13:19:51 +0100 | [diff] [blame] | 1353 | #ifdef CONFIG_BLOCK |
| 1354 | p->plug = NULL; |
| 1355 | #endif |
Alexey Dobriyan | 42b2dd0 | 2007-10-16 23:27:30 -0700 | [diff] [blame] | 1356 | #ifdef CONFIG_FUTEX |
Ingo Molnar | 8f17d3a | 2006-03-27 01:16:27 -0800 | [diff] [blame] | 1357 | p->robust_list = NULL; |
| 1358 | #ifdef CONFIG_COMPAT |
| 1359 | p->compat_robust_list = NULL; |
| 1360 | #endif |
Ingo Molnar | c87e283 | 2006-06-27 02:54:58 -0700 | [diff] [blame] | 1361 | INIT_LIST_HEAD(&p->pi_state_list); |
| 1362 | p->pi_state_cache = NULL; |
Alexey Dobriyan | 42b2dd0 | 2007-10-16 23:27:30 -0700 | [diff] [blame] | 1363 | #endif |
Srikar Dronamraju | 0326f5a | 2012-03-13 23:30:11 +0530 | [diff] [blame] | 1364 | uprobe_copy_process(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1365 | /* |
GOTO Masanori | f9a3879 | 2006-03-13 21:20:44 -0800 | [diff] [blame] | 1366 | * sigaltstack should be cleared when sharing the same VM |
| 1367 | */ |
| 1368 | if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM) |
| 1369 | p->sas_ss_sp = p->sas_ss_size = 0; |
| 1370 | |
| 1371 | /* |
Oleg Nesterov | 6580807 | 2009-12-15 16:47:16 -0800 | [diff] [blame] | 1372 | * Syscall tracing and stepping should be turned off in the |
| 1373 | * child regardless of CLONE_PTRACE. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1374 | */ |
Oleg Nesterov | 6580807 | 2009-12-15 16:47:16 -0800 | [diff] [blame] | 1375 | user_disable_single_step(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1376 | clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE); |
Laurent Vivier | ed75e8d | 2005-09-03 15:57:18 -0700 | [diff] [blame] | 1377 | #ifdef TIF_SYSCALL_EMU |
| 1378 | clear_tsk_thread_flag(p, TIF_SYSCALL_EMU); |
| 1379 | #endif |
Arjan van de Ven | 9745512 | 2008-01-25 21:08:34 +0100 | [diff] [blame] | 1380 | clear_all_latency_tracing(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1381 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1382 | /* ok, now we should be set up.. */ |
Oleg Nesterov | 5f8aadd | 2012-03-14 19:55:38 +0100 | [diff] [blame] | 1383 | if (clone_flags & CLONE_THREAD) |
| 1384 | p->exit_signal = -1; |
| 1385 | else if (clone_flags & CLONE_PARENT) |
| 1386 | p->exit_signal = current->group_leader->exit_signal; |
| 1387 | else |
| 1388 | p->exit_signal = (clone_flags & CSIGNAL); |
| 1389 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1390 | p->pdeath_signal = 0; |
| 1391 | p->exit_state = 0; |
| 1392 | |
Wu Fengguang | 9d823e8 | 2011-06-11 18:10:12 -0600 | [diff] [blame] | 1393 | p->nr_dirtied = 0; |
| 1394 | p->nr_dirtied_pause = 128 >> (PAGE_SHIFT - 10); |
Wu Fengguang | 8371235 | 2011-06-11 19:25:42 -0600 | [diff] [blame] | 1395 | p->dirty_paused_when = 0; |
Wu Fengguang | 9d823e8 | 2011-06-11 18:10:12 -0600 | [diff] [blame] | 1396 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1397 | /* |
| 1398 | * Ok, make it visible to the rest of the system. |
| 1399 | * We dont wake it up yet. |
| 1400 | */ |
| 1401 | p->group_leader = p; |
Oleg Nesterov | 47e6532 | 2006-03-28 16:11:25 -0800 | [diff] [blame] | 1402 | INIT_LIST_HEAD(&p->thread_group); |
Al Viro | 158e164 | 2012-06-27 09:24:13 +0400 | [diff] [blame] | 1403 | p->task_works = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1404 | |
| 1405 | /* Need tasklist lock for parent etc handling! */ |
| 1406 | write_lock_irq(&tasklist_lock); |
| 1407 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1408 | /* CLONE_PARENT re-uses the old parent */ |
Oleg Nesterov | 2d5516c | 2009-03-02 22:58:45 +0100 | [diff] [blame] | 1409 | if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1410 | p->real_parent = current->real_parent; |
Oleg Nesterov | 2d5516c | 2009-03-02 22:58:45 +0100 | [diff] [blame] | 1411 | p->parent_exec_id = current->parent_exec_id; |
| 1412 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1413 | p->real_parent = current; |
Oleg Nesterov | 2d5516c | 2009-03-02 22:58:45 +0100 | [diff] [blame] | 1414 | p->parent_exec_id = current->self_exec_id; |
| 1415 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1416 | |
Oleg Nesterov | 3f17da6 | 2006-02-15 22:13:24 +0300 | [diff] [blame] | 1417 | spin_lock(¤t->sighand->siglock); |
Oleg Nesterov | 4a2c7a7 | 2006-03-28 16:11:26 -0800 | [diff] [blame] | 1418 | |
| 1419 | /* |
| 1420 | * Process group and session signals need to be delivered to just the |
| 1421 | * parent before the fork or both the parent and the child after the |
| 1422 | * fork. Restart if a signal comes in before we add the new process to |
| 1423 | * it's process group. |
| 1424 | * A fatal signal pending means that current will exit, so the new |
| 1425 | * thread can't slip out of an OOM kill (or normal SIGKILL). |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1426 | */ |
Daniel Walker | 23ff444 | 2007-10-18 03:06:07 -0700 | [diff] [blame] | 1427 | recalc_sigpending(); |
Oleg Nesterov | 4a2c7a7 | 2006-03-28 16:11:26 -0800 | [diff] [blame] | 1428 | if (signal_pending(current)) { |
| 1429 | spin_unlock(¤t->sighand->siglock); |
| 1430 | write_unlock_irq(&tasklist_lock); |
| 1431 | retval = -ERESTARTNOINTR; |
Steven Rostedt | f7e8b61 | 2009-06-02 16:39:48 -0400 | [diff] [blame] | 1432 | goto bad_fork_free_pid; |
Oleg Nesterov | 4a2c7a7 | 2006-03-28 16:11:26 -0800 | [diff] [blame] | 1433 | } |
| 1434 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1435 | if (clone_flags & CLONE_THREAD) { |
Oleg Nesterov | b3ac022 | 2010-05-26 14:43:24 -0700 | [diff] [blame] | 1436 | current->signal->nr_threads++; |
Oleg Nesterov | 4ab6c08 | 2009-08-26 14:29:24 -0700 | [diff] [blame] | 1437 | atomic_inc(¤t->signal->live); |
Oleg Nesterov | b3ac022 | 2010-05-26 14:43:24 -0700 | [diff] [blame] | 1438 | atomic_inc(¤t->signal->sigcnt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1439 | p->group_leader = current->group_leader; |
Oleg Nesterov | 47e6532 | 2006-03-28 16:11:25 -0800 | [diff] [blame] | 1440 | list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1441 | } |
| 1442 | |
Oleg Nesterov | 73b9ebf | 2006-03-28 16:11:07 -0800 | [diff] [blame] | 1443 | if (likely(p->pid)) { |
Tejun Heo | 4b9d33e | 2011-06-17 16:50:38 +0200 | [diff] [blame] | 1444 | ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1445 | |
Oleg Nesterov | 73b9ebf | 2006-03-28 16:11:07 -0800 | [diff] [blame] | 1446 | if (thread_group_leader(p)) { |
Eric W. Biederman | 1c4042c | 2010-07-12 17:10:36 -0700 | [diff] [blame] | 1447 | if (is_child_reaper(pid)) { |
Eric W. Biederman | 17cf22c | 2010-03-02 14:51:53 -0800 | [diff] [blame] | 1448 | ns_of_pid(pid)->child_reaper = p; |
Eric W. Biederman | 1c4042c | 2010-07-12 17:10:36 -0700 | [diff] [blame] | 1449 | p->signal->flags |= SIGNAL_UNKILLABLE; |
| 1450 | } |
Oleg Nesterov | c97d989 | 2006-03-28 16:11:06 -0800 | [diff] [blame] | 1451 | |
Oleg Nesterov | fea9d17 | 2008-02-08 04:19:19 -0800 | [diff] [blame] | 1452 | p->signal->leader_pid = pid; |
Alan Cox | 9c9f4de | 2008-10-13 10:37:26 +0100 | [diff] [blame] | 1453 | p->signal->tty = tty_kref_get(current->signal->tty); |
Eric W. Biederman | 5cd1756 | 2007-12-04 23:45:04 -0800 | [diff] [blame] | 1454 | attach_pid(p, PIDTYPE_PGID, task_pgrp(current)); |
| 1455 | attach_pid(p, PIDTYPE_SID, task_session(current)); |
Oleg Nesterov | 9cd80bb | 2009-12-17 15:27:15 -0800 | [diff] [blame] | 1456 | list_add_tail(&p->sibling, &p->real_parent->children); |
Eric W. Biederman | 5e85d4a | 2006-04-18 22:20:16 -0700 | [diff] [blame] | 1457 | list_add_tail_rcu(&p->tasks, &init_task.tasks); |
Christoph Lameter | 909ea96 | 2010-12-08 16:22:55 +0100 | [diff] [blame] | 1458 | __this_cpu_inc(process_counts); |
Oleg Nesterov | 73b9ebf | 2006-03-28 16:11:07 -0800 | [diff] [blame] | 1459 | } |
Sukadev Bhattiprolu | 8586899 | 2007-05-10 22:23:03 -0700 | [diff] [blame] | 1460 | attach_pid(p, PIDTYPE_PID, pid); |
Oleg Nesterov | 73b9ebf | 2006-03-28 16:11:07 -0800 | [diff] [blame] | 1461 | nr_threads++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1462 | } |
| 1463 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1464 | total_forks++; |
Oleg Nesterov | 3f17da6 | 2006-02-15 22:13:24 +0300 | [diff] [blame] | 1465 | spin_unlock(¤t->sighand->siglock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1466 | write_unlock_irq(&tasklist_lock); |
Andrew Morton | c13cf85 | 2005-11-28 13:43:48 -0800 | [diff] [blame] | 1467 | proc_fork_connector(p); |
Paul Menage | 817929e | 2007-10-18 23:39:36 -0700 | [diff] [blame] | 1468 | cgroup_post_fork(p); |
Ben Blum | 4714d1d | 2011-05-26 16:25:18 -0700 | [diff] [blame] | 1469 | if (clone_flags & CLONE_THREAD) |
Tejun Heo | 257058a | 2011-12-12 18:12:21 -0800 | [diff] [blame] | 1470 | threadgroup_change_end(current); |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 1471 | perf_event_fork(p); |
KAMEZAWA Hiroyuki | 43d2b11 | 2012-01-10 15:08:09 -0800 | [diff] [blame] | 1472 | |
| 1473 | trace_task_newtask(p, clone_flags); |
| 1474 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1475 | return p; |
| 1476 | |
Pavel Emelyanov | 425fb2b | 2007-10-18 23:40:07 -0700 | [diff] [blame] | 1477 | bad_fork_free_pid: |
| 1478 | if (pid != &init_struct_pid) |
| 1479 | free_pid(pid); |
Jens Axboe | fd0928d | 2008-01-24 08:52:45 +0100 | [diff] [blame] | 1480 | bad_fork_cleanup_io: |
Louis Rilling | b69f229 | 2009-12-04 14:52:42 +0100 | [diff] [blame] | 1481 | if (p->io_context) |
| 1482 | exit_io_context(p); |
Serge E. Hallyn | ab51601 | 2006-10-02 02:18:06 -0700 | [diff] [blame] | 1483 | bad_fork_cleanup_namespaces: |
Linus Torvalds | 444f378 | 2007-01-30 13:35:18 -0800 | [diff] [blame] | 1484 | exit_task_namespaces(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1485 | bad_fork_cleanup_mm: |
David Rientjes | c9f0124 | 2011-10-31 17:07:15 -0700 | [diff] [blame] | 1486 | if (p->mm) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1487 | mmput(p->mm); |
| 1488 | bad_fork_cleanup_signal: |
Oleg Nesterov | 4ab6c08 | 2009-08-26 14:29:24 -0700 | [diff] [blame] | 1489 | if (!(clone_flags & CLONE_THREAD)) |
Mike Galbraith | 1c5354d | 2011-01-05 11:16:04 +0100 | [diff] [blame] | 1490 | free_signal_struct(p->signal); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1491 | bad_fork_cleanup_sighand: |
Oleg Nesterov | a7e5328 | 2006-03-28 16:11:27 -0800 | [diff] [blame] | 1492 | __cleanup_sighand(p->sighand); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1493 | bad_fork_cleanup_fs: |
| 1494 | exit_fs(p); /* blocking */ |
| 1495 | bad_fork_cleanup_files: |
| 1496 | exit_files(p); /* blocking */ |
| 1497 | bad_fork_cleanup_semundo: |
| 1498 | exit_sem(p); |
| 1499 | bad_fork_cleanup_audit: |
| 1500 | audit_free(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1501 | bad_fork_cleanup_policy: |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 1502 | perf_event_free_task(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1503 | #ifdef CONFIG_NUMA |
Lee Schermerhorn | f0be3d3 | 2008-04-28 02:13:08 -0700 | [diff] [blame] | 1504 | mpol_put(p->mempolicy); |
Paul Menage | b4f48b6 | 2007-10-18 23:39:33 -0700 | [diff] [blame] | 1505 | bad_fork_cleanup_cgroup: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1506 | #endif |
Ben Blum | 4714d1d | 2011-05-26 16:25:18 -0700 | [diff] [blame] | 1507 | if (clone_flags & CLONE_THREAD) |
Tejun Heo | 257058a | 2011-12-12 18:12:21 -0800 | [diff] [blame] | 1508 | threadgroup_change_end(current); |
Tejun Heo | 5edee61 | 2012-10-16 15:03:14 -0700 | [diff] [blame] | 1509 | cgroup_exit(p, 0); |
Shailabh Nagar | 35df17c | 2006-08-31 21:27:38 -0700 | [diff] [blame] | 1510 | delayacct_tsk_free(p); |
Al Viro | a1261f5 | 2005-11-13 16:06:55 -0800 | [diff] [blame] | 1511 | module_put(task_thread_info(p)->exec_domain->module); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1512 | bad_fork_cleanup_count: |
David Howells | d84f4f9 | 2008-11-14 10:39:23 +1100 | [diff] [blame] | 1513 | atomic_dec(&p->cred->user->processes); |
David Howells | e0e8173 | 2009-09-02 09:13:40 +0100 | [diff] [blame] | 1514 | exit_creds(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1515 | bad_fork_free: |
| 1516 | free_task(p); |
Oleg Nesterov | fe7d37d | 2006-01-08 01:04:02 -0800 | [diff] [blame] | 1517 | fork_out: |
| 1518 | return ERR_PTR(retval); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1519 | } |
| 1520 | |
Oleg Nesterov | f106eee | 2010-05-26 14:44:11 -0700 | [diff] [blame] | 1521 | static inline void init_idle_pids(struct pid_link *links) |
| 1522 | { |
| 1523 | enum pid_type type; |
| 1524 | |
| 1525 | for (type = PIDTYPE_PID; type < PIDTYPE_MAX; ++type) { |
| 1526 | INIT_HLIST_NODE(&links[type].node); /* not really needed */ |
| 1527 | links[type].pid = &init_struct_pid; |
| 1528 | } |
| 1529 | } |
| 1530 | |
Al Viro | 9abcf40 | 2007-02-01 13:52:48 +0000 | [diff] [blame] | 1531 | struct task_struct * __cpuinit fork_idle(int cpu) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1532 | { |
Ingo Molnar | 36c8b58 | 2006-07-03 00:25:41 -0700 | [diff] [blame] | 1533 | struct task_struct *task; |
Al Viro | 62e791c | 2012-10-22 22:52:26 -0400 | [diff] [blame] | 1534 | task = copy_process(CLONE_VM, 0, 0, NULL, &init_struct_pid, 0); |
Oleg Nesterov | f106eee | 2010-05-26 14:44:11 -0700 | [diff] [blame] | 1535 | if (!IS_ERR(task)) { |
| 1536 | init_idle_pids(task->pids); |
Akinobu Mita | 753ca4f | 2006-11-25 11:09:34 -0800 | [diff] [blame] | 1537 | init_idle(task, cpu); |
Oleg Nesterov | f106eee | 2010-05-26 14:44:11 -0700 | [diff] [blame] | 1538 | } |
Oleg Nesterov | 73b9ebf | 2006-03-28 16:11:07 -0800 | [diff] [blame] | 1539 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1540 | return task; |
| 1541 | } |
| 1542 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1543 | /* |
| 1544 | * Ok, this is the main fork-routine. |
| 1545 | * |
| 1546 | * It copies the process, and if successful kick-starts |
| 1547 | * it and waits for it to finish using the VM if required. |
| 1548 | */ |
| 1549 | long do_fork(unsigned long clone_flags, |
| 1550 | unsigned long stack_start, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1551 | unsigned long stack_size, |
| 1552 | int __user *parent_tidptr, |
| 1553 | int __user *child_tidptr) |
| 1554 | { |
| 1555 | struct task_struct *p; |
| 1556 | int trace = 0; |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 1557 | long nr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1558 | |
Andrew Morton | bdff746 | 2008-02-04 22:27:22 -0800 | [diff] [blame] | 1559 | /* |
Serge Hallyn | 18b6e04 | 2008-10-15 16:38:45 -0500 | [diff] [blame] | 1560 | * Do some preliminary argument and permissions checking before we |
| 1561 | * actually start allocating stuff |
| 1562 | */ |
Eric W. Biederman | 50804fe | 2010-03-02 15:41:50 -0800 | [diff] [blame] | 1563 | if (clone_flags & (CLONE_NEWUSER | CLONE_NEWPID)) { |
| 1564 | if (clone_flags & (CLONE_THREAD|CLONE_PARENT)) |
Serge Hallyn | 18b6e04 | 2008-10-15 16:38:45 -0500 | [diff] [blame] | 1565 | return -EINVAL; |
Serge Hallyn | 18b6e04 | 2008-10-15 16:38:45 -0500 | [diff] [blame] | 1566 | } |
| 1567 | |
| 1568 | /* |
Tejun Heo | 4b9d33e | 2011-06-17 16:50:38 +0200 | [diff] [blame] | 1569 | * Determine whether and which event to report to ptracer. When |
| 1570 | * called from kernel_thread or CLONE_UNTRACED is explicitly |
| 1571 | * requested, no event is reported; otherwise, report if the event |
| 1572 | * for the type of forking is enabled. |
Roland McGrath | 09a0539 | 2008-07-25 19:45:47 -0700 | [diff] [blame] | 1573 | */ |
Al Viro | e80d666 | 2012-10-22 23:10:08 -0400 | [diff] [blame] | 1574 | if (!(clone_flags & CLONE_UNTRACED)) { |
Tejun Heo | 4b9d33e | 2011-06-17 16:50:38 +0200 | [diff] [blame] | 1575 | if (clone_flags & CLONE_VFORK) |
| 1576 | trace = PTRACE_EVENT_VFORK; |
| 1577 | else if ((clone_flags & CSIGNAL) != SIGCHLD) |
| 1578 | trace = PTRACE_EVENT_CLONE; |
| 1579 | else |
| 1580 | trace = PTRACE_EVENT_FORK; |
| 1581 | |
| 1582 | if (likely(!ptrace_event_enabled(current, trace))) |
| 1583 | trace = 0; |
| 1584 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1585 | |
Al Viro | 62e791c | 2012-10-22 22:52:26 -0400 | [diff] [blame] | 1586 | p = copy_process(clone_flags, stack_start, stack_size, |
Roland McGrath | 09a0539 | 2008-07-25 19:45:47 -0700 | [diff] [blame] | 1587 | child_tidptr, NULL, trace); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1588 | /* |
| 1589 | * Do this prior waking up the new thread - the thread pointer |
| 1590 | * might get invalid after that point, if the thread exits quickly. |
| 1591 | */ |
| 1592 | if (!IS_ERR(p)) { |
| 1593 | struct completion vfork; |
| 1594 | |
Mathieu Desnoyers | 0a16b60 | 2008-07-18 12:16:17 -0400 | [diff] [blame] | 1595 | trace_sched_process_fork(current, p); |
| 1596 | |
Pavel Emelyanov | 6c5f3e7 | 2008-02-08 04:19:20 -0800 | [diff] [blame] | 1597 | nr = task_pid_vnr(p); |
Pavel Emelyanov | 30e49c2 | 2007-10-18 23:40:10 -0700 | [diff] [blame] | 1598 | |
| 1599 | if (clone_flags & CLONE_PARENT_SETTID) |
| 1600 | put_user(nr, parent_tidptr); |
Sukadev Bhattiprolu | a6f5e06 | 2007-10-18 23:39:53 -0700 | [diff] [blame] | 1601 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1602 | if (clone_flags & CLONE_VFORK) { |
| 1603 | p->vfork_done = &vfork; |
| 1604 | init_completion(&vfork); |
Oleg Nesterov | d68b46f | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 1605 | get_task_struct(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1606 | } |
| 1607 | |
Samir Bellabes | 3e51e3e | 2011-05-11 18:18:05 +0200 | [diff] [blame] | 1608 | wake_up_new_task(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1609 | |
Tejun Heo | 4b9d33e | 2011-06-17 16:50:38 +0200 | [diff] [blame] | 1610 | /* forking complete and child started to run, tell ptracer */ |
| 1611 | if (unlikely(trace)) |
| 1612 | ptrace_event(trace, nr); |
Roland McGrath | 09a0539 | 2008-07-25 19:45:47 -0700 | [diff] [blame] | 1613 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1614 | if (clone_flags & CLONE_VFORK) { |
Oleg Nesterov | d68b46f | 2012-03-05 14:59:13 -0800 | [diff] [blame] | 1615 | if (!wait_for_vfork_done(p, &vfork)) |
| 1616 | ptrace_event(PTRACE_EVENT_VFORK_DONE, nr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1617 | } |
| 1618 | } else { |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 1619 | nr = PTR_ERR(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1620 | } |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 1621 | return nr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1622 | } |
| 1623 | |
Al Viro | 2aa3a7f | 2012-09-21 19:55:31 -0400 | [diff] [blame] | 1624 | /* |
| 1625 | * Create a kernel thread. |
| 1626 | */ |
| 1627 | pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags) |
| 1628 | { |
Al Viro | e80d666 | 2012-10-22 23:10:08 -0400 | [diff] [blame] | 1629 | return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn, |
Al Viro | 2aa3a7f | 2012-09-21 19:55:31 -0400 | [diff] [blame] | 1630 | (unsigned long)arg, NULL, NULL); |
| 1631 | } |
Al Viro | 2aa3a7f | 2012-09-21 19:55:31 -0400 | [diff] [blame] | 1632 | |
Al Viro | d212504 | 2012-10-23 13:17:59 -0400 | [diff] [blame] | 1633 | #ifdef __ARCH_WANT_SYS_FORK |
| 1634 | SYSCALL_DEFINE0(fork) |
| 1635 | { |
| 1636 | #ifdef CONFIG_MMU |
Al Viro | e80d666 | 2012-10-22 23:10:08 -0400 | [diff] [blame] | 1637 | return do_fork(SIGCHLD, 0, 0, NULL, NULL); |
Al Viro | d212504 | 2012-10-23 13:17:59 -0400 | [diff] [blame] | 1638 | #else |
| 1639 | /* can not support in nommu mode */ |
| 1640 | return(-EINVAL); |
| 1641 | #endif |
| 1642 | } |
| 1643 | #endif |
| 1644 | |
| 1645 | #ifdef __ARCH_WANT_SYS_VFORK |
| 1646 | SYSCALL_DEFINE0(vfork) |
| 1647 | { |
Al Viro | e80d666 | 2012-10-22 23:10:08 -0400 | [diff] [blame] | 1648 | return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, |
Al Viro | d212504 | 2012-10-23 13:17:59 -0400 | [diff] [blame] | 1649 | 0, NULL, NULL); |
| 1650 | } |
| 1651 | #endif |
| 1652 | |
| 1653 | #ifdef __ARCH_WANT_SYS_CLONE |
| 1654 | #ifdef CONFIG_CLONE_BACKWARDS |
| 1655 | SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, |
| 1656 | int __user *, parent_tidptr, |
| 1657 | int, tls_val, |
| 1658 | int __user *, child_tidptr) |
| 1659 | #elif defined(CONFIG_CLONE_BACKWARDS2) |
| 1660 | SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags, |
| 1661 | int __user *, parent_tidptr, |
| 1662 | int __user *, child_tidptr, |
| 1663 | int, tls_val) |
| 1664 | #else |
| 1665 | SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp, |
| 1666 | int __user *, parent_tidptr, |
| 1667 | int __user *, child_tidptr, |
| 1668 | int, tls_val) |
| 1669 | #endif |
| 1670 | { |
Al Viro | b1e0318 | 2013-01-19 22:13:34 -0500 | [diff] [blame] | 1671 | long ret = do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr); |
| 1672 | asmlinkage_protect(5, ret, clone_flags, newsp, |
| 1673 | parent_tidptr, child_tidptr, tls_val); |
| 1674 | return ret; |
Al Viro | d212504 | 2012-10-23 13:17:59 -0400 | [diff] [blame] | 1675 | } |
| 1676 | #endif |
| 1677 | |
Ravikiran G Thirumalai | 5fd63b3 | 2006-01-11 22:46:15 +0100 | [diff] [blame] | 1678 | #ifndef ARCH_MIN_MMSTRUCT_ALIGN |
| 1679 | #define ARCH_MIN_MMSTRUCT_ALIGN 0 |
| 1680 | #endif |
| 1681 | |
Alexey Dobriyan | 51cc506 | 2008-07-25 19:45:34 -0700 | [diff] [blame] | 1682 | static void sighand_ctor(void *data) |
Oleg Nesterov | aa1757f | 2006-03-28 16:11:12 -0800 | [diff] [blame] | 1683 | { |
| 1684 | struct sighand_struct *sighand = data; |
| 1685 | |
Christoph Lameter | a35afb8 | 2007-05-16 22:10:57 -0700 | [diff] [blame] | 1686 | spin_lock_init(&sighand->siglock); |
Davide Libenzi | b8fceee | 2007-09-20 12:40:16 -0700 | [diff] [blame] | 1687 | init_waitqueue_head(&sighand->signalfd_wqh); |
Oleg Nesterov | aa1757f | 2006-03-28 16:11:12 -0800 | [diff] [blame] | 1688 | } |
| 1689 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1690 | void __init proc_caches_init(void) |
| 1691 | { |
| 1692 | sighand_cachep = kmem_cache_create("sighand_cache", |
| 1693 | sizeof(struct sighand_struct), 0, |
Vegard Nossum | 2dff440 | 2008-05-31 15:56:17 +0200 | [diff] [blame] | 1694 | SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU| |
| 1695 | SLAB_NOTRACK, sighand_ctor); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1696 | signal_cachep = kmem_cache_create("signal_cache", |
| 1697 | sizeof(struct signal_struct), 0, |
Vegard Nossum | 2dff440 | 2008-05-31 15:56:17 +0200 | [diff] [blame] | 1698 | SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); |
Paul Mundt | 20c2df8 | 2007-07-20 10:11:58 +0900 | [diff] [blame] | 1699 | files_cachep = kmem_cache_create("files_cache", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1700 | sizeof(struct files_struct), 0, |
Vegard Nossum | 2dff440 | 2008-05-31 15:56:17 +0200 | [diff] [blame] | 1701 | SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); |
Paul Mundt | 20c2df8 | 2007-07-20 10:11:58 +0900 | [diff] [blame] | 1702 | fs_cachep = kmem_cache_create("fs_cache", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1703 | sizeof(struct fs_struct), 0, |
Vegard Nossum | 2dff440 | 2008-05-31 15:56:17 +0200 | [diff] [blame] | 1704 | SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); |
Linus Torvalds | 6345d24 | 2011-05-29 11:32:28 -0700 | [diff] [blame] | 1705 | /* |
| 1706 | * FIXME! The "sizeof(struct mm_struct)" currently includes the |
| 1707 | * whole struct cpumask for the OFFSTACK case. We could change |
| 1708 | * this to *only* allocate as much of it as required by the |
| 1709 | * maximum number of CPU's we can ever have. The cpumask_allocation |
| 1710 | * is at the end of the structure, exactly for that reason. |
| 1711 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1712 | mm_cachep = kmem_cache_create("mm_struct", |
Ravikiran G Thirumalai | 5fd63b3 | 2006-01-11 22:46:15 +0100 | [diff] [blame] | 1713 | sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN, |
Vegard Nossum | 2dff440 | 2008-05-31 15:56:17 +0200 | [diff] [blame] | 1714 | SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); |
David Howells | 33e5d769 | 2009-04-02 16:56:32 -0700 | [diff] [blame] | 1715 | vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC); |
David Howells | 8feae13 | 2009-01-08 12:04:47 +0000 | [diff] [blame] | 1716 | mmap_init(); |
Al Viro | 6657719 | 2011-06-28 15:41:10 -0400 | [diff] [blame] | 1717 | nsproxy_cache_init(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1718 | } |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1719 | |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1720 | /* |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1721 | * Check constraints on flags passed to the unshare system call. |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1722 | */ |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1723 | static int check_unshare_flags(unsigned long unshare_flags) |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1724 | { |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1725 | if (unshare_flags & ~(CLONE_THREAD|CLONE_FS|CLONE_NEWNS|CLONE_SIGHAND| |
| 1726 | CLONE_VM|CLONE_FILES|CLONE_SYSVSEM| |
Eric W. Biederman | 50804fe | 2010-03-02 15:41:50 -0800 | [diff] [blame] | 1727 | CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWNET| |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1728 | CLONE_NEWUSER|CLONE_NEWPID)) |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1729 | return -EINVAL; |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1730 | /* |
| 1731 | * Not implemented, but pretend it works if there is nothing to |
| 1732 | * unshare. Note that unsharing CLONE_THREAD or CLONE_SIGHAND |
| 1733 | * needs to unshare vm. |
| 1734 | */ |
| 1735 | if (unshare_flags & (CLONE_THREAD | CLONE_SIGHAND | CLONE_VM)) { |
| 1736 | /* FIXME: get_task_mm() increments ->mm_users */ |
| 1737 | if (atomic_read(¤t->mm->mm_users) > 1) |
| 1738 | return -EINVAL; |
| 1739 | } |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1740 | |
| 1741 | return 0; |
| 1742 | } |
| 1743 | |
| 1744 | /* |
JANAK DESAI | 99d1419 | 2006-02-07 12:58:59 -0800 | [diff] [blame] | 1745 | * Unshare the filesystem structure if it is being shared |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1746 | */ |
| 1747 | static int unshare_fs(unsigned long unshare_flags, struct fs_struct **new_fsp) |
| 1748 | { |
| 1749 | struct fs_struct *fs = current->fs; |
| 1750 | |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 1751 | if (!(unshare_flags & CLONE_FS) || !fs) |
| 1752 | return 0; |
| 1753 | |
| 1754 | /* don't need lock here; in the worst case we'll do useless copy */ |
| 1755 | if (fs->users == 1) |
| 1756 | return 0; |
| 1757 | |
| 1758 | *new_fsp = copy_fs_struct(fs); |
| 1759 | if (!*new_fsp) |
| 1760 | return -ENOMEM; |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1761 | |
| 1762 | return 0; |
| 1763 | } |
| 1764 | |
| 1765 | /* |
JANAK DESAI | a016f33 | 2006-02-07 12:59:02 -0800 | [diff] [blame] | 1766 | * Unshare file descriptor table if it is being shared |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1767 | */ |
| 1768 | static int unshare_fd(unsigned long unshare_flags, struct files_struct **new_fdp) |
| 1769 | { |
| 1770 | struct files_struct *fd = current->files; |
JANAK DESAI | a016f33 | 2006-02-07 12:59:02 -0800 | [diff] [blame] | 1771 | int error = 0; |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1772 | |
| 1773 | if ((unshare_flags & CLONE_FILES) && |
JANAK DESAI | a016f33 | 2006-02-07 12:59:02 -0800 | [diff] [blame] | 1774 | (fd && atomic_read(&fd->count) > 1)) { |
| 1775 | *new_fdp = dup_fd(fd, &error); |
| 1776 | if (!*new_fdp) |
| 1777 | return error; |
| 1778 | } |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1779 | |
| 1780 | return 0; |
| 1781 | } |
| 1782 | |
| 1783 | /* |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1784 | * unshare allows a process to 'unshare' part of the process |
| 1785 | * context which was originally shared using clone. copy_* |
| 1786 | * functions used by do_fork() cannot be used here directly |
| 1787 | * because they modify an inactive task_struct that is being |
| 1788 | * constructed. Here we are modifying the current, active, |
| 1789 | * task_struct. |
| 1790 | */ |
Heiko Carstens | 6559eed8 | 2009-01-14 14:14:32 +0100 | [diff] [blame] | 1791 | SYSCALL_DEFINE1(unshare, unsigned long, unshare_flags) |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1792 | { |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1793 | struct fs_struct *fs, *new_fs = NULL; |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1794 | struct files_struct *fd, *new_fd = NULL; |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1795 | struct cred *new_cred = NULL; |
Pavel Emelyanov | cf7b708 | 2007-10-18 23:39:54 -0700 | [diff] [blame] | 1796 | struct nsproxy *new_nsproxy = NULL; |
Manfred Spraul | 9edff4a | 2008-04-29 01:00:57 -0700 | [diff] [blame] | 1797 | int do_sysvsem = 0; |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1798 | int err; |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1799 | |
Eric W. Biederman | 50804fe | 2010-03-02 15:41:50 -0800 | [diff] [blame] | 1800 | /* |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1801 | * If unsharing a user namespace must also unshare the thread. |
| 1802 | */ |
| 1803 | if (unshare_flags & CLONE_NEWUSER) |
| 1804 | unshare_flags |= CLONE_THREAD; |
| 1805 | /* |
Eric W. Biederman | 50804fe | 2010-03-02 15:41:50 -0800 | [diff] [blame] | 1806 | * If unsharing a pid namespace must also unshare the thread. |
| 1807 | */ |
| 1808 | if (unshare_flags & CLONE_NEWPID) |
| 1809 | unshare_flags |= CLONE_THREAD; |
| 1810 | /* |
| 1811 | * If unsharing a thread from a thread group, must also unshare vm. |
| 1812 | */ |
| 1813 | if (unshare_flags & CLONE_THREAD) |
| 1814 | unshare_flags |= CLONE_VM; |
| 1815 | /* |
| 1816 | * If unsharing vm, must also unshare signal handlers. |
| 1817 | */ |
| 1818 | if (unshare_flags & CLONE_VM) |
| 1819 | unshare_flags |= CLONE_SIGHAND; |
Manfred Spraul | 6013f67 | 2008-04-29 01:00:59 -0700 | [diff] [blame] | 1820 | /* |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1821 | * If unsharing namespace, must also unshare filesystem information. |
| 1822 | */ |
| 1823 | if (unshare_flags & CLONE_NEWNS) |
| 1824 | unshare_flags |= CLONE_FS; |
Eric W. Biederman | 50804fe | 2010-03-02 15:41:50 -0800 | [diff] [blame] | 1825 | |
| 1826 | err = check_unshare_flags(unshare_flags); |
| 1827 | if (err) |
| 1828 | goto bad_unshare_out; |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1829 | /* |
Manfred Spraul | 6013f67 | 2008-04-29 01:00:59 -0700 | [diff] [blame] | 1830 | * CLONE_NEWIPC must also detach from the undolist: after switching |
| 1831 | * to a new ipc namespace, the semaphore arrays from the old |
| 1832 | * namespace are unreachable. |
| 1833 | */ |
| 1834 | if (unshare_flags & (CLONE_NEWIPC|CLONE_SYSVSEM)) |
Manfred Spraul | 9edff4a | 2008-04-29 01:00:57 -0700 | [diff] [blame] | 1835 | do_sysvsem = 1; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1836 | err = unshare_fs(unshare_flags, &new_fs); |
| 1837 | if (err) |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1838 | goto bad_unshare_out; |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1839 | err = unshare_fd(unshare_flags, &new_fd); |
| 1840 | if (err) |
Oleg Nesterov | 9bfb23f | 2011-03-22 16:34:09 -0700 | [diff] [blame] | 1841 | goto bad_unshare_cleanup_fs; |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1842 | err = unshare_userns(unshare_flags, &new_cred); |
Daniel Rebelo de Oliveira | fb0a685 | 2011-07-26 16:08:39 -0700 | [diff] [blame] | 1843 | if (err) |
Manfred Spraul | 9edff4a | 2008-04-29 01:00:57 -0700 | [diff] [blame] | 1844 | goto bad_unshare_cleanup_fd; |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1845 | err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy, |
| 1846 | new_cred, new_fs); |
| 1847 | if (err) |
| 1848 | goto bad_unshare_cleanup_cred; |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1849 | |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1850 | if (new_fs || new_fd || do_sysvsem || new_cred || new_nsproxy) { |
Manfred Spraul | 9edff4a | 2008-04-29 01:00:57 -0700 | [diff] [blame] | 1851 | if (do_sysvsem) { |
| 1852 | /* |
| 1853 | * CLONE_SYSVSEM is equivalent to sys_exit(). |
| 1854 | */ |
| 1855 | exit_sem(current); |
| 1856 | } |
Serge E. Hallyn | ab51601 | 2006-10-02 02:18:06 -0700 | [diff] [blame] | 1857 | |
Serge Hallyn | c0b2fc3 | 2006-10-02 02:18:18 -0700 | [diff] [blame] | 1858 | if (new_nsproxy) { |
Pavel Emelyanov | cf7b708 | 2007-10-18 23:39:54 -0700 | [diff] [blame] | 1859 | switch_task_namespaces(current, new_nsproxy); |
| 1860 | new_nsproxy = NULL; |
Serge Hallyn | c0b2fc3 | 2006-10-02 02:18:18 -0700 | [diff] [blame] | 1861 | } |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1862 | |
Pavel Emelyanov | cf7b708 | 2007-10-18 23:39:54 -0700 | [diff] [blame] | 1863 | task_lock(current); |
| 1864 | |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1865 | if (new_fs) { |
| 1866 | fs = current->fs; |
Nick Piggin | 2a4419b | 2010-08-18 04:37:33 +1000 | [diff] [blame] | 1867 | spin_lock(&fs->lock); |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1868 | current->fs = new_fs; |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 1869 | if (--fs->users) |
| 1870 | new_fs = NULL; |
| 1871 | else |
| 1872 | new_fs = fs; |
Nick Piggin | 2a4419b | 2010-08-18 04:37:33 +1000 | [diff] [blame] | 1873 | spin_unlock(&fs->lock); |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1874 | } |
| 1875 | |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1876 | if (new_fd) { |
| 1877 | fd = current->files; |
| 1878 | current->files = new_fd; |
| 1879 | new_fd = fd; |
| 1880 | } |
| 1881 | |
| 1882 | task_unlock(current); |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1883 | |
| 1884 | if (new_cred) { |
| 1885 | /* Install the new user namespace */ |
| 1886 | commit_creds(new_cred); |
| 1887 | new_cred = NULL; |
| 1888 | } |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1889 | } |
| 1890 | |
Serge Hallyn | c0b2fc3 | 2006-10-02 02:18:18 -0700 | [diff] [blame] | 1891 | if (new_nsproxy) |
Linus Torvalds | 444f378 | 2007-01-30 13:35:18 -0800 | [diff] [blame] | 1892 | put_nsproxy(new_nsproxy); |
Serge Hallyn | c0b2fc3 | 2006-10-02 02:18:18 -0700 | [diff] [blame] | 1893 | |
Eric W. Biederman | b2e0d987 | 2012-07-26 05:15:35 -0700 | [diff] [blame] | 1894 | bad_unshare_cleanup_cred: |
| 1895 | if (new_cred) |
| 1896 | put_cred(new_cred); |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1897 | bad_unshare_cleanup_fd: |
| 1898 | if (new_fd) |
| 1899 | put_files_struct(new_fd); |
| 1900 | |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1901 | bad_unshare_cleanup_fs: |
| 1902 | if (new_fs) |
Al Viro | 498052b | 2009-03-30 07:20:30 -0400 | [diff] [blame] | 1903 | free_fs_struct(new_fs); |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1904 | |
JANAK DESAI | cf2e340 | 2006-02-07 12:58:58 -0800 | [diff] [blame] | 1905 | bad_unshare_out: |
| 1906 | return err; |
| 1907 | } |
Al Viro | 3b12538 | 2008-04-22 05:31:30 -0400 | [diff] [blame] | 1908 | |
| 1909 | /* |
| 1910 | * Helper to unshare the files of the current task. |
| 1911 | * We don't want to expose copy_files internals to |
| 1912 | * the exec layer of the kernel. |
| 1913 | */ |
| 1914 | |
| 1915 | int unshare_files(struct files_struct **displaced) |
| 1916 | { |
| 1917 | struct task_struct *task = current; |
Al Viro | 5070451 | 2008-04-26 05:25:00 +0100 | [diff] [blame] | 1918 | struct files_struct *copy = NULL; |
Al Viro | 3b12538 | 2008-04-22 05:31:30 -0400 | [diff] [blame] | 1919 | int error; |
| 1920 | |
| 1921 | error = unshare_fd(CLONE_FILES, ©); |
| 1922 | if (error || !copy) { |
| 1923 | *displaced = NULL; |
| 1924 | return error; |
| 1925 | } |
| 1926 | *displaced = task->files; |
| 1927 | task_lock(task); |
| 1928 | task->files = copy; |
| 1929 | task_unlock(task); |
| 1930 | return 0; |
| 1931 | } |